ES6快速入门（二）

1. Map对象

ES6提供了新的数据结构Map，Map结构提供了“值—值”的对应，是一种更完善的Hash结构实现。如果你需要“键值对”的数据结构，Map比Object更合适。它类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。{"b" => "banana"}并且每一项都包含了key和value
我们来新建一个Map对象，并为其赋值：

    let map = new Map();
    map.set('a','apple');
    map.set('b','banana');
    console.log(map); //   Map {"a" => "apple", "b" => "banana"}

结果如图：

获取Map对象里面的值（map.get()）：

    let map = new Map();
    map.set('a','apple');
    map.set('b','banana');
    console.log(map.get('b'));  //banana

删除Map对象里面的值（map.delete();）：

    let map = new Map();
    map.set('a','apple');
    map.set('b','banana');
    map.delete('a');
    console.log(map); // {"b" => "banana"}

获取Map对象的“长度”：

    let map = new Map();
    map.set('a','apple');
    map.set('b','banana');
    console.log(map.size);  //2
    console.log(map.length); //undefined

map.entries()

    let map = new Map();
    map.set('a','apple');
    map.set('b','banana');
    console.log(map.entries());  //  MapIterator {["a", "apple"], ["b", "banana"]}

遍历Map对象（for...of... ）

    let map = new Map();
    map.set('a','apple');
    map.set('b','banana');
    for(let name of map){
        console.log(name);  //["a", "apple"]  ["b", "banana"]
    }
    //循环出来的是以数组套键值对的方式

如果我们只要Map中的“值”怎么办？别急

    let map = new Map();
    map.set('a','apple');
    map.set('b','banana');
    for(let val of map.values()){
        console.log(val);   //apple   banana
    }

如果我们只要Map中的“键(key)”怎么办？别急

    let map = new Map();
    map.set('a','apple');
    map.set('b','banana');
    for(let key of map.keys()){
        console.log(key);  // a  b
    }

如果我们只要Map中的“键 --- 值”怎么办？也别急

    let map = new Map();
    map.set('a','apple');
    map.set('b','banana');
    for(let [key,value] of map.entries()){
        console.log(key,value);   //a apple     b banana
    }

2.for循环那些事

a) for ... in ...循环

  //循环数组
    let arr = [12,5,8];
    for(let i = 0;i<arr.length;i++){
        console.log(i);    //0 1  2
        console.log(arr[i]);  //12  5  8
    }

    let arr = [12,5,8];
    for(let i in arr){
        console.log(i);      //0 1  2
        console.log(arr[i]);  //12  5  8
    }

    //循环json数据
    let json = {a:12,b:5,c:8};
    for(let name in json){
        console.log(name);  //a  b c
        console.log(json[name]);  //12 5 8
    }

b) for ... of ...循环

  //循环数组
    let arr = [12,5,8];
    for(let name of arr){
        console.log(name);  // 12 5 8
    }

 //循环json数据
    let json = {a:'apple',b:'banana'};
    for(let name of json){
        console.log(name);
    }
//报错，因为不能用for ...of...来循环json数据

c) 删除json的某一条数据

    let json = {a:12,b:5};
    delete json.a;
    console.log(json);  // b:5

3. 箭头函数

ES6标准新增了一种新的函数：Arrow Function（箭头函数）。
为什么叫Arrow Function？因为它的定义用的就是一个箭头：

x => x * x

我们先回顾下ES5函数定义与调用：

    var show = function(){
        alert(12);  
    };
    show();   // 12

    const show = () =>{
        alert(12);  
    };
    show();  // 12 
//个人理解：这里将function关键字去掉然后在“()”后面加一个“=>”

接下来我们举几个例子，来进一步了解下箭头函数：

a) 函数有返回值

//ES5函数写法
    var sum = function(a,b){
        return a+b;
    }
    alert(sum(12,5));
//ES6函数写法
    let sum = (a,b) => {
        return a+b;
    }
    alert(sum(12,5));
  //进化一下  ---   省略花括号
    let sum = (a,b) => a+b;
    alert(sum(12,5));

b) 参数是1个

        var show = function(a){ return 'welcome'}
        //相当于   省略括号
        var show = a => 'welcome'

c) 参数是0个

        var show = function(){ return 'welcome'}
        //相当于   省略括号
        var show = () => 'welcome'

注意：箭头函数下 ，arguments 不能使用了

var show = (a,b) => console.log(this.arguments); // 报错

######箭头函数简单应用：
数组排序

var arr = [12,55,8];

//es5写法
arr.sort(function(n1,n2){
return n1 - n2;
});
//es6写法
arr.sort((n1,n2) => n1-n2);
alert(arr);