JavaScript 数组方法汇总

添加/删除元素

从数组开头或结尾添加和删除元素的方法：

• arr.push(...items) - 在末尾添加元素
• arr.pop() - 从末尾提取元素
• arr.shift() - 从开头提取元素
• arr.unshift(...items) - 在开头添加元素

还有其他一些方法。

splice

如何从数组中删除一个元素？数组是对象，所以可以尝试使用 delete：

let arr = ["I", "go", "home"];delete arr[1]; // 删除 "go"alert(arr[1]); // undefined// 现在 arr = ["I", , "home"];
alert(arr.length); // 3

元素被删除了，但数组仍然有3个元素，可以看到 arr.length == 3。

正常，因为 delete obj.key 是通过键来删除值的，这正是它的工作原理。对于对象而言很适用，但对于数组，通常希望剩余元素能自动填补被删除的位置，从而得到一个长度更短的数组。

所以，应该使用特殊的方法。

arr.splice 方法是数组的瑞士军刀。它可以做任何事情：插入、删除和替换元素。

语法是：

arr.splice(start[, deleteCount, elem1, ..., elemN])

它从索引 start 开始修改 arr：删除 deleteCount 个元素，然后在它们的位置插入 elem1, ..., elemN。返回被删除元素的数组。

通过例子很容易理解。再从删除开始：

let arr = ["I", "study", "JavaScript"];arr.splice(1, 1); // 从索引1删除1个元素alert(arr); // ["I", "JavaScript"]

从索引1开始删除1个元素。在下一个例子中，删除3个元素并用另外两个替换它们：

let arr = ["I", "study", "JavaScript", "right", "now"];// 删除前3个元素并用其他元素替换
arr.splice(0, 3, "Let's", "dance");alert(arr) // 现在 ["Let's", "dance", "right", "now"]

这里可以看到 splice 返回被删除元素的数组：

let arr = ["I", "study", "JavaScript", "right", "now"];// 删除前2个元素
let removed = arr.splice(0, 2);alert(removed); // "I", "study" <-- 被删除元素的数组

splice 方法也可以在不删除任何元素的情况下插入元素。为此，需要将 deleteCount 设置为0：

let arr = ["I", "study", "JavaScript"];// 从索引2开始
// 删除0个元素
// 然后插入 "complex" 和 "language"
arr.splice(2, 0, "complex", "language");alert(arr); // "I", "study", "complex", "language", "JavaScript"

允许负索引

在这里和其他数组方法中，允许使用负索引。它们指定从数组末尾开始的位置，如下所示：

let arr = [1, 2, 5];// 从索引-1（从末尾向前一步）
// 删除0个元素
// 然后插入3和4
arr.splice(-1, 0, 3, 4);alert(arr); // 1,2,3,4,5

slice

arr.slice 方法比看起来类似的 arr.splice 简单得多。

语法是：

arr.slice([start], [end])

它返回一个新数组，复制从索引 start 到 end（不包括 end）的所有项。start 和 end 都可以是负数，在这种情况下，假定位置从数组末尾开始。

它类似于字符串方法 str.slice，但不是子字符串，而是子数组。例如：

let arr = ["t", "e", "s", "t"];alert(arr.slice(1, 3)); // e,s (复制从1到3)alert(arr.slice(-2)); // s,t (复制从-2到末尾)

也可以不带参数调用它：arr.slice() 创建 arr 的副本。这通常用于获取一个副本以便进行不应影响原始数组的进一步转换。

concat

arr.concat 方法创建一个新数组，其中包含来自其他数组和附加项的值。

语法是：

arr.concat(arg1, arg2...)

它接受任意数量的参数 - 数组或值。

结果是一个新数组，包含来自 arr 的项，然后是 arg1、arg2 等。

如果参数 argN 是一个数组，则复制其所有元素。否则，复制参数本身。

例如：

let arr = [1, 2];// 从arr和[3,4]创建一个数组
alert(arr.concat([3, 4])); // 1,2,3,4// 从arr和[3,4]和[5,6]创建一个数组
alert(arr.concat([3, 4], [5, 6])); // 1,2,3,4,5,6// 从arr和[3,4]创建一个数组，然后添加值5和6
alert(arr.concat([3, 4], 5, 6)); // 1,2,3,4,5,6

