阅读 1231

javascript 数组(array) 常用的方法集锦(上)

由于三大框架的出现,对 DOM 的操作转成对数据的操作,对数据的操作主要体现在数组和对象上,今天就以数组为例,对数组的各种操作进行总结

欢迎访问 幸福拾荒者,一个前端知识总结分享平台,与大家一起共同成长共同进步!🙏🙏🙏

concat()

用于连接两个或多个数组,该方法不会改变现有的数组,而仅仅会返回被连接的新数组

  • 语法:Arr.concat(arr1,arr2,……,arrn)
  • 参数: arr1 该参数可以是具体的值,也可以是数组,对象,字符串,bool 值等。可以是任意多个
  • 返回值:返回一个新的数组。该数组是通过把所有 arr1 参数添加到 arrayObject 中生成的。如果要进行 concat() 操作的参数是数组,那么添加的是数组中的每一个元素,而不是数组
let arr = [1, 2];
let arr2 = [123, 456, 678];
let obj = { name: '王二', age: 123 };
let initbool = false;
let newarr = arr.concat([3, 4, 5], 7, 8, [9, 10]);
let newarr2 = arr.concat(3, 4, 5, arr2, obj, initbool);
console.log(arr); //[1, 2]
console.log(newarr); //[1, 2, 3, 4, 5, 7, 8, 9, 10]
console.log(newarr2); //[1, 2, 3, 4, 5, 123, 456, 678, {name: "王二", age: 123}, false]
复制代码

copyWithin()

(ES6 新增) 将指定位置的成员复制到其他位置(会覆盖原有成员),然后返回当前数组。也就是说,使用这个方法,会修改当前数组。

  • 语法: Arr.copyWithin(target, start = 0, end = this.length)

  • 参数:传入的值 默认为 number,传入其他类型值 (bool,string,array,object,undefined)会进行类型转化成 number 类型(参数为 NaN 的话为默认值)

    • target :必需 从该位置开始替换数据。
    • start :可选 从该位置开始读取数据,默认为 0 。如果为负值,表示倒数。
    • end :可选 到该位置前停止读取数据,默认等于数组长度。如果为负值,表示倒数。
  • 返回值:返回当前数组。也就是说,使用这个方法,会修改当前数组

let arr = [1, 2, 3, 4, 5];
let arr1 = [1, 2, 3, 4, 5];
let arr2 = [1, 2, 3, 4, 5];
let arr3 = [1, 2, 3, 4, 5];
let arr4 = [1, 2, 3, 4, 5];
let arr5 = [1, 2, 3, 4, 5];
let arr6 = [1, 2, 3, 4, 5];
let arr7 = [1, 2, 3, 4, 5];
let arr8 = [1, 2, 3, 4, 5];
let arr9 = [1, 2, 3, 4, 5];
let arr10 = [1, 2, 3, 4, 5];
let newarr = arr.copyWithin(0, 3, 4);
arr1.copyWithin(0, 3);
arr2.copyWithin(2);
arr3.copyWithin(1, 2, 4);
arr4.copyWithin(false, 3);
arr5.copyWithin(true, 3);
arr6.copyWithin(2, NaN);
arr7.copyWithin(2);
arr8.copyWithin(2, -1);
arr9.copyWithin(2, -2);
arr10.copyWithin(2, -2, -1);
console.log(arr); //[4, 2, 3, 4, 5]
console.log(newarr); //[4, 2, 3, 4, 5]
console.log(arr1); //[4, 5, 3, 4, 5]
console.log(arr2); //[1, 2, 1, 2, 3]
console.log(arr3); //[1, 3, 4, 4, 5]
console.log(arr4); //[4, 5, 3, 4, 5]
console.log(arr5); //[1, 4, 5, 4, 5]
console.log(arr6); //[1, 2, 1, 2, 3]
console.log(arr7); //[1, 2, 1, 2, 3]
console.log(arr8); //[1, 2, 5, 4, 5]
console.log(arr9); //[1, 2, 4, 5, 5]
console.log(arr10); //[1, 2, 4, 4, 5]
复制代码

entries()

(ES6 新增) 是对键值对的遍历 方法返回一个新的 Array Iterator 对象,该对象包含数组中每个索引的键/值对,不会改变原数组

  • 语法:Array.entries()
  • 参数:
  • 返回值:返回一个新的 Array Iterator 对象,该对象包含数组中每个索引的键/值对
