一、Math常用方法

1、Math.floor()/Math.ceil() 向下取整/向上取整

向下取整：无论正数负数，都取得是最小值
向上取整：无论正数负数，都取的是最大值

Math.floor(1.1)  // 1
Math.floor(-1.1)  // -2
Math.ceil(1.1)  // 2
Math.ceil(-1.1) // -1

2、Math.round() 四舍五入 正数：遇5进一位 负数：大于5进一位 临界点必须大于5

 Math.round(1.5)   // 2
 Math.round(-1.5) // -1
 Math.round(-1.51) // -2

3、Math.min()/Math.max() 最小值/最大值

 Math.min(1,2,3)  // 1
 Math.max(1,2,3)  // 3

4、Math.random() 获取[0-1)之间的数随机

 获取[min,max)之间的随机数
 Math.random()*(max-min)+min

5、Math.abs() 取绝对值

 Math.abs(-1) // 1

6、Math.sqrt() 开平方

 Math.sqrt(9)  // 3

7、Math.pow(n,m) n的m次幂 Math.pow(3,2) //9 8、Math.PI π

 Math.PI  //3.141592653589793

二、数组常用方法

1、Array.pop()/Array.push() 删除最后一个元素，返回值被删除的元素/在数组尾部添加元素，返回值是数组长度（改变原数组）；

2、Array.shift()/Array.unshift() 删除第一个元素，返回值是被删除的元素/在数组头部添加一个元素，返回值是数组的长度（改变原数组）；

3、Array.slice(start,end) 数组截取 （不改变原数组，返回新数组）

4、Array.splice(startIndex, length, item) （改变原数组）

5、Array.reverse() 数组翻转 （改变原数组）

6、Array.join()/split() 将数组转成字符串/将字符串转成数组 （不改变原数组，返回字符串/数组）

7、Array.concat() 连接两个或多个数组 （不改变原数组，返回新数组）

8、Array.indexOf() 字符串、数组通用，返回指定字符首次出现的位置（索引值），返回这个索引值，否则返回-1

9、Array.forEach() 仅遍历数组（item，index，arr），无返回值或返回值为undefined

10、Array.map() 数组遍历 （返回新数组）

11、Array.filter() 数组过滤，返回满足条件的元素（返回新数组）

12、Array.some() 返回布尔值，检测数组中是否有某一个值

13、Array.every() 返回布尔值，检测数组中所有元素是否都符合指定条件

14、Array.reduce(()=>(prev,next,index,arr),initialValue) 数组求和； （第一个参数是上一次前两个参数的和； 第二个参数是下一个下标对应的元素；第三个参数是第二个参数的下标;当前元素数组对象initialValue传递给函数的原始值）

合并二维数组
let arr = [[1, 2], [2, 3], [4, 5], [6, 7]]
let res = arr.reduce((a, b) => { return a.concat(b) }, [])   
console.log(res)//[1,2,2,3,4,5,6,7]

统计一个数组中有多少个不重复的单词
practice = () => {
   let reg = ['B', 'A', 'A', 'B', 'C', 'B', 'G'];
   reg.sort()//会改变原数组
   return reg.reduce((a, b) => { a[b] = (a[b] + 1) || 1; return a; }, {})
}
console.log(practice())//{A: 2, B: 3, C: 1, G: 1}

