一句话总结：
数组为连续且有序的数据结构, 所以若根据下标查找则很快，index[i]一步到位就可实现查询，若遍历查找则很慢(相对而言)。而插入和删除，除了数组末尾的增删很快，其它处则很慢，因为若数组某处要插入或删除一截，当前位置之后的所有元素都会受影响，都必须一个一个地从原来的位置挪动，而数组末尾的增删则不影响其它元素。
常见的时间复杂度:
.entries() 时间复杂度为 O(1)。
迭代器对象会按顺序遍历数组中的每一项，并返回一个包含键（索引）和值的键值对，每次迭代都只需要访问数组中的一个元素，因此时间复杂度为 O(1)。 返回一个包含数组所有索引键值对的迭代器。
values() 时间复杂度为 O(1)
用于返回一个新的 Array Iterator 对象，该对象包含数组中每个元素的值。因为它只是返回一个迭代器对象，而不像遍历数组需要处理所有元素。
在实现上，values() 方法使用迭代器模式（Iterator pattern），通过生成器函数（Generator）返回一个新的 Array Iterator 对象。该对象可以通过 next() 方法逐个返回数组中的每个元素，并在到达数组末尾时返回 { done: true }。
需要注意的是，由于 values() 方法返回的是一个迭代器对象，因此需要使用 for-of 循环或者手动调用 next() 方法来遍历数组的所有元素。同时，在使用 values() 方法时，也需要注意对返回的迭代器对象的正确使用和处理，以避免引发迭代器相关的错误。
isArray() 时间复杂度为 O(1)。
用于判断一个对象是否是数组。isArray() 方法的时间复杂度非常低，几乎可以忽略不计。该方法的底层实现通常是直接返回一个布尔值，即判断目标对象的 [[Class]] 属性是否为 "Array"。
pop() 时间复杂度为 O(1)
在实现上，pop() 方法只需要修改数组的长度属性，并返回被删除的最后一个元素即可，不需要遍历整个数组。因此，pop() 方法的时间复杂度是常数时间复杂度，即 O(1)。
需要注意的是，当数组为空数组时调用 pop() 方法会返回 undefined，而不会有任何错误发生。因此，在使用 pop() 方法时，需要对数组是否为空进行特判。
push() 时间复杂度为 O(1)
用于在数组的末尾添加一个或多个元素，并返回添加元素后的数组的新长度。在实现上，push() 方法只需要修改数组的长度属性，并把新元素添加到数组的末尾即可，不需要遍历整个数组。因此，push() 方法的时间复杂度是常数时间复杂度，即 O(1)。
sort() 时间复杂度为 O(n log n)
用于对数组进行排序，并返回排序后的数组。sort() 方法的时间复杂度不确定，取决于具体的实现和输入数据，不同的实现可能会导致不同的时间复杂度。
在实现上，sort() 方法通常使用经典的快速排序（quicksort）算法，该算法的平均时间复杂度为 O(n log n)，其中 n 是数组的长度，但是最坏情况下的时间复杂度为 O(n^2)，如果数组本身已经有序（升序或降序），则可能会产生最坏情况，导致 sort() 方法的时间复杂度达到 O(n^2)。
为了避免最坏情况，可以使用一些优化措施，例如在排序前随机打乱数组的顺序，或者使用基于归并排序（mergesort）或堆排序（heapsort）的算法，这些算法的时间复杂度为稳定的 O(n log n)。
join() 时间复杂度为 O(n)
用于将数组中的所有元素以指定的分隔符连接成一个字符串。在实现上，join() 方法遍历一遍数组中的所有元素，把它们以指定的分隔符连接起来，并返回一个新的字符串。因此，join() 的时间复杂度和遍历一遍数组是等价的，也就是 O(n)。虽然 join() 的时间复杂度为 O(n)，但是由于该方法本身的功能比较简单，实现方式也比较直接，所以对数组进行 join() 操作的性能消耗很小，在绝大多数情况下不会对程序的性能产生明显的影响。
keys() 时间复杂度为 O(n)
用于获取一个对象的所有属性名（即键），返回一个由所有属性名称组成的数组。在实现上，keys() 方法遍历一遍对象的所有属性，把属性的名称添加到一个数组中，并返回这个数组。因此，keys() 的时间复杂度和遍历一遍对象的所有属性是等价的，也就是O(n)。
concat() 数组末尾操作，时间复杂度O(n)
具体来说，concat() 方法会将第一个数组的所有元素加入到结果数组中，然后将第二个数组的所有元素加入到结果数组中，以此类推，直到所有输入数组中的元素都被添加到结果数组中。因此，它的时间复杂度与元素总数成正比，为 O(n)。
当 concat() 方法只有一个参数且参数为一个空数组时，它的时间复杂度为 O(1)，因为它只需要返回一个新的空数组。在其他情况下，它的时间复杂度都为 O(n)。
copyWithin() 时间复杂度为 O(n)
copyWithin() 方法需要遍历被复制的元素区间，并将每个元素复制到另一个位置，最终生成一个新的数组。由于需要将区间内所有元素复制一遍，因此时间复杂度为 O(n)。
.every() 时间复杂度为 O(n)
具体来说，every() 方法需要遍历数组中的每一个元素，并对其进行指定条件的判断，只有所有元素都满足条件时，该方法才返回 true。如果在遍历过程中发现不符合条件的元素，则会立即停止遍历，并返回 false。因此，时间复杂度为 O(n)。
fill() 时间复杂度为 O(n)
具体来说，fill() 方法需要遍历数组中的每一个元素，并将其替换为指定的元素。因为需要遍历数组中的所有元素，所以时间复杂度为 O(n)。
filter() 时间复杂度为 O(n)
具体来说，filter() 方法需要遍历数组中的每一个元素，并对每个元素进行指定条件的判断。如果满足条件，就将该元素加入到结果数组中。因为需要遍历数组中的所有元素，并将满足条件的元素挑选出来，所以时间复杂度为 O(n)。不会修改原数组，而是返回一个新的数组。
find() 时间复杂度为 O(n)
具体来说，find() 方法需要遍历数组中的每一个元素，并对每个元素进行指定条件的判断。如果找到第一个符合条件的元素，就返回该元素的值，并立即停止遍历。因为需要遍历数组中的所有元素，所以最坏情况下的时间复杂度为 O(n)。
findIndex() 时间复杂度为 O(n)
具体来说，findIndex() 方法需要遍历数组中的每一个元素，并对每个元素进行指定条件的判断。如果找到第一个符合条件的元素，就返回该元素在数组中的索引值，并立即停止遍历。因为需要遍历数组中的所有元素，所以最坏情况下的时间复杂度为 O(n)。如果没有找到满足条件的元素，则返回 -1。
findLast() 时间复杂度为 O(n)
具体来说，findLast() 方法需要遍历数组中的每一个元素，并对每个元素进行指定条件的判断。findLast() 方法返回数组中满足提供的测试函数条件的最后一个元素的值。如果没有找到对应元素，则返回 undefined.
findLastIndex 时间复杂度为 O(n)
具体来说，findLastIndex() 方法需要遍历数组中的每一个元素，并对每个元素进行指定条件的判断。findLast() 方法返回数组中满足提供的测试函数条件的最后一个元素的索引。如果没有找到对应元素，则返回 -1.
flat() 时间复杂度是 O(n)
flat() 方法需要递归遍历所有的元素，所以时间复杂度是 O(n)，其中 n 表示数组中所有元素的个数。flat() 用于将嵌套的数组平铺为一个一维数组。flat() 方法会按照一个指定的深度，递归地将数组中的所有元素提取出来，并放入一个新数组中，该新数组将成为返回值。如果没有提供深度选项，则默认的深度为1。
some() 时间复杂度为 O(n)
在实现上，some() 方法依次遍历数组中的元素，并对每个元素应用指定的回调函数，直到找到一个返回值为 true 的元素为止。如果找到了这样的元素，some() 方法就会立即返回 true，并停止遍历剩余的元素。否则，如果数组中所有元素都不符合指定规则，则 some() 方法返回 false。因此，some() 方法的时间复杂度为 O(n)。
forEach()时间复杂度是 O(n)
它用于遍历数组中的每个元素，并对每个元素执行指定的操作，例如输出到控制台、修改元素值等。forEach() 方法没有返回值，而是为每个元素调用指定的回调函数，通常用于循环遍历数组。无法在循环中使用 break 和 continue 的控制语句，也无法使用 return 来提前结束循环。
map() 时间复杂度为 O(n)
用于对数组中的每个元素进行操作，返回一个新的数组，其中包含对每个元素进行操作后的对应结果。在实现上，map() 方法遍历一遍数组中的所有元素，对每个元素进行指定的操作，并把处理后的结果添加到一个新数组中，最终返回这个新数组。
需要注意的是，map() 方法不会修改原始数组，而是返回一个新的数组。如果不需要保留原始数组，可以考虑使用 forEach() 方法或 for...of 循环来代替 map() 方法。
reduce() 时间复杂度为 O(n)
用于对数组中的每个元素依次执行提供的回调函数，以累加器的方式进行归约，并返回最终的累加结果。reduce() 方法的时间复杂度取决于回调函数的复杂度和数组的长度。假设回调函数的时间复杂度为 O(f)，数组的长度为 n，则 reduce() 方法的时间复杂度为 O(n*f)。
在实现上，reduce() 方法使用提供的初始值（可选）和数组中的第一个元素作为参数调用回调函数，接着用回调函数的返回值作为下一次调用的参数继续执行，直到遍历整个数组，并返回最终累加结果。回调函数被调用的次数为数组的长度，因此，reduce() 方法的时间复杂度为 O(n)，其中 n 是数组的长度。
reduceRight() 时间复杂度为 O(n)
同上, 只是用于从数组的末尾向前依次执行提供的回调函数
shift() 时间复杂度为 O(n)
用于删除数组的第一个元素，并返回被删除的元素。在实现上，shift() 方法需要把数组中每个元素向前移动一位，以覆盖被删除的第一个元素，并返回被删除的元素。因此，如果数组的长度非常大，shift() 方法的时间复杂度会非常高，达到 O(n)，其中 n 是数组的长度。
unshift() 时间复杂度为 O(n)
用于向数组的开头插入一个或多个元素，并返回插入后数组的新长度。在实现上，unshift() 方法需要将插入位置之后的元素向右移动一位，以腾出位置给新元素。这个操作会导致数组中的所有元素向右移动一位，因此时间复杂度为 O(n)。同时，在插入多个元素时，需要逐一将每个元素插入到开头，因此需要进行 n 次插入操作，进一步增加时间复杂度。
slice() 时间复杂度为 O(n)
在实现上，slice() 方法使用指定的起始索引和结束索引从原数组中提取部分元素，然后将这些元素组成一个新数组并返回。在计算切片后新数组的长度时，对于起始索引和结束索引之间的元素，都需要进行一次遍历，这部分操作的时间复杂度为 O(k)，其中 k 是切片后新数组的长度。因此，slice() 方法的时间复杂度为 O(n)。
toString() 时间复杂度为 O(n)
在实现上，toString() 方法会遍历数组中的每个元素，并使用逗号分隔符将其连接成一个字符串，最后返回该字符串。需要注意的是，如果数组元素是对象类型，则默认情况下会调用其 toString() 方法将其转换为字符串。
需要注意的是，由于 toString() 方法返回的是一个字符串，因此在使用该方法时需要注意类型转换，并避免产生不必要的错误。同时，在使用 toString() 方法时，也需要注意数组元素的类型和范围，以避免产生 JavaScript 实现本身的规范问题。
splice() 时间复杂度为 O(n)
用于向数组中增加或删除元素，并返回被删除的元素。在实现上，splice() 方法在删除元素时需要把被删除元素后面的元素向前移动一位，以填补被删除元素的空缺，因此会导致后续元素的位置发生变化。同时，在插入元素时也需要将插入位置之后的元素向右移动一位，以腾出位置给新元素。这些操作都需要涉及数组中剩余元素的移动，导致时间复杂度为 O(n)。
toLocaleString() 时间复杂度为 O(n)
用于将数组转换为本地化字符串。在实现上，toLocaleString() 方法使用本地化规则来格式化数组中的每个元素，然后使用本地化规则的分隔符将这些元素连接成一个字符串，最后返回该字符串。具体来说，toLocaleString() 方法会对数组中的每个元素调用其 toLocaleString() 方法，并使用本地化规则的适当格式化选项，例如货币符号、日期格式和小数点符号等。
from() 时间复杂度为 O(n)
用于将类似数组或可迭代对象转化为真正的数组。这是一个非常实用的方法，可以将各种可迭代对象（如字符串、Set 对象、Map 对象）转换为数组，方便进行数组的各种操作。
from() 方法接受一个可迭代对象（如一个字符串或一个类数组对象），并返回一个新的数组。可迭代对象是指拥有可迭代接口的对象，具有 Symbol.iterator 属性，例如字符串、数组、Set、Map 等。
includes() 时间复杂度为 O(n)
用于判断数组中是否包含指定的元素。该方法返回一个布尔值，如果目标元素在数组中，返回 true，否则返回 false。 这是因为在处理数组时，includes() 方法需要遍历整个数组，查找目标元素是否存在。因此，如果数组很大，性能开销可能会很大。需要注意的是，在数组中查找元素时，includes() 方法使用的是严格相等运算符（===），
indexOf() 时间复杂度为 O(n)
用于查找数组中指定元素的位置, 如果不存在，则返回 -1。在最坏情况下，需要遍历整个数组才能找到目标元素。indexOf() 方法可能会使用一些优化算法，例如二分查找算法，使得其时间复杂度更低。
lastIndexOf() 时间复杂度为 O(n)
用于从数组的末尾开始查找指定元素第一次出现的位置。在实现上，lastIndexOf() 方法从数组的最后一个元素开始遍历，逐一向前查找指定元素，直到找到第一个匹配的元素，或遍历完所有元素。因此，lastIndexOf() 的时间复杂度和数组的长度是成正比的，即 O(n)。
