Js常用数组常用API

JS对数组进行操作的常用API

JS中提供了非常多的对数组进行操作的API，这里给出一些个人用到的API，仅供参考。
能够对原数组进行修改的API共有7个： shift，pop ， unshift，push，sort，reverse，splice

filter/map/reduce

都不会改变原数组
filter，map都返回一个新数组
reduce返回一个值

//filter 不会改变原数组，会返回一个数组 接收一个函数作为参数
const nums = [1,2,3,55,123]
let newNums = nums.filter(function(currentValue, index[可选], array[可选]){
    // currentValue 正在处理的当前元素
    // index 正在处理的当前元素的下标
    // array 方法调用的数组
    //回调函数 需要返回一个boolean
    //true: 会将currentValue加入到数组中
    //false: 过滤掉currentValue
    return 布尔表达式
});

//map 接收一个函数作为参数 会返回一个数组
newNums.map(function(currentValue, index[可选], array[可选]){
    // 参数含义同filter
    return 处理后的值
})

//会返回一个值
//对数组中所有内容汇总
//接收一个函数作为参数 第二个参数为初始化值（可选）
newNums.reduce(function(preValue, currentValue, currentIndex[可选], array[可选]){
    // preValue: 为上一次的返回值 
    // 在第一次调用时，若指定了初始值 initialValue，其值则为 initialValue，
    // 否则为数组索引为 0 的元素 array[0]。
    
    // currentValue：数组中正在处理的元素。
    // 在第一次调用时，若指定了初始值 initialValue，其值则为数组索引为 0 的元素 array[0]，
    // 否则为 array[1]。
    
    // currentIndex：数组中正在处理的元素的索引。
    // 若指定了初始值 initialValue，则起始索引号为 0，否则从索引 1 起始。
    // array：用于遍历的数组
    return 处理
}, initialValue[可选] );

// 三者可以链式调用
array.fiter().map().reduce();

concat

两个不同的数组进行合并，保持原有的数组不变，返回一个新的数组

// 用于合并两个或多个数组，保持原有的数组不变，返回一个新的数组
let res = arr1.concat(arr2, arr3);
// arr1 = [1,2]  arr2 = [2,3]  arr3 = [4,5]
// res = [1,2,2,3,4,5]

// 如果传入的参数 数据类型是字符串，数字和布尔（不是相关对象），concat将字符串和数字的值复制到新数组中。
var alpha = ['a', 'b', 'c'];
var alphaNumeric = alpha.concat(1, [2, 3]);
console.log(alphaNumeric);
// results in ['a', 'b', 'c', 1, 2, 3]

join

把数组中的所有元素放入一个字符串，最后形成的字符串可以再进行处理
该方法不会改变原数组

// .join（）方法 一般情况就直接转为字符串了，如果在括号内填写相关符号的话，那意思就是根据相关的符号进行分隔。
let a = [1,23,4]
n = a.join();
n2 = a.join("");
console.log(n);  //1,23,4 默认以 ','相连
console.log(n2); //1234
console.log(a);  //[1,23,4]

shift/pop ; unshift/push

都会改变原数组

shift() 弹出第一个元素并返回该值
pop()  移除数组末尾的元素并返回该值

unshift(item) 方法可向数组的开头添加一个或更多元素，并返回新的长度。
push(item) 将一个或多个元素添加到数组的末尾，并返回该数组的新长度。

splice/slice

splice 会改变原始数组
slice 不会改变原数组

array.splice(index,deleteCount,item1,.....,itemX)
index: 必需。规定从何处添加/删除元素。该参数是开始插入（或）删除的数组元素的下标，必须是数字。
deleteCount: <=0表示添加元素；如果未规定此参数，则删除从 index 开始到原数组结尾的所有元素。
item1,.....,itemX: 可选。要添加到数组的新元素


slice(start, end) 方法以新的数组对象，返回数组中被选中的元素。
方法选择从给定的 start 参数开始的元素，并在给定的 end 参数处结束，但不包括
slice()返回所有  slice(start)返回从start开始的所有

indexOf / includes

// 返回数组中num所在的下标,没有在其中则返回 -1
arr.indexOf(num) 

 // 判断num是否在arr中，在，返回true;不在,返回false
arr.includes(num)

some

测试数组中是不是至少有1个元素通过了被提供的函数测试，找到通过的立即返回true。它返回的是一个Boolean类型的值。

对一个空数组进行测试，在任何情况下它返回的都是false。

不会改变原数组

let tes = [2,3,5,5,2]
// tes中是否有大于4的元素
let res = tes.some(function(element){
    return element > 4;
})
console.log(res);  // true

every

every() 方法测试一个数组内的所有元素是否都能通过某个指定函数的测试。所有都通过则返回true，否则立即返回false。

若收到一个空数组，此方法在任何情况下都会返回 true。

let tes = [2,3,5,5,2]
// tes中是否都大于4
let res = tes.every(function(element){
    return element > 4;
})
console.log(res);  // false

find / findIndex

find() 方法返回数组中满足提供的测试函数的第一个元素的值。否则返回undefined

some判读数组中有没有满足提供的测试函数的元素

findIndex方法返回数组中满足提供的测试函数的第一个元素的索引

let tes = [2,3,5,5,2]
// 第一个大于4的元素的值 没找到返回undefined
let index = tes.find(value => value > 4);
console.log(index);  // 5

// 第一个大于4的元素的索引 没找到返回 -1
index = tes.findIndex(value => value > 4);
console.log(index);  // 2

fill

用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。不包括终止索引。

// arr.fill(value[, start[, end]])
const array1 = [1, 2, 3, 4];

// fill with 0 from position 2 until position 4
console.log(array1.fill(0, 2, 4));
// [1, 2, 0, 0]

// fill with 5 from position 1
console.log(array1.fill(5, 1));
// [1, 5, 5, 5]

console.log(array1.fill(6));
// [6, 6, 6, 6]

// 初始化一个数组
const array = new Array(10).fill(0);
// 创建了一个大小为10的全是0的数组

flat

flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。数组扁平化。

语法：
指定要提取嵌套数组的结构深度，默认值为 1
var newArray = arr.flat([depth])

const arr1 = [0, 1, 2, [3, 4]];
console.log(arr1.flat());
// [0, 1, 2, 3, 4]

// flat() 方法会移除数组中的空项:

sort

array.sort(sortfunction)
可选。规定排序顺序。必须是函数。
比较函数两个参数 a 和 b，其返回值如下：
　若 a 小于 b，在排序后的数组中 a 应该出现在 b 之前，则返回一个小于 0 的值。
　若 a 等于 b，则返回 0。
　若 a 大于 b，则返回一个大于 0 的值。

var points = [40,100,1,5,25,10];
points.sort(function(a,b){
		return a - b
	});  // 1,5,10,25,40,100

reverse

reverse方法没有参数，原数组改变了，返回的数组也是改变后的数组

var arr = [1, 2, 3];
var arrReturn = arr.reverse();
console.log(arr); //[3,2,1]
console.log(arrReturn); //[3,2,1]

后续更新ing…