微信公众号搜"智元新知"关注
微信扫一扫可直接关注哦!

浅析javascript中Reflect内置对象代码详解

之前的文章一文讲解Vue中路由切换终止异步请求(附代码)》中,给大家介绍了解了vue中路由切换终止异步请求。下面本篇文章给大家了解js中Reflect内置对象,有一定的参考价值,有需要的朋友可以参考一下,希望对你们有所助。

语义

Reflect一个内置的对象,它提供拦截JavaScript操作的方法。这些方法与处理器对象的方法相同。Reflect不是一个函数对象,因此它是不可构造的。

描述

与大多数全局对象不同,Reflect没有构造函数。你不能将其与一个new运算符一起使用,或者将Reflect对象作为一个函数调用Reflect的所有属性方法都是静态的(就像 Math 对象)。

兼容性

Chrome:49+

Firefox (Gecko):42+

其他浏览器暂未实现

句法

Reflect.apply(target, thisArgument, argumentsList)

参数

target

目标函数

thisArgument target

函数调用时绑定的this对象。

argumentsList

target函数调用时传入的实参列表,该参数应该是一个类数组的对象。

方法

Reflect.apply()

Reflect.construct(target, argumentsList[, newTarget])

静态方法Reflect.apply()通过指定的参数列表发起对目标(target)函数调用

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.construct()

Reflect.construct()方法的行为有点像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 (target[propertyKey])获取属性,但它是作为一个函数执行的。

Reflect.get(target, 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.getownPropertyDescriptor()与Object.getownPropertyDescriptor()方法相似。如果在对象中存在,则返回给定的属性属性描述符。否则返回 undefined。

Reflect.getownPropertyDescriptor(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.getPrototypeOf()

静态方法Reflect.getPrototypeOf()与Object.getPrototypeOf()方法是一样的。都是返回指定对象的原型(即,内部的 [[Prototype]] 属性的值)。

Reflect.getPrototypeOf(target)

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

Reflect.has()

静态方法Reflect.has()作用与in操作符相同。

Reflect.has(target, 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.isExtensible()

静态方法Reflect.isExtensible()判断一个对象是否可扩展 (即是否能够添加新的属性)。与它Object.isExtensible()方法相似,但有一些不同,详情可见differences

Reflect.isExtensible(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.preventExtensions()

静态方法Reflect.preventExtensions()方法阻止新属性添加到对象例如:防止将来对对象的扩展被添加到对象中)。该方法Object.preventExtensions()相似,但有一些不同点。

Reflect.preventExtensions(target)

// 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(target, 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.setPrototypeOf()

静态方法Reflect.setPrototypeOf()与Object.setPrototypeOf()方法是一致的。它将指定对象的原型 (即,内部的[[Prototype]] 属性)设置为另一个对象或为null

Reflect.setPrototypeOf(target, 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

推荐学习:JavaScript视频教程

版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。

相关推荐