js array属性及方法

最新推荐文章于 2024-06-10 17:21:12 发布

Neil-

最新推荐文章于 2024-06-10 17:21:12 发布

阅读量1.8k

点赞数 2

分类专栏： web前端 javascript 文章标签：数组 map reduce toString filter

本文链接：https://blog.csdn.net/luofeng457/article/details/90213528

版权

web前端同时被 2 个专栏收录

98 篇文章 0 订阅

订阅专栏

javascript

58 篇文章 0 订阅

订阅专栏

arr.length

arr.concat(arr2, arr3, …)：参数为一系列数组，不会改变旧数组，返回一个新数组；

var arr = [1, 2, 3];
arr.concat();	// [1, 2, 3]
arr.concat(4, 5);	// [1, 2, 3, 4, 5]
arr.concat([6, 7]);	// [1, 2, 3, 6, 7]
arr.concat([4, 5], [6, 7, [8, 9]]);	// [1, 2, 3, 4, 5, 6, 7, [8,9]]

arr.copyWithin(target, start, end)：target表示复制到指定目标索引位置；start和end表示拷贝源的起止索引；start和end均可选，end可以为负；会修改原数组；省略start和end时，默认值分别为0和arr.length

var arr = [1, 2, 3, 4];
arr.copyWithin(1, 0, 2);	// [1, 1, 2, 4]
arr = [1, 2, 3, 4];
arr.copyWithin(1);	// [1, 1, 2, 3]
arr = [1, 2, 3, 4];
arr.copyWithin(2);	// [1, 2, 1, 2]
arr = [1, 2, 3, 4];
arr.copyWithin(3);	// [1, 2, 3, 1]

arr.entries()：返回一个数组的迭代对象；

var arr = ['hello', 'world', '\n'];
var it = arr.entries();
it.next().value;	// [0, "hello"]
it.next().value;	// [1, "world"]
it.next().vallue;	// [2, "\n"]
it.next().value;	// undefined

array.every(callback(currentValue,index,arr), thisValue)：currentValue当前元素值；index可选，当前元素的索引值；arr可选，当前元素所属数组；thisValue当做传递给函数的this使用；不会对空数组进行检测，不会修改原数组；
```
var arr = [1, 2, 3, 4];
arr.every(function(cur, index, arr){
	return cur < 5;
})	// true
```

array.fill(value, start, end)：使用value替换数组中的从数组中start位置到end的元素；该方法会修改原数组

var arr = [1, 2, 3, 4];
arr.fill(5, 1, 3);	// [1, 5, 5, 4]
arr = [1, 2, 3, 4];
arr.fill(1);		// [1, 1, 1, 1]

array.filter(function(currentValue,index,arr), thisValue)：参数解析与every()方法类似，不会修改原数组；返回值为满足条件的所有元素的数组集合；
```
arr.filter(function (cur, index, arr) {
	return index > 1;
})
```

array.find(function(currentValue, index, arr),thisValue)：返回满足条件的第一个元素，不会修改原数组

var arr = [1, 2, 3, 4];
arr.find(function (cur, index, arr) {
	return index > 1;
})								// 3

array.findIndex(function(currentValue, index, arr), thisValue)：返回满足条件的第一个元素的索引，不会修改原数组
```
var arr = [11, 12, 13, 14];
arr.findIndex(function (cur, index, arr) {
	return cur > 12;
})					// 2
```

arr.flat([depth])：数组扁平化，depth参数可选，默认为1，用于控制数组扁平化的层级；

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

array.forEach(callback(currentValue, index, arr), thisValue)：数组中的每个元素都会调用一次callback函数；

var arr = [11, 12, 13, 14],
	arr2 = [];
arr.forEach(function (cur, index, arr) {
	arr2.push(cur - 10);
})
console.log(arr2);	// [1, 2, 3, 4]

Array.from(arrayLike[, mapFn[, thisArg]])：将类数组对象转为对象，返回一个新数组；

