1、let

let 关键字 不可重复声明一个变量名称； let 的作用域为块级作用域； let 没有变量提升；let不影响作用域链效果；

let a =123; 

2、const

const 一般值为大写英文字母 块级作用域 一定要附初始值 常量值不可以修改；对于数组和对象元素修改不算常量不报错；

const b = 456;

3、解构赋值 以数组为例

const F4 = ['小沈阳', '刘能', '宋小宝', '赵四'];
let [xiao, liu, song, zhao] = F4;

4、 模板字符串 字符串可以换行

let str = `字符串${obj}`;

5、简化对象

let name = 123；
const obj = {
    name,
}

6、箭头函数

this是静态的 始终指向当前声明所在的作用域； 不能作为构造函数实例化对象，也就是不能和new一起使用； 不能使用arguments变量；

let fun = a => console.log(1234);

7、rest参数

获取函数实参；代替argument, rest参数必须放在参数最后；

            function rest(a, b, ...args) {
                console.log(args);
            }

8、扩展运算符

... 将数组转为逗号分隔的参数序列；数组合并 , 数组克隆(浅拷贝) 将伪数组转为真数组；

            const tfboys = [1, 2, 3];
            const kuaizi = [1, 2, 3];
            const 合并 = [...tfboys, ...kuaizi];
            const 克隆 = [...kuaizi];

9、symbol

值是唯一的，不能进行运算，定义对象属性不能使用 for in 但是可以使用Reflect.ownKeys来获取对象的所有键名；

            let s1 = new Symbol('test');
            let s2 = Symbol('test');
            let s3 = Symbol.for('fun');
            let s4 = Symbol.for('fun'); //注意这里 s1不等于s2  但是 s3等于s4；
            let game = {
                up: 123,
                down: 456
            };
            let methods = {
                up: Symbol('up'),
                down: Symbol('down')
            }
            game[methods.up] = function() {
                console.log('hello up')
            };
            game[methods.down] = function() {
                console.log('hello down')
            }; //当不确定对象中有哪些方法时；可以使用此方式安全添加;
            let youxi = { //给对象添加一个唯一的key
                name: 'youxi',
                [Symbol("fun1")]: function() {},
            }
            //获取symbol的字符串描述
            console.log(s2.description)//test

10、迭代器

iterator 是一种接口；(可用for of 遍历)循环时先创建一个指针对象指向数据结构起始位置 然后调用next方法指向数据结构的每一个成员，返回value和done；

const xiyou = ['孙悟空'，
                '猪八戒'
            ];
            let iterator = xiyou[Symbol.iterator]();

            console.log(iterator.next()); //{value:'孙悟空',done:false};

            for (let name of xiyou) {
                console.log(name); //孙悟空，猪八戒；
            }
            let arr = { //自定义 for of 循环
                child: [1, 2, 3],
                name: 'parent',
                [Symbol.iterator]() {
                    //索引变量
                    let index = 0;
                    let that = this;
                    return {
                        next: function() {
                            let result = {};
                            if (index < that.child.length) {
                                result = {
                                    value: this.child[index],
                                    done: false
                                };
                                index++;
                                return result;
                            } else {
                                result = {
                                    value: undefined,
                                    done: true
                                };
                                return result;
                            }

                        }
                    }
                }
            }
            for (let name of arr) {
                console.log(name); //1，2,3

            }

11、生成器

其实就是一个特殊的函数，用来进行异步编程的新解决方案；

            function * gen() {
                console.log('hello');
            }

            let iterator = gen();

            iterator.next(); //hello

            function * gen2() {
                console.log(1);
                yield '一个'; //理解为函数代码的分隔符；
                console.log(2);
                yield '两个';
                console.log(3);
                yield '三个';
            }
            for (let v of gen2()) { //此处结合迭代器一起理解
                console.log(v); //一个，两个，三个
            }

            function * gen3(arg) { //生成器传参
                console.log(arg); //A
                let one = yield 1; // B
                let two = yield 2; //C
            }

            let iterator3 = gen3('A');
            iterator3.next(); //传递A；
            iterator3.next('B');
            iterator3.next('C');

            //异步编程 避免出现回调地狱
            function one() {
                setTimeout(() => {
                    console.log(1);
                    iterator4.next();
                }, 1000);
            }

            function two() {
                setTimeout(() => {
                    console.log(2);
                    iterator4.next();
                }, 2000);
            }

            function three() {
                setTimeout(() => {
                    console.log(3);
                }, 3000);
            }

            function * gen4() {
                yield one();
                yield two();
                yield three();
            }
            let iterator4 = gen4();
            iterator4.next();

