ES6语法（Reflect、Proxy、Promise）

• Reflect

ES6 中引入了 Reflect 对象，它提供了一组静态方法，这些方法对应于一些操作符。下面是一些 Reflect API 的示例用法：

1. 使用 Reflect.apply 进行函数调用：

   function greet(name) {
     console.log(`Hello, ${name}!`);
   }
   
   Reflect.apply(greet, null, ['Alice']); // 输出: Hello, Alice!
   

2. 使用 Reflect.construct 创建对象实例：

   class Person {
     constructor(name) {
       this.name = name;
     }
   }
   
   const person = Reflect.construct(Person, ['Alice']);
   console.log(person.name); // 输出: Alice
   

3. 使用 Reflect.get 获取属性值：

   const obj = { name: 'Alice' };
   const name = Reflect.get(obj, 'name');
   console.log(name); // 输出: Alice
   

4. 使用 Reflect.set 设置属性值：

   const obj = {};
   Reflect.set(obj, 'name', 'Alice');
   console.log(obj.name); // 输出: Alice
   

5. 使用 Reflect.deleteProperty 删除属性：

   const obj = { name: 'Alice' };
   Reflect.deleteProperty(obj, 'name');
   console.log(obj.name); // 输出: undefined
   

6. 使用 Reflect.has 检查属性是否存在：

   const obj = { name: 'Alice' };
   console.log(Reflect.has(obj, 'name')); // 输出: true
   console.log(Reflect.has(obj, 'age')); // 输出: false
   

Reflect API 提供了一种更加统一和灵活的方式来进行对象操作，同时也为 Proxy 对象的拦截器提供了更多的底层操作支持。 

• Proxy

ES6 中的 Proxy 对象用于定义基本操作的自定义行为（例如属性查找、赋值、枚举、函数调用等）。下面是一些 ES6 Proxy API 的示例用法：

1. 创建一个简单的 Proxy 对象来拦截属性访问：

   const target = {
     name: 'Alice',
     age: 30
   };
   
   const handler = {
     get: function(target, prop) {
       console.log(`Getting property: ${prop}`);
       return target[prop];
     }
   };
   
   const proxy = new Proxy(target, handler);
   
   console.log(proxy.name); // 触发 get 拦截，输出: Getting property: name 和 Alice
   console.log(proxy.age); // 触发 get 拦截，输出: Getting property: age 和 30

2. 创建一个 Proxy 对象来拦截属性设置：

   const target = {};
   
   const handler = {
     set: function(target, prop, value) {
       console.log(`Setting property: ${prop} to ${value}`);
       target[prop] = value;
       return true;
     }
   };
   
   const proxy = new Proxy(target, handler);
   
   proxy.name = 'Alice'; // 触发 set 拦截，输出: Setting property: name to Alice
   console.log(proxy.name); // 输出: Alice
   

3. 创建一个 Proxy 对象来拦截函数调用：

   const target = {
     greet: function(name) {
       return `Hello, ${name}!`;
     }
   };
   
   const handler = {
     apply: function(target, thisArg, args) {
       console.log(`Calling function: ${target.name} with args: ${args.join(', ')}`);
       return Reflect.apply(...arguments);
     }
   };
   
   const proxy = new Proxy(target.greet, handler);
   
   console.log(proxy('Alice')); // 触发 apply 拦截，输出: Calling function: greet with args: Alice 和 Hello, Alice!
   

通过使用 Proxy 对象，我们可以在对象上设置各种拦截操作，从而实现对 JavaScript 对象各种操作的自定义行为。这为开发人员提供了更灵活和强大的能力来控制对象的访问和操作。 

• Promise

 ES6 引入了 Promise 对象，它用于异步编程，解决了回调地狱（callback hell）的问题，使得异步操作更加清晰和易于管理。下面是一些 ES6 Promise API 的示例用法：

1. 创建一个简单的 Promise 对象，表示异步操作：

   const myPromise = new Promise((resolve, reject) => {
     // 异步操作，例如读取文件、发送网络请求等
     const success = true;
     if (success) {
       resolve('Operation succeeded');
     } else {
       reject('Operation failed');
     }
   });
   
   // 处理异步操作的结果
   myPromise.then((result) => {
     console.log(result); // 输出: Operation succeeded
   }).catch((error) => {
     console.error(error);
   });
   

2. 使用 Promise.all 来处理多个异步操作并行执行：

   const promise1 = Promise.resolve('Hello');
   const promise2 = 10;
   const promise3 = new Promise((resolve, reject) => {
     setTimeout(resolve, 1000, 'World');
   });
   
   Promise.all([promise1, promise2, promise3]).then((values) => {
     console.log(values); // 输出: ['Hello', 10, 'World']
   });
   

3. 使用 Promise.race 来处理多个异步操作中的第一个完成的情况：

   const promise1 = new Promise((resolve, reject) => {
     setTimeout(resolve, 1000, 'One');
   });
   const promise2 = new Promise((resolve, reject) => {
     setTimeout(resolve, 2000, 'Two');
   });
   
   Promise.race([promise1, promise2]).then((value) => {
     console.log(value); // 输出: One，因为 promise1 先完成
   });
   

4. 使用 Promise.resolve 和 Promise.reject 来创建已经解决或已经拒绝的 Promise 对象：

   const resolvedPromise = Promise.resolve('Resolved');
   const rejectedPromise = Promise.reject('Rejected');
   
   resolvedPromise.then((value) => {
     console.log(value); // 输出: Resolved
   });
   rejectedPromise.catch((error) => {
     console.error(error); // 输出: Rejected
   });
   

Promise 对象提供了一种更加优雅和便捷的方式来处理异步操作，使得代码更易读、易维护，同时也提供了丰富的方法来处理异步操作的组合和控制流。