ES6新增的api

230 阅读4分钟

Object

Object.assign

Object.assign方法用于将所有可枚举的属性的值从一个或多个源对象分配到目标对象。它将返回目标对象。 说人话就是,它可以用来讲各种属性简单的拷贝到一个目标对象上。我们可以拿它来做一个浅拷贝。

function shallowClone(obj){
    return Object.assign({},obj)  //这边总共可以写多个参数,第一个参数是目标对象,第二个之后则是要拷贝的对象
}

Object.keys

Object.keys用于返回一个由一个给定对象的自身可枚举属性组成的数组,这个数组的排列顺序和自身的排列顺序和正常的排列顺序类似,常常可以用来获得对象类型的属性数组方便遍历

const obj = {a:1,b:2,c:3}
Object.keys(obj) // [a,b,c]

Array

Array.from

这个方法把一个类数组或可迭代的对象创建一个新的,浅拷贝的数组实例 可以传两个参数,第一个是要转化的对象,另一个是要转化的时候进行的方法。

//Array.from(toArrObj,fn)
function toArray(){
            //这个方法将传入的类数组变成一个乘两倍的数组
            return Array.from(arguments,(x)=>{return x*2})
        }

        console.log(toArray(1, 2, 3, 4));

Array.of

创建一个具有可变数量参数的新数组实例,而不考虑参数的数量和实例

Array.of(5) // [,,,,] 它的值为undefined
Array.of(1,2,3) // [1,2,3]

Array.prototype.fill

用一个固定值填充一个数组中从起始索引到终止索引内的全部元素,不包括终止索引

// Array.prototype.fill(value,start[,end]]) 第一个参数是要改变的值,第二个是开始改变值的索引,不写就是全部,第三个是结束的索引,不写就是开始索引之后全部
const array = [1,2,3,4,5]
console.log(array.fill(1, 2, 4)); // [1,2,1,1,5]

Array.prototype.find / Array.prototype.findIndex

返回数组中满足给出测试的第一个元素的值/索引

const arr = ["a","b","c","d"]
console.log(arr.find((x)=>{return x === "c"}));   //返回c
console.log(arr.findIndex((x) => {return x === "c"}));  // 返回2

Array.prototype.copyWithin

浅复制数组的一部分到同一数组中的另一个位置,并返回它,不会改变原数组的长度

//这个方法有三个参数,第一个是要被复制元素替代的位置,第二个是复制的起始部位,第三个是复制的终止部位,但是这个部位的元素不包括,即(x,1,2)就是复制从1开始的一个元素,(x,2,4)就是复制从2开始的两个元素

const arr = [1,2,3,4]
console.log(arr.copyWithin(0, 1, 3));
console.log(arr);

Array.prototype.entries

返回一个新的Array Iterator对象,该对象包含数组中每个索引的键/值对(本人理解这个就是对象iterator的一个封装)

const arr = ['a','b','c']
const iteratorl = arr.entries()
console.log(iteratorl.next().value);  //[0,'a']
console.log(iteratorl.next().value);  //[1,'b']

Array.prototype.keys/Array.prototype.values

方法返回一个包含数组中每个索引键/索引值的Array Iterator对象 说白了就是前面的entries的拆开来

const arr = ['a','b','c']
const iteratorKeys = arr.keys();
console.log(iteratorKeys.next().value); //0
console.log(iteratorKeys.next().value); //1
const iteratorValue = arr.values();
console.log(iteratorValue.next().value); //'a'
console.log(iteratorValue.next().value); //'b'

String

String.prototype.includes

用于判断一个字符串是否包含在另一个字符串中,根据情况返回true或false

const str = "xiaoznz"
console.log(str.includes("xiao")); //true
console.log(str.includes("damao")); //false

String.prototype.repet

构造并返回一个新字符串,该字符串包含被连接在一起的指定数量的字符串的副本

const str = "xiao"
str.repet(2) //"xiaoxiao" 就是简单的重复

String.prototype.startsWith/String.prototype.endWith

用来判断当前字符串是否以另外一个给定的子字符串开头/结尾,根据结果返回true或者false

const str = "xiaolovexiaoxiao"
console.log(str.startsWith("xi"));  // true
console.log(str.endsWith("xi"));  // false

Number

Number.EPSILON

表示1与Number可表示的大于1的最小浮点数之间的差值

//这玩意就是数学上的ε,可以拿来做各种数字的测试
const x = 0.2
const y = 0.3
const z = 0.1
equal = (Math.abs(x-y+z)) < Number.EPSILON  // equal为true

Number.isInteger/Number.isFinite/Number.isNaN

判断给定的参数是否为整数/有穷数/NaN(原有方法中也有个isNaN,es6中改进了方法,现在Number.isNaN更为精确)

// isInteger
const num1 = 123
const num2 = 1.23
console.log(Number.isInteger(num1)); //true
console.log(Number.isInteger(num2)); //false
//isFinite
const num3 = 1/0;
const num4 = 3;
console.log(Number.isFinite(num3)); //false
console.log(Number.isFinite(num4)); //true
//isNaN
const num5 = NaN
const num6 = 1000
console.log(Number.isNaN(num5));  //true
console.log(Number.isNaN(num6));  //false

Number.isSafeInteger

判断传入的参数是否是安全整数(-(2^53-1)到(2^53-1))之间的整数

console.log(Number.isSafeInteger(3));  // true
console.log(Number.isSafeInteger(Math.pow(2, 53)));  //false

Math

Math.sign

返回一个数是正还是负

Math.sign(10) // 1
Math.sign(-2) // -1

Math.imul

将传入的两个参数分别转化为32为整数,相乘后返回32位结果

Math.imul(12,0o4) // 48

以上,基本上总结完了es6新加的一大堆api