var arr = [1, 2, 3, 4];
Array.from('foo');	// ["f", "o", "o"]
Array.from(arr);	// [1, 2, 3, 4]
function foo() {
	console.log(Array.from(arguments));	
}
foo();		// [1, 2, 3, 4]
var set = new Set(['foo', 'bar', 'baz', 'foo'])	// Set(3) {"foo", "bar", "baz"}
Array.from(set);	// ["foo", "bar", "baz"]
Array.from([1, 2, 3], x => x*x);	// [1, 4, 9]
Array.from({length: 5}, (v, i) => i);	// [0, 1, 2, 3, 4]

arr.includes(valueToFind[, fromIndex])：判断数组是否包含某个值，fromIndex表示索引起始位置；
```
var arr = [11, 12, 13, 14];
arr.includes(11);	// true
arr.includes(11, 1);	// false
```

Array.isArray(item)：ES6新增，判断输入item是否为数组；

Array.isArray(new Uint8Array(32));	// false
Array.isArray({ __proto__: Array.prototype });	// false

arr.indexOf(item, fromIndex)：返回数组中第一个item的索引，不存在则返回-1；fromIndex为负认为是相对于数组末尾的偏移，但搜索仍然从头开始；对应有arr.lastIndexOf(item, fromIndex)，搜索数组中从末尾搜索的第一个item的索引；
arr.join(combinator)：使用连接符combinator将数组或类数组的元素拼接为一个字符串；

arr.keys()：返回数组的key

var arr = ['a', , 'c'];
console.log([...arr.keys]);	// [0, 1, 2]

arr.map(callback(cur, index, arr), thisArg)：对每个数组元素调用callback，并返回一个新数组；而arr.forEach()方法则没有返回值；

var arr = [1, 2, 3];
arr.map((cur, index, arr) => cur * 2);	// [2, 4, 6]

	
var map = Array.prototype.map;
var a = map.call('Hello World', function(x) { 
  return x.charCodeAt(0); 
});
a;	// [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]

arr.push()、arr.pop()、arr.shift()、arr.unshift()：数组增删操作；

arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])：callback回调会在数组的每个元素上执行一次，accumulator为累加器，每次调用的初始值为上一次callback的返回值，第一次如果提供initialValue则为initialValue，否则为数组的第一个元素值；currentValue为当次调用的元素；index及array为可选，分别为当前元素的索引及被操作的数组；initilValue可选，表示累加器的初始值；

对应有arr.reduceRight()方法；

function reducer(acc, cur, index, arr) {
	console.log(index, acc, cur)
	return acc + cur;
}

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

arr.reduce(reducer, 10);
// 0 10 1
// 1 11 2
// 2 13 3
// 3 16 4
// 20
arr.reduce(reducer);
// 1 1 2
// 2 3 3
// 3 6 4
// 10

/* 数组扁平化 */
var arr = [[1, 2], [3, 4], [5, 6]]
arr.reduce((acc, cur) => acc.concat(cur), []);	// [1, 2, 3, 4, 5, 6]

/* 统计数组中每个元素出现的次数 */
var sports = ['basketball', 'baseball', 'football', 'baseball'];
function counter(balls, ball) {
	if (ball in balls) {
		balls[ball]++
	} else {
		balls[ball] = 1;
	}
	return balls;
}
sports.reduce(counter, {});		// {basketball: 1, baseball: 2, football: 1}

/* Polyfill */
if (!Array.prototype.reduce) {
	Object.defineProperty(Array.prototype, 'reduce', {
		value: function (callback) {
			if (this === null) {
				throw new TypeError('called on null or undefined');
			}
			if (typeof callback !== 'function') {
				throw new TypeError(callback + ' is not a function');
			}

			var o = Object(this);

			var len = o.length >>> 0;	// 转为非负整数

			var k = 0;
			var value;

			// 第一次调用callback
			if (arguments.length >= 2) { // 存在initialValue
				value = arguments[1];
			} else {
				while (k<len && !(k in o)) {
					k++;
				}
				if (k >= len) {
					throw new TypeError('empty Array with no initialValue');
				}
				value = o[k++];
			}

			// 后续调用callback
			while (k < len) {
				if (k in o) {
					value = callback(value, o[k], k, o);
				}
				k++;
			}
			return value;
		}
	})
}

