ES6总结--（2）

1.数值拓展

    Number.isFinite(), Number.isNaN()

      与isFinite、isNaN不同，这两个新⽅法只对数值有效， Number.isFinite() 对于⾮数值⼀

律返回 false , Number.isNaN() 只有对于 NaN 才返回 true ，⾮ NaN ⼀律返回

false 。

Number.isFinite(0.8); // true 
Number.isFinite(NaN); // false 
Number.isFinite(Infinity); // false 
Number.isNaN(NaN) // true 
Number.isNaN(15) // false

    Number.parseInt(), Number.parseFloat()

      ES6 将全局⽅法 parseInt() 和 parseFloat() ，移植到 Number 对象上⾯，⾏为完全

保持不变。

Number.parseInt('12.34') // 12 
Number.parseFloat('123.45#') // 123.45

    Number.isInteger()

     Number.isInteger() ⽤来判断⼀个数值是否为整数。

Number.isInteger(25) // true 
Number.isInteger(25.1) // false

2.对象拓展

    2.1 对象简写

    ES6 允许在⼤括号⾥⾯，直接写⼊变量和函数，作为对象的属性和⽅法。这样的书写更加

简洁。

let name = "terry"
let age = 12; 
let sayHello = function(){ 
  console.log('hello world'); 
} 
let obj = { 
 name,age,sayName,foo(){
 } 
}

    2.2 对象的扩展运算符

    对象中也可以使⽤扩展运算符

    解构赋值

let {name,...other} = { name: 'terry', age: 12, gender: 'male' };
name // 'terry' 
other // {age: 12, gender: 'male'}

   扩展运算符

    对象的扩展运算符（ ... ）⽤于取出参数对象的所有可遍历属性，拷⻉到当前对象之

中。 对象的扩展运算符等同于使⽤ Object.assign() ⽅法。

let obj = {name: 'terry', age: 12, gender: 'male'} 
let o = {...obj}
o // {name: 'terry', age: 12, gender: 'male'}

   2.3 Object静态方法扩展

     Object.is()

     ⽤于⽐较两个值是否相等，与严格⽐较运算符（===）的⾏为基本⼀致。不同之处只有两个：⼀是+0 不等于 -0 ，⼆是 NaN 等于⾃身。

+0 === -0 //true 
NaN === NaN // false 
Object.is(+0, -0) // false 
Object.is(NaN, NaN) // true

     Object.assign()

    ⽤于对象的合并，将源对象（source）的所有可枚举属性，复制到⽬标对象（target）。

let obj1 = { name: 'terry', age: 13, gender: 'male' }
let obj2 = Object.assign({},obj1) 
obj1 === obj2 // false 
obj1.age = obj.age + 1; 
obj1.age // 14 6 obj2.age // 13

    如果源对象中的对象存在嵌套关系，进⾏浅拷⻉

let o1 = {a:{age:1}}
let o2 = Object.assign({},o1) 
o1 === o2 // false 
o1.a.age = 2 
o2.a.age // 2

    Object.setPrototypeOf()

    为某个对象设置原型

let prototype = { 
 foo(){console.log('foo')}, 
 bar(){console.log('bar')} 
} 
let obj = {} 
Object.setPrototypeOf(obj,prototype)

    Object.getPrototypeOf()

    获取某个对象的原型

Object.getPrototype(obj)

    Object.getOwnPropertySymbols()

    获取指定对象的所有 Symbol 属性名。该⽅法返回⼀个数组，成员是当前对象的所有⽤作

属性名的 Symbol 值。

    Object.keys()

    该⽅法返回⼀个数组，成员是参数对象⾃身的（不含继承的）所有可遍历（enumerable）属性的键名。

let obj = { name: 'terry', age: 14, gender: 'male' }; 
Object.keys(obj) //[ 'name', 'age', 'gender' ]

   Object.values()

    该⽅法返回⼀个数组，成员是参数对象⾃身的（不含继承的）所有可遍历（enumerable）属性的键值。

let obj = { name: 'terry', age: 14, gender: 'male' }; 
Object.values(obj) //[ 'terry', 14, 'male' ]

   Object.entries()

    该⽅法返回⼀个数组，成员是参数对象⾃身的（不含继承的）所有可遍历（enumerable）属性的键值对数组。

let obj = { name: 'terry', age: 14, gender: 'male' }; 
Object.entries(obj) //[ [ 'name', 'terry' ], [ 'age', 14 ], [ 'gender', 'male'] ]

   Object.fromEntries()

    该⽅法是entries的逆操作，⽤于将⼀个键值对数组转为对象。

let entries = [[ 'name', 'terry'], ['age', 14], ['gender', 'male']]; 
let obj = Object.fromEntries(entries)

