JS骚操作

js中一些简化操作

数组去重

双重for循环去重

function unique(arr){
    for(let i=0;i < arr.length; i++){
        for(let j=i+1;j < arr.length;j++){
            if(arr[i] === arr[j]){
                arr[j].splice(j,1);
                j--;
            }
        }
    }
    return arr
}

利用indexOf去重

function unique(arr){
    let newArray = []
    for(let i=0;i<arr.length;i++){
        if( newArray.indexOf(arr[i]) === -1 ){
            newArray.push(arr[i])
        }
    }
    return newArray;
}

使用Array.from()和new Set()去重

function unique(arr){
    return Array.from(new Set(arr));
}

数组转为对象

let arr = ["1","2","3"];
/* 常见处理 */
let obj = {};
for (let key in arr) {
    obj[key] = arr[key];
}
/* 精简类型 */
let obj = {...arrr}

类型转换

//string串转number
Number(string)
parseInt(string)
+string
//number转string
String(number)
number.toString()
number + ''

性能追踪

如果想测试一段代码的执行耗时，可以尝试使用performance

let start = performance.now();
let sum = 0;
for(let i=0;i<10000;i++){
	sum+=i;
}
let end = performance.now();
console.log(start)
console.log(end)

对象合并

let obj1 = {a:1}
let obj1 = {b:2}
//assgin合并方法
Object.assign(obj1,obj2)
//展开操作符合并方法
let con = {...obj1,...obj2}

短路运算

**我们可以通过 && 和 || 来简化我们的代码 **

if(ok){
	search();
}

//使用&&
ok && search();
//使用||
let name = null || 'hellow'

数组扁平化

let arr = [1, [2, [3, 4]]];

//递归实现
function flatten(arr){
	if(Array.isArray(arr)){
		return new Error('传入的值不是数组');
	}
	let result = []; 
	for(let i=0;i<arr.length;i++){
		if(Array.isArray(arr[i])){
			result = result.concat(flatten(arr[i]));
		}else{
			result.push(arr[i])
		}
	}
	return result;
}

//reduce方法实现
function flatten(arr) {
  return arr.reduce(function (prev, next) {
    return prev.concat(Array.isArray(next) ? flatten(next) : next);
  }, []);
}

//简易方法实现 flat(deep) deep是展开嵌套数组的深度
arr.flat(3)

求幂运算

比如实现$2^{10}$，使用JS编写：

//Math.pow(底数,幂数)
let num = Math.pow(2,10);
//es7添加了指数运算符号 **
let num = 2 ** 10;

浮点数转整数

Math.floor() //向上取整，直接去掉所有的小数
Math.ceil()  //向下取整，只要是有小数就 +1
Math.round() //四舍五入

//位运算符 ~~,>>,<<,| 都可以对负数取整   >>>不可对负数取整 都是实现Math.flooor()的功能
~~6.95     //6
6.95 >> 0  //6
6.95 << 0  //6
6.95 | 0   //6
6.95 >>> 0 //6
~6.95      //-7 实现了类似Math.ceil()的功能，但是会转成负数

获取数组的最后一项

arr[arr.length - 1];
let last = arr.slice(-1)[0];

Object.create(null) 和 {}

//Object.create(proto,[propertiesObject]) proto是新创建对象的原型，propertiesObject是自身添加的可枚举的属性
let obj = Object.create(null,{
	a:{
		writable:true,
		configurable:true,
		value:"1"
	}
})

区别：
通过{}创建的对象继承了Object自身的方法，如hasOwnProperty、toString等，在新对象上可以直接使用。

而使用Object.create(null)创建的对象，除了自身属性a之外，原型链上没有任何属性。
也就是我们可以通过Object.create(null)这种方式创建一个纯净的对象，我们可以自己定义hasOwnProperty、toString等方法，完全不必担心会将原型链上的同名方法覆盖掉。

数组拷贝

let copyArr = arr.slice()
let copyArr = [...arr]
let copyArr = new Array(...arr)
let copyArr = arr.concat()

避免多条件并列

if (status === 'process' || status === 'wait' || status === 'fail') {
  doSomething()
}

//switch case 
switch(status) {
  case 'process':
  case 'wait':
  case 'fail':
    doSomething()
}

//includes
const enum = ['process', 'wait', 'fail']
if (enum.includes(status)) {
  doSomething()
}