通常，它只从数组中复制元素。其他对象，即使看起来像数组，也会作为一个整体添加：

let arr = [1, 2];let arrayLike = {0: "something",length: 1
};alert(arr.concat(arrayLike)); // 1,2,[object Object]

…但是如果一个类数组对象有一个特殊的 Symbol.isConcatSpreadable 属性，那么它会被 concat 当作数组处理：添加它的元素而不是它本身：

let arr = [1, 2];let arrayLike = {0: "something",1: "else",[Symbol.isConcatSpreadable]: true,length: 2
};alert(arr.concat(arrayLike)); // 1,2,something,else

遍历：forEach

arr.forEach 方法允许为数组的每个元素运行一个函数。

语法：

arr.forEach(function(item, index, array) {// ... 对元素执行某些操作
});

例如，这显示数组的每个元素：

// 对每个元素调用alert
["Bilbo", "Gandalf", "Nazgul"].forEach(alert);

这段代码更详细地说明了它们在目标数组中的位置：

["Bilbo", "Gandalf", "Nazgul"].forEach((item, index, array) => {alert(`${item} is at index ${index} in ${array}`);
});

函数的结果（如果它返回任何内容）会被丢弃和忽略。

在数组中搜索

现在介绍在数组中搜索的方法。

indexOf/lastIndexOf 和 includes

arr.indexOf 和 arr.includes 方法具有相似的语法，并且基本上与它们的字符串对应物相同，但操作的是项而不是字符：

• arr.indexOf(item, from) - 从索引 from 开始查找 item，并返回找到它的索引，否则返回-1。
• arr.includes(item, from) - 从索引 from 开始查找 item，如果找到则返回 true。

通常，这些方法只使用一个参数：要搜索的项。默认情况下，搜索从开头开始。例如：

let arr = [1, 0, false];alert(arr.indexOf(0)); // 1
alert(arr.indexOf(false)); // 2
alert(arr.indexOf(null)); // -1alert(arr.includes(1)); // true

请注意，indexOf 使用严格相等 === 进行比较。因此，如果们查找 false，它会找到确切的 false 而不是零。

如果想检查数组中是否存在某个项而不需要索引，则首选 arr.includes。

arr.lastIndexOf 方法与 indexOf 相同，但从右向左查找。

let fruits = ['Apple', 'Orange', 'Apple']alert(fruits.indexOf('Apple')); // 0 (第一个Apple)
alert(fruits.lastIndexOf('Apple')); // 2 (最后一个Apple)

includes 方法正确处理 NaN

includes 的一个小但值得注意的特性是它正确处理 NaN，不像 indexOf：

const arr = [NaN];
alert(arr.indexOf(NaN)); // -1 (错误，应该是0)
alert(arr.includes(NaN));// true (正确)

这是因为 includes 是在 JavaScript 后期添加的，并且在内部使用了更新的比较算法。

find 和 findIndex/findLastIndex

想象一下，有一个对象数组。如何找到具有特定条件的对象？这时 arr.find(fn) 方法就派上用场了。

语法是：

let result = arr.find(function(item, index, array) {// 如果返回true，则返回该项并停止迭代// 对于假值情况返回undefined
});

该函数为数组的元素逐个调用：

• item 是元素。
• index 是其索引。
• array 是数组本身。

如果它返回 true，则停止搜索，返回该元素。如果没有找到任何内容，则返回 undefined。

例如，有一个用户数组，每个用户都有 id 和 name 字段。要求找到 id == 1 的那个：

let users = [{id: 1, name: "John"},{id: 2, name: "Pete"},{id: 3, name: "Mary"}
];let user = users.find(item => item.id == 1);alert(user.name); // John

在现实生活中，对象数组是很常见的，所以 find 方法非常有用。

请注意，在示例中为 find 提供了一个参数 item => item.id == 1 的函数。这是典型的，这个函数的其他参数很少使用。

arr.findIndex 方法具有相同的语法，但返回找到元素的索引而不是元素本身。如果没有找到任何内容，则返回-1。

