《ECMAScript6入门》整理（中）

4、数值的扩展

二进制和八进制数值表示法

ES6提供了二进制和八进制数值的新写法，分别用0b和0o表示

0b111110111 ===503 //true  二进制
0o767 === 503 //true  八进制

Number.isFinite()：用来检测Infinite
Number.isNaN()：用来检测NaN

ps：这两个方法与传统方法的区别是，传统方法先通过调用Number()将非数值转化成数值，再判断。这两个方法只对数值有效，非数值一律返回false

Number.parseInt()、 parseFloat()

ES6将全局方法 parseInt()和parseFloat()，移到了Number对象上，行为完全保持布标

Number.isInteger()：

用来判断一个数是否是整数，需要注意的是，整数和浮点数使用同样的存储方法， 所以1和1.0被视为同一个值。

    Number.isInteger(25)  //true
    Number.isInteger(25.0)  //true

安全整数Number.isSafeInteger()

javaScript能准确表示的整数的范围-2^53~2^53;

    var inside = Number.Max_SAFE_INTEGER;
    var outside = inside+1;
    Number.isInteger(inside);  //true
    Number.isSafeInteger(inside); //true
    Number.isInteger(outside );  //true
    Number.isSafeInteger(outside ); //false

Math对象的扩展

Math.trunc()
用于除去一个数的小数部分，返回其整数部分

    Math.trunc(4.1)  // 4
    Math.trunc(4.9)  // 4
    Math.trunc(-4.1)  // -4
    Math.trunc(-4.9)  // -4

数学方法

• Math.acosh(x) // 返回x的反双曲余弦
• Math.asinh(x) //返回x的反双曲正弦
• Math.atanh(x)//返回x的反双曲正切
• Math.cbrt(x)返回x的立方根
• Math.clz32(x)返回x的32位二进制整数表示形式的前导0的个数
• Math.cosh(x)返回x的双曲余弦
• Math.expm1(x)返回e^x-1
• Math.fround(x)返回x的单精度浮点数形式
• Math.hypot(…value)返回所有参数的平方和平方根
• Math.imul(x,y)返回两个参数以32位整数形式相乘的结果
• Math.log1p(x)返回ln(1+x)
• Math.log10(x)返回以10底x的对数
• Math.log2(x)返回以2为底x的对数
• Math.sign(x)如果x是负数，返回-1，x为0则返回0，x为整数返回1
• Math.tanh(x)返回x的双曲正切

5、数组的扩展

Array.from():将类似数组的对象和可遍历的对象转换成真正的数组
Array.of()：将一组值转换成数组
数组实例的find()：找出第一个符合条件的数组元素

    [1,5,10,13].find(function(value,index,arr){return value>9})  //10

数组实例的findIndex():找出第一个符合条件的数组位置

[1,5,10,13].findIndex(function(value,index,arr){return value>9})  //2

数组实例的fill()：使用给定值补充一个数组

    ['a','b','c'].fill(7); //[7,7,7]
    ['a','b','c'].fill(7,1,2); //['a',7,'c']  //第二、三个参数分别表示填充的起始和结束位置

数组实例的entries(),keys()和values()
用于遍历数组它们都返回一个遍历器，可以用for…of循环进行遍历。keys()是对键名的遍历，values()是对键值的遍历，entries是对键值对的遍历

    for(let index of ['a','b'].keys()){
        console.log(index);   // 0  ,  1
    }
    for(let elem of ['a','b'].values()){
        console.log(elem );   // a  ,  b
    }
    for(let [index,elem] of ['a','b'].entries){
        console.log(index,elem);  //0 a      1 b
    }

数组推导

ES6允许直接通过现有的数组生成新数组，这种方法称为数组推到

    let a1 = [1,2,3,4,5,6,7];
    let a2 = [for (i of a1) i * 2]  //[2,4,6,8,10,12,14]

等价于

    let a2 =a1.map(function(i){return i*2})
    let a3 = [for (j of a1) if(j >4&& j<7) j];  //[5,6]

等价于

    let a3 = a1.filter(function(j){return j>4&&j<7});
    Array.observe()
    Array.unobserve()

用于监听（取消监听）数组的变化，指定回调函数

6、对象的扩展

Object.is()
比较两个值是否严格相等，它与严格比较运算符的行为基本一致，不过有两点区别 :

• 1、+0不等于-0；

• 2、NaN等于自身

  Object.assign()
  将源对象的所有可枚举属性复制到目标对象，第一个参数是目标对象，后面的参数是源对象，注意如果目标对象和源对象有相同的属性名，或者多个源对象有同名属性，那么后面的属性会覆盖前面的属性

    let target = {a:1,b:1};
    let source1 = {b:2,c:2};
    let source2 = {c:3};
    Object.assign(target ,source1 ,source2);
    target //{a:1,b:2,c:3}

proto属性:用来读取或设置当前对象的prototype对象

    let obj = {
        _proto_:someOtherObj,
        method:function(){...}
    }

