JavaScript ECMAScript 6

块级作用域let
使用let声明的变量，只在块级作用域中有效，在块之外无法访问。
解构数组与对象

function breakfast() {
  return ['watermelon', 'burger', 'pizza'];
}
var temp = breakfast();
console.log(temp[0], temp[1], temp[2]); // watermelon, burger, pizza

let [a, b, c] = breakfast();
console.log(a, b, c); // watermelon, burger, pizza

function breakfast() {
    return { a: 'watermelon', b: 'pizza', c: 'burger' }
}
let { a: a, b: b, c: c } = breakfast();
console.log(a, b, c); // watermelon, pizza, burger

模板字符串

let a = 'watermelon',
    b = 'movie';

let c = '今天吃' + a + '吃完看' + b;
console.log(c); // 今天吃watermelon吃完看movie

let d = `今天吃 ${a} 吃完看 ${b}`;
console.log(d); // 今天吃 watermelon 吃完看 movie

判断字符串包含内容

let str = '你好，我是小周 ❤️';
console.log(str.startsWith('你好')); // true
console.log(str.endsWith('❤️')); // true
console.log(str.endsWith('你好')); // false
console.log(str.includes(" ")); // true

默认参数

function say(str) {
    console.log(str);
}
function say1(str = '嘿嘿') {
    console.log(str);
}
say(); // undefined
say1(); // 嘿嘿
say1('heart'); // heart

展开操作符

let arr = ['heart', 'smile', 'love'];
console.log(arr); // ['heart', 'smile', 'love']
console.log(...arr); // heart, smile, love
let brr = ['王子', ...arr]; 
console.log(brr); // [王子,'heart', 'smile', 'love']
console.log(...brr); // 王子, heart, smile, love

function f1(a, b, ...c) {
    console.log(a, b, c);
    console.log(a, b, ...c);
}
f1('apple','rainbow','snowman','secreat');
// apple, rainbow, ["snowman", "secreat"]
// apple, raivbow, snoeman, secreat

函数名称

function f1() { }
console.log(f1.name); // f1
let f2 = function () { };
console.log(f2.name); // f2
let f3 = function f4() { };
console.log(f3.name); // f4

箭头函数
需要注意，箭头函数没有this

let f1 = a => a;

let f2 = (a, b) => {
    return a + b;
}

console.log(f1(10)); // 10
console.log(f2(10, 10)); // 20

对象表达式
键值一致的时候可以省略值，函数写法可以省略function。

let a = 'rainbow';
let b = 'snowman';

const obj = {
    a: a,
    b: b,
    say: function () {

    }
}

const es6obj = {
    a,
    b,
    say() {

    }
}

console.log(obj); // { a: 'rainbow', b: 'snowman', say: [Function: say] }
console.log(es6obj); // { a: 'rainbow', b: 'snowman', say: [Function: say] }

常量
使用const关键字定义常量，限制的是给常量分配值的动作，但是不限制常量中的值。

const app = ['snowman', 'rainbow'];
console.log(...app); // snowman, rainbow
app.push('laugh');
console.log(...app); // snowman, rainbow, laugh
app = 10; // TypeError: Assignment to constant variable.

判断两个值是否相等
有些情况使用和=可能得到的结果不理想，可以使用Object.is()

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

复制对象

let obj = {};
Object.assign(
    // 目标对象
    obj,
    // 源
    { a: 'snowman' }
);
console.log(obj); // { a: 'snowman' }

设置对象的prototype和proto

let obj1 = {
    get() {
        return 1;
    }
}
let obj2 = {
    a: 10,
    get() {
        return 2;
    }
}
let test = Object.create(obj1);
console.log(test.get()); // 1
console.log(Object.getPrototypeOf(test) === obj1); // true
Object.setPrototypeOf(test, obj2);
console.log(test.get()); // 2
console.log(Object.getPrototypeOf(test) === obj2); // true

let obj1 = {
    get() {
        return 1;
    }
}
let obj2 = {
    a: 10,
    get() {
        return 2;
    }
}
let test = {
    __proto__: obj1
}
console.log(test.get()); // 1
console.log(Object.getPrototypeOf(test) === obj1); // true
test.__proto__ = obj2;
console.log(test.get()); // 2
console.log(Object.getPrototypeOf(test) === obj2); // true

