数组

数组（Array）是一种用于存储多个值的有序集合。数组允许你按索引访问其元素，并提供了许多内置的方法来操作数组中的数据。

数组创建

可以通过数组字面量来创建数组

//创建数组
let a = [1, 2, 3];

属性和方法

名称	类型	参数	返回值	说明
`length`	属性		`int`	获取数组长度
`join`	方法	`separator?:string`	`string`	将数组的所有元素连接成一个字符串
`push`	方法	`elements: ...any`	`int`	向数组末尾添加一个或多个元素
`pop`	方法		`any`	移除并返回数组末尾的元素
`shift`	方法		`any`	移除并返回数组头部的元素
`unshift`	方法	`elements: ...any`	`int`	向数组头部添加一个或多个元素
`slice`	方法	`start?: int, end?: int`	`any[]`	截取数组的子数组，支持负数索引
`splice`	方法	`start: int, deleteCount?: int, items?: ...any`	`any[]`	从数组中删除或添加元素，并返回被删除的元素组成的数组
`indexOf`	方法	`element: any`	`int`	返回数组中第一次出现元素的索引
`lastIndexOf`	方法	`element: any`	`int`	返回数组中最后一次出现元素的索引
`filter`	方法	`predicate: Function`	`any[]`	过滤数组中的元素
`sort`	方法	`compareFn?:(a:any,b:any) => boolean\|int\|float`	`any[]`	对数组进行排序
`map`	方法	`callback: Function`	`any[]`	映射数组中的元素
`copy`	方法		`any[]`	返回数组的浅拷贝
`delete`	方法	`index: int`	`any[] \| nil`	删除数组中指定索引的元素，索引无效时返回nil
`includes`	方法	`element: any`	`boolean`	检查数组是否包含指定元素
`reverse`	方法		`any[]`	原地反转数组中的元素，并返回修改后的数组
`unique`	方法		`any[]`	原地移除数组中的重复元素，并返回修改后的数组
`some`	方法	`callback: Function`	`boolean`	检查数组中是否有任意元素满足条件
`every`	方法	`callback: Function`	`boolean`	检查数组中所有元素是否都满足条件

length

返回数组的长度。

示例


let arr = [1, 2, 3];
console.log(arr.length); // 输出: 3

join

将数组的所有元素连接成一个字符串。

示例


// 使用逗号连接
let result = ["a", "b", "c"].join(",");
console.log(result); // 输出: "a,b,c"

// 分隔符默认为，
result = ["a", "b", "c"].join();
console.log(result); // 输出: "a,b,c"

push

向数组末尾添加一个或多个元素。

示例

let arr = [1, 2, 3];
let length = arr.push(4);
console.log(length); // 输出(返回新的数组长度): 4
console.log(arr); // 输出: [1, 2, 3, 4]

// 支持一次添加多个元素
arr.push(5, 6);
console.log(arr); // 输出: [1, 2, 3, 4, 5, 6]

pop

移除并返回数组末尾的元素。

示例


let arr = [1, 2, 3];
let item = arr.pop();
console.log(item); // 输出: 3
console.log(arr); // 输出: [1, 2]

shift

移除并返回数组头部的元素。

示例


let arr = [1, 2, 3];
let item = arr.shift();
console.log(item); // 输出: 1
console.log(arr); // 输出: [2, 3]

unshift

向数组头部添加一个或多个元素。

示例


let arr = [1, 2, 3];
let length = arr.unshift(0);
console.log(length); // 输出(返回新的数组长度): 4
console.log(arr); // 输出: [0, 1, 2, 3]

// 支持一次添加多个元素
arr.unshift(-2, -1);
console.log(arr); // 输出: [-2, -1, 0, 1, 2, 3]

slice

截取数组的子数组。两个参数均为可选，支持负数索引（从末尾计算）。

语法

arr.slice(start?:int, end?:int)

参数

start: (可选) 起始索引，默认为0。负数表示从末尾计算。
end: (可选) 结束索引（不包含），默认为数组长度。负数表示从末尾计算。

示例

let arr = [1, 2, 3, 4, 5];
let result = arr.slice(1, 3);
console.log(result); // 输出: [2, 3]

// 省略end参数，截取到末尾
let result2 = arr.slice(2);
console.log(result2); // 输出: [3, 4, 5]

// 使用负数索引
let result3 = arr.slice(-2);
console.log(result3); // 输出: [4, 5]

splice

从数组中删除或添加元素，并返回被删除的元素组成的数组。

语法

arr.splice(start:int, deleteCount?:int, ...items)

参数

start: 起始索引，支持负数索引（从末尾计算）。
deleteCount: (可选) 要删除的元素个数。省略时删除从start到末尾的所有元素；负数视为0。
items: (可选) 要添加到数组中的新元素。

示例

let arr = [1, 2, 3, 4, 5];
arr.splice(1, 2, 6, 7);
console.log(arr); // 输出: [1, 6, 7, 4, 5]

// 只传start，删除从start到末尾的所有元素
let arr2 = [1, 2, 3, 4, 5];
let removed = arr2.splice(2);
console.log(arr2); // 输出: [1, 2]
console.log(removed); // 输出: [3, 4, 5]

indexOf

返回数组中第一次出现元素的索引。

示例


let arr = [1, 2, 3, 2, 1];
let index = arr.indexOf(2);
console.log(index); // 输出: 1

index = arr.indexOf(4);
console.log(index); // 输出: -1

lastIndexOf

返回数组中最后一次出现元素的索引。

示例


