欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页

JS常用静态方法总结

程序员文章站 2024-02-20 16:15:04
...

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. 如果只有一个参数,会直接返回该参数,如果该参数不是对象会转换成对象再返回。undefinednull无法转成对象,所以如果它们作为参数,就会报错。
  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新增加的数据结构SetMap

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

如果参数类型不是NaNNumber.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