let arr = ['a', 'b', 'c'];
let iterator1 = arr.entries();
console.log(iterator1); //Iterator
console.log(iterator1.next()); //{value: Array(2), done: false}
console.log(iterator1.next().value); //[1, "b"]
console.log(iterator1.next().value); //[2, "c"]
console.log(iterator1.next().value); // undefined
console.log(arr); // ["a", "b", "c"]
复制代码

every()

用于检测数组所有元素是否都符合指定条件(通过函数提供)

  • 语法:Arr.every(function(currentValue,index,arr), thisValue)
  • 参数:
  • function(currentValue, index,arr) 必须。函数,数组中的每个元素都会执行这个函数
    • currentValue:必须。当前元素的值
    • index:可选。当前元素的索引值
    • arr:可选。当前元素属于的数组对象
  • thisValue:可选。对象作为该执行回调时使用,传递给函数,用作 "this" 的值。如果省略了 thisValue ,"this" 的值为 "undefined"
  • 返回值:布尔值。如果所有元素都通过检测返回 true,否则返回 false
const isBigEnough = (element, index, array) => {
	return element >= 10;
};
let passed1 = [12, 5, 8, 130, 44].every(isBigEnough);
let passed2 = [12, 54, 18, 130, 44].every(isBigEnough);
console.log(passed1); // false
console.log(passed2); // true
复制代码

fill()

(ES6 新增)用一个固定值填充一个数组中从起始索引到终止索引内的全部元素

  • 语法:Arr.fill(value, start, end)
  • 参数:
  • value:用来填充数组元素的值
  • start:可选 起始索引,默认值为 0
  • end:可选 终止索引,默认值为 this.length。
  • 返回值:修改后的原数组。
let arr1 = [1, 2, 3];
let arr2 = [1, 2, 3];
let arr3 = [1, 2, 3];
let arr4 = [1, 2, 3];
let arr5 = [1, 2, 3];
let arr6 = [1, 2, 3];
let arr7 = [1, 2, 3];
let arr8 = [1, 2, 3];
let arr9 = [1, 2, 3];
let newarr = arr1.fill(7);
arr2.fill(4);
arr3.fill(4, 1);
arr4.fill(4, 1, 2);
arr5.fill(4, 1, 1);
arr6.fill(4, 3, 3);
arr7.fill(4, -3, -2);
arr8.fill(4, NaN, NaN);
arr9.fill(4, 3, 5); // [1, 2, 3]
console.log(arr1); //[7, 7, 7]
console.log(newarr); //[7, 7, 7]
console.log(arr2); // [4, 4, 4]
console.log(arr3); // [1, 4, 4]
console.log(arr4); // [1, 4, 3]
console.log(arr5); // [1, 4, 3]
console.log(arr6); // [1, 2, 3]
console.log(arr7); // [1, 2, 3]
console.log(arr8); // [4, 2, 3]
console.log(arr9); // [1, 2, 3]
复制代码

filter()

创建一个新数组, 其包含通过所提供函数实现的测试的所有元素

  • 语法:arr.filter(callback(element index array),thisArg])
  • 参数:
  • callback 用来测试数组的每个元素的函数。调用时使用参数 (element, index, array)。返回 true 表示保留该元素(通过测试),false 则不保留。它接受三个参数
    • element:当前在数组中处理的元素
    • index:可选 正在处理元素在数组中的索引
    • array:可选 调用了 filter 筛选器的数组
  • thisArg 可选。执行 callback 时的用于 this 的值。
  • 返回值:一个新的通过测试的元素的集合的数组,如果没有通过测试则返回空数组
let arr = [1, 2, 4, 5, 6, 9, 10, 15];
let newarr = arr.filter(function(x) {
	return x % 2 !== 0;
});
console.log(arr); // [1, 2, 4, 5, 6, 9, 10, 15]
console.log(newarr); //[1, 5, 9, 15]
//去重
let arr2 = ['apple', 'strawberry', 'banana', 'pear', 'apple', 'orange', 'orange', 'strawberry'];
let arr3 = arr2.filter(function(element, index, self) {
	return self.indexOf(element) === index;
});
console.log(arr3); // ["apple", "strawberry", "banana", "pear", "orange"]
复制代码

