• ES6新特性

    目录

    let 声明变量

    const声明常量

     解构赋值

    模板字符串

    对象的简化写法

    箭头函数

    函数参数的默认值设置

    rest参数

    扩展运算符

    symbol

    创建使用

    Symbol.hasInstance

    Symbol.isConcatSpreadable

    迭代器 iterator

    工作原理

    自定义遍历数据

    生成器 generator

    创建和使用

    参数的传递

    案例

    promise

    基本使用

    then方法

    catch

    set

    map

    class

    数值扩展

    对象扩展方法

    模块化

    ES6模块化语法

    es7新特性 

    async await

    es8对象扩展方法

    es9扩展运算符&&rest参数对对象的操作

    es10对象扩展方法fromEntries

    es10字符串扩展方法

    es10数组扩展方法

    description获取Symbol字符串

    Promise.公有方法

    可选链操作符

       BigInt大整数

    globalThis绝对全局对象

    let 声明变量

    不能重复声明，块级作用域（if else for while） ，不存在变量提升，不影响作用域链

    1.   //不能重复声明，
    2.     // let start = 1
    3.     // let start = 2
    4.  
    5.     // 块级作用域
    6.     // {
    7.     //     let age = 18
    8.     // }
    9.     // console.log(age);
    10.  
    11.     // 不存在变量提升
    12.     // console.log(a);
    13.     // let a = 1
    14.  
    15.     // 不影响作用域链
    16.     // {
    17.     //     let age = 18
    18.     //     function fn() {
    19.     //         console.log(age);
    20.     //     }
    21.     //     fn()
    22.     // }

    const声明常量

    必须有初始值，常量的值不能修改，块级作用域，操作空间地址不算重新赋值

    1.  
    2.     // 必须有初始值
    3.     // const age = 18
    4.  
    5.     // 常量的值不能修改
    6.     // age = 8
    7.  
    8.     // 块级作用域
    9.     // {
    10.     //     const age = 18
    11.     // }
    12.     // console.log(age);
    13.  
    14.     // 操作空间地址不算重新赋值
    15.     // const arr = [1, 2, 3]
    16.     // arr.push(4)

     解构赋值

    允许按照一定格式从数组和对象中提取值，对变量进行赋值

    1.     // 数组的解构
    2.     // let f4 = ['小沈阳', '刘能', '赵四', '宋小宝']
    3.     // let [x, l, z, s] = f4
    4.     // console.log(x, l, z, s);
    5.  
    6.     // 对象解构
    7.     // let zhao = {
    8.     //     name: '赵本山',
    9.     //     age: '60',
    10.     //     xiaopin: function () {
    11.     //         console.log('我可以演小品');
    12.     //     }
    13.     // }
    14.     // let { xiaopin } = zhao
    15.     // xiaopin()

    模板字符串

    可以识别换行符，拼接变量

    1.     let age = 18
    2.     let str = `我今年${age}了`
    3.     console.log(str);

    对象的简化写法

    kv 一致省略v 函数可以不写function

    1.     let age = 18
    2.     let name = 'jyc'
    3.     let obj = {
    4.         name,
    5.         age,
    6.         fn() {
    7.             console.log(obj.age);
    8.         }
    9.     }
    10.     obj.fn()

    箭头函数

    •     没有自己的this，this指向函数声明时所在作用域下this的值
    •     不能作为构造函数
    •     不能使用arguments
    •     形参就一个值可以省略小括号，执行语句就一个值可以省略花括号和return
    1.     // var age = 18
    2.     // let obj = {
    3.     //     age: 22
    4.     // }
    5.     // function getAge() {
    6.     //     console.log(this.age);
    7.     // }
    8.     // let getAge1 = () => {
    9.     //     console.log(this.age);
    10.     // }
    11.     // getAge()
    12.     // getAge1()
    13.     // getAge.call(obj)
    14.     // getAge1.call(obj)
    15.  
    16.  
    17.     // let fn = a => a + a
    18.     // console.log(fn(1));

    函数参数的默认值设置

    允许函数参数赋初始值

    1.    function add(a, b, c = 10) {
    2.         return a + b + c
    3.     }
    4.     // console.log(add(1, 2));
    5.  
    6.  
    7.     //与解构赋值结合
    8.     function reqire({ host, userName, password, port = 8080 }) {
    9.         console.log(host);
    10.         console.log(userName);
    11.         console.log(password);
    12.         console.log(port);
    13.     }
    14.     reqire({
    15.         host: ' 172.168.0.0.1',
    16.         userName: 'root',
    17.         password: 'root',
    18.  
    19.     })

    rest参数

    用于获取函数实参代替arguments

    1.  
    2.     // arguments es5伪数组
    3.     // function data() {
    4.     //     console.log(arguments);
    5.     // }
    6.  
    7.  
    8.     // rest参数必须要放到最后得到数组
    9.     function data(a, b, ...args) {
    10.         console.log(args);
    11.     }
    12.     data('小白', '小明', '小李', 1, 2, 3)//(4) ['小李', 1, 2, 3]

    扩展运算符

    合并 浅克隆 伪数组转数组

    1.     //合并
    2.     let a = [1, 2, 3]
    3.     let b = [4, 5, 6]
    4.     let arr = [...a, ...b]
    5.     console.log(arr);
    6.  
    7.     //浅克隆
    8.     let arr2 = [...arr]
    9.     console.log(arr2);
    10.  
    11.     // 伪数组转数组
    12.     function fn() {
    13.         console.log([...arguments]);
    14.     }
    15.     fn('小白', '小明', '小李')

    symbol

    es6引入了一种新的原始值类型symbol，表示独一无二的值，

    symbol是唯一的，用来解决命名冲突的问题，不能参与运算，不能使用for in 使用refice，ownkeys

    主要用于给对象添加属性和方法

    创建使用

    1.     let game = {
    2.         name: '俄罗斯方块',
    3.         up: () => { },
    4.         down: () => { }
    5.     }
    6.     let methods = {
    7.         up: Symbol(),
    8.         down: Symbol(),
    9.     }
    10.     game[methods.up] = function () {
    11.         console.log('我可以改变形状');
    12.     }
    13.     game[methods.down] = function () {
    14.         console.log('我可以下降');
    15.     }
    16.     console.log(game);

    Symbol.hasInstance

    当其对象用 instanceof，判断是否为该对象的实例时会调用这个方法

    1.     class Person {
    2.         static [Symbol.hasInstance]() {
    3.             console.log('我被用来检测类型');
    4.             return true
    5.         }
    6.     }
    7.     let o = {}
    8.     console.log(o instanceof Person); //true

    Symbol.isConcatSpreadable

    等于的是一个布尔值，表示Array.prototype.content（）时是否可以展开

    1.     let arr1 = [1, 2, 3]
    2.     let arr2 = [4, 5, 6]
    3.     arr1[Symbol.isConcatSpreadable] = false
    4.     let arr = arr1.concat(arr2)
    5.     console.log(arr);//(4) [Array(3), 4, 5, 6]

    迭代器 iterator

    迭代器是一种接口 ，为各种不同的数据结构，提供统一的访问机制，任何数据结构只要部署了iterator接口就可以完成遍历操作

    es6创造了一种新的遍历命令 for...of..  iterator接口主要提供 for...of..消费

    具备iterator接口的数据 array ，arguments，set map string typeArray NodeList

    工作原理

    • 创建一个指针对象，指向当前数据结构的起始位置，
    • 第一次调用对象的.next方法，指针自动指向数据结构的第一个成员
    • 接下来不断调用.next方法，指针一直往后移动，直到指向最后一个成员
    • 每次调用next方法，返回一个包含value和done属性的对象
    1.     let arr = [10, 20, 30]
    2.  
    3.     let iterator = arr[Symbol.iterator]()//一个函数 得到一个对象 
    4.     console.log(iterator);//得到一个对象 ，有一个next方法（指针）
    5.     console.log(iterator.next());//包含一个value 和done属性的对象
    6.     console.log(iterator.next())
    7.     console.log(iterator.next())
    8.     console.log(iterator.next())// {value: undefined, done: true}done表示完成状态

    自定义遍历数据

    1.     const banji = {
    2.         name: '终极一班',
    3.         stus: [
    4.             'zs',
    5.             'ls',
    6.             'ww',
    7.             'xm'
    8.         ],
    9.         [Symbol.iterator]() {
    10.             let index = 0
    11.             let self = this
    12.             return {
    13.                 next: function () {
    14.                     if (index < self.stus.length) {
    15.                         const result = { value: self.stus[index], done: false }
    16.                         index++
    17.                         return result
    18.                     } else {
    19.                         return { value: undefined, done: true }
    20.                     }
    21.                 }
    22.             }
    23.         }
    24.     }
    25.     for (const val of banji) {
    26.         console.log(val);
    27.     }

    生成器 generator

    生成器其实是一个特殊的函数 可以解决异步编程

    可以使用 yield 语句 函数代码的分割符

    创建和使用

    1.     function* gen() {
    2.         console.log(11);
    3.         yield '一只没有耳朵'
    4.         console.log(22);
    5.         yield '一只没有尾巴'
    6.         console.log(33);
    7.         yield '真奇怪'
    8.         console.log(44);
    9.     }
    10.     let iterator = gen()
    11.     console.log(iterator);// 返回迭代器对象
    12.     iterator.next()//控制生成器函数执行
    13.     iterator.next()
    14.     iterator.next()
    15.     iterator.next()

    参数的传递

    next函数传递的参数当做上一次 yield 的语句的返回结果

    1.     function* gen(args) {
    2.         console.log(args);
    3.         let one = yield 11
    4.         console.log(one);
    5.         let two = yield 22
    6.         console.log(two);
    7.         let three = yield 33
    8.         console.log(three);
    9.     }
    10.     let iterator = gen('aa')
    11.  
    12.     iterator.next('bb')
    13.     iterator.next('cc')
    14.     iterator.next('dd')
    15.     iterator.next()

    案例

    模拟获取 用户数据 订单数据 商品数据

    1.     function getUsers() {
    2.         setTimeout(() => {
    3.             let data = '用户数据'
    4.             //第二次调用next的 将数据传入 当做第一个yield的语句的返回结果
    5.             iterator.next(data)
    6.         }, 1000);
    7.     }
    8.     function getOrders() {
    9.         setTimeout(() => {
    10.             let data = '订单数据'
    11.             iterator.next(data)
    12.         }, 1000);
    13.     }
    14.     function getGoods() {
    15.         setTimeout(() => {
    16.             let data = '商品数据'
    17.             iterator.next(data)
    18.         }, 1000);
    19.     }
    20.     function* gen() {
    21.         let user = yield getUsers()
    22.         console.log(user);
    23.         let Orders = yield getOrders()
    24.         console.log(Orders);
    25.         let Goods = yield getGoods()
    26.         console.log(Goods);
    27.     }
    28.     let iterator = gen()
    29.     iterator.next()

    promise

    promise是一个构造函数用来封装异步操作，并可以获取成功或者失败的结果

    promise构造函数 promise（excutor）

    promise.prototype.then    promise.prototype.catach

    基本使用

    1.  
    2.     let p = new Promise(function (resolve, reject) {
    3.         setTimeout(() => {
    4.             // let data = '用户数据'
    5.             // resolve(data)
    6.             reject(new Error('失败'))
    7.         }, 1000);
    8.     })
    9.     p.then((res) => {
    10.         console.log(res);
    11.     }).catch((err) => {
    12.         console.log(err);
    13.     })
    14.

    then方法

    •  调用then方法返回的是promise 状态由回调函数执行结果决定，
    •     如果回调函数是非promise类型的属性，转态是成功，返回值是为成功值
    •     是一个promise promise状态决定了.then的状态
    •     抛出错误为失败的promise
    1.  let p = new Promise(function (resolve, reject) {
    2.         setTimeout(() => {
    3.             let data = '用户数据'
    4.             resolve(data)
    5.             // reject(new Error('失败'))
    6.         }, 1000);
    7.     })
    8.     let result = p.then((res) => {
    9.         console.log(res);
    10.         return new Promise((resolve, reject) => {
    11.             resolve('ok')
    12.         })
    13.     }, err => {
    14.         console.log(err);
    15.     })
    16.     //调用then方法返回的是promise 状态由回调函数执行结果决定，
    17.     // 如果回调函数是非promise类型的属性，转态是成功，返回值是为成功值
    18.     // 是一个promise promise状态决定了.then的状态
    19.     //抛出错误为失败的promise
    20.     console.log(result);
    21.     result.then((res) => {
    22.         console.log(res);
    23.     })
    24.     // 链式调用
    25.     p.then(res => {
    26.  
    27.     }).then(res => { 
    28.  
    29.     })

    catch

    捕捉失败的promise

    1.     let p = new Promise(function (resolve, reject) {
    2.         setTimeout(() => {
    3.  
    4.             reject(new Error('失败'))
    5.         }, 1000);
    6.     })
    7.     p.catch(err => {
    8.         console.log(err);
    9.     })

    set

    set数据结构，他类似于数组，但成员的值是唯一的，集合实现了iterator接口，所以可以使用扩展运算符和for..of遍历结合的属性和方法

    • size 返回集合元素的个数
    • add 增加一个元素返回当前集合
    • delete 删除元素，返回布尔值
    • has 检测集合中包含某个元素，返回布尔值、

    • clear 清空集合

    1.    let s = new Set([1, '1'])
    2.     // 元素的个数
    3.     console.log(s.size)
    4.     // 添加元素
    5.     s.add(2)
    6.     console.log(s);
    7.     //删除元素
    8.     s.delete(2)
    9.     console.log(s);
    10.     // 检测
    11.     console.log(s.has(1));
    12.     // 清空
    13.     // s.clear()
    14.     // console.log(s);
    15.  
    16.     for (const val of s) {
    17.         console.log(val);
    18.     }

    应用

    1. let arr = [1, 2, 3, 4, 5, 4, 3, 2, 1]
    2.     // 去重
    3.     // let result = [...new Set(arr)]
    4.     // console.log(result);
    5.     //交集
    6.     let arr2 = [4, 5, 6]
    7.     // let result = [...new Set(arr)].filter(item => new Set(arr2).has(item))
    8.     // console.log(result);
    9.     // 并集
    10.     // let result = [...new Set([...arr, ...arr2])]
    11.     // console.log(result);
    12.     //差集
    13.     let result = [...new Set(arr)].filter(item => !(new Set(arr2).has(item)))
    14.     console.log(result);

    map

    他类似于对象，也是键值对的集合，但是键的范围不限于字符串，各种类型的值（包括对偶）都可以作为键 也实现了iterator接口 可以使用for..of 和扩展运算符

    • size返回map元素个数
    • set 增加一个新元素 返回放前map
    • ger 返回健名对象的键值，
    • has 检测集合中包含某个元素，返回布尔值、
    • clear 清空集合
    1.  
    2.  
    3.     let map = new Map()
    4.     // 添加元素
    5.     map.set('name', 'zs')
    6.     map.set('change', function () {
    7.         console.log(111);
    8.     })
    9.     let key = {
    10.         love: '爱好'
    11.     }
    12.     map.set(key, ['唱', '跳', 'rap'])
    13.     console.log(map);
    14.     // 个数
    15.     console.log(map.size);
    16.     // 删除
    17.     // map.delete('name')
    18.     // console.log(map);
    19.     // 获取
    20.     // console.log(map.get('change')());
    21.     // 清空
    22.     // map.clear()
    23.     // console.log(map);
    24.     //遍历
    25.     for (const v of map) {
    26.         console.log(v);
    27.     }

    class

    • class声明类
    • constructor定义构造函数初始化
    • exends继承父类
    • super调用父级构造方法
    • static定义静态方法和属性

    es5

    1.     function Phone(brand, price) {
    2.         // 实例属性
    3.         this.brand = brand
    4.         this.price = price
    5.     }
    6.     // 静态属性方法
    7.     Phone.name = '手机'
    8.     Phone.change = function () {
    9.         console.log('我可以改变事件');
    10.     }
    11.     //实例方法
    12.     Phone.prototype.call = function () {
    13.         console.log('我可以打电话');
    14.     }
    15.     //子类属性继承（改变this指向）
    16.     function SmartPhone(brand, price, color, size) {
    17.         Phone.call(this, brand, price)
    18.         this.color = color
    19.         this.size = size
    20.     }
    21.     // 修改子类原型继承父类方法
    22.     SmartPhone.prototype = new Phone
    23.     // constructor 指回子类
    24.     SmartPhone.prototype.constructor = SmartPhone
    25.     SmartPhone.prototype.playGame = function () {
    26.         console.log('我可以打游戏');
    27.     }
    28.     let huawei = new SmartPhone('华为', 2999, '白色', 5)
    29.     huawei.call()
    30.     console.log(huawei);

    es6

    1.  class Phone1 {
    2.         constructor(brand, price) {
    3.             // 实例属性
    4.             this.brand = brand
    5.             this.price = price
    6.         }
    7.         // //实例方法
    8.         call() {
    9.             console.log('我可以打电话');
    10.         }
    11.         // 静态属性属性方法
    12.         static name = '手机'
    13.         static change() {
    14.             console.log('我可以改变事件');
    15.         }
    16.     }
    17.     //extends 继承
    18.     class SmartPhone1 extends Phone1 {
    19.         constructor(brand, price, color, size) {
    20.             //调用父类的构造器完成属性继承
    21.             super(brand, price)
    22.             this.color = color
    23.             this.size = size
    24.         }
    25.         playGame() {
    26.             console.log('我可以打游戏');
    27.         }
    28.         //重写父类方法
    29.         call() {
    30.             console.log('我可以视频通话');
    31.         }
    32.         // 获取劫持
    33.         get say() {
    34.             console.log('我被读取了');
    35.             return 11
    36.         }
    37.         //设置劫持
    38.         set say(newVal) {
    39.             console.log('我被修改了' + newVal);
    40.         }
    41.     }
    42.     let huawei = new SmartPhone1('华为', 2999, '黑色', 5)
    43.     huawei.call()
    44.     console.log(huawei);
    45.     huawei.say = 99
    46.     console.log(huawei.say);

    数值扩展

    •     Number.EPSILON 最小精度
    •     二进制 八进制
    •     Number.isFinite 检测一个值是否为有限小数
    •     Number.isNaN 是否为NaN
    •     Number.parseInt  parseFloat 字符串转整数 
    •     Number.isInteger 判断是否为整数
    •     Math.trunc 将小数部分抹除掉
    •     Math.sign 判读一个数字为正数负数还是0
    1.     // Number.EPSILON 最小精度
    2.     function equal(a, b) {
    3.         if (Math.abs(a - b) < Number.EPSILON) {
    4.             return true
    5.         } else {
    6.             return false
    7.         }
    8.         console.log(equal(0.1 + 0.2, 0.3));
    9.     }
    10.     // 二进制 八进制
    11.     let b = 0b1010
    12.     console.log(b);
    13.     // Number.isFinite 检测一个值是否为有限小数
    14.     console.log(Number.isFinite(100 / 0));
    15.     // Number.isNaN 是否为NaN
    16.     console.log(Number.isNaN('99'));
    17.     // Number.parseInt 字符串转整数
    18.     console.log(Number.parseInt('255efqxx'));
    19.     console.log(Number.parseFloat('3.14efwefw'));
    20.     // Number.isInteger 判断是否为整数
    21.     console.log(Number.isInteger(44.4));
    22.     // Math.trunc 将小数部分抹除掉
    23.     console.log(Math.trunc(23.14));
    24.     // Math.sign 判读一个数字为正数负数还是0
    25.     console.log(Math.sign(-99));
    26.

    对象扩展方法

    •     // Object.is 判断两个值是否完全相等
    • // Object.assign 对象的合并
    •    // Object.setPrototypeOf 设置原型对象
    •     // Object.getPrototypeOf  获取原型对象

    1.     // Object.is 判断两个值是否完全相等
    2.     console.log(Object.is(NaN, NaN));
    3.     console.log(Object.is(120, 121));
    4.     // Object.assign 对象的合并
    5.     let statu = {
    6.         name: 'zs',
    7.         age: 18
    8.     }
    9.     let statu2 = {
    10.         name: 'ls',
    11.         age: 22,
    12.         sex: '男'
    13.     }
    14.     let res = Object.assign(statu, statu2)
    15.     console.log(res);
    16.     // Object.setPrototypeOf 设置原型对象
    17.     // Object.getPrototypeOf  获取原型对象
    18.     let arr = [11]
    19.     let obj = {
    20.         a: 10
    21.     }
    22.     console.log(Object.setPrototypeOf(obj, arr));
    23.     console.log(Object.getPrototypeOf(obj));

    模块化

    模块化是一个大的程序文件，拆分成许多个小的文件 然后把小文件合起来

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

    • CommonJS----》nodejs
    • Amd---》requireJS
    • cmd--》seaJS

    ES6模块化语法

    export 用于规定模块的对外接口

    import 用于输入其他模块提供的功能

    暴露

    export 分别暴露

    export{} 统一暴露

    export defult{} 默认暴露

     导入

    通用导入方式

    import * as from ‘xxx’

    解构赋值

    import{a,b}from 'xxx' 如果是默认暴露import {defult as data}from‘xxx’（因为默认暴露的是一个对象 使用别名的形式）

    针对默认暴露的简便写法

    import data from‘xxx’

    es7新特性 

    includes 数组方法 是否含有某一项 返回布尔值

    **运算等同于 Math.pow

    1.     let arr = [1, 2, 3]
    2.     let res = arr.includes(4)
    3.     console.log(res);
    4.     //**
    5.     console.log(2 ** 10);

    async await

    解决异步编程

    async

    • async返回一个promise对象 
    • promis对象的结果有async函数执行的返回值决定
    • （返回的不是一个promise对象，返回的成功的promise，抛出异常返回失败的promise）（如果返回的是一个promise 由这个promise的状态决定）
    1.     async function fn() {
    2.         // return 1
    3.         // new Error('失败')
    4.         return new Promise((reslove, reject) => {
    5.             // return reslove(11)
    6.             reject('失败')
    7.         })
    8.     }
    9.     let res = fn()
    10.     res.then((result) => {
    11.         console.log(result);
    12.     }).catch((err) => {
    13.         console.warn(err);
    14.     });

    await

    • await必须写在async函数里
    • await右边表达式一般为promise
    • await返回的是promise成功的值
    • await的promise失败了，需要通过try catch捕获
    1.     let p = new Promise((reslove, reject) => {
    2.         return reslove(11)
    3.         // reject('失败')
    4.     })
    5.     async function fn() {
    6.         try {
    7.             let result = await p
    8.             console.log(result);
    9.         } catch (e) {
    10.             console.warn(e);
    11.         }
    12.     }
    13.     fn()

    es8对象扩展方法

    Object.keys(obj) 获取对象的所有键

    (Object.values(obj) 获取对象的所有值

    Object.entries(obj) 方法返回一个给定对象自身可枚举属性的键值对数组。快速创建map结构

    Object.getOwnPropertyDescriptors(obj1)获取对象的描述对象（是否可写，枚举，删除）

    1.     let obj = {
    2.         name: 'zs',
    3.         age: 18
    4.     }
    5.     //args：原型对象 描述对象
    6.     let obj1 = Object.create(null, {
    7.         name: {
    8.             value: 'zs',
    9.             writable: true,
    10.             configurable: true,
    11.             enumerable: true
    12.         }
    13.     })
    14.  
    15.     //获取对象的所有键
    16.     console.log(Object.keys(obj));
    17.     // 获取对象的所有值
    18.     console.log(Object.values(obj));
    19.     // 方法返回一个给定对象自身可枚举属性的键值对数组。快速创建map结构
    20.     console.log(new Map(Object.entries(obj)));
    21.     //获取对象的描述对象（是否可写，枚举，删除）
    22.     console.log(Object.getOwnPropertyDescriptors(obj1));

    es9扩展运算符&&rest参数对对象的操作

    1.     function fn({ age, sex, ...user }) {
    2.         console.log(age);
    3.         console.log(sex);
    4.         console.log(user);
    5.     }
    6.     fn({
    7.         age: 18,
    8.         sex: '男',
    9.         name: 'zs',
    10.         job: '前端'
    11.     })
    12.     let age = { age: 18 }
    13.     let sex = { sex: '男', }
    14.     let name = { name: 'zs' }
    15.     let job = { job: '前端' }
    16.     let user = { ...age, ...sex, ...job, ...name }
    17.     console.log(user);

    es10对象扩展方法fromEntries

    fromEntries：将二维数组，map转为对象

     Object.entries对象转为二维数组

    1.  
    2.     const result = Object.fromEntries([
    3.         ['name', 'lise'],
    4.         ['job', '前端']
    5.     ])
    6.     const map = new Map()
    7.     map.set('name', 'zs')
    8.     const res = Object.fromEntries(map)
    9.     console.log(result);
    10.     console.log(res);
    11.     let data = Object.entries({
    12.         name: 'ww'
    13.     })
    14.     console.log(data);

    es10字符串扩展方法

    trimStart左侧空格

    trimEnd右侧空格

    1.     let str = ' love  '
    2.     console.log(str);
    3.     console.log(str.trimStart());
    4.     console.log(str.trimEnd());

    es10数组扩展方法

    flat数组将维

    flatMap数组循环将维

    1.     let arr = [1, 2, 3, [4, 5, 6]]
    2.     let res = arr.flat()
    3.     console.log(res);
    4.     let result = res.flatMap(item => [item * 10])
    5.     console.log(result);

    description获取Symbol字符串

    1.  
    2.     let w = Symbol('ls')
    3.     console.log(w.description);

    Promise.公有方法

    Promise.allSettled promise 的状态始终是成功  保存着每一个promise的状态

    Promise.all 有一个失败promise的状态就为失败

    1.     let p1 = new Promise((resolve, reject) => {
    2.         setTimeout(() => {
    3.             resolve('成功')
    4.         }, 1000);
    5.     })
    6.     let p2 = new Promise((resolve, reject) => {
    7.         setTimeout(() => {
    8.             reject('失败')
    9.         }, 1000);
    10.     })
    11.     let res = Promise.allSettled([p1, p2])
    12.     let result = Promise.all([p1, p2])
    13.     console.log(res);
    14.     console.log(result);

    可选链操作符

    1.     function fn(args) {
    2.         const res = args?.obj?.a
    3.         console.log(res);
    4.     }
    5.     fn({
    6.         b: 10,
    7.         // obj: {
    8.         //     a: 1
    9.         // }
    10.     })

       BigInt大整数

    1.     let max = Number.MAX_SAFE_INTEGER
    2.     console.log(max);
    3.     console.log(max + 1);
    4.     console.log(max + 2);
    5.     console.log(max + 8);
    6.     console.log(BigInt(max) + BigInt(10));

    globalThis绝对全局对象

  • 相关阅读:
    LNMP搭建
    面试题整理 2
    Zookeeper
    用LOL英雄图片点缀你的博客
    NPW（监控片的）的要点精讲
    【数据结构】C++实现二叉搜索树
    ES 日期格式处理
    通过Nginx配置域名映射到本地项目
    猿创征文 | 用PolarDB-X开发应用
    20uec++多人游戏【小球与玩家互动】
  • 原文地址：https://blog.csdn.net/qq_63358859/article/details/125977961