es6常用api总结(上)

• 变量

  • ES6新增let变量，用来声明变量，用法类似于var，只是声明的变量只在let命令所在的代码块内有效

  • 例1：

  • for(var j = 0; j < 3 j++) {} console.log(j); // 3
    for(let i = 0; i < 3 i++) {} console.log(i); // ReferenceError: i is not defined
    

  • 例2：

  • var a = [];
    for (var i = 0; i < 10; i++) {
      a[i] = function () {
        console.log(i);
      };
    }
    a[6](); // 10
    

  • var a = [];
    for (let i = 0; i < 10; i++) {
      a[i] = function () {
        console.log(i);
      };
    }
    a[6](); // 6
    

  • const也是用于声明变量，表明声明一个常量，一旦声明后，值不能被修改，也就意味着一旦声明就必须进行初始化

  • 例：

  • const str = 123;
    str = 456; // TypeError: Assignment to constant variable.
    

  • 以上两种声明方式不存在变量提升，也就是只能在声明之后使用，一旦在声明之前使用则会报错，var则存在声明提升

  • 例：

  • console.log(a); // undefined;
    var a = 1;
    console.log(b); // 报错
    let b = 1;
    

  • 在一个块级作用域内，同一个变量不能被重复声明

  • let a = 1;
    let a = 2; // 报错
    

  • 块级作用域

    • 类似于function，在块级作用域外不能访问作用域内的变量

    • 例：

    • {
          let a = 1;
      }
      

• 变量解构与赋值

  • 准确来说是模式匹配

    • 数组的解构

    • 例1:

    • let [a, b, c] = [1, 2, 3];
      // a 1
      // b 2
      // c 3
      

    • 以上是按照顺序进行匹配赋值

    • 例2：

    • let [a, , b] = [1, 2];
      // a 1
      // b undefined
      

    • 例3：设置默认值

    • let [a = 3, , b = 4] = [1, 2];
      // a 1
      // b 4
      

    • 对象的解构

    • 例1：

    • let {a, b} = {a: 1, b: 2}
      // a 1
      // b 2
      

    • 例2：

    • let {c, b} = {a: 1, b: 2}
      // c undefined
      // b 2
      

    • 例3：设置默认值

    • let {a = 1, b = 2} = {a: 3}
      // a 3
      // b 2
      

    • 解构嵌套

    • 例：

    • let obj = {
        p: [
          'Hello',
          { y: 'World' }
        ]
      };
      
      let { p: [x, { y }] } = obj;
      x // "Hello"
      y // "World"
      
      

• 字符串扩展

  • 模板字符串

    • 在es5及之前，想要将几个字符串组合为一个，并且加上参数，必须通过+来拼接

    • 例：

    • let h = '标题';
      let p = '段落';
      let result = '<div>'
      + '<h1>' + h + '<h1>'
      + '<p>' + p + '</p>'
      + '</div>';
      

    • 在es6中新增反引号来标识的模板字符串来简化上面这一过程

    • 例：

    • let h = '标题';
      let p = '段落';
      let result = `<div>
          <h1>${h}</h1>
          <p>${p}</p>
      div`;
      

    • 上面的${}中可以写任何表达式

    • 例：

    • let h = '标题';
      let p = '段落';
      let result = `<div>
          <h1>${h ? h : '标题不存在'}</h1>
          <p>${p}</p>
      div`;
      

    • 模板字符串也可以用来执行函数

    • 例：

    • alert`1`;
      

  • 以下方法用来表示一个字符串是否在两一个字符串中，支持两个参数

  • includes 第一个参数表示需要查找的字符串，第二个参数表示查找的起始下标位置

  • let a = 'abc';
    let result1 = a.includes('a'); // true
    let result2 = a.includes('d'); // false
    let result3 = a.includes('a', 1); // false
    

  • startsWith 第一个参数表示需要查找的字符串，第二个参数表示查找的起始下标位置

  • let a = 'abc';
    let result1 = a.startsWith('a'); // true
    let result2 = a.startsWith('b'); // false
    let result3 = a.startsWith('b', 1); // true
    

  • endsWith 第一个参数表示需要查找的字符串，第二个参数表示查找的字符串从前往后的个数，查前多少个的意思，不按照下标来计算

  • let a = 'abc';
    let result1 = a.endsWith('c'); // true
    let result2 = a.endsWith('b'); // false
    let result3 = a.endsWith('b', 2); // true
    

• 数值的方法

  • Number.isInteger()

  • 判断是否为一个整数

  • 例：

  • Number.isInteger(2); // true
    Number.isInteger(2.1); // false
    

  • 指数运算符**,指数运算符从右往左计算

  • 例：

  • let result = 2 ** 3; // 8
    let result = 2 ** 3 ** 2; // 512  相当于2 ** (3 ** 2)
    

