es6

对象的计算属性名
以前对象的属性是不允许动态修改的，es6支持属性赋值，如：
以前：
let obj1= {
    name: '熊二', 
    age: 18,
    sec: '女'
};


现在可以：
let nameStr = 'name';
let ageStr = 'age';
let obj1 = {
    [nameStr]: '熊二',
    [`${ageStr}`]: 18,
    ['sec']: '女'
}
console.log(obj1)   // {     name: '熊二',      age: 18,     sec: '女' };


Object.assign(target,source) 对象合并
Object.assign方法用于对象的合并，将源对象（source）的所有可枚举属性，复制到目标对象（target）。第一个参数是目标对象，后面的参数都是源对象。
注意，如果目标对象与源对象有同名属性，或多个源对象有同名属性，则后面的属性会覆盖前面的属性。
var target = { a: 1, b: 1 };
var source1 = { b: 2, c: 2 };
var source2 = { c: 3 };

Object.assign(target, source1, source2);
target // {a:1, b:2, c:3}
Object.assign方法实行的是浅拷贝，而不是深拷贝。也就是说，如果源对象某个属性的值是对象，那么目标对象拷贝得到的是这个对象的引用。
var obj1 = {a: {b: 1}};
var obj2 = Object.assign({}, obj1);

obj1.a.b = 2;
obj2.a.b // 2
上面代码中，源对象obj1的a属性的值是一个对象，Object.assign拷贝得到的是这个对象的引用。这个对象的任何变化，都会反映到目标对象上面。
Object.assign 应用
（3）克隆对象
function clone(origin) {
  return Object.assign({}, origin);
}
上面代码将原始对象拷贝到一个空对象，就得到了原始对象的克隆。
不过，采用这种方法克隆，只能克隆原始对象自身的值，不能克隆它继承的值。如果想要保持继承链，可以采用下面的代码。
function clone(origin) {
  let originProto = Object.getPrototypeOf(origin);
  return Object.assign(Object.create(originProto), origin);
}
（4）合并多个对象
     将多个对象合并到某个对象。
const merge =
  (target, ...sources) => Object.assign(target, ...sources);
如果希望合并后返回一个新对象，可以改写上面函数，对一个空对象合并。
const merge =
  (...sources) => Object.assign({}, ...sources);


函数的参数默认值：
funtion ( a = ' $ ' ) {   }      
在形参位置可以传默认值，意思为：不穿参数默认使用 a = ' $ ' 

forEach和map的区别
let arr = [
    {
        id:1,
        name:'小一'
    },
    {
        id:2,
        name:'小二'
    },
    {
        id:3,
        name:'小三'
    }
]
let newArr1 = arr.filter((item)=>{
    return item.id ===1;
})
console.log(newArr1) // [{id:1,name:'小一'}]
let newArr0 = arr.filter((item)=>{
    return item.id;
})
console.log('filter', newArr0) // [{id:1,name:'小一'},{id:2,name:'小二'},{id:3,name:'小三'}]

let newArr2 = arr.map((item)=>{
 return item.id;
})
console.log(newArr2)// [1,2,3]

共同点：都是返回一个新的数组
Map
Map是一组键值对的结构，具有极快的查找速度。具有以下方法：
let m = new Map();
 m.set('xiaoming',{name:'小明',age:16});
 m.set('xiaohuang',{name:'小黄',age:18});
 m.get('xiaoming')     //{name:'小明',age:16}
 m.has('xiaohuang')    //true
 m.delete('xiaoming');
 m.has('xiaoming')     //true

应用：

//获取xiaomhuang对应的成绩
let nameArr = ['xiaoming', 'xiaolan', 'xiaohaung']
let numberArr = [80, 90, 76]
numberArr.forEach((numberItem) => {
    nameArr.forEach((itemName, itemNameIndex) => {
        if(itemName === 'xiaohaung') {
            numberArr[itemNameIndex] // 76
        };
    })
})

//使用Map
let m = new Map([
    ['xiaoming', 80],
    ['xiaolan', 90],
    ['xioahuang', 76]
]);
m.get('xioahuang') // 76

 