arr.findLastIndex 方法类似于 findIndex，但从右向左搜索，类似于 lastIndexOf。

这是一个例子：

let users = [{id: 1, name: "John"},{id: 2, name: "Pete"},{id: 3, name: "Mary"},{id: 4, name: "John"}
];// 找到第一个John的索引
alert(users.findIndex(user => user.name == 'John')); // 0// 找到最后一个John的索引
alert(users.findLastIndex(user => user.name == 'John')); // 3

filter

find 方法查找单个（第一个）使函数返回 true 的元素。如果可能有很多，可以使用 arr.filter(fn)。
语法类似于 find，但 filter 返回所有匹配元素的数组：

let results = arr.filter(function(item, index, array) {// 如果为true，则将item推入results并继续迭代// 如果没有找到任何内容，则返回空数组
});

例如：

let users = [{id: 1, name: "John"},{id: 2, name: "Pete"},{id: 3, name: "Mary"}
];// 返回前两个用户的数组
let someUsers = users.filter(item => item.id < 3);alert(someUsers.length); // 2

转换数组

继续讨论转换和重新排序数组的方法。

map

arr.map 方法是最有用和最常用的方法之一。

它为数组的每个元素调用函数并返回结果数组。

语法是：

let result = arr.map(function(item, index, array) {// 返回新值而不是item
});

例如，将每个元素转换为其长度：

let lengths = ["Bilbo", "Gandalf", "Nazgul"].map(item => item.length);
alert(lengths); // 5,7,6

sort(fn)

调用 arr.sort() 对数组进行原地排序，更改其元素顺序。它还返回排序后的数组，但通常忽略返回值，因为 arr 本身被修改。

例如：

let arr = [1, 2, 15];// 该方法重新排列arr的内容
arr.sort();alert(arr); // 1, 15, 2

结果有什么奇怪的吗？顺序变成了1, 15, 2。不正确。但为什么？默认情况下，项按字符串排序。
字面上，所有元素都转换为字符串进行比较。对于字符串，应用字典顺序，确实"2" > “15”。
要使用自己的排序顺序，需要提供一个函数作为 arr.sort() 的参数。
该函数应该比较两个任意值并返回：

function compare(a, b) {if (a > b) return 1; // 如果第一个值大于第二个值if (a == b) return 0; // 如果值相等if (a < b) return -1; // 如果第一个值小于第二个值
}

例如，按数字排序：

function compareNumeric(a, b) {if (a > b) return 1;if (a == b) return 0;if (a < b) return -1;
}let arr = [1, 2, 15];arr.sort(compareNumeric);alert(arr); // 1, 2, 15

现在它已经正常工作了。让重新梳理一下发生了什么。arr 可以存放任意类型的数组元素，包括数字、字符串或对象等。有一组待排序的项，要实现排序就需要一个能比较元素的函数，默认是按字符串顺序排列的。

arr.sort(fn) 方法封装了通用的排序算法实现（通常是优化过的快速排序或Timsort）。无需关心其内部运作机制，只需提供用于元素比较的函数 fn 即可，排序算法会自动遍历数组并进行重新排序。

另外，如果需要追踪具体比较了哪些元素——

[1, -2, 15, 2, 0, 8].sort(function(a, b) {alert(a + " <> " + b);return a - b;
});

算法可能在过程中将一个元素与多个其他元素进行比较，但它试图尽可能少地进行比较。

比较函数可以返回任何数字

实际上，比较函数只需要返回一个正数表示"大于"，返回一个负数表示"小于"。这允许编写更短的函数：

let arr = [1, 2, 15];arr.sort(function(a, b) { return a - b; });alert(arr); // 1, 2, 15

箭头函数最佳实践

还记得箭头函数吗？可以在这里使用它们来使排序更整洁：

arr.sort((a, b) => a - b);

这与上面的较长版本完全相同。

对字符串使用 localeCompare

还记得字符串比较算法吗？默认情况下，它按代码比较字母。对于许多字母表，最好使用 str.localeCompare 方法正确排序字母，例如 Ö。例如，让用德语对几个国家进行排序：

