json数组操作方法

在JavaScript中，操作JSON数组（实际上是JavaScript对象数组）有多种方法。这里列举一些常用的数组操作方法，并简要说明它们的用途和用法。

1. push()

• 用途：向数组末尾添加一个或多个元素，并返回新的长度。
• 示例：

  let arr = [{name: "Alice"}, {name: "Bob"}];
  arr.push({name: "Charlie"});
  console.log(arr); // 输出: [{name: "Alice"}, {name: "Bob"}, {name: "Charlie"}]
  

2. pop()

• 用途：删除数组的最后一个元素，并返回该元素。
• 示例：

  let arr = [{name: "Alice"}, {name: "Bob"}];
  let last = arr.pop();
  console.log(last); // 输出: {name: "Bob"}
  console.log(arr); // 输出: [{name: "Alice"}]
  

3. shift()

• 用途：删除数组的第一个元素，并返回该元素。
• 示例：

  let arr = [{name: "Alice"}, {name: "Bob"}];
  let first = arr.shift();
  console.log(first); // 输出: {name: "Alice"}
  console.log(arr); // 输出: [{name: "Bob"}]
  

4. unshift()

• 用途：向数组的开头添加一个或多个元素，并返回新的长度。
• 示例：

  let arr = [{name: "Alice"}, {name: "Bob"}];
  arr.unshift({name: "Charlie"});
  console.log(arr); // 输出: [{name: "Charlie"}, {name: "Alice"}, {name: "Bob"}]
  

5. splice()

• 用途：可以用来添加/删除数组中的元素。
• 参数：第一个参数是开始位置，第二个参数是要移除的数量，后续参数是要添加的新元素。
• 示例：

  let arr = [{name: "Alice"}, {name: "Bob"}, {name: "Charlie"}];
  arr.splice(1, 1, {name: "David"}); // 从索引1开始，删除1个元素，然后插入{name: "David"}
  console.log(arr); // 输出: [{name: "Alice"}, {name: "David"}, {name: "Charlie"}]
  

6. map()

• 用途：创建一个新数组，其结果是调用提供的函数处理原数组的每个元素的结果。
• 示例：

  let arr = [{name: "Alice", age: 30}, {name: "Bob", age: 25}];
  let ages = arr.map(item => item.age);
  console.log(ages); // 输出: [30, 25]
  

7. filter()

• 用途：创建一个新数组，包含通过测试的所有元素。
• 示例：

  let arr = [{name: "Alice", age: 30}, {name: "Bob", age: 25}, {name: "Charlie", age: 35}];
  let adults = arr.filter(item => item.age >= 30);
  console.log(adults); // 输出: [{name: "Alice", age: 30}, {name: "Charlie", age: 35}]
  

8. find()

• 用途：返回数组中满足提供的测试函数的第一个元素的值。否则返回undefined。
• 示例：

  let arr = [{name: "Alice", age: 30}, {name: "Bob", age: 25}, {name: "Charlie", age: 35}];
  let person = arr.find(item => item.name === "Bob");
  console.log(person); // 输出: {name: "Bob", age: 25}
  

9. forEach()

• 用途：对数组的每个元素执行一次提供的函数。
• 示例：

  let arr = [{name: "Alice"}, {name: "Bob"}];
  arr.forEach(item => console.log(item.name));
  // 输出:
  // Alice
  // Bob
  

当然，随着JavaScript的发展，ES6及更高版本引入了一些新的数组操作方法，这些方法使得处理数组变得更加方便和强大。下面是一些新增加的方法：

10. Array.from()

• 用途：从类数组对象或可迭代对象中创建一个新的数组实例。
• 示例：

  let arrayLike = {0: 'a', 1: 'b', 2: 'c', length: 3};
  let arr = Array.from(arrayLike);
  console.log(arr); // 输出: ['a', 'b', 'c']
  

11. Array.of()

• 用途：创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。
• 示例：

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

12. includes()

• 用途：判断数组是否包含某个指定的值，如果存在则返回true，否则返回false。
• 示例：

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

13. entries()

• 用途：返回一个新的数组迭代器对象，该对象包含了数组中每个索引的键值对。
• 示例：

  let arr = ['a', 'b', 'c'];
  for (let entry of arr.entries()) {
    console.log(entry);
  }
  // 输出:
  // [0, 'a']
  // [1, 'b']
  // [2, 'c']
  

14. keys()

• 用途：返回一个新的数组迭代器对象，该对象包含了数组中每个索引的键。
• 示例：

  let arr = ['a', 'b', 'c'];
  for (let key of arr.keys()) {
    console.log(key);
  }
  // 输出:
  // 0
  // 1
  // 2
  

15. values()

• 用途：返回一个新的数组迭代器对象，该对象包含了数组中每个索引的值。
• 示例：

  let arr = ['a', 'b', 'c'];
  for (let value of arr.values()) {
    console.log(value);
  }
  // 输出:
  // 'a'
  // 'b'
  // 'c'
  

16. flat()

• 用途：将数组的子数组结构展平，返回一个新数组。
• 示例：

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

17. flatMap()

• 用途：首先使用映射函数映射每个元素，然后将结果展平一级深度，最后返回结果。
• 示例：

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

·8. at()

• 用途：返回数组中指定位置的元素，支持负数索引。
• 示例：

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

当然，随着ECMAScript标准的不断演进，更高版本的JavaScript引入了更多有用的数组操作方法。以下是ES10（ES2019）及更高版本中的一些新增方法：

