ES6新特性

let arr = [1,2,3]

const [x,y,z] = arr;// x，y，z将与arr中的每个位置对应来取值
// 然后打印
console.log(x,y,z);

    name:"jack",
    age:21,
    language: [‘java‘,‘js‘,‘css‘]
}

// 解构表达式获取值
const {name,age,language} = person;
// 打印
console.log(name);
console.log(age);
console.log(language);

function add(a , b) {
        // 判断b是否为空，为空就给默认值1
        b = b || 1;
        return a + b;
    }
    // 传一个参数
    console.log(add(10));

function add(a , b = 1) {
    return a + b;
}
// 传一个参数
console.log(add(10));

var print = function (obj) {
    console.log(obj);
}
// 简写为：
var print2 = obj => console.log(obj);

// 两个参数的情况：
var sum = function (a , b) {
    return a + b;
}
// 简写为：
var sum2 = (a,b) => a+b;

var sum3 = (a,b) => {
    return a + b;
}

let person = {
    name: "jack",
    // 以前：
    eat: function (food) {
        console.log(this.name + "在吃" + food);
    },
    // 箭头函数版：
    eat2: food => console.log(person.name + "在吃" + food),// 这里拿不到this
    // 简写版：
    eat3(food){
        console.log(this.name + "在吃" + food);
    }
}

const person = {
    name:"jack",
    age:21,
    language: [‘java‘,‘js‘,‘css‘]
}

function hello(person) {
    console.log("hello," + person.name)
}

var hi = ({name}) =>  console.log("hello," + name);

let arr = [‘1‘,‘20‘,‘-5‘,‘3‘];
console.log(arr)

arr = arr.map(s => parseInt(s));

console.log(arr)

const arr = [1,20,-5,3]

const promise = new Promise(function(resolve, reject) {
  // ... 执行异步操作

  if (/* 异步操作成功 */){
    resolve(value);// 调用resolve，代表Promise将返回成功的结果
  } else {
    reject(error);// 调用reject，代表Promise会返回失败结果
  }
});

promise.then(function(value){
    // 异步执行成功后的回调
});

promise.then(function(value){
    // 异步执行成功后的回调
}).catch(function(error){
    // 异步执行失败后的回调
})

const p = new Promise(function (resolve, reject) {
    // 这里我们用定时任务模拟异步
    setTimeout(() => {
        const num = Math.random();
        // 随机返回成功或失败
        if (num < 0.5) {
            resolve("成功！num:" + num)
        } else {
            reject("出错了！num:" + num)
        }
    }, 300)
})

// 调用promise
p.then(function (msg) {
    console.log(msg);
}).catch(function (msg) {
    console.log(msg);
})

// Set构造函数可以接收一个数组或空
let set = new Set();
set.add(1);// [1]
// 接收数组
let set2 = new Set([2,3,4,5,5]);// 得到[2,3,4,5]

set.add(1);// 添加
set.clear();// 清空
set.delete(2);// 删除指定元素
set.has(2); // 判断是否存在
set.keys();// 返回所有key
set.values();// 返回所有值
set.entries();// 返回键值对集合
// 因为set没有键值对，所有其keys、values、entries方法返回值一样的。
set.size; // 元素个数。是属性，不是方法。

// map接收一个数组，数组中的元素是键值对数组
const map = new Map([
    [‘key1‘,‘value1‘],
    [‘key2‘,‘value2‘],
])
// 或者接收一个set
const set = new Set([
    [‘key1‘,‘value1‘],
    [‘key2‘,‘value2‘],
])
const map2 = new Map(set)
// 或者其它map
const map3 = new Map(map);

const util = {
    sum(a,b){
        return a + b;
    }
}

const util = {
    sum(a,b){
        return a + b;
    }
}
export util;

export const util = {
    sum(a,b){
        return a + b;
    }
}

var name = "jack"
var age = 21
export {name,age}

// 无需声明对象的名字
export default {
    sum(a,b){
        return a + b;
    }
}

// 导入util
import util from ‘hello.js‘
// 调用util中的属性
util.sum(1,2)

import {name, age} from ‘user.js‘

console.log(name + " , 今年"+ age +"岁了")