12、Promise

异步编程新解决方案 一个构造函数 封装异步操作获取成功或失败的结果 有三种状态 初始化 成功 失败；

            const p = new Promise(function(resolve, reject) {
                resolve(123); //成功
                reject(456); //失败
            })
            p.then(value => {
                console.log(value); //123
            });
            p.catch(err => {
                console.log(err); //456
            });


           //Promise.allSettled 批量执行promise 整体永远为成功状态；
           
           console.log(Promise.allSettled(['promise对象','promise对象']))

           Promise.all(['promise对象','promise对象'])  //全成功整体才会成功

13、set 集合

            let s = new Set();
            let s2 = new Set([1, 2, 3, 1, 2, 3]); //会自动去重；

            size //元素个数；
            add // 添加元素;
            delete //删除元素；
            has //判断是否存在这个元素
            clear //清空集合
            // 可使用 for of遍历set集合

            用处： 数组去重 求交集 求并集 求差集;

            let arr1 = [1, 2, 3], //交集
                arr2 = [2, 3, 4];
            let result = [...new Set(arr1)].filter(item => new Set(arr2).has(item));
            let union = [...new Set([...arr1, ...arr2])]; //并集
            let diff = [...new Set(arr1)].filter(item => !(new Set(arr2).has(item))); //差集

14、map

类似对象 键值对集合 但是建不限于字符串；

            let m = new Map();

            m.set(Key, value); //添加

            m.size //

            m.delete(key); //删除

            m.get(key); //取值

            m.clear(); //清空

            // 可使用 for of遍历set集合

15、class 类 对象模板

            class Phone {
                //构造方法 new 之后自动执行
                constructor(brand, price) {
                    this.brand = brand;
                    this.price = price;
                }

                //静态属性 只属于Phone自己 不属于实例对象
                static name = '手机';

                call() {
                    console.log('我是手机');
                }
            }
            //继承
            class child extends Phone {
                constructor(brand, price, size) {
                    super(brand, price); //相当于调用父类构造方法
                    this.size = size;
                }
                call() { //重写父类方法（不继承父类使用自己的同名函数）
                    console.log('我是新手机');
                }
            }

            //类的 get 和 set;
            class newPhone {
                get price() {
                    console.log('价格被读取了');
                }
                set price(newVal) {
                    console.log('价格被修改了');
                }
            }
            let huawei = new Phone('华为', 10000);
            let xiaomi = new newPhone();


            //公有属性&&私有属性
            class Person{
                //公有属性 类内类外都能拿到
                name
                //私有属性 只能在类内使用 外部拿不到
                #age
                
                constructor(name,age){
                    
                    this.name = name;
                    this.#age = age;
                    
                }
                
            }

16、Number的扩展

            Number.EPSILON //js表示的最小精度
            二进制 && 八进制
            Number.isFinite() //判断一个数值是否为有限数字
            Number.isNaN() //判断数值是否为nan
            Number.parseInt() Number.parseFloat() //放在了number下 取整数 包含小数
            Number.isInteger() //判断是否为整数
            Math.trunc() //将数字小数部分抹除
            Math.sign() //判断一个数到底为正数负数还是0   返回 1 0 -1

