ES6的Reflect对象

Reflect对象的方法与Proxy对象的方法一一对应,只要proxy对象上有的方法reflect也能找到。

ES6将Object对象的一些属于语言内部的方法放到Reflect对象上,从Reflect上能拿到语言内部的方法。如:Object.defineProperty。

Reflect一共有13个静态方法:

Reflect.apply(target, thisArg, args)
Reflect.construct(target, args)
Reflect.get(target, name, receiver)
Reflect.set(target, name, value, receiver)
Reflect.defineProperty(target, name, desc)
Reflect.deleteProperty(target, name)
Reflect.has(target, name)
Reflect.ownKeys(target)
Reflect.isExtensible(target)
Reflect.preventExtensions(target)
Reflect.getOwnPropertyDescriptor(target, name)
Reflect.getPrototypeOf(target)
Reflect.setPrototypeOf(target, prototype)

Reflect.get(target, name, receiver)

Reflect.get方法查找并返回target的name属性,如果没有,则返回undefined。如果第一个参数不是对象,则Reflect.get则会报错。

// Reflect.get(target, name, receiver) 

var myObject = {
  foo: 1
}
Reflect.get(myObject, ‘foo‘)   // 1

如果name属性是读取函数(getter),则读取函数里的this绑定Reflect.get的receiver参数。

var myObject = {
  foo: 1,
  bar: 2,
  get baz() {
    return this.foo + this.bar;
  },
};

var myReceiverObject = {
  foo: 4,
  bar: 4,
};

Reflect.get(myObject, ‘baz‘, myReceiverObject)  // 8

Reflect.set(target, name, value, receiver)

Reflect.set方法设置target对象的name属性等于value。

// Reflect.set(target, name, value, receiver);

var myObject = {
  foo: 1,
  set bar(value) {
    return this.foo = value;
  },
}

myObject.foo   // 1

Reflect.set(myObject, ‘foo‘, 2);
myObject.foo    // 2

如果name参数是一个赋值函数,则赋值函数的this绑定Reflect.set的receiver参数。

var myObject = {
  foo: 4,
  set bar(value) {
    return this.foo = value;
  },
};

var myReceiverObject = {
  foo: 0,
};

Reflect.set(myObject, ‘bar‘, 1, myReceiverObject);
myObject.foo // 4
myReceiverObject.foo // 1

Reflect.has(obj, name)

Reflect.has对应 name in obj 里面的in操作,如果第一个参数不是对象,Reflect.has和in都会报错。

var myObject = {
  foo: 1,
};

// 旧写法
‘foo‘ in myObject    // true

// 新写法
Reflect.has(myObject, ‘foo‘)    // true

Reflect.deleteProperty(obj, name)

Reflect.deleteProperty方法等同于delete obj[name],用于删除对象属性。该方法返回一个布尔值。如果删除成功或删除的属性不存在,则返回true,如果删除失败,删除的属性依然还在,则返回false。

const myObj = { foo: ‘bar‘ };

// 旧写法
delete myObj.foo;

// 新写法
Reflect.deleteProperty(myObj, ‘foo‘);

Reflect.construct(target, args)

Reflect.construct方法等同于new target(...args),这提供了一种不使用new,来调用构造函数的方法。

function Greeting(name) {
  this.name = name;
}

// new 的写法
const instance = new Greeting(‘张三‘);

// Reflect.construct 的写法
const instance = Reflect.construct(Greeting, [‘张三‘]);

Reflect.getPrototypeOf(obj)

Reflect.getPrototypeOf方法用读取对象的__proto__属性,对应Object.getPrototypeOf(obj)方法。它们的区别是,如果参数不是对象,Object.getPrototypeOf会将参数转化为对象,而Reflect.getPrototypeOf会报错。

const myObj = new FancyThing();

// 旧写法
Object.getPrototypeOf(myObj) === FancyThing.prototype;

// 新写法
Reflect.getPrototypeOf(myObj) === FancyThing.prototype;

Reflect.setPrototypeOf(obj, newProto)

Reflect.setPrototypeOf方法是设置对象的__proto__属性,返回第一个参数对象,对应Object.setPrototypeOf(obj, newProto)。如果第一个参数不是对象,Object.setPrototypeOf会返回第一个参数对象,而Reflect.setPrototypeOf会报错。如果第一个参数是undefined或null,则两个都会报错。