let countries = ['Österreich', 'Andorra', 'Vietnam'];alert(countries.sort((a, b) => a > b ? 1 : -1)); // Andorra, Vietnam, Österreich (错误)alert(countries.sort((a, b) => a.localeCompare(b))); // Andorra,Österreich,Vietnam (正确)

reverse

arr.reverse 方法反转 arr 中元素的顺序。

例如：

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

它还返回反转后的数组 arr。

split 和 join

这是现实生活中的一个场景。正在编写一个消息应用程序，用户输入逗号分隔的接收者列表：John, Pete, Mary。但对来说，名称数组比单个字符串更方便。如何得到它？
str.split(delim) 方法正是这样做的。它通过给定的分隔符 delim 将字符串拆分为数组。
在下面的例子中，按逗号后跟空格拆分：

let names = 'Bilbo, Gandalf, Nazgul';let arr = names.split(', ');for (let name of arr) {alert(`A message to ${name}.`); // A message to Bilbo (和其他名称)
}

split 方法有一个可选的第二个数字参数 - 对数组长度的限制。如果提供了，则忽略额外的元素。实际上很少使用：

let arr = 'Bilbo, Gandalf, Nazgul, Saruman'.split(', ', 2);alert(arr); // Bilbo, Gandalf

拆分为字母

使用空字符串 s 调用 split(s) 会将字符串拆分为字母数组：

let str = "test";alert(str.split('')); // t,e,s,t

arr.join(glue) 方法与 split 相反。它创建一个由 arr 项组成的字符串，由 glue 连接。例如：

let arr = ['Bilbo', 'Gandalf', 'Nazgul'];let str = arr.join(';'); // 使用;将数组粘合成字符串alert(str); // Bilbo;Gandalf;Nazgul

reduce/reduceRight

当需要遍历一个数组时 - 可以使用 forEach、for 或 for..of。
当需要遍历并返回每个元素的数据时 - 可以使用 map。

arr.reduce 和 arr.reduceRight 方法也属于这一类，但稍微复杂一些。它们用于基于数组计算单个值。

语法是：

let value = arr.reduce(function(accumulator, item, index, array) {// ...
}, [initial]);

该函数应用于所有数组元素，一个接一个，并将其结果"携带"到下一个调用。

参数：

• accumulator - 是前一个函数调用的结果，第一次调用等于 initial（如果提供了）。
• item - 当前的数组项。
• index - 其位置。
• array - 数组。

当函数被应用时，前一个函数调用的结果作为第一个参数传递给下一个函数。
因此，第一个参数本质上是存储所有先前执行的组合结果的累加器。在最后，它成为 reduce 的结果。听起来复杂吗？通过例子最容易理解。这里一行代码得到数组的和：

let arr = [1, 2, 3, 4, 5];let result = arr.reduce((sum, current) => sum + current, 0);alert(result); // 15

传递给 reduce 的函数只使用2个参数，这通常足够。看看发生了什么细节。
在第一次运行时，sum 是初始值（reduce 的最后一个参数），等于0，current 是第一个数组元素，等于1。所以函数结果是1。
在第二次运行时，sum = 1，将第二个数组元素（2）加进去并返回。
在第三次运行时，sum = 3，再添加一个元素，依此类推…

计算流程：

或者以表格形式，其中每行表示对下一个数组元素的函数调用：

sum	current	result
第一次调用	0	1
第二次调用	1	2
第三次调用	3	3
第四次调用	6	4
第五次调用	10	5

在这里可以清楚地看到前一个调用的结果如何成为下一个调用的第一个参数。

也可以省略初始值：

let arr = [1, 2, 3, 4, 5];// 从reduce中移除初始值（没有0）
let result = arr.reduce((sum, current) => sum + current);alert(result); // 15

结果是一样的。这是因为如果没有初始值，那么 reduce 将数组的第一个元素作为初始值，并从第二个元素开始迭代。

计算表与上面相同，减去第一行。

但这种用法需要非常小心。如果数组为空，那么没有初始值的 reduce 调用会报错。

这是一个例子：

let arr = [];// 错误：没有初始值的空数组的reduce
// 如果存在初始值，reduce将返回它对于空数组arr。
arr.reduce((sum, current) => sum + current);

