JS常用静态方法总结

JS对象常用静态方法

Object.is()

用来比较两个值是否严格相等，与严格比较运算符（===）的行为基本一致。

不同之处只有两个：一是+0不等于-0，二是NaN等于自身。

+0 === -0 //true
NaN === NaN // false

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

Object.assign()

Object.assign(newObject,object1,object2,object3...)

用法：

用于对象的合并，将多个对象的所有可枚举属性复制到目标对象。

参数：

newObject：目标对象

object1,object2,object3…：源对象

注意：

1. 目标对象中如果与源对象有同名属性，后边的属性会覆盖原来的属性。
2. 该方法是浅克隆，只复制一层，更深层次的对象克隆的是内存地址。
3. 如果只有一个参数，会直接返回该参数，如果该参数不是对象会转换成对象再返回。undefined和null无法转成对象，所以如果它们作为参数，就会报错。
4. 如果非对象的参数出现在源对象位置，首先会转换成对象，如果无法转换就会跳过

实际开发常见用途

1.为对象添加属性

let obj = { a:1,b:2,c:3 }
Object.assign(obj, { d:4,e:5 });
// obj {a: 1, b: 2, c: 3, d: 4, e: 5}

2.为对象添加方法

Object.assign(SomeClass.prototype, {
  someMethod(arg1, arg2) {
    ···
  },
  anotherMethod() {
    ···
  }
});

// 等同于下面的写法
SomeClass.prototype.someMethod = function (arg1, arg2) {
  ···
};
SomeClass.prototype.anotherMethod = function () {
  ···
};

3.浅拷贝对象

var obj = {
	a: "LiLei",
    b: {
        a: "LiXiaolei",
        b: 21,
    },
  };
var cloneObj = Object.assign({}, obj);
cloneObj.a = "changed";
cloneObj.b.a = "changed";

console.log(obj.a); //LiLei
console.log(obj.b.a); // "changed"

var obj2 = { a: 1, b: 2, c: 3 };
var cloneObj2 = Object.assign({}, obj2);
cloneObj2.b = 10;
console.log(obj2);
// { a: 1, b: 2, c: 3 }
console.log(cloneObj2);
// { a: 1, b: 10, c: 3 }

可以看到修改cloneObj2.b，原来obj2没有发生变化。

4.合并多个对象

let params = {};
let thisform = { a:1,b:2,c:true };
let userInfo = {userName:"LiMing"};
Object.assign(params, thisform, userInfo);
// params {a: 1, b: 2, c: true, userName: "LiMing"}

Object.keys()

Object.keys(object)

**作用：**返回一个由给定对象的自身（不含继承） 可枚举 （enumerable）属性名组成的数组，数组中属性名的排列顺序和 for...in 循环中的顺序一致。

**参数：**要返回其枚举自身属性名的对象。

**返回值：**一个表示给定对象的所有可枚举属性的字符串数组。

var arr = ['a', 'b', 'c'];
console.log(Object.keys(arr)); // console: ['0', '1', '2']

var obj = { 0: 'a', 1: 'b', 2: 'c' };
console.log(Object.keys(obj)); // console: ['0', '1', '2']

var anObj = { 100: 'a', 2: 'b', 7: 'c' };
console.log(Object.keys(anObj)); // console: ['2', '7', '100']

var obj = { b: 'b', c: 'c',a: 'a' };
console.log(Object.keys(obj)); // console: ["b", "c", "a"]

Object.values()

ES2017引入了跟Object.keys配套的Object.values和Object.entries，作为遍历一个对象的补充手段，供for…of循环使用。

Object.values()方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历属性的键值，返回数组的成员顺序，与属性的遍历规则一致。

Object.entries()

Object.entries方法返回一个数组，成员是参数对象自身的（不含继承的）所有可遍历（enumerable）属性的键值对数组。

Object.entries的基本用途是遍历对象的属性，另一个用处是，将对象转为真正的Map结构。

const obj = {foo : "bar", baz : 10};
const map = new Map(Object.entries(obj))
console.log(map);