17、对象方法扩展

            Object.is() //判断两个对象是否相等
            Object.assign() //对象合并
            Object.setPrototypeOf() Object.getPrototypeOf() //设置&&获取原型对象
            Object.values() //返回一个给定对象的所有可枚举属性值的数组
            Object.entries() //返回一个给定对象自身可遍历属性[key,value]的数组
            Object.getOwnPropertyDescriptor() //返回指定对象所有的自身属性的描述对象
            Object.fromEntries([
                [name:小明],
                [age:18]
            ]) //二维数组转为对象 还可将map转为普通对象 和entries相反

18、es6模块化

防止命名冲突 代码复用 高维护性 export import

           export let a = 123 ;
            
            <script type = 'module'>
               import * as obj from 'url';
               console.log(obj);
            </script>
            
             export{ 
                //批量导出
             }
            export default{
                //默认导出
            }

19、includes

检测数组中是否包含某个元素 返回布尔值；

const arr = [1,2,3,4];      
arr.includes(1)//true;

20、 指数操作符 「**」

用来实现幂运算 功能和 math.pow结果相同

  2**10 //2的十次方 1024

21. async await

           // async函数返回结果为promise
              
              async function fun(){
                  return 123;
              }
              const result = fun();
              result.then(res=>{
                   console.log(res);
              })

 //await 必须写在 asyuc 函数中  右侧一般为promise对象  返回的peomise成功的值  如果失败了 使用 try catch 捕获
        //async await 结合使用可以让异步代码像同步一样执行       
               async function fun2(){
                   try{
                       let result1 =  await new Promise();
                       let result2 =  await new Promise(); //此处代码将同步执行
                       
                   }catch (e){
                       console.log(e);
                   }
               }

22、在es9 中为对象提供了像数组一样的 rest参数和扩展运算符

               function fun({color,...info}){
                   // info 为 {type:1,size:2}
               }
               fun({color:'red',type:1,size:2});
               
               
               const obj = {
                   q:1,
                   w:2,
               }
               // ...obj =>  'q:1,w:2'
                const obj1 = {
                    e:3
                } 
                const obj2 = {
                    r:4
                }
                
                const obj3 ={
                    ...obj1,...obj2
                } //可以做对象合并

23、正则部分

                命名捕获分组 ：
                   let str = `<a href='https://www.baidu.com'>百度</a>`;
                   // 提取url 和 test
                   const reg = /<a href='(?<url>.*)'>(?<text>.*)<\/a>/;
                   const result = reg.exec(str); //result.groups.url || result.groups.text；
                
                反向断言：
                   let str =`12345中国地大物博666啦啦啦`;
                   
                   const reg = /\d+(?=啦)/; //正向断言 根据后面内容判断
                   
                   const result = reg.exec(str); //666
                 
                   const reg = /(?<=博)\d+/; //反向断言
                   
                   
                 dotAll模式：
                   // dot . 元字符 除换行符以外的任意单个字符；
                   //dotAll 可以匹配任意字符，包括换行符；
                   let str = `
                       <ul>
                          <li>
                             <a>百度</a>
                             <p>搜狗</p>
                          </li>
                       </ul>
                   `
                     const reg = /<li>.*?<a>(.*?)<\/a>.*?<p>(.*?)<\/p>/gs;
                     let result;
                     while(result = reg.exec(str)){
                         console.log(result)
                     }

24、 字符串方法扩展

trimStart trimEnd 清除左侧右侧空白
matchAll(正则)； 根据正则返回数据

25、数组方法扩展

flat() 将多维数组转化低位数组 参数为深度是一个数字
flatMap() 将map和flat结合 既能遍历又降维

26、可选链操作符 ?.

obj?.name //当obj存在的时候去获取name

27、动态import

                btn.onclick=function(){
                    import('./1.js').then(module=>{
                        //可调用1.js中的方法
                    })
                }               

28、bigint 类型 大整形 用于大数值运算 不能直接和普通number进行运算

              let n = 521n; 
              
              let n1 = 123 ;
              
              console.log(BigInt(n1))//123n
              

29、绝对全局对象 globalThis

我们在写代码时想对全局对象进行操作，可以忽略任何限制直接使用globalThis