因此建议始终指定初始值。

arr.reduceRight 方法做同样的事情，但从右到左。

Array.isArray

数组不构成单独的语言类型。它们基于对象。所以 typeof 无助于区分普通对象和数组：

alert(typeof {}); // object
alert(typeof []); // object (相同)

…但是数组使用得如此频繁，以至于有一个特殊的方法：Array.isArray(value)。如果 value 是数组，则返回 true，否则返回 false。

alert(Array.isArray({})); // falsealert(Array.isArray([])); // true

大多数方法支持 “thisArg”

几乎所有调用函数的数组方法 - 如 find、filter、map，除了 sort 之外 - 都接受一个可选的附加参数 thisArg。

这个参数在上面的部分没有解释，因为它很少使用。但为了完整性，必须涵盖它。

这是这些方法的完整语法：

arr.find(func, thisArg);
arr.filter(func, thisArg);
arr.map(func, thisArg);
// ...
// thisArg是可选的最后一个参数

thisArg 参数的值成为 func 的 this。

例如，这里使用 army 对象的方法作为过滤器，thisArg 传递上下文：

let army = {minAge: 18,maxAge: 27,canJoin(user) {return user.age >= this.minAge && user.age < this.maxAge;}
};let users = [{age: 16},{age: 20},{age: 23},{age: 30}
];// 找到army.canJoin返回true的用户
let soldiers = users.filter(army.canJoin, army);alert(soldiers.length); // 2
alert(soldiers[0].age); // 20
alert(soldiers[1].age); // 23

如果在上面的例子中使用 users.filter(army.canJoin)，那么 army.canJoin 将作为独立函数调用，this=undefined，从而导致立即错误。

调用 users.filter(army.canJoin, army) 可以替换为 users.filter(user => army.canJoin(user))，后者做同样的事情。后者更常用，因为对大多数人来说更容易理解。

总结

数组方法速查表：

添加/删除元素：

• push(...items) - 在末尾添加元素
• pop() - 从末尾提取元素
• shift() - 从开头提取元素
• unshift(...items) - 在开头添加元素
• splice(pos, deleteCount, ...items) - 在索引 pos 处删除 deleteCount 个元素并插入 items
• slice(start, end) - 创建一个新数组，从索引 start 复制到 end（不包括 end）
• concat(...items) - 返回一个新数组：复制当前数组的所有成员并添加 items。如果任何 items 是数组，则取其元素

搜索元素：

• indexOf/lastIndexOf(item, pos) - 从位置 pos 开始查找 item，返回索引或-1（如果未找到）
• includes(value) - 如果数组有 value 则返回 true，否则返回 false
• find/filter(func) - 通过函数过滤元素，返回使函数返回 true 的第一个/所有值
• findIndex 类似于 find，但返回索引而不是值

遍历元素：

• forEach(func) - 为每个元素调用 func，不返回任何内容

转换数组：

• map(func) - 从对每个元素调用 func 的结果创建一个新数组
• sort(func) - 原地排序数组，然后返回它
• reverse() - 原地反转数组，然后返回它
• split/join - 将字符串转换为数组并返回
• reduce/reduceRight(func, initial) - 通过对每个元素调用 func 并传递中间结果来计算数组的单个值

其他：

• Array.isArray(value) 检查 value 是否为数组，如果是则返回 true，否则返回 false

请注意，sort、reverse 和 splice 方法会修改数组本身。

这些方法是最常用的，涵盖了99%的使用场景。但还有其他一些：

• arr.some(fn)/arr.every(fn) 检查数组。

  函数 fn 类似于 map 对数组的每个元素调用。如果任何/所有结果为 true，则返回 true，否则返回 false。

  这些方法的行为有点像 || 和 && 运算符：如果 fn 返回真值，arr.some() 立即返回 true 并停止迭代其余项；如果 fn 返回假值，arr.every() 立即返回 false 并停止迭代其余项。可以使用 every 来比较数组：

  function arraysEqual(arr1, arr2) {return arr1.length === arr2.length && arr1.every((value, index) => value === arr2[index]);
  }alert(arraysEqual([1, 2], [1, 2])); // true
  