find()

(ES6 新增) 用来查找目标元素,找到就返回该元素,找不到返回 undefined

  • 语法:arr.find(callback(element index array),thisArg])
  • 参数:
  • callback 在数组每一项上执行的函数,接收 3 个参数
    • element:当前遍历到的元素
    • index:可选 当前遍历到的索引
    • array:可选 数组本身
  • thisArg 可选。指定 callback 的 this 参数。
  • 返回值:当某个元素通过 callback 的测试时,返回数组中的一个值,否则返回 undefined。
let arr1 = [1, 2, 3, 4, 5, 6, 7, 8];
let arr2 = arr1.find((value, index, arr) => {
	return value > 4;
});
let arr3 = arr1.find((value, index, arr) => {
	return value > 14;
});
console.log(arr1); // [1, 2, 3, 4, 5, 6, 7, 8]
console.log(arr2); //5
console.log(arr3); //undefined
复制代码

findIndex()

(ES6 新增) 方法返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1

  • 语法:arr.findIndex(callback(element index array),thisArg])
  • 参数:
  • callback 在数组每一项上执行的函数,接收 3 个参数
    • element:当前遍历到的元素
    • index:可选 当前遍历到的索引
    • array:可选 数组本身
  • thisArg 可选。指定 callback 的 this 参数。
  • 返回值:返回数组中满足提供的测试函数的第一个元素的索引。否则返回-1。
let arr1 = [1, 2, 3, 4, 5, 6, 7, 8];
let arr2 = arr1.findIndex((value, index, arr) => {
	return value > 4;
});
let arr3 = arr1.findIndex((value, index, arr) => {
	return value > 14;
});
console.log(arr1); // [1, 2, 3, 4, 5, 6, 7, 8]
console.log(arr2); //4
console.log(arr3); //-1
复制代码

forEach()

对数组的每个元素执行一次提供的函数

  • 语法:arr.forEach(callback(currentValue index array),thisArg])
  • 参数:
  • callback 在数组每一项上执行的函数,接收 3 个参数
    • currentValue:数组中正在处理的当前元素
    • index:可选 数组中正在处理的当前元素的索引。
    • array:可选 forEach()方法正在操作的数组。
  • thisArg 可选。指定 callback 的 this 参数。
  • 返回值:undefined, 对原数组的操作有影响
let arr = [{ a: 1 }, {}];
arr.forEach(function(item, idx) {
	item.b = idx;
});
console.log(arr); // [{a: 1, b: 0}, {b: 1}]
复制代码

from()

(ES6 新增) from() 方法用于通过拥有 length 属性的对象或可迭代的对象来返回一个数组。如果对象是数组返回 true,否则返回 false。

  • 语法:Array.from(object, mapFunction, thisValue)
  • 参数:
  • object:必需,要转换为数组的对象。
  • mapFunction:可选,数组中每个元素要调用的函数。
  • thisValue:可选,映射函数(mapFunction)中的 this 对象。
  • 返回值:对象是数组返回 true,否则返回 false
let setObj = new Set(['a', 'b', 'c']);
let arr = Array.from(setObj);
console.log(arr); //["a", "b", "c"]
console.log(Array.from([1, 2, 3], x => x + x)); //[2, 4, 6]
复制代码

includes()

(ES6 新增)方法用来判断一个数组是否包含一个指定的值,根据情况,如果包含则返回 true,否则返回 false。

  • 语法:arr.includes(searchElement, fromIndex)
  • 参数:
  • searchElement :需要查找的元素值
  • fromIndex 从该索引处开始查找 searchElement。如果为负值,则按升序从 array.length + fromIndex 的索引开始搜索。默认为 0。
  • 返回值:如果包含则返回 true,否则返回 false; (includes 方法使用全等(===)来判断一个元素是否符合您的搜索)
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, NaN].includes(NaN); // true
let e1 = { name: 'zs', age: '12' };
let e2 = { name: 'ls', age: '13' };
let arr1 = [e1, e2];
let arr4 = arr1.includes(e1);
console.log(arr4); //true
复制代码

indexOf()