let arr = [1, 2, 3, 2, 1];
let index = arr.lastIndexOf(2);
console.log(index); // 输出: 3

index = arr.lastIndexOf(4);
console.log(index); // 输出: -1

filter

过滤数组中的元素。

示例


let arr = [1, 2, 3, 4, 5];
let result = arr.filter(x => x % 2 === 0);
console.log(result); // 输出: [2, 4]

sort

对数组进行排序。比较函数支持返回boolean、int或float类型：

返回boolean：true表示a在b之前
返回int或float：负数表示a在b之前，正数表示a在b之后，0表示相等

语法

arr.sort(compareFn?:(a:any,b:any) => boolean|int|float)

参数

compareFn: (可选) 比较函数。如果不提供比较函数,默认将元素转为字符串进行比较

如果比较函数返回true,表示a元素应该排在b元素之前。如果比较函数返回false,表示a元素不应该排在b元素之前。如果比较函数返回负数，表示a在b之前；返回正数，表示a在b之后；返回0表示相等。

示例

let arr = [3, 1, 4, 1, 5, 9];
arr.sort();
console.log(arr); // 输出: [1, 1, 3, 4, 5, 9]

arr = [3, 1, 4, 1, 5, 9];
arr.sort((i, j) => {
	return i < j
});
console.log(arr); // 输出: [1, 1, 3, 4, 5, 9]

// 使用数值比较函数
arr = [3, 1, 4, 1, 5, 9];
arr.sort((a, b) => a - b);
console.log(arr); // 输出: [1, 1, 3, 4, 5, 9]

map

映射数组中的元素。

示例


let arr = [1, 2, 3];
let result = arr.map(x => x * 2);
console.log(result); // 输出: [2, 4, 6]

copy

返回数组的浅拷贝。

示例


let src = [3, 43, 15, 65, 2];
let dest = src.copy();
console.log(dest); // 输出: [3, 43, 15, 65, 2]

delete

删除数组中指定索引的元素。

示例


let arr = [1, 2, 3, 4, 5];
arr.delete(2);
console.log(arr); // 输出: [1, 2, 4, 5]

includes

检查数组是否包含指定元素。

示例


let arr = [1, 2, 3];
let result = arr.includes(2);
console.log(result); // 输出: true

result = arr.includes(4);
console.log(result); // 输出: false

some

用于测试数组中的某些元素是否满足提供的条件（通过回调函数的测试）。只要数组中至少有一个元素满足条件，some() 方法就会返回true；如果没有任何元素满足条件，则返回false。

用法

array.some(callback(element, index, array));

参数说明

element：当前正在处理的数组元素。
index（可选）：当前元素的索引。
array（可选）：被遍历的数组本身。

示例

// 示例1：检查数组中是否有大于 10 的数
const numbers = [5, 8, 12, 1, 4];
const hasLargeNumber = numbers.some(number => number > 10);
console.log(hasLargeNumber);  // 输出: true （因为12大于10）

// 示例2：检查对象数组中是否有某个属性的值为 true
const users = [
	{id: 1, active: false},
	{id: 2, active: true},
	{id: 3, active: false}
];
const hasActiveUser = users.some(user => user.active === true);
console.log(hasActiveUser);  // 输出: true （因为有一个用户active为true）
// 或者使用显式函数：
const hasActiveUser1 = users.some((user, index, array) => {
	return user.active === true;
});
console.log(hasActiveUser1); // 输出: true （因为有一个用户active为true）

every

用于测试数组中的所有元素是否都满足提供的条件（通过回调函数的测试）。只有当数组中所有元素都满足条件时，every() 方法才会返回 true；如果有一个或多个元素不满足条件，则返回 false。

用法

array.every(callback(element, index, array));

参数说明

element：当前正在处理的数组元素。
index（可选）：当前元素的索引。
array（可选）：被遍历的数组本身。

示例

// 示例1：检查数组中所有数是否都小于 10
const numbers = [5, 8, 6, 1, 4];
const allNumbersLessThanTen = numbers.every(number => number < 10);
console.log(allNumbersLessThanTen);  // 输出: true （因为所有数字都小于10）

// 示例2：检查对象数组中所有用户的 active 属性是否为 true
const users = [
	{id: 1, active: true},
	{id: 2, active: true},
	{id: 3, active: true}
];
const allUsersActive = users.every(user => user.active === true);
console.log(allUsersActive);  // 输出: true （因为所有用户的 active 属性都为 true）

// 示例3：使用显式函数检查
const allUsersActive1 = users.every((user, index, array) => {
	return user.active === true;
});
console.log(allUsersActive1);  // 输出: true （因为所有用户的 active 属性都为 true）

// 示例4：检查数组中所有字符串长度是否大于 3
const words = ['tree', 'book', 'apple'];
const allWordsLongerThanThree = words.every(word => word.length > 3);
console.log(allWordsLongerThanThree);  // 输出: true （因为所有字符串长度都大于3）

// 示例5：检查数组中所有元素是否为正数
const values = [1, 2, 3, 4];
const allValuesPositive = values.every(value => value > 0);
console.log(allValuesPositive);  // 输出: true （因为所有值都是正数）

reverse

反转数组中的元素。

示例


let arr = [1, 2, 3];
arr.reverse();
console.log(arr); // 输出: [3, 2, 1]

unique

移除数组中的重复元素。

示例


let arr = [1, 2, 2, 3, 3, 3];
arr.unique();
console.log(arr); // 输出: [1, 2, 3]

数组

ON THIS PAGE