Reflect

Reflect has some internal methods of the Object object, and some methods will be deployed on the Object object and the Reflect object at the same time, that is to say, the methods existing on the Object object can also be accessed through Reflect.
In the case of Reflect alone, it can be understood that Reflect inherits some built-in methods of Object and provides optimization

Some methods on the Object object have some defects. For example, an error will be thrown when a getter or setter is performed on a non-writable or non-enumerable property on Object.defineProperty. For this error, we need try catch to catch it, and Reflect.defineProperty will throw false to indicate that the operation failed (Reflect will throw true and false to indicate whether the operation is successful or not for the operation of the object).
Object

const obj = { name : 'undefeated east' }
Object.defineProperty(obj,'age',{
    value : 100,
    writable : true,  // read only
    configurable : false  // Cannot be deleted and modified
})

Object.defineProperty(obj,'age',{
    get(){ return 200 }
})
console.log(obj.age); //  TypeError : Cannot redefine property: age
// Error, cannot redefine attribute

Reflect

const obj2 = { name : 'western defeat' }
Object.defineProperty(obj2,'age',{
    value : 100,
    writable : true,  // read only
    configurable : false  // Cannot be deleted and modified
})

let status = Reflect.defineProperty(obj2,'age',{
    get(){ return }
})

console.log(status); //  false
console.log(obj2.age); // 100
// Reflect will throw false to indicate that the operation failed

Some operations of Object are imperative

let obj3 = {
    name : 'undefeated east',
    age : 100
}

console.log('name' in obj3);  // true
console.log(delete obj3.age);  // true
console.log(obj3);  // {name: 'Eastern Undefeated'}

The operation of Reflect is functional

let obj4 = {
    name : 'western defeat',
    age : 100
}

console.log(Reflect.has(obj4,'name'));  // true
console.log(Reflect.deleteProperty(obj4,'age')); // true
console.log(obj4);  // {name: 'Western Seeking Defeat'}

From the above case, we can know that some methods inside Object can be accessed on Reflect. The Reflect object has 13 static methods in total, as follows:

1,Reflect.apply(target, thisArg, args)

2,Reflect.construct(target, args)

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

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

5,Reflect.defineProperty(target, name, desc)

6,Reflect.deleteProperty(target, name)

7,Reflect.has(target, name)

8,Reflect.ownKeys(target)

9,Reflect.isExtensible(target)

10,Reflect.preventExtensions(target)

11,Reflect.getOwnPropertyDescriptor(target, name)

12,Reflect.getPrototypeOf(target)

13,Reflect.setPrototypeOf(target, prototype)

The following is an explanation of the use of some of the above methods

Reflect.get(target,name,receiver)

Reglect.get() has three parameters, which are

 1,`target` : target
 2,`name`: object properties
 3,`receiver`:  proxy object (can be ignored)

Function: Find and return the name attribute of the target object, if the attribute does not exist, return undefined

let o = {
    name : 'East',
    text : 'undefeated'
}
console.log(Reflect.get(o,'name'));  // East

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

It is used to set the name attribute of the target object to be equal to the value. If the modification is successful, it returns true, and if it fails, it returns false

  let o2 = {
    name : 'Introduction to Art',
  }
// If the setting here is not modifiable, then back will output false, and the value of price will be undefined
//   Object.defineProperty(o2,'price',{
//     configurable : false
//   })
  let back = Reflect.set(o2,'price',100)
  console.log(back); // true
  console.log(o2);  // {name: 'Introduction to Art', price: 100}

Reflect.has(obj, name)

Equivalent to the in operator in Object, it judges whether the current attribute exists in the target object, true exists, false does not exist

let o3 = {
    name : 'History of Chinese Arts and Crafts'
}

console.log('name' in o3);  // true
console.log(Reflect.has(o3,'name')); // true

If the first parameter of Reflect.has is not an object, an error will be reported

Reflect.deleteProperty(obj, name)

Equivalent to the delete operation of Object: delete obj.name, used to delete the properties of the object

let o4 = {
    book : 'Windy Grass',
    text : 'a helping hand'
}
// Object
delete o4.book
console.log(o4);  // {text: 'A hand'}
// Reflect
Reflect.deleteProperty(o4,'text')
console.log(o4);  // {}

Reflect.construct(target, args)

Equivalent to new class(params), Reflect here can create a method to call the constructor without new

function Person(name){
    this.name = name
}

// new wording
let onNew = new Person('East')

// Reflect.construct
let onNew2 = Reflect.construct(Person,['undefeated'])

