ES6，也称为ECMAScript 2015，是JavaScript语言的最新版本，提供了很多新特性和功能。

https://es6.ruanyifeng.com/

let 和 const 命令：

let命令：用于声明块级作用域内的变量，它的作用域是该代码块内。

const命令：用于声明常量，该常量的值在声明之后不能更改。

变量的解构赋值

let arr = [1, 2, 3];
//设置一个数组//把数组的第一个值赋值给一个变量a，第二个值赋值给变量b，那么我们可以这样写：
let [a, b] = arr;
console.log(a); // 1
console.log(b); // 2
//这就是变量的解构赋值,把变量分开来赋值,跟正常的赋值不太一样...//解构赋值也适用于对象：
let obj = {name: 'John', age: 20};
let {name, age} = obj;
console.log(name); // John
console.log(age); // 20

字符串的扩展:ES6中提供了很多新的字符串方法，例如startsWith、endsWith、includes、repeat等。

//startsWith方法:用于判断一个字符串是否以特定的字符开头
let str = "Hello World";
console.log(str.startsWith("Hello")); // true
console.log(str.startsWith("Hi")); // false//endsWith方法:判断一个字符串是否以特定的字符结尾
let str = "Hello World";
console.log(str.endsWith("World")); // true
console.log(str.endsWith("Universe")); // false//includes方法:用于判断一个字符串是否包含特定的字符
let str = "Hello World";
console.log(str.includes("Hello")); // true
console.log(str.includes("Hi")); // false//repeat方法:用于把一个字符串重复N次
let str = "Hello ";
console.log(str.repeat(3)); // Hello Hello Hello

数值的扩展:ES6 提供了一些新的数值方法，用于检查数值是否是有限的，是否是安全整数，以及将字符串解析为数值。

console.log(Number.isFinite(15)); // true
console.log(Number.isFinite(NaN)); // false
console.log(Number.isSafeInteger(9007199254740990)); // true
console.log(Number.isSafeInteger(9007199254740992)); // false
console.log(Number.parseInt('12.34')); // 12整型
console.log(Number.parseFloat('12.34#')); // 12.34浮点型

函数的扩展：ES6 提供了一些新的函数特性，例如默认参数、箭头函数、rest 参数等。

// 默认参数
function add(a, b = 10) {return a + b;
}
console.log(add(5)); // 15// 箭头函数
const square = (x) => x * x;
console.log(square(5)); // 25// rest 参数
function sum(...numbers) {return numbers.reduce((a, b) => a + b, 0);
}
console.log(sum(1, 2, 3, 4, 5)); // 15

数组的扩展：ES6 提供了一些新的数组方法，例如 Array.from、Array.of、Array.prototype.fill、Array.prototype.copyWithin 等。

// Array.from
let arrayLike = {'0': 'a','1': 'b','2': 'c',length: 3
};
let arr = Array.from(arrayLike);
console.log(arr); // ['a', 'b', 'c'],把对象转化为数组// Array.of
console.log(Array.of(1, 2, 3)); // [1, 2, 3]// Array.prototype.fill
console.log(Array(5).fill(1)); // [1, 1, 1, 1, 1],fill(1),就是都变成1// Array.prototype.copyWithin
console.log([1, 2, 3, 4, 5].copyWithin(0, 3, 4)); // [4, 2, 3, 4, 5],target,start,end

对象的扩展：ES6中的对象的扩展提供了很多方便的特性，以下是一些常见的用法

//对象的属性简写：ES6允许在对象字面量中使用 简写形式 定义对象的属性
let name = 'John';
let age = 25;
let user = {name,age
};
console.log(user); // { name: 'John', age: 25 }//对象的计算属性名：ES6允许通过表达式 动态计算属性名
let prop = 'name';
let user = {[prop]: 'John'
};
console.log(user); // { name: 'John' }//对象的方法简写：ES6允许在对象字面量中使用简写形式定义 对象的 方法
let user = {sayHi() {console.log('Hi');}
};
user.sayHi(); // Hi

Set 和 Map 数据结构：Set 数据结构允许存储任意类型的唯一值，没有重复的值。 Map 数据结构允许存储任意类型的键值对，键值对可以通过键值访问，键可以是任意类型。

