ES6~ES12

class Person1 {}
let person2 = class {};类的构造函数如果我们希望在创建对象的时候给类传递一些参数，这个时候应该如何做呢？每个类都可以有一个自己的构造函数（方法），这个方法的名称是固定的constructor。当我们通过new操作符，操作一个类的时候会调用这个类的构造函数constructor。每个类只能有一个构造函数，如果包含多个构造函数，那么会抛出异常。

class Person {
  constructor(name) {
    this.name = name;
  }
  static createPerson(name) {
    return new Person(name);
  }
}
let p = Person.createPerson("sun");
console.log(p); //Person { name: "sun" }类的继承在ES6中新增了使用extends关键字，可以方便的帮助我们实现继承

class Person {}
class Student extends Person {}super关键字super关键字可以对父类中的方法进行调用。

class sArray extends Array {
  lastItem() {
    return this[this.length - 1];
  }
}
let arr = new sArray(2, 3, 4, 5, 6);
arr.push(7);
console.log(arr.lastItem());JavaScript中的多态多态（英语：polymorphism）指为不同数据类型的实体提供统一的接口，或使用一个单一的符号来表示多个不同的类型。如此看来JavaScript是一定存在多态的。

function sum(a, b) {
  console.log(a + b);
}
sum(10, 20);
sum("abc", "cba");二，基础语法1，字面量增强写法属性增强写法是对象中代表键值的变量名称与键名一致，则可以直接缩写为一个。函数增强写法是对象中的函数，function() 可以改为 ()计算属性写法

let name = "sun";
let age = 19;
let person = {
  name,
  age,
  [name + 123]: "hello",
  eating() {
    console.log(this.name);
  },
};
console.log(person); //{ name: "sun", age: 19, sun123: "hello", eating: [Function: eating] }2，解构ES6中新增了一个从数组或对象中方便获取数据的方法，称之为解构Destructuring。数组结构：基本解构过程、顺序解构、解构出数组、默认值

let obj = {
  name: "sun",
  age: 19,
  height: 190,
};
let { age, name: newName, height, address = "上海" } = obj;
console.log(age, newName, address); //19 sun 上海解构的应用场景解构目前在开发中使用是非常多的：

// 暂时性死区
let obj = "hello";
function say() {
  console.log(obj);
  let obj = "nihao";
}
say();var、let、const的选择尽量不使用var，优先选择const，次选择let

let name = "sun",
  age = 20;
console.log(`${name} is ${age} years old now!`); //sun is 20 years old now!

function foo(...args) {
  console.log(args);
}
foo("helloworld"); //[ "helloworld" ]
foo`hello${name}world${age}`; //[ [ "hello", "world", "" ], "sun", 20 ]4，展开语法展开语法 (Spread syntax), 可以在函数调用/数组构造时，将数组表达式或者 string 在语法层面展开；还可以在构造字面量对象时，将对象表达式按 key-value 的方式展开。在函数调用时使用展开语法

function sum(x, y, z) {
  return x + y + z;
}
const numbers = [1, 2, 3];
console.log(sum(...numbers)); //6在 new 表达式中应用

var obj1 = { foo: "bar", x: 42 };
var obj2 = { foo: "baz", y: 13 };

var clonedObj = { ...obj1 };
// 克隆后的对象：{ foo: "bar", x: 42 }

var mergedObj = { ...obj1, ...obj2 };
// 合并后的对象：{ foo: "baz", x: 42, y: 13 }5，数值的表示在ES6中规范了二进制和八进制的写法：

const s1 = Symbol();
const s2 = Symbol();
console.log(s1 === s2); //false

const obj = {
  [s1]: "sun",
  [s2]: 20,
};
console.log(obj[s1], obj[s2]); //sun 20,只能通过obj[]访问，不能通过obj.s1获取属性值description获取描述