Set
let s = new Set();
 console.log('初始',s) //{}
 s.add(1);
 console.log(s) // {1}
 s.add('1') 
 console.log(s) // {1,'1'}
 s.add(1);
 console.log(s) // {1,'1'}
 s.delete('1') 
 console.log(s) // {1}
 
 let arr = [1,2,3,1];
 let newSet = new Set(arr);
 console.log('去重',newSet );

proxy（代理对象）
es5中，我们可以使用 Object.defineProperty和Object.defineProperty来实现对对象的监听。
Proxy 代理的作用，好处是将 条件 和 对象 隔离开，利于后期代码维护


let obj = {
    name: "猿跑跑",
    age: 28
}

let p = new Proxy(obj, {
    get: function(target, key) {   // 获取的拦截函数(获取时执行)
        if(key in target) {
            console.log(target[key])
        } else {
            console.log("对象没有此属性");
        }
    },
    set: function(target, key, value) {   //设置的拦截函数(值设置时执行)
        target[key] = value;
        console.log("设置成功,值为：",target[key]);
    },
    has: function (target,key) { // 是否存在某个属性
        if (key in target) { // 判断obj对象中是否存在key属性
            console.log('存在');
        } else {
            console.log('不存在');
        };
    }
});

p.age = 22;    // 设置
p.age; // 22
p.height;  // 对象没有此属性
'age' in p; // 存在
'weight' in p; // 不存在


一、filterfilter 是`过滤`的意思，所以这个方法的作用就是返回一个匹配过滤条件的新数组，
let arr = ['a','b','a','c'];
let newArr = arr.fillter((item)=>{
    return item === 'a';
})
console.log(newArr) //['a','a']

场景：数组去重、取交集 
var a = [1, 2, 3, 4] 
var b = [3, 4, 5, 6] 
let intersection = a.filter(v => b.includes(v)) 
let difference = a.concat(b).filter(v => !a.includes(v) || !b.includes(v)) 
console.log('交集', intersection) 
console.log('去重', difference)


求数组的最小值
var arr = [23, 45, 40, 30, 12];
var iMin = Math.min(...arr);
console.log(iMin);

文件导出：
    //  es5的导出
    module.exports = 'bmw7';

    //  es6的导出（带默认接口）
    export default {
       str:'bmw6'
    }

文件导入：
    //  es5导入模块
    var modeA = require('./mod/a.js');

    //  es6导入模块
    import modeA from './mod/a.js'

模块化
es6:
如果：导出为
     export default  obj
那么：引入为
     import modeA from './mod/a.js'

如果：导出为
     export const str = aaa
那么：引入为
     import { str } from './mod/a.js'

const getDate = () => {
    let d = new Date();
    return d.getFullYear() + '-' + (d.getMonth() + 1) + '-' + d.getDate();
};

export { getDate };


module.js导出:
a.js导入:
这两者的区别是，export {<变量>}导出的是一个变量的引用，export default导出的是一个值
什么意思呢，就是说在a.js中使用import导入这2个变量的后，在module.js中因为某些原因x变量被改变了，那么会立刻反映到a.js，而module.js中的y变量改变后，a.js中的y还是原来的值
链接：https://juejin.im/post/5c6234f16fb9a049a81fcca5

箭头函数的简写：
函数： 有大括号并有返回值时。this指向创建它的作用域，而我们通常说的运行环境。

（a）=>{
   return  'b'
}
es6可写成 :
      a => 'b'


复制（延展）数组：（只能复制一层，不能复制嵌套很多层 ，不能深度 复制）
ver  arr  =  [ 'a'  ,  'b'  ]
...arr     ===    'a'  ,  'b'            将arr数据拿出来
[ ...arr ]    ===   复制数组 （将arr数据拿出来,放到一个新的数组）


对象的延展
let obj1 = {
    name: '李四',
    age: 6
}
let obj2 = {
    ...obj1,
    height: 160
}
console.log('扩展后', obj2);