const myObj = new FancyThing();

// 旧写法
Object.setPrototypeOf(myObj, OtherThing.prototype);

// 新写法
Reflect.setPrototypeOf(myObj, OtherThing.prototype);

Reflect.apply(func, thisArgs, args)

Reflect.apply相当于fn.apply

const ages = [11, 33, 12, 54, 18, 96];

// 旧写法
const youngest = Math.min.apply(Math, ages);
const oldest = Math.max.apply(Math, ages);
const type = Object.prototype.toString.call(youngest);

// 新写法
const youngest = Reflect.apply(Math.min, Math, ages);
const oldest = Reflect.apply(Math.max, Math, ages);
const type = Reflect.apply(Object.prototype.toString, youngest, []);

Reflect.defineProperty(target, propertyKey, attributes)

Reflect.defineProperty等同于Object.defineProperty,用来为对象定义属性。未来后者会被逐渐废除。如果第一个参数不是对象,就会抛出错误信息。

function MyDate() {
  /*…*/
}

// 旧写法
Object.defineProperty(MyDate, ‘now‘, {
  value: () => Date.now()
});

// 新写法
Reflect.defineProperty(MyDate, ‘now‘, {
  value: () => Date.now()
});

Reflect.getOwnPropertyDescriptor(target, propertyKey)

Reflect.getOwnPropertyDescriptor方法等同于Object.getOwnPropertyDescriptor,用于得到指定属性的描述对象,将来会代替后者。如果第一个参数不是对象Object.getOwnPropertyDescriptor不报错,返回undefined,而Reflect.getOwnPropertyDescriptor会报错,表示参数非法。

var myObject = {};
Object.defineProperty(myObject, ‘hidden‘, {
  value: true,
  enumerable: false,
});

// 旧写法
var theDescriptor = Object.getOwnPropertyDescriptor(myObject, ‘hidden‘);

// 新写法
var theDescriptor = Reflect.getOwnPropertyDescriptor(myObject, ‘hidden‘);

Reflect.isExtensible (target)

Reflect.isExtensible等同于Object.isExtensible,返回一个布尔值,表示当前对象是否可扩展。如果参数不是对象,Object.isExtensible会返回false,因为本来就是不可扩展的,而Reflect.isExtensible则报错。

const myObject = {};

// 旧写法
Object.isExtensible(myObject) // true

// 新写法
Reflect.isExtensible(myObject) // true

Reflect.preventExtensions(target)

Reflect.preventExtensions等同于Object.preventExtensions,用于让一个对象变为不可扩展,返回一个布尔值,表示是否操作成功。如果参数不是对象,Object.preventExtensions在ES5下会报错,ES6下会返回传入的值,Reflect.preventExtensions则会报错。

var myObject = {};

// 旧写法
Object.preventExtensions(myObject) // Object {}

// 新写法
Reflect.preventExtensions(myObject) // true

Reflect.ownKeys (target)

Reflect.ownKeys方法用于返回对象的所有属性,等同于Object.getOwnPropertyNames与Object.getOwnPropertySymbols之和。

var myObject = {
  foo: 1,
  bar: 2,
  [Symbol.for(‘baz‘)]: 3,
  [Symbol.for(‘bing‘)]: 4,
};

// 旧写法
Object.getOwnPropertyNames(myObject)
// [‘foo‘, ‘bar‘]

Object.getOwnPropertySymbols(myObject)
//[Symbol(baz), Symbol(bing)]

// 新写法
Reflect.ownKeys(myObject)
// [‘foo‘, ‘bar‘, Symbol(baz), Symbol(bing)]

原文:

https://www.cnblogs.com/kdcg/p/9139273.html

原文地址:https://www.cnblogs.com/xjy20170907/p/11557876.html

时间: 2025-02-01 07:56:41

ES6的Reflect对象的相关文章

Reflect对象

