'use strict';

if (true){
    let fruit = ':apple';
    console.log('a' + fruit);
}

//定义常量const，常量可扩展
const fruits = [];
fruits.push('apple');
fruits.push('lem');
console.log(fruits);

//解构数组Array
function breakfast(){
    return ['cake', 'tea', 'apple'];
}
//取数组的值再赋值给变量
let [dessert, drink, fruit] = breakfast();
console.log(dessert, drink, fruit);

//解构对象
function breakfastObject() {
    return {dessert: 'cake', drink: 'tea', fruit: 'apple'};
}
let {dessert: des, drink: dri, fruit: fru} = breakfastObject();
console.log(des, dri, fru);


//字符模板 `${}`
let c = 'cake', t = 'tea';
let b = `今天的早餐是 ${c} 与 ${t}`;
console.log(b);
//带标签的字符模板
let d = kitchen`今天的早餐是 ${c} 与 ${t}`;
function kitchen(strings, ...values) {
    console.log(strings);
    console.log(values);

    let result = '';
    for (var i=0; i<values.length; i++){
        result +=strings[i];
        result +=values[i];
    }
    result += strings[strings.length - 1];
    return result;
}
console.log(d);

//字符串操作
console.log(d.startsWith('今天'));
console.log(d.endsWith('tea'));
console.log(d.includes('早餐'));

//方法的默认参数
function testDefaultParmas(par1 = '111', par2 = '222') {
    return `${par1} ${par2}`;
}
console.log(testDefaultParmas());
console.log(testDefaultParmas('777', '888'));


//展开操作符...
let ff = ['cake', 'tea', 'apple'];
let f2 = ['banner', ...ff];
console.log(...ff);
console.log(f2);
console.log(...f2);
//剩余操作符...
function brek(de, dr, ...df) {
    console.log(de, dr, df);
}
brek('aa', 'bb', 'cc', 'dd');

//解构参数
function be(a, b, {c, d} = {}) {
    console.log(a, b, c, d);
}
be('aa', 'bb', {c: 'cc', d: 'dd'});

//获取函数名
let bf = function superBf(argument) {

}
console.log(bf.name);

//箭头函数  格式： let 函数名 = 函数的参数 => 函数的返回值
let arrowName = arrowParame => arrowParame;
console.log(arrowName(123));
let arrowNames = (arrowParam1, arrowParam2) => {
    return `这里可以编辑函数要返回的结果内容，比如${arrowParam1}、${arrowParam2}`
};
console.log(arrowNames(123,'321'));

//定义对象属性
let food = {};
food.f11 = 'cake';      //点号属性
food['f3'] = 'banner';  //中括号属性
let f22 = 'fff f2';
food[f22] = 'aaaa2';    //对象属性
console.log(food);


/*
    判断两个值是否相等 == === Object.is()
    ==：等同，比较运算符，两边值类型不同的时候，先进行类型转换，再比较；
    ===：恒等，严格比较运算符，不做类型转换，类型不同就是不等；
    Object.is()是ES6新增的用来比较两个值是否严格相等的方法，与===的行为基本一致
 */
+0 == -0;   //true
+0 === -0;  //true
Object.is(+0, -0);  //false

//拷贝对象的值
let bb1 = {a1 : 111};
let bb2 = Object.assign({}, bb1);
console.log(bb2);


//设置对象的prototype  Object.setPrototypeOf()
let di1 = {
    getDrink(){
        return 'coffer';
    }
};
let di2 = {
    getDrink(){
        return 'peer';
    }
};
let sundy = Object.create(di1);
console.log(sundy.getDrink());
console.log(Object.getPrototypeOf(sundy) === di1);

Object.setPrototypeOf(sundy, di2);
console.log(sundy.getDrink());
console.log(Object.getPrototypeOf(sundy) === di2);

//设置对象的prototype  __proto__
let sundy2 = {
    __proto__: di1
};
console.log(Object.getPrototypeOf(sundy2) === di1);

//super
let sundy3 = {
    __proto__: di2,
    getDrink(){
        return super.getDrink() + 'zzzzzz';
    }
};
console.log(sundy3.getDrink());


//迭代器
function chef(foods) {
    let i = 0;
    return {
        next(){
            let done = (i >= foods.length);
            let value = !done ? foods[i++] : undefined;
            return {
                value: value,
                done: done
            }
        }
    }
}
let ss = chef(['apple', 'lem']);
console.log(ss.next());
console.log(ss.next());
console.log(ss.next());

//自动生成迭代器
function* chef(foods) {
    for (var i = 0; i< foods.length; i++){
        yield foods[i];
    }
}
let s2 = chef(['aaa', 'bbb']);
console.log(s2.next());
console.log(s2.next());
console.log(s2.next());



//类class
class MyClass {
    constructor(par){
        this.par = par;
        this.par2 = [];
    }

    get pp(){
        return this.par2;
    }

    set pp(p){
        this.par2.push(p);
    }

    doMethod(){
        console.log(this.par);
    }

    //类的静态方法，无需实例化也可直接访问
    static sMethod(food){
        console.log(food);
    }
}
MyClass.sMethod('00000');
let myClass = new MyClass();
console.log(myClass.pp = '111111');
console.log(myClass.pp = '222222');
console.log(myClass.pp);


//类的继承
//父类
class Person {
    constructor(name, birthday){
        this.name = name;
        this.birthday = birthday;
    }

    intro(){
        return `姓名：${this.name}, 生日： ${this.birthday}`;
    }
}
//子类
class Man extends Person{
    constructor(name, birthday){
        super(name, birthday);
    }
}

let zhansan = new Man('张三', '1980-08-09');
console.log(zhansan.intro());


//Set处理不重复的集合
let desserts = new Set('ab');   //初始化带a、b两个值的集合
desserts.add('c');  //添加一个值
desserts.add('a');  //添加一个重复值，不会写进集合
console.log(desserts);
console.log(desserts.size); //集合的长度
console.log(desserts.has('b')); //判断集合是否包含一个值
desserts.delete('b');   //删除一个集合的值
console.log(desserts);
desserts.forEach(ds => {    //遍历集合
    console.log(ds);
});
desserts.clear();   //清空集合
console.log(desserts);


//Map
let foodMap = new Map();    //初始化map
let fruitKey = {}, cookKey = function () {}, dessertKey = '甜品'; //定义几个key
foodMap.set(fruitKey, 'apple'); //插入键值
foodMap.set(cookKey, 'soap');
foodMap.set(dessertKey, 'cake');
console.log(foodMap);
console.log(foodMap.get(fruitKey)); //根据键获取值
foodMap.delete(cookKey);    //根据键删除值
console.log(foodMap.has(cookKey));  //判断键是否存在
foodMap.forEach((value, key) => {   //遍历map
    console.log(`${key}, ${value}`);
});