美文网首页web 前端读书
总结一下 ES6到ES11 出现的新东西吧

总结一下 ES6到ES11 出现的新东西吧

作者: 赵佳乐1016 | 来源:发表于2022-03-21 11:19 被阅读0次

    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

    相关文章

      网友评论

        本文标题:总结一下 ES6到ES11 出现的新东西吧

        本文链接:https://www.haomeiwen.com/subject/pwzidrtx.html