方法返回在数组中可以找到一个给定元素的第一个索引,如果不存在,则返回-1。

  • 语法:arr.indexOf(searchElement[, fromIndex = 0])
  • 参数:
  • searchElement: 要查找的元素
  • fromIndex: 开始查找的位置。如果该索引值大于或等于数组长度,意味着不会在数组里查找,返回-1。如果参数中提供的索引值是一个负值,则将其作为数组末尾的一个抵消,即-1 表示从最后一个元素开始查找,-2 表示从倒数第二个元素开始查找 ,以此类推。 注意:如果参数中提供的索引值是一个负值,并不改变其查找顺序,查找顺序仍然是从前向后查询数组。如果抵消后的索引值仍小于 0,则整个数组都将会被查询。其默认值为 0,indexOf 方法使用全等(===)来判断一个元素是否符合您的搜索
  • 返回值:首个被找到的元素在数组中的索引位置; 若没有找到则返回 -1
let arr = [{ name: 'zs', age: '12' }, { name: 'ls', age: '13' }];
let index = arr.indexOf({ name: 'zs', age: '12' });
console.log(index); //-1
let e1 = { name: 'zs', age: '12' };
let e2 = { name: 'ls', age: '13' };
let arr1 = [e1, e2];
let index1 = arr1.indexOf(e2);
console.log(index1); //1
复制代码

isArray()

isArray() 方法用于判断一个对象是否为数组。如果对象是数组返回 true,否则返回 false。

  • 语法:Array.isArray(obj)
  • 参数:
  • obj:必需,要判断的对象。
  • 返回值:布尔值,如果对象是数组返回 true,否则返回 false。
console.log(Array.isArray([])); //true
console.log(Array.isArray([1])); //true
console.log(Array.isArray(new Array())); //true
console.log(Array.isArray()); //false
console.log(Array.isArray({})); //false
console.log(Array.isArray(null)); //false
console.log(Array.isArray(undefined)); //false
console.log(Array.isArray(17)); //false
console.log(Array.isArray('Array')); //false
console.log(Array.isArray(true)); //false
console.log(Array.isArray(false)); //false
复制代码

join()

方法将一个数组(或一个类数组对象)的所有元素连接成一个字符串并返回这个字符串。

  • 语法:Arr.join(separator)
  • 参数:
  • separator: 可选。指定要使用的分隔符。如果省略该参数,则使用逗号作为分隔符。
  • 返回值:返回一个字符串。该字符串是通过把 Arr 的每个元素转换为字符串,然后把这些字符串连接起来,在两个元素之间插入 separator 字符串而生成的。
let elements = ['1', '2', '3'];
console.log(elements.join());
console.log(elements.join('+'));
console.log(elements.join('-'));
复制代码

keys()

(ES6 新增) keys() 方法用于从数组创建一个包含数组键的可迭代对象。如果对象是数组返回 true,否则返回 false。

  • 语法:arr.keys()
  • 参数:
  • 返回值:一个数组可迭代对象
let arr = ['a', 'b', 'c'];
let iterator = arr.keys();
console.log(iterator.next()); // { value: 0, done: false }
console.log(iterator.next()); // { value: 1, done: false }
console.log(iterator.next()); // { value: 2, done: false }
console.log(iterator.next()); // { value: undefined, done: true }
复制代码

lastIndexOf()

lastIndexOf() 方法可返回一个指定的字符串值最后出现的位置,在一个字符串中的指定位置从后向前搜索。如果要检索的字符串值没有出现,则该方法返回 -1。

  • 语法:array.lastIndexOf(item,start)
  • 参数: item: 必需。规定需检索的字符串值 start: 可选的整数参数。规定在字符串中开始检索的位置。它的合法取值是 0 到 stringObject.length -1。如省略该参数,则将从字符串的最后一个字符处开始检索。
  • 返回值:如果在 stringObject 中的 fromindex 位置之前存在 searchvalue,则返回的是出现的最后一个 searchvalue 的位置。
let arr = ['ab', 'cd', 'ef', 'ab', 'cd'];
console.log(arr.lastIndexOf('cd')); //4
console.log(arr.lastIndexOf('cd', 2)); //1
console.log(arr.lastIndexOf('ab', -3)); //0
复制代码

对数组的总结下篇javascript 数组(array) 常用的方法集锦(下)

欢迎访问 幸福拾荒者 了解更多前端知识!

关注下面的标签,发现更多相似文章
评论