一.数组

1. 添加和删除元素的方法

1.1 push

  • 功能:在数组末尾添加一个或多个元素。

  • 返回值:新数组的长度。

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    arr.push(4, 5); // [1, 2, 3, 4, 5]

1.2 pop

  • 功能:删除数组末尾的一个元素。

  • 返回值:被删除的元素。

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    const removed = arr.pop(); // [1, 2], removed = 3

1.3 unshift

  • 功能:在数组开头添加一个或多个元素。

  • 返回值:新数组的长度。

  • 示例:

    1
    2
    const arr = [2, 3];
    arr.unshift(0, 1); // [0, 1, 2, 3]

1.4 shift

  • 功能:删除数组开头的一个元素。

  • 返回值:被删除的元素。

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    const removed = arr.shift(); // [2, 3], removed = 1

1.5 splice

  • 功能:修改数组内容,可删除、替换或添加元素。

  • 返回值:被删除的元素组成的数组。

  • 示例:

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

2. 查找元素的方法

2.1 indexOf

  • 功能:返回指定元素在数组中的第一个索引,如果不存在则返回 -1。

  • 示例:

    1
    2
    const arr = [1, 2, 3, 2];
    arr.indexOf(2); // 1

2.2 lastIndexOf

  • 功能:返回指定元素在数组中的最后一个索引,如果不存在则返回 -1。

  • 示例:

    1
    2
    const arr = [1, 2, 3, 2];
    arr.lastIndexOf(2); // 3

2.3 includes

  • 功能:判断数组是否包含指定的元素。

  • 返回值:布尔值。

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    arr.includes(2); // true

2.4 find

  • 功能:返回第一个满足条件的元素。

  • 示例:

    1
    2
    const arr = [1, 2, 3, 4];
    const found = arr.find(num => num > 2); // 3

2.5 findIndex

  • 功能:返回第一个满足条件的元素的索引。

  • 示例:

    1
    2
    const arr = [1, 2, 3, 4];
    const index = arr.findIndex(num => num > 2); // 2

3. 遍历数组的方法

3.1 forEach

  • 功能:对数组的每个元素执行回调函数。

  • 返回值undefined

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    arr.forEach(num => console.log(num)); // 输出:1, 2, 3

3.2 map

  • 功能:创建一个新数组,数组中的每个元素是回调函数的返回值。

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    const squared = arr.map(num => num ** 2); // [1, 4, 9]

3.3 filter

  • 功能:创建一个新数组,包含所有通过测试的元素。

  • 示例:

    1
    2
    const arr = [1, 2, 3, 4];
    const even = arr.filter(num => num % 2 === 0); // [2, 4]

3.4 reduce

  • 功能:通过回调函数对数组中的每个值进行累加,返回最终结果。

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    const sum = arr.reduce((acc, curr) => acc + curr, 0); // 6

3.5 reduceRight

  • 功能:从数组的末尾开始执行回调函数。

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    const result = arr.reduceRight((acc, curr) => acc + curr, 0); // 6

4. 转换数组的方法

4.1 join

  • 功能:将数组元素转为字符串并用指定的分隔符连接。

  • 返回值:字符串。

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    arr.join('-'); // "1-2-3"

4.2 toString

  • 功能:将数组转为逗号分隔的字符串。

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    arr.toString(); // "1,2,3"

4.3 flat

  • 功能:将嵌套数组展开为一个新数组。

  • 参数:展开的深度(默认为 1)。

  • 示例:

    1
    2
    const arr = [1, [2, [3]]];
    arr.flat(2); // [1, 2, 3]

4.4 flatMap

  • 功能:对每个元素执行回调函数后扁平化结果。

  • 示例:

    1
    2
    const arr = [1, 2, 3];
    arr.flatMap(x => [x, x * 2]); // [1, 2, 2, 4, 3, 6]

5. 排序和操作数组的方法

5.1 sort

  • 功能:对数组进行排序(默认按字符串 Unicode 顺序)。

  • 注意:对原数组进行修改。

  • 示例:

    1
    2
    const arr = [3, 1, 2];
    arr.sort((a, b) => a - b); // [1, 2, 3]

