ES6扩展

• 字符串扩展

• 正则扩展

• 数值扩展

• 函数扩展

• 对象扩展

• 数组扩展

字符串扩展

模版字符串

    let data="jsiasj";
    console.log(`data:${data}`); // data:jsiasj

部分新的方法

• padStart、padEnd

    <!-- padStart方法 -->
    let str = 'i';

    let str1 = str.padStart(5, 'mooc');
    console.log(str1); // 'mooci'

    let str1 = str.padStart(9, 'mooc');
    console.log(str1); // 'moocmooci'

• repeat

    console.log('i'.repeat(10)); // 'iiiiiiiiii'

• startsWith、endsWith：判断字符串是不是以...开头\结尾

    const str = 'A promsie is a promsie';

    console.log(str.startsWith('B')); // false
    console.log(str.startsWith('A pro')); // true

• includes

    const str = 'A promise is a promise';

    if(str.includes('a promise')){
        console.log("存在"); //存在
    }

新的 Unicode 表示法和遍历方式

使用 for-of 遍历字符串

    var str = "promise";

    for (let word of str){
        console.log(word);
    }

Unicode 表示法

Unicode 是一项标准，包括字符集、编码方案等

它是为了解决传统的字符编码方案的局限而产生的，为每种语言中的每个字符设定了统一并且唯一的二进制编码，以满足跨语言、跨平台进行文本转换、处理的要求

一般的 Unicode 编码支持 0000~ffff

如果想要表示 "\u1f436" 这种字符串，则需要"\u{1f436}"写法

    <!-- codePointAt 获取字符串中对应的一个码点 -->
    🐶.codePointAt(0); // 128054

    <!-- 如果想要获取🐶的 Unicode 编码 -->
    🐶.codePointAt(0).toString(16); // 1f436

正则扩展

u 修饰符

    <!-- '\ud83d\udc36'为一个字符，但是如果像下列这样写的话，系统会将其视为两个字符，才为 true -->
    console.log(/^\ud83d/.test('\ud83d\udc36')); // true

    <!-- 添加 u 修饰符，系统会将其视为一个字符 -->
    console.log(/^\ud83d/u.test('\ud83d\udc36')); // false

y 修饰符

    const r1 = /imooc/g;
    const r2 = /imooc/y;

    const str = 'imoocimooc-imooc';

    console.log(r1.exec(str)); // "imooc", index=0
    console.log(r1.exec(str)); // "imooc", index=5
    console.log(r1.exec(str)); // "imooc", index=11
    console.log(r1.exec(str)); // null

    console.log(r2.exec(str)); // "imooc", index=0
    console.log(r2.exec(str)); // "imooc", index=5
    console.log(r2.exec(str)); // null

数值扩展

新的进制表示法

0o或0O表示八进制

0b或0B表示二进制

新的方法与安全数

• isFinite：是否为无限

• isSafeInteger：是否处于js能精确表示的范围

  范围为 Number.MIN_SAFE_INTEGER ~ Number.MAX_SAFE_INTEGER

• 幂运算（默认右结合）

      let a = 2 ** 10;
      console.log(a); // 1024
  

函数扩展

函数参数默认值

剩余参数

    function add(..args){
        console.log(args); // [1, 2, 3, 4, 5]
    }

    add(1, 2, 3, 4, 5);

箭头函数

    const add1 = (a, b) => {
        return a + b;
    };

    const add2 = function(a, b){
        return a + b;
    }

    console.log(add1(2, 2)); // 4
    console.log(add2(2, 2)); // 4

    <!-- 以上两种方法相同 -->

    const pop = arr => void arr.pop();
    console.log(pop([1, 2, 3])); // undefined

    const pop = arr => arr.pop();
    console.log(pop([1, 2, 3])); // 3

    const pop = arr => {
        // 因为其没有 return，所以不会有返回值
        arr.pop();
    }

箭头函数中并无 arguments 对象，只能用扩展运算符实现 arguments 的功能

    const log = (...args) => {
        console.log(args);
    }

    log(1, 2, 3); // [1, 2, 3]

箭头函数并不像普通函数一样具有函数作用域

对象扩展

对象的简洁表示法

    const getUserInfo = (id = 1) => {
        const name = 'xiaoming';
        const age = 10;
        return {
            name, // 会自动寻找同名变量，相当于 name: name
            age,
            say(){
                console.log(this.name + this.age);
            }
        }
    }

    const xiaoming = getUserInfo();

属性名表达式

    const key = 'age';
    const xiaoming = {
        name: 'xiaoming',
        [key]: 14 // [`${key}123`]: 14
    }

