《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) <
4000
span class="hljs-keyword">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也会自动清除