const set = new Set();//允许存储任意类型的唯一值，没有重复的值
set.add(1);
set.add(2);
set.add(3);
console.log(set.size); // 3const map = new Map();//存储任意类型的键值对，键可以是任意类型。
map.set("name", "John");
map.set("age", 30);
console.log(map.get("name")); // John

!!Proxy：代理对象 proxy,使用一个代理处理器比如handler 进行控制。

常用handler 对象的 get 拦截器，以实现对代理对象的读取操作的拦截。
当代码试图读取代理对象的属性时，get 拦截器就会被调用，就会按照get里写的内容进行输出,就实现了对输出的控制。

const target = { name: 'John Doe' };
const handler = {get: function(target, property) {console.log(`Getting property: ${property}`);return target[property];}
};
const proxy = new Proxy(target, handler);
console.log(proxy.name);
// Output: Getting property: name
// John Doe//这里'Getting property:'仅仅是字符串,${property}中的property是一个变量

Reflect：Reflect 对象与 Proxy 对象类似，但它提供了对内置对象的方法的访问。

const object = {};
console.log(Reflect.defineProperty(object, "property", { value: 42 }));
console.log(object.property); // 42

Promise 对象：Promise 对象用于处理异步操作的结果，可以通过 .then() 和 .catch() 方法访问最终的结果。

const promise = new Promise((resolve, reject) => {// 异步操作代码if (/* 异步操作成功 */) {resolve(value);} else {reject(error);}
});
promise.then(value => {// 当异步操作成功时被调用
}).catch(error => {// 当异步操作失败时被调用
});const promise = new Promise((resolve, reject) => {setTimeout(() => {resolve("Success");}, 1000);
});
promise.then(result => {console.log(result); // Success
});

Iterator 和 for…of 循环：Iterator 是一种数据结构的遍历机制，它可以逐个遍历它的元素。for…of 循环是一种可以自动遍历 Iterator 接口的语法。

for of与lterator配合使用,遍历数组,记住这个就行

let arr = [1, 2, 3];
let iterator = arr[Symbol.iterator]();
for (let value of iterator) {console.log(value);
}
// Output: 1 2 3
//简而言之,lterator是一种数据结构的遍历机制,与for of连用,用来遍历所有元素

Generator 函数：Generator 函数通过使用关键字 yield 暂停执行，并通过关键字 next() 恢复执行。

每当 yield 关键字被调用时，Generator 函数的执行就会暂停。当调用 next() 方法时，执行将恢复，并返回一个包含当前生成值和执行状态的对象。

Generator 函数的主要优点在于可以生成迭代器，并对外部环境的影响最小。它们可以用于实现懒加载（lazy loading）、数据流处理、任务调度等多种功能。

function* generator() {yield 1;yield 2;yield 3;
}
const iterator = generator();
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: 3, done: false }
console.log(iterator.next()); // { value: undefined, done: true }

async 函数：一种新的异步函数的语法。它可以让你把异步代码写成同步的风格，使代码变得更加简洁和可读。

async function getData() {let result = await fetch("https://some-api.com/data");return result.json();
}
//这样在写getdata类的函数时候,就不怕异步问题了

Class 的基本语法：Class 是 ES6 中引入的面向对象编程的新语法。类是一种特殊的函数，它提供了构造函数、实例方法、静态方法等特性。

class Animal {constructor(name) {this.name = name;}speak() {console.log(`${this.name} makes a noise.`);}
}
const animal = new Animal('Dog');
animal.speak(); // Dog makes a noise.
//也就是js也可以写类了,更加面向对象编程了

Class 的继承：ES6 中的类支持继承，您可以使用 extends 关键字在父类和子类之间建立继承关系。

class Animal {constructor(name) {this.name = name;}speak() {console.log(`${this.name} makes a noise.`);}
}
class Dog extends Animal {constructor(name) {super(name);}speak() {console.log(`${this.name} barks.`);}
}
const dog = new Dog('Lucy');
dog.speak(); // Lucy barks.

Module 的语法：在 ES6 中，引入了模块这个新的概念。模块是独立的代码块，可以被重复使用，并且可以在不影响全局作用域的情况下导出和引入数据。

// 文件：math.js
export function add(a, b) {return a + b;
}

然后就可以在别的文件里导入模块

// 文件：app.js
import { add } from './math.js';console.log(add(1, 2)); // 输出：3

模块简而言之就是export,import