• 函数的扩展

  • 为参数加默认值

  • 例：es5中,为了保证程序的正常运行，我们一般会像下面这样写

  • function fn(a, b) {
      a = a || 123;
      b = b || 456;
      console.log(a, b); // 1 456
    }
    fn(1, '');
    

  • es6中

  • 例：

  • function fn(a = 123, b = 456) {
      console.log(a, b); // 1 456
    }
    fn(1, '');
    

  • 配合解构

  • function fn({a = 123, b = 456}) {
      console.log(a, b); // 1 456
    }
    fn({a: 1})
    

  • 箭头函数

  • 例：

  • let fn1 = id => {
      console.log(id); // 1
    }
    fn1(1);
    // 等同于
    let fn2 = function(id) {
      console.log(id); // 2
    }
    fn2(2);
    
    // 需要返回值时
    let fn3 = id => id;
    // 等同于
    let fn4 = function(id) {
      return id;
    }
    
    // 箭头函数会把箭头后面的{}解析为代码块，如果需要返回一个对象时,需要用小括号包裹
    let fn5 = (id1, id2) => ({a: id1 ** 2, b: id2 ** 3});
    

  • rest参数

  • 例：

  • // 当参数不固定时，想要获取一个参数的集合
    // es5
    function fn1() {
      console.log(arguments) // [2, 3, 4] 是一个伪数组
    }
    fn1(2, 3, 4);
    // es6
    function fn2(...arg) {
      console.log(arg) // [2, 3, 4] 真实的数组
    }
    fn2(2, 3, 4);
    

• 扩展运算符

  • 数组的扩展

  • 例：

  • 扩展到的地方必须有一个宿主，比如对象或者数组

  • let [...a] = [1, 2, 3];
    console.log(a); // [1, 2, 3]
    let {...b} = [1, 2, 3];
    console.log(b); {0: 1, 1: 2, 2: 3}
    

  • 例：

  • let a = [1, 2, 3];
    let b = [...a];
    console.log(b); // [1, 2, 3];
    

  • 合并数组

  • let a = [1, 2, 3];
    let b = [4, 5, 6];
    let c = [...a, ...b];
    console.log(c); // [1, 2, 3, 4, 5, 6]
    

  • 只能进行浅拷贝

  • let a = [
      {
          name: 'li'
      }
    ]
    let b = [...a];
    console.log(a[0] === b[0]); // true;
    b[0].name = 'wang';
    console.log(a[0] === b[0]); // true;
    // 我们发现b拷贝于a，但是当b里面子对象的值发生改变后，依然影响到了a，所以慎用
    

  • 与解构混用

    • 当使用扩展运算符时，把扩展运算符的表达式放在最后一位，否则会报出错误

  • let a = [1, 2, 3, 4, 5];
    let [b, ...c] = a;
    console.log(b, c); // 1, [2, 3, 4, 5]
    

  • 字符串扩展

  • let a = 'hello';
    let [...b] = a;
    console.log(b); // ['h', 'e', 'l', 'l', 'o'];
    

  • Array.form()方法

  • 用于将类数组的对象转为真实的数组，比如dom

  • let domList = document.getElementsByTagName('div');
    let result = Array.from(domList);
    console.log(resule, result instanceof Array); // [div, div, div] true
    

  • Array.of()

  • 用于将一组值转为数组

  • let a = '123';
    let b = '456';
    let result = Array.of(a, b);
    console.log(result); // ['123', '456']
    

  • Array.fill()

  • 用于填充一个数组，常常用于数组的初始化，设置默认的初始值

  • let a = [1, 2, 3].fill(0);
    console.log(a); // [0, 0, 0]
    

  • 还可以接受第二个和第三个参数, 分别代表填充的起始位置和结束位置，不会填充结束位置

  • let a = [1, 2, 3, 4, 5].fill({name: 'li'}, 2, 3);
    console.log(a); // [1, 2, {name: 'li'}, 4, 5]
    

  • 数组实例的includes方法

  • 相当于indexOf(),用于检测一个元素是否存在于一个数组中，返回布尔值，和indexOf不同的是，它可以检测到NaN的是否存在，而在es5中NaN和任何值都是不相等的

  • let a = [1, 2, 3, NaN];
    console.log(a.includes(2)); // true
    console.log(a.includes(NaN)); // true
    console.log(a.includes(5)); // false
    

  • 也可以接受两个参数，第二个参数代表检查的起始位置，默认从0开始

  • let a = [1, 2, 3, NaN];
    console.log(a.includes(2, 0)); // true
    console.log(a.includes(2, 2)); // false
    console.log(a.includes(NaN， -1)); // true 从倒数的位置查，如果负值绝对值大于数组长度，则从0开始
    

参考：http://es6.ruanyifeng.com/