console.log(Object.keys(obj)); //[]
console.log(Object.getOwnPropertyNames(obj)); //[];
console.log(Object.getOwnPropertySymbols(obj)); //[ Symbol(), Symbol(), Symbol(), Symbol() ]
const skeys = Object.getOwnPropertySymbols(obj);
for (let i of skeys) {
  console.log(obj[i]); //sun 20 180 河南
}相同值的Symbol前面我们讲Symbol的目的是为了创建一个独一无二的值，那么如果我们现在就是想创建相同的Symbol应该怎么来做呢？

function add(x = 10, y = 20) {
  return x + y;
}
console.log(add(1, 2)); // 3
console.log(add()); //30配合解构使用

function foo({ name, age } = { name: "sun", age: 20 }) {
  return `${name} is ${age} years old now!`;
}
let obj1 = {
  name: "xiaoming",
  age: 18,
};
console.log(foo(obj1)); //xiaoming is 18 years old now!
console.log(foo()); //sun is 20 years old now!2，函数的剩余参数ES6中引用了rest parameter，可以将不定数量的参数放入到一个数组中。如果最后一个参数是 … 为前缀的，那么它会将剩余的参数放到该参数中，并且作为一个数组；

function foo(m, n, ...args) {
  console.log(m, n); // 1 2
  console.log(args); //[3, 4, 5, 6, 7, 8, 9, 0];
}
let arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
foo(...arr);剩余参数和arguments区别

// 箭头函数
let fun = (name) => {
    return `Hello ${name} !`;
};

// 普通函数
let fun = function (name) {
    return `Hello ${name} !`;
};箭头函数的参数

let fun = val => val;
// 等同于
let fun = function (val) { return val };

let sum = (num1, num2) => num1 + num2;
// 等同于
let sum = function(num1, num2) {
  return num1 + num2;
};如果箭头函数的函数体只有一句代码，就是返回一个对象，可以像下面这样写：

// 用小括号包裹要返回的对象，不报错
let getTempItem = id => ({ id: id, name: "Temp" });

// 但绝不能这样写，会报错，因为对象的大括号会被解释为函数体的大括号
let getTempItem = id => { id: id, name: "Temp" };如果箭头函数的函数体只有一条语句并且不需要返回值（最常见是调用一个函数），可以给这条语句前面加一个void关键字

const obj = {
  name: "sun",
  age: 20,
};
console.log(Object.keys(obj)); //[ "name", "age" ]
console.log(Object.values(obj)); //[ "sun", 20 ]2，Object entries通过Object.entries 可以获取到一个数组，数组中会存放可枚举属性的键值对数组

const obj = {
  name: "sun",
  age: 20,
};
console.log(Object.entries(obj)); //[ [ "name", "sun" ], [ "age", 20 ] ]3，String Padding某些字符串我们需要对其进行前后的填充，来实现某种格式化效果，ES8中增加了 padStart 和 padEnd 方法，分别是对字符串的首尾进行填充的。

function foo(a, b) {
  console.log(a, b);
}
foo(10, 20);4，getOwnPropertyDescriptors获取属性描述符5，async和awaitES9

const obj = {
  name: "sun",
  age: 20,
};
const entriesObj = Object.entries(obj);
console.log(entriesObj); //[ [ "name", "sun" ], [ "age", 20 ] ]

const fromEntriesObj = Object.fromEntries(entriesObj);
console.log(fromEntriesObj); //{ name: "sun", age: 20 }实例：url参数转对象

const queryString = "name=sun&age=20&height=190";
const searchParams = new URLSearchParams(queryString);
console.log(searchParams); //URLSearchParams { "name" => "sun", "age" => "20", "height" => "190" }
for (let i of searchParams) {
  console.log(i); // ["name", "sun"]["age", "20"]["height", "190"];
}
const queryObj = Object.fromEntries(searchParams);
console.log(queryObj); //{ name: "sun", age: "20", height: "190" }3，trimStart、trimEnd去除一个字符串首尾的空格，我们可以通过trim方法，如果单独去除前面或者后面呢？ES10中给我们提供了trimStart和trimEnd

const obj = {
  name: "sun",
  age: 18,
  height: 1.88,
};
for (const key in obj) {
  console.log(key); //sun age height
}6，Dynamic Import：动态导入7，Promise.allSettled8，import metaES12