[2 数组是对象，因此它们在JS中也具有方法。

切片（开始）：在新数组中提取部分数组，而无需突变原始数组。

令ARR = ['a'，'b'，'c'，'d'，'e']; // USECASE：提取直到索引作为参数传递 arr.slice（2）; // ['c'，'d'，'e'] // USECASE：从[第一个索引]提取到[第二个索引1]值。 arr.slice（2,4）; // ['c'，'d']即数组的长度将是末端或4-2 = 2 // USECase：提取最后2个元素 arr.slice（-2）; // ['d'，'e'] // USECase：提取最后一个元素。 arr.slice（-1）; // ['e'] // USECASE：从索引中提取的摘录传递给最后两个元素。 arr.slice（1，-2）; // ['e'] // USECASE：创建数组的浅副本 arr.slice（）; //第一条 [... arr]; //第二条

剪接：突变原始阵列

//剪接：删除从索引开始的元素。突变源。大批。 //返回：删除数组的一部分 令arr = ['a'，'b'，'c'，'d'，'e']; // arr.splice（2）; // ['c'，'d'，'e'] // arr; // ['a'，'b'] // USECASE：删除数组的最后一个元素 // arr.splice（-1）; // ['e'] // arr; // ['a'，'b'，'c'，'d'] // USECASE：删除否元素。剪接（索引，DeleteCount） arr.splice（1，3）; // ['b'，'c'，'d'] arr; // ['a'，'e']

let arr = ['a','b','c','d','e'];

// Usecase: Extract till index passed as argument
arr.slice(2); // [ 'c', 'd', 'e' ]

// Usecase: Extract from [first index] to [second index-1] value.
arr.slice(2,4); // [ 'c', 'd' ] i.e Length of array will be end-begin or 4-2 = 2 

// Usecase: Extract last 2 elements
arr.slice(-2); // [ 'd', 'e' ]

// Usecase: Extract the last element.
arr.slice(-1);  // [ 'e' ]  

// Usecase: Extract from index passed to leaving the last two elements.
arr.slice(1,-2);  // [ 'e' ]  

// Usecase: Create a shallow copy of an array
arr.slice(); // 1st way
[...arr]; // 2nd way

// splice: remove the elements begining from the index passed. Mutates the orig. array.
// returns: part of the removed array
let arr = ['a','b','c','d','e'];
// arr.splice(2); // [ 'c', 'd', 'e' ]
// arr; // [ 'a', 'b' ]

// Usecase: Remove last element of the array
// arr.splice(-1); // [ 'e' ]
// arr; // [ 'a', 'b', 'c', 'd' ]

// Usecase: Delete no of elements. splice(index, deleteCount)
arr.splice(1, 3); // [ 'b', 'c', 'd' ]
arr; // [ 'a', 'e' ]

CONCAT：加入两个阵列。

让ARR1 = ['a'，'b'，'c'，'d'，'e']; 令arr2 = ['f'，'g'，'h'，'i'，'j']; [... arr1，... arr2]; //第一条 arr2 = arr1.concat（arr2）; //第二条

let arr = ['a','b','c','d','e'];
let arr2 = arr.reverse();
arr;
arr2;

加入：加入两个阵列。

让ARR1 = ['a'，'b'，'c'，'d'，'e']; 令arr2 = ['f'，'g'，'h'，'i'，'j']; const x = arr1.concat（arr2）; X.Join（' - '）; //'a-b-c-d-e-f-g-h-h-i-j'

let arr1 = ['a','b','c','d','e'];
let arr2 = ['f','g','h','i','j'];

[...arr1, ...arr2];       // 1st way
arr2 = arr1.concat(arr2); // 2nd way

AT：从末尾开始计数，以索引为-1

suports方法链接。在数组，字符串

上作品

令ARR = ['a'，'b'，'c'，'d'，'e']; arr [0]; //第一条 arr.at（0）; //第二条 //获取数组的最后一个元素 arr [arr.length -1]; //第一条 arr.slice（-1）[0]; //第二条 arr.at（-1）; //第三条 arr.at（0）; //'a' arr.at（-1）; //'e'

let arr = ['a','b','c','d','e'];
let arr2 = arr.reverse();
arr;
arr2;

//使用foreach方法在数组上循环。 令帐户= [2000，-300，400，-200，-500，1000，-300]; //使用for-for的阵列循环 （让帐户的钱）{ 如果（钱> 0）{ console.log（`存放$ {货币}`）; } 别的 { console.log（`删除$ {Math.abs（nose）}`）; } } // .entries（）：返回一个数组。 //将输出作为索引值对返回。 //第一个元素必须是索引，第二个元素必须是元素 - 值 for（让[i，Money] of account.entries（））{ 如果（钱> 0）{ console.log（`交易$ {i 1}，存入$ {货币}`）; } 别的 { console.log（`transAction $ {i 1}，撤回$ {Math.abs（money）}`）; } } //使用需要回调fn的foreach循环循环。 // foreach会致电回调fn，而不是我们。 // foreach将在每个迭代中将每个元素作为参数传递。 account.foreach（功能（货币）{ 如果（钱> 0）{ console.log（`存放$ {货币}`）; } 别的 { console.log（`删除$ {Math.abs（nose）}`）; } }）; //迭代1：将arg1传递给cb-fn（arg1） //迭代2：将arg2传递给cb-fn（arg2） //迭代3：将arg3传递给CB-FN（arg3） // ..... // ..... // foreach将通过每个元素将每个元素，索引和数组作为参数中的每一个迭代中。参数顺序很重要，而不是这些参数的否，即第一个元素应该是当前元素，第二个元素应为索引，第三个元素应为整个数组，该数组正在循环。 //第一个元素必须是元素 - 值，第二个元素应为索引，第三个元素必须是整个数组。这就是它与array.entries（）的不同之处 account.foreach（函数（钱，i，arr）{ 如果（钱> 0）{ console.log（`交易$ {i 1}，将$ {货币}存入$ {arr}`）; } 别的 { console.log（`transaction $ {i 1}，从$ {arr}`）撤回$ {math.abs（money）}'）; } }）;

何时使用和foreach：

for：当我们需要循环脱离数组时使用。

let arr = ['a','b','c','d','e'];

arr[0];    // 1st way
arr.at(0); // 2nd way

// Get the last element of the array
arr[arr.length - 1];  // 1st way
arr.slice(-1)[0];     // 2nd way
arr.at(-1);           // 3rd way

arr.at(0); // 'a'
arr.at(-1); // 'e'