ES6常用总结

const

使用const声明的常量必须赋值、赋值后不可再更改
const定义的常量如果是引用类型 可以改变对象内属性

es6中class类

基本使用：
    class Person {
        constructor(name, age) {
            this.name = name;
            this.age = age;
        }

        showName() {
            console.log(this.name)
        }
    }
    var p = new Person('kobe', 39);

继承:
    class Chinese extends Person {
        子类继承父类，若有自己独有的属性和方法，应该重写constructor构造器，
        构造器中应传入父类公共的属性，将 super()函数写入constructor中并位于第一位，
        并将父类属性传入super()函数中，此时 super() 就相当于父类中构造器constructor
     constructor(name, age, IdNumber) {
        super(name, age);
        this.IdNumber = IdNumber;
     }
     showName() {//父类方法重写
            console.log(this.name,this.age,this.grade);
     }
    }
	var p = new Chinese('ss', 12, 45);
	p.showName();
	
可以使用super直接调用父类的方法  super.say();
                class son extends Father {

                  say() {
                    console.log(super.say() + '儿子')
                  }
                }

三点运算符 …value

函数中使用

function fn(...value) {  value是一个真数组 将参数归为一个数组中
    console.log(value);
    for (var i = 0; i < value.length; i++) {
    console.log(value[i]);
  }
}

fn(1, 30); // 结果：[1, 30]

数组中使用

var arr1=[1,6];
var arr2 = [2,3,4,5];

让arr2插入到arr1中

arr1 = [1,...arr2,6];
console.log(arr1);// 1 2 3 4 5 6

var arr=[1,2,3];
console.log(...item) 1   2    3

导入、导出

export const num = 'xxx'
export function...
export default ....
import {} from 'xxx'
import xxx from 'xxx'

形参默认值

function Point(x = 0, y = 0) {
    this.x = x;
    this.y = y;
}

var p1 = new Point(10, 20);
console.log(p1); // Point {x: 10, y: 20}

var p2 = new Point();
console.log(p2);// Point {x: 0, y: 0}

字符串扩展

var str = 'ab';
console.log(str.includes('b'));//true
console.log(str.startsWith('a'));//true
console.log(str.endsWith('b'));//true
console.log(str.repeat(3)); //ababab

数值扩展

------、数值扩展

Number.isFinite() -- 是否是有限数
console.log(Number.isFinite(123));//true
console.log(Number.isFinite(Infinity));//false

Number.isNaN()--是否是非数字
console.log(Number.isNaN(123));//false
console.log(Number.isNaN(NaN));//true

Number.isInteger()--是否是整数
console.log(Number.isInteger(123));//true
console.log(Number.isInteger(123.56));//false

Number.parseInt()--将字符串转换为整数
console.log(Number.parseInt('123.abs'));//123

Math.trunc()--直接去除小数部分
console.log(Math.trunc(343.56));//343

数组扩展

Array.from()//将伪数组转为真数组
Array.of(v1,v2,v3)//将一系列数值转为数组
[].find(function( item ,index ){ return item > 4; });//找出第一个满足条件返回true的数值
[].findIndex(function( item ,index ){ return item > 4; });//找出第一个满足条件返回true的数值的下标

对象扩展

console.log(0 == -0 );//true
console.log(NaN == NaN );//false NaN与任何数都不相等
Object.is(s1,s2);//判断两个对象是否相等 以字符串为标准判断的
	Object.is( 0 , -0) ;//false
	Object.is( NaN , NaN);//true
Object.assign(目标对象, 源对象, 源对象,源对象...);//将源对象的属性复制到目标对象上

直接操作__proto__属性
    var obj1 = {};
    var obj2 = {grade: 5};
    obj1.__proto__ = obj2;
    console.log(obj1.grade);//5

Promise

基本使用

Promise是ES6提供的一种处理异步编程的对象 目的是以一种优雅的方式解决回调地狱
有了promise对象，可以将异步操作以同步的流程表达出来，
避免层层嵌套的回调地狱 Promise是一个构造函数 通过实例化方式使用
    示例：
    const p = new Promise((resolve,reject)=>{
     setTimeOut(()=>{
         if..
           resolve('成功');
         else..
            reject('失败');
     },3000)
    });
    p.then((data)=>{},err=>{})
(promise会立即执行 应该将其放在方法中)

多层嵌套

new Promise((resolve, reject) => {
  resolve('aaa');
  // reject('失败了')
}).then((data) => {
  console.log(data + '第一层处理结果')
  return new Promise((resolve, reject) => {
    resolve(data + '第二层请求');
  })
}).then((data) => {
  console.log(data)

  return new Promise((resolve, reject) => {
    resolve(data + '第三层');
  })
}).then((data) => {
  console.log(data)
}).catch(() => {
  console.log('错误回调')
})

同时处理多次异步请求

Promise.all([
  new Promise((resolve, reject) => {
    setTimeout(() => {
      resolve('11')
    }, 1000)
  }),
  new Promise((resolve) => {
    setTimeout(() => {
      resolve('22')
    }, 2000)
  })
]).then((results) => {
  console.log(results)
})

set、map

https://blog.csdn.net/zm17671443092/article/details/108586989