Object.setPrototypeOf():用来设置一个对象的prototype对象

    let o = Object.setPrototypeOf({},null);

Object.getPrototypeOf():用来读取一个对象的prototype对象

增强对象的写法

ES6允许直接写入变量和函数作为对象的属性和方法

    var person ={
        name:'张三'，
        birth,  //等同于  birth:birth
        hello(){
            console,log('我的名字是',this.name)
        }
        //等同于hello:function(){...}
    }

属性名表达式

ES6允许定义对象时用表达式作为对象的属性名。在写法上，要把表达式放在方括号内

    var suffix = "word";
    var a = {
        "first word" : "hello",
        [suffix] : "world",
        ["last"+suffix] : "!"
    }
    a["first word"] //hello
    a[suffix] //world
    a["word"] //world
    a[last word] //!

Symbol

ES6引入了一个新的原始数据类型Symbol

    let mySymbol = Symbol('test');
    mySymbol .name //Test
    typeOf mySymbol  //Symbol

Symbol最大的特点就是每一个Symbol都是不相等的， Symbol类型适合作为标识符，用于对象的属性名，保证属性名之间不会发生冲突

Proxy

Proxy可以理解成在目标对象之前，架设一层“拦阻”，外界对该对象的访问，都必须先通过这层拦截，可以被过滤或改写。

    let person = {name:"张三"}；
    let proxy = new Proxy(
        person,{
            get:function(target,property){
                if(property in target){
                    return target[porperty];
                }else{
                    throw new ReferenceError(Perporty\""+perporty+"\" does not exist.");
                }
            }
        }
    )
    property.name //张三
    property.age //抛出一个错误
    Object.observe()
    Objectunobserve()

用来监听或取消监听对象的变化，一旦监听到对象发生变化，就会触发回调函数

7、函数的扩展

ES6允许为函数参数设置默认值

    function Point(x=0,y=0){
        this.x = x;
        this.y = y;
    }
    var p = new Point();  //p = {x:0,y:0}

强制参数：

function throwIfMissing(){
    throw new Error('Missing parameter');
}
function foo(mustBeProvided = throwIfMissing()){
    return mustBeProvided;
}
foo() //Error:Missing parameter

rest参数

ES6引入了rest参数(…变量名)，用于获取函数多余的参数。rest参数搭配的变量是一个数组，该变量将多余的参数放进数组中。rest参数后不能有其他参数，否则会报错

    function add(...values){
        let sun = 0;
        for(let va1 of values){
        sum +=va1;
        }
        return sum;
    }
    add(2,3,5);//10

扩展运算符

扩展运算符是三个点(…)它是rest参数的逆运算，将一个数组转化为用逗号隔开的参数序列。该运算符主要用在函数调用。

    let a = [1];
    let b = [2,3,4];
    let c = [1,...a,...b]//0,1,2,3,4

箭头函数

ES6允许使用箭头定义函数

    var f = v => v;
    var f = function (v) {return v};
    var f =() => 5;
    var f = function(){return 5;};

如果箭头函数的代码块多余一条语句，则用大括号括起来，并用return语句返回。如果返回一个对象，则需要在对象外加小括号。

    var getTempItem = id =>({id:id,name:"Temp"});

注意：
1、函数体内的this对象，绑定定义时所在的对象，而不是使用时所在的对象。
2、不可以当做构造函数，也就是说，不可以使用new命令
3、不可以使用argument对象，该对象的函数体不存在。
4、由于this在箭头函数中被绑定，所以不能用call(),apply(),bind()这些方法改变this的指向。

8、Set和Map数据结构

Set

基本用法

set类似于数组，只不过成员不会重复，Set可接受一个数组为参数来初始化

var item =new Set([1,2,3,4,4,5,5,5,5]);
item.size//5

set在加入值得时候，不会进行类型转换，也就是说5和“5”是不同的值

set的属性

• Set.prototype.constructor：构造函数，默认就是Set函数
• Set.prototype.zise：Set的成员总数

Set的方法

• add(value);添加一个成员
• delete(value);删除一个成员
• has(value);是否有这个成员
• clear();清除所有成员

Map

基本用法

map是键值对的集合，但也能用对象做键。
接受数组初始化

    var map = new Map([["name","张三"],["title","Author"]]);
    map.size//2
    map.has("name")//true
    map.get("name")//"张三"

注意:
只有同一对象的引用，Map结构才会视为同一个键，同样值的两个实例，被视为不同的键。

属性和方法

• size
• set(key,value)
• get(key)
• has(key)
• delete(key)
• clear()
• forEach()

遍历

• keys()
• values()
• entries()

for(let item of map.entries()){
    console.log("Key:%s,Value:%s",item[0],item[1]);
}

WeakMap

只接受对象（null除外）为键名，键名是对象的弱引用。键被清除,WeakMap也会自动清除