简单记录下ES6新增的新特性

let 和 const

• 特点： let 用于声明可重新赋值的变量，const 用于声明不可重新赋值的常量。
• 使用场景： 替代 var，更安全地声明变量。
• 举例：

let variable1 = '可重新赋值的变量';
const constant1 = '不可重新赋值的常量';

console.log(variable1); // 输出：可重新赋值的变量
console.log(constant1); // 输出：不可重新赋值的常量

箭头函数

• 特点： 使用更简洁的语法创建函数，并且自动绑定 this。
• 使用场景： 在不需要 this 动态绑定的场合，提供更短的语法。
• 举例：

// 普通函数
function add(a, b) {
  return a + b;
}

// 箭头函数
const add = (a, b) => a + b;

console.log(add(2, 3)); // 输出：5

模板字符串

• 特点： 使用反引号（`）创建多行字符串和在字符串中插入变量。
• 使用场景： 更方便地处理多行字符串和变量插入。
• 举例：

let name = 'John';
let greeting = `Hello, ${name}!`;

console.log(greeting); // 输出：Hello, John!

解构赋值

• 特点： 从数组或对象中提取值，并将其赋给变量。
• 使用场景： 方便地从数据结构中提取数据。
• 举例：

// 解构数组
let [a, b] = [1, 2];

// 解构对象
let { x, y } = { x: 1, y: 2 };

console.log(a, b, x, y); // 输出：1 2 1 2

默认参数

• 特点： 允许在函数声明时为参数指定默认值。
• 使用场景： 简化函数调用，防止传入 undefined。
• 举例：

function greet(name = 'Guest') {
  console.log(`Hello, ${name}!`);
}

greet(); // 输出：Hello, Guest!

展开运算符

• 特点： 允许在数组和对象字面量中展开元素。
• 使用场景： 方便地将多个元素组合在一起。
• 举例：

// 展开数组
let arr1 = [1, 2, 3];
let arr2 = [...arr1, 4, 5];

// 展开对象
let obj1 = { a: 1, b: 2 };
let obj2 = { ...obj1, c: 3, d: 4 };

console.log(arr2, obj2); // 输出：[1, 2, 3, 4, 5] {a: 1, b: 2, c: 3, d: 4}

类和继承

• 特点： 引入了类和类继承的概念，使面向对象编程更加直观。
• 使用场景： 创建和组织代码的对象。
• 举例：

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    console.log(`${this.name} makes a sound.`);
  }
}

class Dog extends Animal {
  speak() {
    console.log(`${this.name} barks.`);
  }
}

let myDog = new Dog('Buddy');
myDog.speak(); // 输出：Buddy barks.

模块化

• 特点： 引入了 import 和 export，使得 JavaScript 可以更好地组织和复用代码。
• 使用场景： 将代码分割成独立的模块，提高可维护性。
• 举例：

// 在一个模块中导出变量
export const myVariable = 42;

// 在另一个模块中导入变量
import { myVariable } from './myModule';

console.log(myVariable); // 输出：42

Promise

• 特点： 用于更好地处理异步操作，避免回调地狱。
• 使用场景： 处理异步操作，使代码更清晰。
• 举例：

const myPromise = new Promise((resolve, reject) => {
  // 异步操作
  if (/* 操作成功 */) {
    resolve('成功');
  } else {
    reject('失败');
  }
});

myPromise
  .then(result => console.log(result))
  .catch(error => console.error(error));

Map 和 Set

• 特点： Map 是一组键值对的集合，其中键可以是任意数据类型；Set 是一组唯一值的集合。
• 使用场景： 用于存储和操作一组唯一的数据，提供更灵活的数据结构。
• 例子：

// Map
let myMap = new Map();
myMap.set('key1', 'value1');
myMap.set('key2', 'value2');
console.log(myMap.get('key1')); // 输出：value1

// Set
let mySet = new Set();
mySet.add('value1');
mySet.add('value2');
mySet.add('value1'); // 重复的值不会被添加
console.log(mySet.size); // 输出：2

Proxy

• 特点： Proxy 允许创建对象的代理，可以拦截并自定义对象上的操作；Reflect 提供了与 Proxy 相同的方法，用于执行对象默认操作。
• 使用场景： 用于拦截对象上的操作，实现自定义的行为，增强对象的控制。
• 例子：

// Proxy
let handler = {
  get: function (target, prop) {
    return prop in target ? target[prop] : 'Not Found';
  }
};
let myProxy = new Proxy({ a: 1, b: 2 }, handler);
console.log(myProxy.a); // 输出：1
console.log(myProxy.c); // 输出：Not Found

Symbol

• 特点： Symbol 是一种新的基本数据类型，表示独一无二的值，常用作对象属性的键。
• 使用场景： 用于创建不可变且唯一的属性键。
• 例子：

const mySymbol = Symbol('mySymbol');
let myObject = {};
myObject[mySymbol] = 'Hello, Symbol!';