The first parameter of Reflect.construct is not a function and an error will be reported

Reflect.getPrototypeOf(obj)

Corresponding to Object.getPrototypeOf(obj), used to read the __proto__ attribute of the object

let o5 = new String()

// Object.getPrototypeOf()
console.log(Object.getPrototypeOf(o5) == String.prototype); // true

// Reflect.getPrototypeOf()
console.log(Reflect.getPrototypeOf(o5) == String.prototype); // true

Reflect.setPrototypeOf(obj, newProto)

Corresponds to Object.setPrototypeOf(obj, newProto), which is used to set the prototype of the target object (prototype)

let o6 = {}
Reflect.setPrototypeOf(o6,Array.prototype)
console.log(o6.length);  // 0

Reflect.defineProperty(target, propertyKey, attributes)

Equivalent to Object.defineProperty, Reflect.defineProperty() is used to define the properties of the object.

let o7 = {
    name : 'undefeated east'
}

Reflect.defineProperty(o7,'age',{
    value : 100,
    configurable: true,
    enumerable : true,
    writable : true
})
console.log(o7);  // {name: 'Eastern Invincible', age: 100}

If the first parameter of Reflect.defineProperty() is not an object, an error will be thrown.

Reflect.getOwnPropertyDescriptor(target, propertyKey)

Corresponds to Object.getOwnPropertyDescriptor, which is used to obtain the description object of the specified property

let o8 = {
    name : 'undefeated east'
}

Reflect.defineProperty(o8,'age',{
    value : 100,
    configurable: true,
    enumerable : true,
    writable : true
})

let back8 = Reflect.getOwnPropertyDescriptor(o8,'age')
console.log(back8);  // {value: 100, writable: true, enumerable: true, configurable: true}

If the first parameter of Reflect.getOwnPropertyDescriptor() is not an object, an error will be thrown.

Reflect.isExtensible (target)

Equivalent to Object.isExtensible, returns a Boolean value indicating whether the current object is extensible

let o9 = {}
let back9 = Reflect.isExtensible(o9)
console.log(back9);  // true

If the parameter is not an object, an error will be reported, and non-objects are inherently non-extensible

console.log(Reflect.isExtensible(100));  // report error

Reflect.preventExtensions(target)

Equivalent to Object.preventExtensions, which can make the target object become non-extensible, and return a Boolean value to indicate whether the setting is successful

let b = {}
let info =  Reflect.preventExtensions(b)
console.log(info); // true
console.log(Reflect.isExtensible(b)); // false

If the parameter is not an object, an error will be reported

Reflect.ownKeys (target)

Used to return all properties of the target object, including Symbol

let address = Symbol.for('Wuhan')
let b2 = {
    name : 'undefeated east',
    age : 100,
    [address] : 'World City Plaza'
}

let info2 = Reflect.ownKeys(b2)
console.log(info2); // ['name', 'age', Symbol( Wuhan)]

If the parameter of Reflect.ownKeys () is not an object, an error will be reported

Reflect.apply(func, thisArg, args)

Used to execute the given function after binding this object. If you want to bind a this object to the number of rows, you can use the apply method, but the shareholding function defines its own apply method, so it can only be written as Function.prototype.apply.call(fn, obj, args) method nesting , while Reflect can be simplified.

 let arr = [1,2,3,4,5,6,7]
 
 // old way
 let a = Math.min.apply( Math, arr)
 let a2 = Math.max.apply( Math, arr)
 let a3 = Object.prototype.toString.call(a)
 console.log(a);   // 1
 console.log(a2);  // 7
 console.log(a3);  // [object Number]

 // new wording
 let a4 = Reflect.apply( Math.min, Math, arr)
 let a5 = Reflect.apply( Math.max, Math, arr)
 let a6 = Reflect.apply( Object.prototype.toString, a4, [])
 console.log(a4);  // 1
 console.log(a5);  // 7
 console.log(a6);  // [object Number]

apply method:
Function.apply(obj,args)The method accepts two parameters  
obj: This object will replace Function class this object
args: This is the array, which will be passed as a parameter Function

In fact, some static functions on Reflect correspond to the methods available on Object before ES2015. Although some methods look similar in behavior, there are often some subtle differences between them. The Reflect object has a total of 13 static methods. The following table details the differences between the methods available on the Object and Reflect API s. Note that if a method does not exist in the API, it is marked as N/A.

Links to sources for data comparison in the above tables: Comparing Reflect and Object methods

Case source code: https://gitee.com/wang_fan_w/es6-science-institute

If you think this article is helpful to you, please light up the star