19. Array.prototype.flat()

• 用途：将嵌套的数组“拉平”，返回一个新数组。
• 参数：可选参数，表示要递归展平的层数，默认为1。
• 示例：

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

20. Array.prototype.flatMap()

• 用途：先对数组中的每个元素进行映射，然后再将结果展平一层。
• 示例：

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

21. Array.prototype.at()

• 用途：返回数组中指定位置的元素，支持负数索引。
• 示例：

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

22. Array.prototype.toString()

• 用途：将数组转换为字符串，每个元素之间用逗号分隔。
• 示例：

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

23. Array.prototype.toLocaleString()

• 用途：将数组转换为本地化的字符串，每个元素之间用逗号分隔。
• 示例：

  let arr = [1, 2, 3, 4];
  console.log(arr.toLocaleString()); // 输出: "1,2,3,4" (根据本地化设置可能不同)
  

24. Array.prototype.copyWithin()

• 用途：将数组的一部分复制到同一数组中的另一个位置，并返回它，不会改变原数组的长度。
• 参数：目标起始位置、源起始位置、源结束位置（可选）。
• 示例：

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

25. Array.prototype.fill()

• 用途：用一个固定值填充一个数组中从起始索引到终止索引内的全部元素。
• 参数：填充的值、起始索引（可选）、终止索引（可选）。
• 示例：

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

26. Array.from()

• 用途：从类数组对象或可迭代对象中创建一个新的数组实例。
• 示例：

  let arrayLike = {0: 'a', 1: 'b', 2: 'c', length: 3};
  let arr = Array.from(arrayLike);
  console.log(arr); // 输出: ['a', 'b', 'c']
  

27. Array.of()

• 用途：创建一个具有可变数量参数的新数组实例，而不考虑参数的数量或类型。
• 示例：

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

28. Array.prototype.some()

• 用途：测试数组中是否有至少一个元素通过提供的函数测试。
• 示例：

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

29. Array.prototype.every()

• 用途：测试数组中所有元素是否都通过提供的函数测试。
• 示例：

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

30. Array.prototype.reduce()

• 用途：对数组中的每个元素执行一个由您提供的reducer函数（升序执行），将其结果汇总为单个返回值。
• 示例：

  let arr = [1, 2, 3, 4];
  let sum = arr.reduce((acc, curr) => acc + curr, 0);
  console.log(sum); // 输出: 10
  

31. Array.prototype.reduceRight()

• 用途：与reduce()类似，但它是从右到左执行。
• 示例：

  let arr = [1, 2, 3, 4];
  let sum = arr.reduceRight((acc, curr) => acc + curr, 0);
  console.log(sum); // 输出: 10
  

32. Array.prototype.sort()

• 用途：对数组的元素进行排序。
• 参数：可选的比较函数。
• 示例：

  let arr = [1, 3, 2, 5, 4];
  arr.sort((a, b) => a - b);
  console.log(arr); // 输出: [1, 2, 3, 4, 5]
  

33. Array.prototype.reverse()

• 用途：将数组中的元素顺序反转。
• 示例：

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

34. Array.prototype.concat()

• 用途：用于合并两个或多个数组。此方法不会更改现有数组，而是返回一个新数组。
• 示例：

  let arr1 = [1, 2, 3];
  let arr2 = [4, 5, 6];
  let combined = arr1.concat(arr2);
  console.log(combined); // 输出: [1, 2, 3, 4, 5, 6]
  

35. Array.prototype.slice()

• 用途：提取原数组的一部分，返回一个新数组，不修改原数组。
• 参数：开始索引（可选）、结束索引（可选）。
• 示例：

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

36. Array.prototype.splice()

• 用途：可以在数组中添加/删除项目，然后返回被删除的项目。
• 参数：开始索引、删除的元素个数、插入的元素（可选）。
• 示例：

  let arr = [1, 2, 3, 4, 5];
  let removed = arr.splice(1, 2, 'a', 'b');
  console.log(arr); // 输出: [1, 'a', 'b', 4, 5]
  console.log(removed); // 输出: [2, 3]
  

37. Array.prototype.indexOf()

• 用途：返回数组中第一个匹配指定值的元素的索引，如果没有找到则返回-1。
• 示例：

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

38. Array.prototype.lastIndexOf()

• 用途：返回数组中最后一个匹配指定值的元素的索引，如果没有找到则返回-1。
• 示例：

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

39. Array.prototype.join()

• 用途：将数组的所有元素连接成一个字符串并返回这个字符串。
• 参数：元素之间的分隔符（可选）。
• 示例：

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

40. Array.prototype.includes()

• 用途：判断数组是否包含某个指定的值，如果存在则返回true，否则返回false。
• 示例：

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

41. Array.prototype.entries()

• 用途：返回一个新的数组迭代器对象，该对象包含了数组中每个索引的键值对。
• 示例：

  let arr = [1, 2, 3];
  for (let [index, value] of arr.entries()) {
    console.log(index, value);
  }
  // 输出:
  // 0 1
  // 1 2
  // 2 3
  

42. Array.prototype.keys()

• 用途：返回一个新的数组迭代器对象，该对象包含了数组中每个索引的键。
• 示例：

  let arr = [1, 2, 3];
  for (let key of arr.keys()) {
    console.log(key);
  }
  // 输出:
  // 0
  // 1
  // 2
  

43. Array.prototype.values()

• 用途：返回一个新的数组迭代器对象，该对象包含了数组中每个索引的值。
• 示例：

  let arr = [1, 2, 3];