javascript Reflect

javascript Reflect
意味
ReflectはJavaScriptをブロックする操作方法を提供する内蔵のオブジェクトです.これらの方法はプロセッサオブジェクトの方法と同じである.Reflectは関数オブジェクトではないので、作成できません.
説明
ほとんどのグローバルオブジェクトとは異なり、Reflectはコンストラクタがありません.new演算子と一緒に使ったり、Reflectオブジェクトを関数として呼び出したりすることはできません.Reflectのすべての属性と方法は、Mathオブジェクトのように静的である.
互換性
Chrome:49+Firefox:42+その他のブラウザはまだ実現されていません.
文章法
Reflect.apply(targt,thisAgment,argments List)
パラメータ
ターゲット関数thisAgmentターゲット関数呼び出し時にバインディングされたthisオブジェクトです.argments List target関数が呼び出された時に入ってきた参加リストです.このパラメータはクラスの配列のオブジェクトです.
方法
Reflect.apply()
Reflect.co nstruct(target,argments List[,newTarget])
静的方法Reflect.apply()は、指定されたパラメータリストを介してターゲット関数の呼び出しを開始する.

Reflect.apply(Math.floor, undefined, [1.75]); 
// 1;

Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);
// "hello"

Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index;
// 4

Reflect.apply("".charAt, "ponies", [3]);
// "i"

Reflect.co nstruct()Reflect.co nstruct()方法の動作はnewオペレータの構造関数に似ています.new target(…args)を実行するのに相当します.

var d = Reflect.construct(Date, [1776, 6, 4]);
d instanceof Date; // true
d.getFullYear(); // 1776

Reflect.defineProperty()Reflect.defineProperty()は、Object.definePropertyのように見える静的な方法ですが、ブール値を返します.

const object1 = {};

if (Reflect.defineProperty(object1, 'property1', {value: 42})) {
  console.log('property1 created!');
  // expected output: "property1 created!"
} else {
  console.log('problem creating property1');
}

console.log(object1.property1);
// expected output: 42

Reflect.deleteProperty()静的方法Reflect.deleteProperty()は、属性の削除を許可する.それはdelete operatorに似ていますが、それは関数です.Reflect.deletePropertyは、オブジェクトの属性を削除することを許可します.Boolean値を返します.属性が削除されたかどうかを表します.それはほとんど非厳格なdelete operatorと同じです.
Reflect.deleteProperty(target,propertyKey)

var obj = { x: 1, y: 2 };
Reflect.deleteProperty(obj, "x"); // true
obj; // { y: 2 }

var arr = [1, 2, 3, 4, 5];
Reflect.deleteProperty(arr, "3"); // true
arr; // [1, 2, 3, , 5]

//        ，   true
Reflect.deleteProperty({}, "foo"); // true

//         ，   false
Reflect.deleteProperty(Object.freeze({foo: 1}), "foo"); // false

Reflect.get()Reflect.get()メソッドの働き方は、objectから属性を取得するようですが、関数として実行されます.
Reflect.get(targt,propertyKey[,receiver])

// Object
var obj = { x: 1, y: 2 };
Reflect.get(obj, "x"); // 1

// Array
Reflect.get(["zero", "one"], 1); // "one"

// Proxy with a get handler
var x = {p: 1};
var obj = new Proxy(x, {
  get(t, k, r) { return k + "bar"; }
});
Reflect.get(obj, "foo"); // "foobar"

Reflect.getOwnPropertyDescriptor()静的方法Reflect.getOwn PropertyDescriptor()はObject.getOwn PropertyDescriptor()の方法と似ています.オブジェクト内に存在する場合、指定された属性の属性記述子を返します.undefinedを返します.
Reflect.getOwn ProptyDescripter(target,propertyKey)

Reflect.getOwnPropertyDescriptor({x: "hello"}, "x");
// {value: "hello", writable: true, enumerable: true, configurable: true}

Reflect.getOwnPropertyDescriptor({x: "hello"}, "y");
// undefined

Reflect.getOwnPropertyDescriptor([], "length");
// {value: 0, writable: true, enumerable: false, configurable: false}

Reflect.get ProttypeOf()静的方法Reflect.get ProttypeOf()はObject.get ProttypeOf()と同じです.いずれも指定されたオブジェクトの原型(すなわち、内部の［Prottype］属性の値)を返します.
Reflect.get ProttypeOf(taget)

Reflect.getPrototypeOf({}); // Object.prototype
Reflect.getPrototypeOf(Object.prototype); // null
Reflect.getPrototypeOf(Object.create(null)); // null

Reflect.has()静的方法Reflect.has()作用はin操作子と同じです.
Reflect.has(targt、propertyKey)