5.2 reverse

  • 功能:反转数组顺序。

  • 注意:对原数组进行修改。

  • 示例:

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

5.3 concat

  • 功能:合并数组,不改变原数组。

  • 示例:

    1
    2
    3
    const arr1 = [1, 2];
    const arr2 = [3, 4];
    const result = arr1.concat(arr2); // [1, 2, 3, 4]

5.4 slice

  • 功能:返回数组的浅拷贝(从开始索引到结束索引,不包括结束索引)。

  • 示例:

    1
    2
    const arr = [1, 2, 3, 4];
    const result = arr.slice(1, 3); // [2, 3]

6. 创建数组的方法

6.1 Array.from

  • 功能:从类数组对象或可迭代对象创建数组。

  • 示例:

    1
    Array.from('abc'); // ['a', 'b', 'c']
    Array.from() 的常见应用场景
    1. 从字符串生成字符数组

      1
      2
      3
      const str = "hello";
      const chars = Array.from(str);
      console.log(chars); // 输出:['h', 'e', 'l', 'l', 'o']
    2. 创建等差数列

      1
      2
      const arr = Array.from({ length: 5 }, (_, i) => i + 1);
      console.log(arr); // 输出:[1, 2, 3, 4, 5]
    3. 去重并转换为数组

      1
      2
      const unique = Array.from(new Set([1, 2, 2, 3]));
      console.log(unique); // 输出:[1, 2, 3]

6.2 Array.of

  • 功能:根据一组值创建一个新数组。

  • 示例:

    1
    Array.of(1, 2, 3); // [1, 2, 3]

6.3 new Array

  • 功能:创建指定长度或元素的数组。

  • 示例:

    1
    2
    new Array(3); // [empty × 3]
    new Array(1, 2, 3); // [1, 2, 3]

1. 静态方法

这些方法是直接通过 Array 构造函数调用的,而不是通过数组实例。

方法描述
Array.isArray(value)判断传入的值是否为数组。
Array.from(arrayLike)从类数组对象或可迭代对象创建一个新数组。
Array.of(...elements)根据传入参数创建一个新的数组。

2. 实例方法

以下方法适用于数组实例。

2.1 迭代相关的方法

方法描述
.forEach(callback)遍历数组,对每个元素执行提供的回调函数(无返回值)。
.map(callback)返回一个新数组,数组中的每个元素是原数组元素调用回调函数的结果。
.filter(callback)返回一个新数组,包含所有通过回调函数测试的元素。
.reduce(callback, initialValue)对数组元素进行累计处理,并返回累计结果。
.reduceRight(callback, initialValue)从右向左对数组元素累计处理,并返回累计结果。
.find(callback)返回第一个满足回调函数条件的元素,如果没有找到,返回 undefined
.findIndex(callback)返回第一个满足回调函数条件的元素索引,如果没有找到,返回 -1
.some(callback)如果数组中至少有一个元素通过回调函数测试,返回 true
.every(callback)如果数组中所有元素都通过回调函数测试,返回 true
.entries()返回一个新的迭代器对象,包含数组中每个索引的键值对。
.keys()返回一个新的迭代器对象,包含数组中每个索引的键。
.values()返回一个新的迭代器对象,包含数组中每个索引的值。
.flat(depth)返回一个新数组,将嵌套数组按照指定深度展平。
.flatMap(callback)结合 .map().flat() 功能,先映射再展平结果。

2.2 添加/删除元素的方法

方法描述
.push(...items)向数组末尾添加一个或多个元素,并返回新数组的长度。
.pop()删除数组最后一个元素,并返回被删除的元素。
.unshift(...items)向数组开头添加一个或多个元素,并返回新数组的长度。
.shift()删除数组第一个元素,并返回被删除的元素。
.splice(start, deleteCount, ...items)在数组指定位置插入、删除或替换元素,返回被删除的元素组成的数组。
.concat(...items)合并数组,返回一个新数组,不影响原数组。

2.3 访问元素的方法

方法描述
.slice(start, end)返回原数组的一个浅拷贝,不包括 end 索引。
.at(index)返回数组指定索引的元素(支持负索引)。
[index]直接通过索引访问数组元素。

2.4 查找元素的方法