arr.reverse()：数组反转，会修改原数组；

var arr = [1, 2, 3, 4];
arr.reverse();	// [4, 3, 2, 1]

var arr = [[1, 2], [3, 4], [5, 6]];
arr.reverse();	// [[5, 6], [3, 4], [1, 2]]

arr.slice([begin[, end]])：begin参数必须，默认为0，不传或传其他不识别类型的值，begin均为0；begin不小于arr.length返回空数组，begin为负从数组末尾开始截取；end可选，默认为arr.length，可以为负，大于arr.length取arr.length；

该方法不会修改原数组

var arr = [1, 2, 3, 4];
arr.slice();		// [1, 2, 3, 4]
arr.slice(0);		// [1, 2, 3, 4]
arr.slice(null);	// [1, 2, 3, 4]		
arr.slice('aaa');	// [1, 2, 3, 4]		
arr.slice(4);		// []
arr.slice(-2);		// [3, 4]
arr.slice(1,3);		// [2, 3]
arr.slice(1, 5);	// [2, 3, 4]
arr.slice(0, -1);	// [1, 2, 3]
arr.slice(1, -3);	// [];

arr.some(callback(element[, index[, array]])[, thisArg])：判断数组中是否存在元素满足判断条件，返回值为布尔类型；
arr.sort([compareFunction(el1, el2)])：数组排序，比较函数为可选参数；默认以每个元素对应的unicode值进行排序；

Unicode 编码单元（code points）的范围从 0 到 1,114,111（0x10FFFF）。开头的 128 个 Unicode 编码单元和 ASCII 字符编码一样。使用String.prototype.charCodeAt()方法可以查看常见字符对应的unicode编码；数组0对应48，A对应65，a对应97
```
var arr = [2, 1, 3, 4, 11, 21];
arr.sort();		// [1, 11, 2, 21, 3, 4]
var arr = ['Kobe', 'James', 'Jordan'];
arr.sort();		// ["James", "Jordan", "Kobe"]

/* 数值排序 */
var arr = [2, 1, 3, 4, 11, 21];
arr.sort((x, y) => x-y)		// 升序排列
arr.sort((x, y) => y-x)		// 降序排列
```
array.splice(start[, deleteCount[, item1[, item2[, …]]]])：数组添加、删除，仅start为必选；deleteCount为删除元素个数，deleteCount为0或负数，则无元素移除；deleteCount省略或大于arr.length-start，start到数组结束的所有元素均被删除；item1/item2等为添加的数据；返回值为被删除元素组成的数组；该方法会修改原数组
```
var arr = [1, 2, 3, 4, 11, 21];
arr.splice(1);	// arr: [1]
var arr = [1, 2, 3, 4, 11, 21];
arr.splice(1, 3);	// arr: [1, 11, 21]
var arr = [1, 2, 3, 4, 11, 21];
arr.splice(1, 6);	// arr: [1]
var arr = [1, 2, 3, 4, 11, 21];
arr.splice(1, 1, 5, 6)	// arr: [1, 5, 6, 3, 4, 11, 21]
```

arr.toString()：

var arr = [1, [2, 3], [4, [5, 6]]];
arr.toString();		// "1,2,3,4,5,6"

arr.values()：获取数组项的值；

参考文献：

Neil-

关注

2
点赞
踩
7

收藏

觉得还不错? 一键收藏
打赏
0
评论
js array属性及方法

arr.lengtharr.concat(arr2, arr3, …)：参数为一系列数组，不会改变旧数组，返回一个新数组；var arr = [1, 2, 3];arr.concat(); // [1, 2, 3]arr.concat(4, 5); // [1, 2, 3, 4, 5]arr.concat([6, 7]); // [1, 2, 3, 6, 7]arr.concat([4...
复制链接

扫一扫