整理笔记：JS的骚操作，提升代码简洁性

1. 数组去重
   实现数组去重大多都是通过双层遍历或indexOf的方式。
   双层for循环去重

function unique(arr) {
	for(var i = 0; i < arr.length; i++) {
		for(var j = i + 1; j< arr.length; j++) {
			if (arr[i] == arr[j]) {
				arr.splice(j,1); //splice() 方法用于添加或删除数组中的元素,会改变原始数组！
				j--;
				}
			}
		}
		return arr;
}

利用indexOF去重

function unique(arr) {
	if (!Array.isArray(arr)) {
		console.log("type error!");
		return;
	}
	var array = [];
	for (var i = 0; i < arr.length; i++) {
		if(array.indexOf(arr[i] === -1) {  //indexOf() 方法是查找数组内的数值是否存在这个数组内，如果不存在则返回 -1
			array.push(arr[i]); //push()方法可在将新的数值添加到数组中
		}
	}
	return array;
}

更简单的方式：利用Array.from与set去重

function unique(arr) {
	if (!Array.isArray(arr)) {
		console.log("type error!");
		return;
	}
	return Array.from(new Set(arr));
}
          这代码实现不要太简洁！

2. 数组转化为对象（Array to Object）
   常见方法

var obj = {};
var arr = ["1","2","3"];
for (var key in arr) {
	obj[key] = arr[key];
}
console.log(obj)

//输出
//{0：1， 1：2， 2：3}

简单快速方法

const arr = [1,2,3]
const obj = {...arr}
console.log(obj)

//输出
//{0:1, 1:2, 2:3}

3. 合理利用三元表达式
   有些场景需要针对不同的条件，给变量赋予不同的值，往往会采用下面方式

const isGood = true;
let feeling;
if (isGood) {
	feeling = 'good'
}else {
	feeling = 'bad'
}
console.log(`I feel ${feeling}`)

//输出
// I feel good

为什么不采用三元表达式？

const isGood = true;
const feeling = isGood ? 'good' : 'bad'
console.log(`I feel ${feeling}`)

这种所谓的单行思想，其实就是代码的简洁性

4. 转换为数字类型
   这种很常见，大家用的比较多的可能是parseInt()、Number()这种

const age = "69"
const ageConvert = parseInt(age);  //parseInt() 函数可解析一个字符串，并返回一个整数
console.log(typeof ageConvert);

也可以通过+来实现转换

const age = "69";
const ageConvert = +age;
console.log(typeof ageConvert);

//输出: number

5. 转换为字符串类型
   转换为字符串一般用toString()、String()实现

let a = 123
a.toString(); // '123'

也可以通过value + ""这种来实现

let a = 123;
a + ""; //'123'

6. 性能追踪
   如果想测试一段js代码的执行耗时，就可以试试下performance

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

7. 合并对象
   两个对象合并大家用的比较多的可能就是Object.assign

const obj1 = { a:1 }
const obj2 = { b:2 }
console.log(Object.assign(obj1, obj2))

//输出
// { a:1, b:2 }

更简洁的方法

const obj1 = { a:1 }
const obj2 = { b:2 }
const combinObj = { ...obj1, ...obj2 }
console.log(combinObj)

//输出
// { a:1, b:2 }
//也就是通过展开操作符（spread operator）来实现！

8. 短路运算
   可以通过&&或||来简化代码，比如

if (isOnline) {
	postMessage();
}
// 使用&&
isOnline && postMessage();

// 使用//
let name = null || "森林"

9. 数组扁平化
   递归方法
   实现思路：循环数组，如果数据中还有数组的话，递归调用flatten扁平函数（利用for循环扁平），用concat连接，最终返回result

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

function flatten(arr) {
	var result =[];
	for (var i = 0,len = arr.length; i < len; i++) {
		if (Array.isArray(arr[i])) {
			result = result.concat(flatten(arr[i]));
		} else {
			result.push(arr[i]);
		}
	}
	return result;
}
console.log(arr));  // [1,2,3,4]

reduce方法
实现思路：使用reduce, 当数组中还有数组的话，递归调用flatten扁平函数(利用reduce扁平), 用concat连接，最终返回arr.reduce的返回值

var arr = [1,[2,[3,4]]];
function flatten(arr){
    return arr.reduce(function(prev, cur){
        return prev.concat(Array.isArray(cur) ? flatten(cur) : cur)
    },[])
}

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

但是es6提供了一个新方法flat（depth），参数depth，代表展开嵌套数组的深度，默认是1

let arr = [1,[2,3,[4,[5]]]];
arr.flat(3); //[1,2,3,4,5]

10. 求幂运算

Math.pow()方法
求2^10
console.log(Math.pow(2,10));

ES7引入了指数运算符**，**与Math.pow()一样的计算结果
console.log(2 **10); 

// 输出1024

11. 浮点数转为整数
    ~~，>>，<<，>>>，|这些位运算符的方法（推荐这个更快的方式）

console.log(~~6.95); //6
console.log(6.95 >> 0); //6
console.log(6.95 << 0); //6
console.log(6.95 | 0); //6
// >>>不可对负数取整
console.log(~~6.95); //6

大家一般用到Math.floor()、Math.celi()、Math.round()

12. 截断数组

如果有修改数组长度为某固定值的需求

let array = [0,1,2,3,4,5];
array.length = 3;
console.log(array); 

// 输出：[0, 1, 2]

13. 获取数组中的最后一项
    大家用到比较多的是

let arr = [0,1,2,3,4,5];
const last = arr[arr.length - 1];
console.log(last);

// 输出：5

slice方法

let arr = [0,1,2,3,4,5];
const last = arr.slice(-1)[0];
console.log(last);

//输出：5

14. 拷贝数组
    Array.slice方法

const arr = [1,2,3,4,5];
const copyArr = arr.slice();

展开操作符方法

const arr = [1,2,3,4,5];
const copyArr = [...arr];

Array构造函数和展开操作符方法

const arr = [1,2,3,4,5];
const copyArr = new Array(...arr);

Array.concat方法

const arr = [1,2,3,4,5];
const copyArr = arr.concat();

15. 避免多条件并列
    多个||语句
    开发中有时会遇到多个条件，执行相同的语句，这种写法语义性、可读性都不太好

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

switch case方法

switch (status) {
case "process":
case "wait":
case "fail":
	doSomething();
}

includes方法

const enums = ["process", "wait", "fail"];
if (enums.includes(status)) {
	doSomething();
}