方法描述
.indexOf(searchElement, fromIndex)返回数组中第一个匹配元素的索引,未找到返回 -1
.lastIndexOf(searchElement, fromIndex)返回数组中最后一个匹配元素的索引,未找到返回 -1
.includes(value, fromIndex)判断数组是否包含某个值,返回 truefalse

2.5 排序和反转的方法

方法描述
.sort(compareFunction)对数组元素排序,默认按照 Unicode 字符顺序。
.reverse()反转数组中元素的顺序。

2.6 填充和复制的方法

方法描述
.fill(value, start, end)用指定值填充数组的部分或全部元素。
.copyWithin(target, start, end)从数组中复制一部分元素到数组的另一个位置,不会改变数组长度。

2.7 转换和连接的方法

方法描述
.join(separator)将数组的所有元素转换为字符串并用指定分隔符连接,返回字符串。
.toString()返回数组的字符串表示。
.toLocaleString()根据语言环境将数组转换为字符串。

3. 特殊的 Symbol 属性方法

方法描述
[Symbol.iterator]()返回数组的默认迭代器,支持 for...of 循环。
[Symbol.unscopables]返回一个对象,指定在 with 语句中哪些属性不可用。

题目:

三数之和

给你一个整数数组 nums ,判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != ji != kj != k ,同时还满足 nums[i] + nums[j] + nums[k] == 0 。请你返回所有和为 0 且不重复的三元组。

注意:答案中不可以包含重复的三元组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
* @param {number[]} nums
* @return {number[][]}
*/
var threeSum = function(nums) {
const ans = [] // 在这里用来存储的是最后的结果
const length = nums.length;
if(nums === null || length < 3) return ans // 判断这个数,如果不符合规范的话就return[]
nums.sort((a,b) => a-b)
for(let i=0; i<length;i++) {
// 首先判断这个数字的第一个是不是大于0,如果大于0的话,就说明的是这个不能构成三个数字加起来伟0
if(nums[i] > 0 ) break;
// 因为不能包含重复的三元组,判断一下
if( i>0 && nums[i] === nums[i-1]) continue
let left = i+1
let right = length-1
while(right>left) {
let result = nums[i] + nums[left] + nums[right]
if(result === 0) {
ans.push([nums[i], nums[left], nums[right]])
while(right>left && nums[left] === nums[left+1]) left++
while(right>left && nums[right] === nums[right-1]) right--
left++
right--
}
else if(result>0) right--
else if(result<0) left++
}
}
return ans
};

四数之和

给你一个由 n 个整数组成的数组 nums ,和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] (若两个四元组元素一一对应,则认为两个四元组重复):

  • 0 <= a, b, c, d < n
  • abcd 互不相同
  • nums[a] + nums[b] + nums[c] + nums[d] == target

你可以按 任意顺序 返回答案 。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
/**
* @param {number[]} nums
* @param {number} target
* @return {number[][]}
*/
var fourSum = function(nums, target) {
const app = []
const length = nums.length
nums.sort((a,b)=>a-b)
if(length<4){
return app
}
for(let i=0;i<length-3;i++){
if(i>0&&nums[i]+nums[i+1]+nums[i+2]+nums[i+3]>target){
break
}else if(i>0&&nums[i]===nums[i-1]){
continue
}else if(nums[i]+nums[length-1]+nums[length-2]+nums[length-3]<target){
continue
}
for(let j=i+1;j<length-2;j++){
if(j>i+1&&nums[j]===nums[j-1]){
continue
}
if(j>i+1&&nums[i]+nums[j]+nums[j+1]+nums[j+2]>target){
break
}
if(j>i+1&&nums[i]+nums[j]+nums[length-1]+nums[length-2]<target){
continue
}
let left=j+1;
let rigth=length-1;
while(rigth>left){
let sume = nums[i]+nums[j]+nums[left]+nums[rigth]
if(sume===target){
app.push([nums[i],nums[j],nums[left],nums[rigth]])
while(rigth>left&&nums[left]===nums[left+1]){
left++
}
left++
while(rigth>left&&nums[rigth]===nums[rigth-1]){
rigth--
}
rigth--
}else if(sume>target){
rigth--
}else if(sume<target){
left++
}
}
}
}
return app
};