常用操作数组的方法-修改和不修改原数组

 新增

  Array.prototype.flat()：将嵌套的数组“拉平”成一个新数组

// 返回新数组 flat默认参数为1
const arr3 = [1, 2, [3, 4, [5, 6, [7, 8, [9, 10]]]]];  
console.log(arr3.flat(Infinity));  
// 输出: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  
// 使用Infinity作为深度，意味着无论嵌套多深，都会被拉平  
  
console.log(arr3.flat(2));  
// 输出: [1, 2, 3, 4, 5, 6, [7, 8, [9, 10]]]  
// 指定深度为2，所以只拉平两层

Object.keys()：返回一个由给定对象自身所有可枚举属性键组成的数组 

const user = {  
  name: '张三',  
  age: 30,  
  email: 'zhangsan@example.com'  
};  
  
// 使用 Object.keys() 获取所有属性键  
const keys = Object.keys(user);  
  
// 输出: ["name", "age", "email"]  
console.log(keys);  
  
// 遍历对象的所有属性  
keys.forEach(key => {  
  console.log(`${key}: ${user[key]}`);  
});  
  
// 输出:  
// name: 张三  
// age: 30  
// email: zhangsan@example.com

Object.values()：返回一个给定对象自身的所有可枚举属性值的数组  

// 定义一个对象  
const person = {  
  name: 'David',  
  age: 30,  
  city: 'New York'  
};  
  
// 使用 Object.values() 获取对象所有值的数组  
const values = Object.values(person);  
  
// 输出这个数组  
console.log(values); // 输出: ['David', 30, 'New York']  
  
// 遍历这个数组  
values.forEach(value => {  
  console.log(value); // 依次输出: David, 30, New York  
});

---

概念   

        数组是 JavaScript 中的一种数据结构，它具有多个方法，主要可以分为对原数组进行操作的方法和返回新数组的方法。

修改原数组的方法：

• push()： 将一个或多个元素添加到数组的末尾，并返回数组新的长度。

let fruits = ['apple', 'banana'];
let length = fruits.push('orange');
console.log(fruits); // ["apple", "banana", "orange"]
console.log(length); // 3

• pop()：移除数组的最后一个元素，并返回该元素。

let fruits = ['apple', 'banana', 'orange'];
let lastElement = fruits.pop();
console.log(fruits); // ["apple", "banana"]
console.log(lastElement); // "orange"

• shift()：移除数组的第一个元素，并返回该元素。

let fruits = ['apple', 'banana', 'orange'];
let firstElement = fruits.shift();
console.log(fruits); // ["banana", "orange"]
console.log(firstElement); // "apple"

• unshift(): 在数组的开头添加一个或多个元素，并返回数组的新长度。

let fruits = ['apple', 'banana'];
let length = fruits.unshift('orange', 'kiwi');
console.log(fruits); // ["orange", "kiwi", "apple", "banana"]
console.log(length); // 4

• splice(): 从数组中添加或删除元素，并返回被删除的元素。

let fruits = ['apple', 'banana', 'orange'];
let removedElements = fruits.splice(1, 1, 'kiwi', 'strawberry');
console.log(fruits); // ["apple", "kiwi", "strawberry", "orange"]
console.log(removedElements); // ["banana"]

• sort(): 对数组进行排序，并返回排序后的数组。

let fruits = ['kiwi', 'banana', 'apple', 'orange'];
console.log(fruits.sort()); // ["apple", "banana", "kiwi", "orange"]

• reverse(): 颠倒数组元素的顺序，并返回数组。

let fruits = ['apple', 'banana', 'orange'];
console.log(fruits.reverse()); // ["orange", "banana", "apple"]

• fill(): 用一个固定值填充数组，从起始索引到结束索引，并返回修改后的数组。

let array = [1, 2, 3, 4, 5];
console.log(array.fill(0, 2, 4)); // [1, 2, 0, 0, 5]

• copyWithin(): 将一部分数组元素复制到其他位置，覆盖原有的值，并返回修改后的数组。

let array = [1, 2, 3, 4, 5];
console.log(array.copyWithin(0, 3, 4)); // [4, 2, 3, 4, 5]

返回新数组的方法：

• concat(): 将两个或多个数组合并为一个数组，并返回新数组。

let fruits1 = ['apple', 'banana'];
let fruits2 = ['orange', 'kiwi'];
let fruits3 = ['strawberry'];
let newFruitsArray = fruits1.concat(fruits2, fruits3);
console.log(newFruitsArray); // ["apple", "banana", "orange", "kiwi", "strawberry"]

• slice(): 选取数组的一部分，并返回这部分内容组成的新数组。

let fruits = ['apple', 'banana', 'orange', 'kiwi', 'strawberry'];
let subArray = fruits.slice(1, 4);
console.log(subArray); // ["banana", "orange", "kiwi"]

• filter(): 创建一个新的数组，包含通过指定函数测试的所有元素。

let scores = [75, 80, 90, 92, 68, 74, 82];
let passedScores = scores.filter((score) => score >= 80);
console.log(passedScores); // [80, 90, 92, 82]

• map(): 创建一个新的数组，其中的元素是调用指定函数后的返回值。

let numbers = [1, 2, 3, 4, 5];
let squaredNumbers = numbers.map((number) => number * number);
console.log(squaredNumbers); // [1, 4, 9, 16, 25]

• reduce(): 对数组中的所有元素执行指定的函数，并以单个返回值聚合数组中的所有值。

let numbers = [1, 2, 3, 4, 5];
let sum = numbers.reduce((accumulator, currentValue) => accumulator + currentValue);
console.log(sum); // 15

• forEach(): 对数组中的每个元素执行指定的函数，没有返回值。

let fruits = ['apple', 'banana', 'orange'];
fruits.forEach((fruit) => console.log(fruit));
// 输出
// apple
// banana
// orange

• every(): 检测数组中的所有元素是否满足指定的条件，并返回布尔值。

let scores = [75, 80, 90, 92, 68, 74]; 
let allPassed = scores.every((score) => score >= 60);
console.log(allPassed); // true

• some(): 检测数组中的是否有至少一个元素满足指定的条件，并返回布尔值。

let scores = [75, 80, 90, 92, 68, 74];
let hasAtLeastOnePassed = scores.some((score) => score >= 80);
console.log(hasAtLeastOnePassed); // true

• indexOf(): 返回数组中指定元素的第一个匹配项的位置，如果不存在则返回 -1。

let fruits = ['apple', 'banana', 'orange'];
let indexOfBanana = fruits.indexOf('banana');
console.log(indexOfBanana); // 1

let indexOfGrape = fruits.indexOf('grape');
console.log(indexOfGrape); // -1

• lastIndexOf(): 返回数组中指定元素的最后一个匹配项的位置，如果不存在则返回 -1。

let fruits = ['apple', 'banana', 'orange', 'banana'];
let lastIndexOfBanana = fruits.lastIndexOf('banana');
console.log(lastIndexOfBanana); // 3

let lastIndexOfGrape = fruits.lastIndexOf('grape');
console.log(lastIndexOfGrape); // -1

        在进行修改原数组的方法时，确保操作完成后数组的结构和指向数据的引用不发生改变。