一.Reflect对象基础 Reflect对象是ES6出现的新的API,用于操作对象内部的方法. 特点: 1. 对于操作有明确的返回结果.如返回布尔值表示操作成功与否 2. 和Proxy的拦截方法一一对应,实现操作的默认行为 3.将in,delete,new等命令,用方法实现 4.该对象的方法将逐渐取代Object上的方法 二.静态方法 和Proxy的拦截方法一一对应,一共有13个方法: 所有方法的第一个参数都必须是对象.否则报错. 返回布尔值的方法有: 1. Reflect.set(targe

ES6中对对象的扩展

ES6允许直接写入变量和函数作为对象的属性和方法.这样的书写更加简洁. ES6允许在对象中只写属性名,不写属性值.这时,属性值等于属性名所代表的变量. function f(x , y){ return {x ,y}; } f(1,2)// Object {x:1,y:2} function getPoint(){ var x=1; var y=10; return {x,y}; } getPoint()//{x:1,y:10} js语言定义对象的属性有两种方法.obj.foo=true;obj

ES6新特性:Javascript中的Reflect对象

Reflect介绍: Reflect这个对象在我的node(v4.4.3)中还没有实现, babel(6.7.7)也没有实现 ,新版本的chrome是支持的, ff比较早就支持Proxy和Reflect了,要让node支持Reflect可以安装harmony-reflect ; Reflect不是构造函数, 要使用的时候直接通过Reflect.method()调用, Reflect有的方法和Proxy差不多, 而且多数Reflect方法原生的Object已经重新实现了. 什么要使用Reflect

ES6数组和对象的扩展

es6数组的扩展 扩展运算符 扩展运算符是对具有Iterator 接口的对象,都可以使用扩展运算符 Array.from() 用于将两类对象转化为真正的数组 1.类似数组的对象(只要据有length属性, 都可以被转化为数组) 2.可遍历(iterable)的对象 Array.of() 将一组值转化为数组 find和findIndex find方法,用于找出第一个符合条件的数组成员,没有找到会返回undefiend,findIndex方法返回的是第一个符合条件成员的位置, 如果找不到返回-1,

ES6 - promise对象

Promise的设计初衷 我们使用ajax请求数据,得到数据后再对数据进行操作,可是有时候,对得到的数据进行操作的过程中,可能又要用到ajax请求,这时,我们的代码就变成了这样: $.ajax({ success:function(res1){ //...请求B开始,B依赖A返回的数据 $.ajax({ sucess:function(res2){ //...请求C开始,C依赖B返回的数据 $.ajax({ sucess:function(res3){ } }); } }); } }); 这种写

ES6的promise对象应该这样用

ES6修补了一位Js修真者诸多的遗憾. 曾几何时,我这个小白从js非阻塞特性的坑中爬出来,当我经历了一些回调丑陋的写法和优化的尝试之后,我深深觉得js对于多线程阻塞式的开发语言而言,可能有着其太明显的缺点,而又无法忽略的是也正因为这一点,node.js处理并行的能力被人看作优点,在我看来,这其实有着些讽刺的意味,就好像踢足球时有的人总夸你腿短,所以频率快下盘稳好控球...好在js从出生以来就有一种独特的特质,就是模仿,对,就是模仿,模仿别人的优点来补足自己,同时保持自己的长处. ES6就是通过P

es6 之 promise 对象

异步编程 传统方案:事件 + 回调函数 ES6 的新方案:Promise 对象 Promise 异步操作有 3 种状态 pending: 进行中 resolved: 已完成 rejected: 已失败 Promise 异步操作的状态变化仅限下面两种方式 pending –> resolved pending –> rejected 创建一个 Promise 实例: promise 构造函数接收一个函数作为参数,并且这个函数有两个参数,这两个参数是也是两个函数,不过这两个函数由 JavaScri

ES6中Promise对象个人理解

Promise是ES6原生提供的一个用来传递异步消息的对象.它减少了传统ajax金字塔回调,可以将异步操作以同步操作的流程表达出来使得代码维护和可读性方面好很多. Promise的状态: 既然是用来传递异步消息的那肯定就会有异步消息的状态:所以promise提供了3种状态:pending(进行中),resolved(已完成或者称 fulfilled),rejected(失败).不同的是Promise不会受外界影响,只有异步操作结果才能决定当前是哪种状态,任何其他非异步操作都不能改变.所以当状态发

ES6学习之对象扩展

简介表示法(直接写入变量和函数,作为对象的属性和方法) let x = "test" let obj={ x, //属性名为变量名,属性值为变量值 y(){console.log("hello")} } //以上相当于 let obj = { x:'test', y:function(){ console.log("hello") } } 属性名表达式(表达式作为对象的属性名,把表达式放在方括号内.) let aa = "hello&q