3.数组拓展

    3.1 扩展运算符

     可以看做是rest的逆运算，⽤于将数组中的元素拆分出来

console.log(...[1, 2, 3]) // 1,2,3

    3.2 静态⽅法扩展

      Array.from()

        ⽤于将两类对象转为真正的数组：类似数组的对象和可遍历的对象

let arrayLike = { 
    '0': 'a', 
    '1': 'b', 
    '2': 'c', 
    length: 3 
};
// ES5的写法
var arr1 = [].slice.call(arrayLike); // ['a', 'b', 'c'] 
// ES6的写法
let arr2 = Array.from(arrayLike); // ['a', 'b', 'c']

      Array.of()

       ⽤于将⼀组值，转换为数组。

Array.of(3, 11, 8) // [3,11,8] 
// 模拟实现
function ArrayOf(){ 
 return [].slice.call(arguments);
 }

4.实例方法拓展

      find() 和 findIndex()

       与filter类似，属于数组类型⽅法， find ⽅法⽤于找出第⼀个符合条件的数组成员。它的参数是⼀个回调函数，所有数组成员依次执⾏该回调函数，直到找出第⼀个返回值为 true 的成员，然后返回该成员。如果没有符合条件的成员，则返回 undefined 。

       findIndex ⽅法的⽤法与 find ⽅法⾮常类似，返回第⼀个符合条件的数组成员的位置，如果所有成员都不符合条件，则返回 -1 。

[1, 4, -5, 10].find((n) => n < 0) //-5 
[1, 5, 10, 15].findIndex(value => value>9) //2

      fill()

     使⽤给定值，填充⼀个数组。

new Array(3).fill(7) 
// [7, 7, 7]

      entries()，keys() 和 values()

      它们都返回⼀个遍历器对象，可以⽤ for...of 循环进⾏遍历，唯⼀的区别是 keys() 是对键名的遍历、 values() 是对键值的遍历， entries() 是对键值对的遍历。

let arr = ["jacky","vicky","tom"] 
let keys = arr.keys() 
let values = arr.values(); 
let entries = arr.entries();

      includes()

       返回⼀个布尔值，表示某个数组是否包含给定的值，与字符串的 includes ⽅法类似。

['jacky','tom','vicky'].includes('tom') //true

      flat()

       该⽅法⽤于将嵌套的数组“拉平”，变成⼀维的数组。该⽅法返回⼀个新数组，对原数据没有影响。 flat() 默认只会“拉平”⼀层，如果想要“拉平”多层的嵌套数组，可以将 flat() ⽅法的参数写成⼀个整数，表示想要拉平的层数，默认为1。 如果不管有多少层嵌套，都要转成⼀维数组，可以用Infinity 关键字作为参数。

[1, 2, [3, 4]].flat() // [1, 2, 3, 4] 
[1, 2, [3, [4, 5]]].flat() // [1, 2, 3, [4, 5]] 
[1, 2, [3, [4, 5]]].flat(2) // [1, 2, 3, 4, 5] 
[1, [2, [3]]].flat(Infinity) // [1, 2, 3]

      flatMap()

       该⽅法对原数组的每个成员执⾏⼀个函数（相当于执⾏ Array.prototype.map() ），然后对返回值组成的数组执⾏ flat() ⽅法。该⽅法返回⼀个新数组，不改变原数组。 该⽅法只能展开⼀层数组。

// 相当于 [[2, 4], [3, 6], [4, 8]].flat() 
[2, 3, 4].flatMap((x) => [x, x * 2]) // [2, 4, 3, 6, 4, 8]

5.函数拓展

    5.1 函数默认值

       声明参数的时候，可以通过'='为参数设置⼀个默认值

function log(x, y = 'World') { 
 console.log(x, y); 
 } 
log('Hello') // Hello World

    5.2 参数解构

function foo({x, y = 5}) { 
 console.log(x, y); 
 } 
foo({}) // undefined 
foo({x: 1}) // 1 5 
foo({x: 1, y: 2}) // 1 2 
foo() // TypeError: Cannot read property 'x' of undefined

    5.3 rest参数

      ⽤于将所有的参数整合到⼀个数组中

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

    5.4 箭头函数

      更简便的函数写法。如果箭头函数不需要参数或需要多个参数，就使⽤⼀个圆括号代表参数部分；如果箭头函数的代码块部分多于⼀条语句，就要使⽤⼤括号将它们括起来，并且使⽤return语句返回。

      箭头函数中的this指向包含该箭头函数的外部函数的this

var f = v => v; 
// 等同于
var f = function (v) {
 return v; 
 }; 
var sum = (num1, num2) => num1 + num2;
// 等同于
var sum = function(num1, num2) {
return num1 + num2;
};
var sum = (num1, num2) => { return num1 + num2; }