Reflect.has({x: 0}, "x"); // true
Reflect.has({x: 0}, "y"); // false

//             ，  true 
Reflect.has({x: 0}, "toString");

// Proxy     .has()     
obj = new Proxy({}, {
  has(t, k) { return k.startsWith("door"); }
});
Reflect.has(obj, "doorbell"); // true
Reflect.has(obj, "dormitory"); // false

Reflect.isExtensioble()静的方法Reflect.isExtensiobleは、オブジェクトが拡張可能かどうか(すなわち、新しい属性を追加できるかどうか)を判断する.Object.isExtensebleと似ていますが、いくつかの違いがあります.詳細はdifferencesに見えます.
Reflect.isExtenseble(target)

// New objects are extensible. 
var empty = {};
Reflect.isExtensible(empty); // === true 

// ...but that can be changed. 
Reflect.preventExtensions(empty); 
Reflect.isExtensible(empty); // === false 

// Sealed objects are by definition non-extensible. 
var sealed = Object.seal({}); 
Reflect.isExtensible(sealed); // === false 

// Frozen objects are also by definition non-extensible. 
var frozen = Object.freeze({}); 
Reflect.isExtensible(frozen); // === false

//diff Object.isExtensible
Reflect.isExtensible(1);
// TypeError: 1 is not an object

Object.isExtensible(1);
// false

Reflect.ownKeys()静的方法Reflect.ownKeys()は、ターゲットオブジェクト自身の属性キーからなる配列を返します.
Reflect.ownKeys(target)

const object1 = {
  property1: 42,
  property2: 13
};

var array1 = [];

console.log(Reflect.ownKeys(object1));
// expected output: Array ["property1", "property2"]

console.log(Reflect.ownKeys(array1));
// expected output: Array ["length"]
Reflect.ownKeys({z: 3, y: 2, x: 1}); // [ "z", "y", "x" ]
Reflect.ownKeys([]); // ["length"]

var sym = Symbol.for("comet");
var sym2 = Symbol.for("meteor");
var obj = {[sym]: 0, "str": 0, "773": 0, "0": 0,
           [sym2]: 0, "-1": 0, "8": 0, "second str": 0};
Reflect.ownKeys(obj);
// [ "0", "8", "773", "str", "-1", "second str", Symbol(comet), Symbol(meteor) ]
// Indexes in numeric order, 
// strings in insertion order, 
// symbols in insertion order

Reflect.prevent Extensions()静的方法Reflect.prevent Extensions()方法は、新しい属性がオブジェクトに追加されるのを阻止する.例えば、将来のオブジェクトへの拡張がオブジェクトに追加されるのを防ぐ.この方法はObject.prevent Extensions()と似ているが、いくつかの異なる点がある.
Reflect.prevent Extensions(taget)

// Objects are extensible by default.
var empty = {};
Reflect.isExtensible(empty); // === true

// ...but that can be changed.
Reflect.preventExtensions(empty);
Reflect.isExtensible(empty); // === false

//diff Object.preventExtensions()
Reflect.preventExtensions(1);
// TypeError: 1 is not an object

Object.preventExtensions(1);
// 1

Reflect.set()静的方法Reflect.set()の動作は、オブジェクトに属性を設定するように動作します.
Reflect.set(targt,propertyKey,value[,receiver])

// Object
var obj = {};
Reflect.set(obj, "prop", "value"); // true
obj.prop; // "value"

// Array
var arr = ["duck", "duck", "duck"];
Reflect.set(arr, 2, "goose"); // true
arr[2]; // "goose"

// It can truncate an array.
Reflect.set(arr, "length", 1); // true
arr; // ["duck"];

// With just one argument, propertyKey and value are "undefined".
var obj = {};
Reflect.set(obj); // true
Reflect.getOwnPropertyDescriptor(obj, "undefined");
// { value: undefined, writable: true, enumerable: true, configurable: true }

Reflect.set ProttypeOf()静的方法Reflect.set ProttypeOf()はObject.set ProttotypeOf()の方法と一致しています.指定されたオブジェクトのプロトタイプ(すなわち、内部の「Prottype」属性)を別のオブジェクトまたはnullに設定します.
Reflect.set ProttypeOf(targt、prototype)

Reflect.setPrototypeOf({}, Object.prototype); // true

// It can change an object's [[Prototype]] to null.
Reflect.setPrototypeOf({}, null); // true

// Returns false if target is not extensible.
Reflect.setPrototypeOf(Object.freeze({}), null); // false

// Returns false if it cause a prototype chain cycle.
var target = {};
var proto = Object.create(target);
Reflect.setPrototypeOf(target, proto); // false

posted@
2019-03-02 18:27邱秋閲読(
…)コメント(
コレクションを編集