设置super

let obj1 = {
    get() {
        return 1;
    }
}
let test = {
    __proto__: obj1,
    get() {
        return super.get() + 'snowman';
    }
}
console.log(test.get()); // snowman

迭代器

// 迭代器
function die(arr) {
    let i = 0;

    return {
        next() {
            let done = (i >= arr.length);
            let value = !done ? arr[i++] : undefined;

            return {
                value: value,
                done: done
            }
        }
    }
}
let arr = ['snowman', 'laugh', 'rainbow'];

let dieArr = die(arr);
console.log(dieArr.next()); // { value: 'snowman', done: false }
console.log(dieArr.next()); // { value: 'laugh', done: false }
console.log(dieArr.next()); // { value: 'rainbow', done: false }
console.log(dieArr.next()); // { value: undefined, done: true }

// 简化迭代器
function* die(arr) {
    for (let i = 0; i < arr.length; i++) {
        yield arr[i];
    }
}
let test = die(['rainbow','snowman']);
console.log(test.next()); // { value: 'rainbow', done: false }
console.log(test.next()); // { value: 'snowman', done: false }
console.log(test.next()); // { value: undefined, done: true }

构建类，获取和修改类的属性

class stu {
    constructor(name) {
        this.name = name;
    }
    say() {
        return this.name + '说奥里给';
    }
}
let xiaoming = new stu("小明");
console.log(xiaoming.say()); // 小明说奥里给

class stu {
    constructor(name) {
        this.name = name;
    }
    get() {
        return this.name;
    }
    set(newStr) {
        this.name = newStr;
    }
}
let xiaoming = new stu("小明");
console.log(xiaoming.get()); // 小明
xiaoming.set("大明")
console.log(xiaoming.get()); // 大明

static
无需实例化对象也可以直接使用static修饰的方法。

class stu {
    static say(str) {
        console.log(str);
    }
}
stu.say("奥里给 静态方法"); // 奥里给 静态方法

extends
使用继承，减少冗余代码

class Person {
    constructor(name, bir) {
        this.name = name;
        this.bir = bir;
    }
    showInfo() {
        return '姓名：' + this.name + '生日：' + this.bir;
    }
}
class A extends Person {
    constructor(name, bir) {
        super(name, bir);
    }
}
let zhouql = new A("周棋洛", "2002-06-01");
// 周棋洛本身是没有showInfo方法的，是继承自Person的
console.log(zhouql.showInfo()); // 姓名：周棋洛生日：2002-06-01

set和map
set集合中不允许重复
map集合中存储键值对

// 创建Set集合
let food = new Set('apple', 'pear');
// 重复添加，只有一个能进去
food.add('watermelon');
food.add('watermelon');

console.log(food); // Set(3) { 'apple', 'pear', 'watermelon' }
// 当前集合大小
console.log(food.size); // 3
// 判断集合中是否存在某一元素
console.log(food.has('watermelon')); // true
// 删除集合中某一元素
food.delete('pear');
console.log(food); // Set(2) { 'apple', 'watermelon' }
// 循环遍历集合
food.forEach(f => {
    console.log(f);
}); // apple pear
// 清空集合
food.clear();
console.log(food); // Set(0) {}


// Map集合
let food = new Map();
let a = {}, b = function () { }, c = "name";

food.set(a, 'apple');
food.set(b, 'pear');
food.set(b, 'pear');
food.set(c, '米饭');

console.log(food); // Map(3) { {} => 'apple', [Function: b] => 'pear', 'name' => '米饭' }
console.log(food.size); // 3
console.log(food.get(a)); // watermelon
food.delete(c);
console.log(food); // Map(2) { {} => 'apple', [Function: b] => 'pear'}
console.log(food.has(a)); // true

food.forEach((v, k) => {
    console.log(`${k} + ${v}`);
}); // [object Object] + apple   function () { } + pear
food.clear();
console.log(food); // Map(0) {}

模块化

// 27模块测试.js
let a = '🍉';
let f1 = function (str = '你丫的写参数') {
    console.log(str);
}
export { a, f1 };

// 另一个模块
import {a, f1} from './27模块测试.js';
console.log(a);
f1();
f1('知道了');