Object.getOwnPropertyNames(obj)

Object.getOwnPropertyNames返回一个数组，包含对象自身的所有属性（不含 Symbol 属性，但是包括不可枚举属性）的键名。

Object.getOwnPropertySymbols(obj)

Object.getOwnPropertySymbols返回一个数组，包含对象自身的所有 Symbol 属性的键名。

数组常用静态方法

Array.from()

用于将两类对象转化为真正的数组：类数组对象，和可遍历的对象（包括ES6新增加的数据结构Set和Map）

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']
123456789101112

实际开发中，多数用于DOM 操作返回的 NodeList 集合，以及函数内部的arguments对象。

注意：该方法是浅克隆，只复制一层，更深层次的对象克隆的是内存地址。

Array.isArray()

用于判断一个对象是否为数组，如果是返回true，否则返回false

Array.isArray([1, 2, 3]);  
// true
Array.isArray({foo: 123}); 
// false
Array.isArray("foobar");   
// false
Array.isArray(undefined);  
// false

Array.of()

用于将一组数据装进一个数组中。

因为数组构造函数Array()在传入参数个数不同的时候回返回不同的结果，具体返回结果看一下代码。

Array(); 		   // [  ]
Array(7);          // [ , , , , , , ]
Array(1, 2, 3);    // [1, 2, 3]

Array.of(); 	   // [  ]
Array.of(7);       // [7]
Array.of(1, 2, 3); // [1, 2, 3]

Array.of() 方法不存在 Array() 由于参数个数不同而导致的重载，它的行为很稳定，所以一般用前者代替后者。

数值常用静态方法

Number.isFinite(), Number.isNaN()

ES6 在Number对象上，新提供了Number.isFinite()和Number.isNaN()两个方法。

Number.isFinite()用来检查一个数值是否为有限的（finite），即不是Infinity。

注意，如果参数类型不是数值，Number.isFinite一律返回false。

Number.isNaN()用来检查一个值是否为NaN。

如果参数类型不是NaN，Number.isNaN一律返回false。

它们与传统的全局方法isFinite()和isNaN()的区别：

传统方法先调用Number()将非数值的值转为数值，再进行判断，而这两个新方法只对数值有效，

Number.isFinite()对于非数值一律返回false, Number.isNaN()只有对于NaN才返回true，非NaN一律返回false。

Number.parseInt(), Number.parseFloat()

ES6 将全局方法parseInt()和parseFloat()，移植到Number对象上面，行为完全保持不变。

Number.isInteger()

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

JavaScript 内部，整数和浮点数采用的是同样的储存方法，所以 25 和 25.0 被视为同一个值。

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

数学常用静态方法

Math.trunc()

Math.trunc方法用于去除一个数的小数部分，返回整数部分。

Math.trunc = Math.trunc || function(x) {
  return x < 0 ? Math.ceil(x) : Math.floor(x);
};

Math.sign()

Math.sign方法用来判断一个数到底是正数、负数、还是零。对于非数值，会先将其转换为数值。

它会返回五种值。

• 参数为正数，返回+1；
• 参数为负数，返回-1；
• 参数为 0，返回0；
• 参数为-0，返回-0;
• 其他值，返回NaN。

Math.sign(-5) // -1
Math.sign(5) // +1
Math.sign(0) // +0
Math.sign(-0) // -0
Math.sign(NaN) // NaN

如果参数是非数值，会自动转为数值。对于那些无法转为数值的值，会返回NaN。

Math.sign = Math.sign || function(x) {
  x = +x; // convert to a number
  if (x === 0 || isNaN(x)) {
    return x;
  }
  return x > 0 ? 1 : -1;
};

常用计算静态方法

1）PI 取圆周率
2）abs() 取绝对值
3）ceil() 向上取整
4）floor() 向下取整
5）round() 四舍五入
6）max() 取最大值
7）min() 取最小值
8）pow() 取X的y次幂
9）random() 取随机数 >=0 <1