扩展运算符

复制对象——浅拷贝

    const obj1 = {
        a: 1,
        b: 2,
        d: {
            aa: 1,
            bb: 2
        }
    }

    const cObj1 = {...obj1}; // 浅拷贝
    console.log(cObj1.d.aa); // 1
    cObj1.d.aa = 99;
    console.log(cObj1.d.aa); // 99
    console.log(cObj1.d.aa); // 99

合并对象——浅拷贝

    const newObj = {
        ...obj2,
        ...obj1
    }

    newObj.d.aa = 22;
    console.log(obj1.d.aa); // 22

部分新的方法和属性

Object.is

    console.log(Object.is(+0, -0)); // false
    console.log(+0 === -0); // true
    console.log(Object.is(NaN, NaN)); // true
    console.log(NaN === NaN); // false

Object.assign —— 浅拷贝

用途为合并对象或复制对象

    const obj = {
        a: 1,
        b: {
            c: 2
        }
    };

    const newObj = Object.assign({a: 3}, obj);

    console.log(newObj.b.c); // 2

    newObj.b.c = 100;

    console.log(obj.b.c); // 100

keys、values、entries

• keys：返回迭代对象中的索引值

• values：索引值所对应的值

• entries：entries() 方法返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)

    const obj = {
        a: 1,
        b: 2,
        c: 3,
        d: 4
    };

    console.log(Object.keys(obj)); // ["a", "b", "c", "d"]

    console.log(Object.values(obj)); // [1, 2, 3, 4]

    console.log(Object.entries(obj));

    for (let [k, v] of Object.entries(obj)) {
        console.log(k, v); // a 1<br>b 2<br>c 3<br>d 4<br>
    }

新的方法

setPrototypeOf(obj, objProto)

修改 obj 的原型对象为 objProtot

getPrototypeOf(obj)

获取 obj 的原型对象

super

可以访问到原型对象上的属性和方法

对象上有函数时，必须使用对象的简洁表示法才可以

    const obj = {name: 'xiaoming'};

    const cObj = {
        say() {
            console.log(`My name is ${super.name}`);
        }
    }

    Object.setPrototypeOf(cObj, obj);

    cObj.say(); // My name is xiaoming

数组扩展

结合扩展运算符使用

    const user = ['小明', 14, ['吃饭', '打游戏'], '我今年大二'];

    function say(name, age, hobby, desc) {
        console.log(`我叫${name}, 我今年${age}岁，我喜欢${hobby.join('和')}, ${desc}`);
    }

    say(...user);

合并数组与复制数组

    const arr1 = [1, 2, 3, 4];
    const arr2 = [4, 2, 2, 1];
    const arr3 = [2.2, '123', false];

    <!-- 合并数组 -->
    <!-- 第一种方法 -->
    const cArr1 = [1, 2, 3, ...arr3];

    <!-- 第二种方法 -->
    const cArr2 = [...arr1, ...arr2, ...arr3];

    <!-- 复制数组 -->
    <!-- 第一种方法 -->
    const cArr3 = [...arr1];

    <!-- 第二种方法 -->
    const [...cArr4] = arr3;

新方法

Array.from

from()方法的作用是将一个 ArrayLike 对象或者 Iterable 对象（类数组对象）转换成一个 Array

类数组对象的属性名必须为数值型或字符串型的数字

对象中的 length 键值对表示的是最终由 from 方法转换的数组的长度

接收两个参数，一个是需要转换的对象，一个是回调函数

    const obj = {
        0: 1,
        1: 'dfsa',
        2: false,
        length: 3
    }

    console.log(Array.from(obj));

Array.of

将传进去的参数转换为数组

    console.log(Array.of(1, 2, '123', false));

Array(num).fill(value, start end)

将value填充数组，填充个数为数组的长度

即使数组里面有值，它也会将原来有的值覆盖掉

接受三个参数，start为开始填充的位置，end为结束填充的位置

Array.includes(value)

判断数组中是否有value，返回布尔值

keys、values、entries

这里不过多阐述，请参照上面的笔记

find

根据条件（回调）按顺序遍历数组，当回调返回true时，就返回当前遍历到的值

    const res = [1, 7, 6, 3].find(function(value, index, arr){
        console.log('value', value);
        console.log('index', index);
        console.log('arr', arr);

        return value % 2 === 0;
    });

    console.log(res);

findIndex

根据条件（回调）按顺序遍历数组，当回调返回true时，就返回当前遍历到的下标