• arr.fill(value, start, end) - 用重复的 value 从索引 start 到 end 填充数组

• arr.copyWithin(target, start, end) - 将其元素从位置 start 到 end 复制到自身的目标位置（覆盖现有元素）

• arr.flat(depth)/arr.flatMap(fn) 从多维数组创建一个新的扁平数组

查看速查表并找到正确的方法。示例将帮助你正确编写它。

---

单词、短语表

单词/短语	音标	词性	词根/词缀	释义	搭配	例子
array	/əˈreɪ/	n.	-	数组	array methods, array element	“Arrays provide a lot of methods.”
method	/ˈmeθəd/	n.	-	方法	array methods, call a method	“Arrays provide a lot of methods.”
splice	/splaɪs/	v.	-	拼接	splice elements, array splice	“The arr.splice method is a Swiss army knife for arrays.”
slice	/slaɪs/	v.	-	切片	slice array, string slice	“The method arr.slice is much simpler than the similar-looking arr.splice.”
concat	/kənˈkæt/	v.	con- (together) + catenare (to chain)	连接	concat arrays, string concat	“The method arr.concat creates a new array that includes values from other arrays.”
iterate	/ˈɪtəreɪt/	v.	iter- (again)	迭代	iterate array, iterate through	“The arr.forEach method allows to run a function for every element of the array.”
forEach	/fɔːrˈiːtʃ/	n.	-	遍历方法	array forEach, use forEach	“The arr.forEach method allows to run a function for every element of the array.”
indexOf	/ˈɪndeks ɒv/	n.	-	索引查找方法	array indexOf, string indexOf	“The methods arr.indexOf and arr.includes have the similar syntax.”
includes	/ɪnˈkluːdz/	v.	in- (in) + claudere (to close)	包含	array includes, string includes	“The methods arr.indexOf and arr.includes have the similar syntax.”
find	/faɪnd/	v.	-	查找	find element, array find	“Here the arr.find(fn) method comes in handy.”
filter	/ˈfɪltər/	v.	-	过滤	filter array, use filter	“If there may be many, we can use arr.filter(fn).”
map	/mæp/	v.	-	映射	map array, array map	“The arr.map method is one of the most useful and often used.”
sort	/sɔːrt/	v.	-	排序	sort array, array sort	“The call to arr.sort() sorts the array in place.”
reverse	/rɪˈvɜːrs/	v.	re- (back) + vertere (to turn)	反转	reverse array, array reverse	“The method arr.reverse reverses the order of elements in arr.”
split	/splɪt/	v.	-	分割	split string, array split	“The str.split(delim) method does exactly that.”
join	/dʒɔɪn/	v.	-	连接	join array, array join	“The call arr.join(glue) does the reverse to split.”
reduce	/rɪˈdjuːs/	v.	re- (back) + ducere (to lead)	归约	reduce array, array reduce	“The methods arr.reduce and arr.reduceRight also belong to that breed.”
accumulator	/əˈkjuːmjəleɪtər/	n.	ac- (to) + cumulare (to heap)	累加器	reduce accumulator, accumulator value	“accumulator - is the result of the previous function call”
initial	/ɪˈnɪʃəl/	adj.	in- (into) + ire (to go)	初始的	initial value, initial state	“equals initial the first time (if initial is provided)”
isArray	/ɪz əˈreɪ/	n.	-	数组检查方法	Array.isArray, use isArray	“Array.isArray(value) checks value for being an array.”
thisArg	/ðɪs ɑːrg/	n.	-	this参数	pass thisArg, thisArg value	“Almost all array methods that call functions accept an optional additional parameter thisArg.”
element	/ˈelɪmənt/	n.	-	元素	array element, element order	“The element was removed, but the array still has 3 elements.”
property	/ˈprɒpəti/	n.	proper (one’s own)	属性	object property, special property	“other objects, even if they look like arrays, are added as a whole unless they have a special Symbol.isConcatSpreadable property”
algorithm	/ˈælɡərɪðəm/	n.	-	算法	sorting algorithm, comparison algorithm	“includes was added to JavaScript much later and uses the more up-to-date comparison algorithm internally.”
syntax	/ˈsɪntæks/	n.	syn- (together) + tassein (to arrange)	语法	method syntax, syntax error	“The syntax is: arr.splice(start[, deleteCount, elem1, …, elemN])”
callback	/ˈkɔːlbæk/	n.	-	回调函数	callback function, pass callback	“The function is called for elements of the array, one after another.”
multidimensional	/ˌmʌltɪdaɪˈmenʃənəl/	adj.	multi- (many) + dimension	多维的	multidimensional array, flat multidimensional array	“arr.flat(depth)/arr.flatMap(fn) create a new flat array from a multidimensional array.”
cheat sheet	/ˈtʃiːt ʃiːt/	n.	-	速查表	array cheat sheet, use cheat sheet	“A cheat sheet of array methods.”
transformation	/ˌtrænsfərˈmeɪʃən/	n.	trans- (across) + formare (to form)	转换	array transformation, data transformation	“Let’s move on to methods that transform and reorder an array.”
reorder	/ˌriːˈɔːrdər/	v.	re- (again) + order	重新排序	reorder array, reorder elements	“Let’s move on to methods that transform and reorder an array.”
Swiss army knife	/swɪs ˈɑːrmi naɪf/	n.	-	瑞士军刀（比喻多功能工具）	like a Swiss army knife	“The arr.splice method is a Swiss army knife for arrays.”
in place	/ɪn pleɪs/	adv.	-	原地（不创建新对象）	modify in place, sort in place	“The call to arr.sort() sorts the array in place.”
lexicographic	/ˌleksɪkəˈɡræfɪk/	adj.	lexico- (word) + -graphic (writing)	字典序的	lexicographic ordering, lexicographic comparison	“For strings, lexicographic ordering is applied.”
localeCompare	/loʊˈkæl kəmˈpeər/	n.	local + compare	本地化比较方法	string localeCompare, use localeCompare	“For many alphabets, it’s better to use str.localeCompare method.”
intermediate	/ˌɪntərˈmiːdiət/	adj.	inter- (between) + medius (middle)	中间的	intermediate result, intermediate value	“calculate a single value over the array by calling func for each element and passing an intermediate result between the calls.”
elaborate	/ɪˈlæbərət/	adj.	e- (out) + laborare (to work)	详尽的	elaborate code, more elaborate	“And this code is more elaborate about their positions in the target array.”
generic	/dʒəˈnerɪk/	adj.	genus (kind)	通用的	generic sorting, generic algorithm	“The arr.sort(fn) method implements a generic sorting algorithm.”
handle	/ˈhændl/	v.	-	处理	handle errors, handle NaN	“The includes method handles NaN correctly.”
modify	/ˈmɒdɪfaɪ/	v.	modus (measure) + facere (to make)	修改	modify array, modify elements	“Please note that methods sort, reverse and splice modify the array itself.”
occupy	/ˈɒkjupaɪ/	v.	ob- (over) + capere (to take)	占据	occupy space, occupy place	“But for arrays we usually want the rest of elements to shift and occupy the freed place.”
shorthand	/ˈʃɔːrthænd/	n.	-	简写	arrow function shorthand, use shorthand	“We can use arrow functions here for neater sorting.”
standalone	/ˈstændələʊn/	adj.	stand + alone	独立的	standalone function, standalone application	“army.canJoin would be called as a standalone function, with this=undefined”
scenario	/sɪˈnɑːrioʊ/	n.	-	场景	falsy scenario, test scenario	“for falsy scenario returns undefined”
transformation	/ˌtrænsfərˈmeɪʃən/	n.	trans- (across) + formare (to form)	转换	array transformation, data transformation	“methods that transform and reorder an array”
multidimensional	/ˌmʌltɪdaɪˈmenʃənəl/	adj.	multi- (many) + dimensional	多维的	multidimensional array, flat multidimensional array	“arr.flat(depth)/arr.flatMap(fn) create a new flat array from a multidimensional array”
elaborate	/ɪˈlæbərət/	adj.	e- (out) + laborare (to work)	详尽的	elaborate code, more elaborate	“And this code is more elaborate about their positions in the target array.”