1、Object.prototype.toString.call，返回Object实例的数据类型
let date = new Date()
Object.prototype.toString.call(date) //返回 ['object','date']
Object.prototype.toString.call(date).slice(8,-1), // 截取从第八位到倒数第二位(不含) 返回 date
//获取实例的真实数据类型，toString方法返回(['object','object']),Object的toString允许被修改，通过call方法获取原型上的toString方法，获取到数据类型
//call更改date的上下文指向，指引到object，从而返回真实的数据类型
2、reduce，求和、求大小
let array = [1,23,4,123,523,111234,12312]
array.reduce((a,b) => a+b) //返回所有元素总和
array.reduce((a,b) => a<b) //返回数组中的最小值,同理可得最大值
3、Array(5).fill(0),填充一维数组、二维数组
let array = Array(5).fill(0)
array 返回 [0,0,0,0,0]
array.map(() = > Array(5).fill(0))
array 返回 [[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0],[0,0,0,0,0]]
4、过滤虚假值
let array = [123,4123,'',false,123,-1]
array.filter(Boolean)
//得到[123,41123,123,-1]
5、排序,倒序
//字符串数组
sort(),reverse(),localCompare()
let array = ['Jamf','Bodine','Prentice']
array.sort() //返回['Bodine','Jamf','Prentice']
array.reverse() //返回['Prentice','Jamf','Bodine']
//数字数组
let nums = [123,3,2,53,6]
nums.sort((a,b)=>a-b) // 返回[2,3,6,53,123]
nums.sort((a,b)=>b-a) //返回 [123,53,6,3,2]
//对象数组
const objectArr = [{ first_name: 'Lazslo', last_name: 'Jamf' },{ first_name: 'Pig', last_name: 'Bodine' },{ first_name: 'Pirate', last_name: 'Prentice' }];
objectArr.sort((a, b) => a.last_name.localeCompare(b.last_name));
// 输出
(3) [{…}, {…}, {…}]
0: {first_name: "Pig", last_name: "Bodine"}
1: {first_name: "Lazslo", last_name: "Jamf"}
2: {first_name: "Pirate", last_name: "Prentice"}
length: 3
6、去除重复值
let array = [123,321,5,3,65,3,6,5,65]
let a = array.filter((item,index,arr) => {arr.indexOf(item) === index})
//剔除重复值，如果有indexOf得到的下表索引和index不匹配就不返回
let b = [...new Set(array)]
//通过Set剔除重复值，Set内的元素不允许重复。...操作符，将对象内的每一项都拆开返回
7、创建计数器
var strs = 'akagasdfigs'
let obj = {}
for(let char in strs){
obj[char] = obj[char] +1 || 1
}
console.log(obj)
结果:{a: 3, k: 1, g: 2, s: 2, d: 1, …}
a: 3
d: 1
f: 1
g: 2
i: 1
k: 1
s: 2
[[Prototype]]: Object
8、多层嵌套三元运算符(没什么好说的)
function feve(i){
return i<97?'小于97'
:i<50? '小于50'
:i<30?'i<30';
}
9、对象合并
let xyz = {
age: 10,
name: 'Y'
}
let yzx = {
city: 'YC',
}
let zxy = {
company: 'LCZ'
}
let abcc = Object.assign(xyz,yzx,zxy);
console.log(abcc)
//结果：{age: 10, name: 'Y', city: 'YC', company: 'LCZ'}
let abcd = {...xyz,...zxy,...yzx}
console.log(abcd)
//结果：{age: 10, name: 'Y', company: 'LCZ', city: 'YC'}
10、打乱数组排序(伪随机？)
let arras = [12,45,2,6,2,1,12315,23,56];
arras.sort(()=>Math.random() - 0.5);
console.log(arras)
//(9) [56, 2, 1, 45, 6, 23, 2, 12315, 12]
//(9) [12315, 1, 23, 56, 2, 6, 2, 45, 12]
//(9) [2, 6, 56, 12, 2, 12315, 23, 1, 45]
//通过返回random()的大小进行随机排序
PS：不同浏览器对sort()方法的支持度是不一样，导致这个方法其实只能算是伪随机
1、Chrome的sort:
基于V8引擎，它的排序算进行了很多的优化，但是核心是小于等于10的数组用插入排序（稳定），大于10的采用了quickSort（不稳定）
2、FireFox的sort 基于SpiderMonkey引擎，采用了归并排序（稳定）
3、Safari的sort 基于Nitro（JavaScriptCore ）引擎，如果没有自定义的排序规则传入，采用桶排序（不一定稳定， 桶排序的稳定性取决于桶内排序的稳定性, 因此其稳定性不确定。），传入自定义规则，采用归并排序（稳定）
4、Microsoft Edge/IE9+ 基于Chakra引擎，采用快排（不稳定）
11、打乱数组排序(Plus？)
let arras = [12,45,2,6,2,1,12315,23,56];
let x,j;
for(let i = arras.length;i;i--){
j = Math.floor(Math.random() * i)
x = arras[i-1]
arras[i-1] = arras[j]
arras[j] = x
}
//通过元素位置间的相互交换从而打乱数组排序
//Math.floor(x)返回小于x的最大整数。 3.1=3 4.5=4 5.9=5
//PS 10和11哪个更好有待商榷
12、空合并算子
//空合并运算符 (??) 是一个逻辑运算符，当其左侧操作数为空或未定义时返回其右侧操作数，否则返回其左侧操作数。
let x = null??'301L' //返回301L
let y = 0??'301L' //返回 0
13、Object.entries()、Object.keys()、Object.values()将Object属性转成属性数组
let obj = {a: 1,b:2,c:3}
console.log(Object.entries(obj)) //返回三个数组 ['a',1],['b',2],['c',3]
console.log(Object.keys(obj)) //返回['a','b','c']
console.log(Object.values(obj)) //返回[1,2,3]
14、交换位置
let a:number = 123;
let c:number = 456;
[a,c] = [c,a];
console.log(`a: ${a}`)
console.log(`c: ${c}`)
//打印结果
//[LOG]: "a: 456"
//[LOG]: "c: 123"
或者
let a:number = 123;
let c:number = 456;
let b = a+c
a = b-a
c = b-a
// [a,c] = [c,a];
console.log(`a: ${a}`)
console.log(`c: ${c}`)
//得到结果也是一样的