数组去重
practice = () => {
    let reg = [1,1,2,2,22,4,4,6,6,8];
    return reg.reduce((a, b) => { 
        return a.includes(b)?a:a.concat(b)
        // return a.includes(b)?a:[...a,b] }, [])
}
// console.log(practice())[1, 2, 22, 4, 6, 8]

15、Array.isArray() 是Array 类型的一个静态方法，判断是否为数组

var a = [1,2,3];
console.log(typeof a);  //返回“object”
console.log(Array.isArray(a));  //true

16、Array.from() 将类数组或可迭代对象转为数组

17、Array.of() 数组创建，将参数内不同的元素（数据类型）转为数组，若为空就返回一个空数组

var arr = Array.of()
console.log(arr)  // []

var arr1 = Array.of(1)
console.log(arr1)   // [1]

var arr2 = Array.of(1,2,3)
console.log(arr2)   // [1, 2, 3]

var arr3 = Array.of(undefined)
console.log(arr3)  // [undefined]

var arr4 = Array.of(1,'2',3,true,null,undefined)
console.log(arr4)  // [1, "2", 3, true, null, undefined]

Array.of()与Array()区别：
Array.of(7) 创建一个具有单个元素 **7** 的数组，而 Array(7) 创建一个长度为7的空数组（注意：这是指一个有7个空位(empty)的数组，而不是由7个 undefined 组成的数组）。
var arr5 = Array.of(7) console.log(arr5) // [7]
var arr6 = Array(7) console.log(arr6) // [ , , , , , , ]

18、Array.find() 查找数组中符合条件的第一个元素

19、Array.findIndex() 查找数组中符合条件的第一个元素的索引，找不到返回-1

20、Array.includes() 检测数组中是否包含一个值，返回true、false

21、Array.fill() 将一定范围索引的数组元素内容填充为单个指定的值。第一个参数是填充的数字，第二个参数是起始位置，第三个参数是填充的终止位置的下标

用于向空数组的初始化，接受一个参数，表示填充的值
var arr1 = [];
arr1.fill(6);
console.log(arr1);  //[] 原数组中没有定长度，没有数据可以替换，所以结果仍为空

var arr3 = ['a','b','c'];
arr3.fill(7);
console.log(arr3);  //[7,7,7]，将数组的每一项都替换为7

var arr4 = new Array(5);
arr4.fill(5);
console.log(arr4);//[5,5,5,5,5],将数组的5项都填充为5

-接受两个参数，用于指定填充的起始位置和结束位置
var arr2 = [0,0,0];
arr2.fill(3,2,5);
console.log(arr2); //[0,0,3]从第二位填充到第四位，但是数组的长度只有3

var arr5 = [1,2,3,4,5];
arr5.fill(6,2,4);
console.log(arr5); //[1,2,6,6,5]将数组的第二位到第三位填充为6

22、Array.entries() 遍历键和值 返回一个数组的迭代对象，该对象包含数组的键值对 (key/value)。
迭代对象中数组的索引值作为key，数组元素作为value。

//定义数组
let arr = ['法外狂徒','职业法师','北大还行','花呗宗师','人生小目标'];
arr.entries();//返回一个可迭代数组
/*
[0, "法外狂徒"]
[1, "职业法师"]
[2, "北大还行"]
[3, "花呗宗师"]
[4, "人生小目标"]
*/
for(let [index,value] of arr.entries()){
    //利用数组解构
    console.log(index,value)
}

23、Array.keys() 遍历键名

24、Array.values() 遍历值

25、Array.flat() 嵌套数组转一维数组

26、Array.sort() 数组排序

var arr2 = [20,13,11,8,0,11];
// 按升序排列
arr2.sort(function(a,b){
    //a,b表示相邻的两个元素
    //若返回值>0,数组元素将按升序排列
    //若返回值<0,数组元素将按降序排列
    return a-b; 
});
console.log(arr2); //[0,8,11,11,13,20]; 新数组按升序排列

// 按降序排列
arr2.sort(function(a,b){
    //a,b表示相邻的两个元素
    //若返回值>0,数组元素将按升序排列
    //若返回值<0,数组元素将按降序排列
    return b-a; 
});
console.log(arr2); //[20,13,11,11,8,0]; 新数组按降序排列

// 随机排序
arr2.sort(function(a,b){
    return Math.random()-0.5;  //返回值的正负概率分别为50%，故升降序排列是随机的
});
console.log(arr2); //新数组随机排序