Array

arr.0; // 语法错误

console.log(years["2"] !== years["02"]);

const fruits = [];
fruits.push("banana", "apple", "peach");
console.log(fruits.length); // 3

fruits[5] = "mango";
console.log(fruits[5]); // 'mango'
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 6

fruits.length = 10;
console.log(fruits); // ['banana', 'apple', 'peach', empty x 2, 'mango', empty x 4]
console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
console.log(fruits.length); // 10
console.log(fruits[8]); // undefined

fruits.length = 2;
console.log(Object.keys(fruits)); // ['0', '1']
console.log(fruits.length); // 2

const colors = ["红", "黄", "蓝"];
colors[5] = "紫";
colors.forEach((item, index) => {
  console.log(`${index}：${item}`);
});
// 输出：
// 0：红
// 1：黄
// 2：蓝
// 5：紫

colors.reverse(); // ['紫', 空槽 × 2, '蓝', '黄', '红']

const colors = ["红", "黄", "蓝"];
colors[5] = "紫";
const iterator = colors.keys();
for (const key of iterator) {
  console.log(`${key}：${colors[key]}`);
}
// 输出
// 0：红
// 1：黄
// 2：蓝
// 3：undefined
// 4：undefined
// 5：紫

const newColors = colors.toReversed(); // ['紫', undefined, undefined, '蓝', '黄', '红']

arr.copyWithin(0, 1, 2); // 改变了 arr
const arr2 = arr.slice().copyWithin(0, 1, 2); // 不改变 arr
const arr3 = [...arr].copyWithin(0, 1, 2); // 不改变 arr

method(callbackFn, thisArg)

function method(callbackFn, thisArg) {
  const length = this.length;
  for (let i = 0; i < length; i++) {
    if (i in this) {
      const result = callbackFn.call(thisArg, this[i], i, this);
      // 使用 result 做一些事，也许更早地返回
    }
  }
}

const arrayLike = {
  0: "a",
  1: "b",
  length: 2,
};
console.log(Array.prototype.join.call(arrayLike, "+")); // 'a+b'

Array.prototype.flat.call({}); // []

const a = { length: 0.7 };
Array.prototype.push.call(a);
console.log(a.length); // 0

function f() {
  console.log(Array.prototype.join.call(arguments, "+"));
}

f("a", "b"); // 'a+b'

// 使用数组字面量创建的 'fruits' 数组。
const fruits = ["Apple", "Banana"];
console.log(fruits.length);
// 2

// 使用 Array() 构建函数创建的 'fruits2' 数组。
const fruits2 = new Array("Apple", "Banana");
console.log(fruits2.length);
// 2

// 使用 String.prototype.split() 方法创建的 'fruits3' 数组。
const fruits3 = "Apple, Banana".split(", ");
console.log(fruits3.length);
// 2

const fruits = ["Apple", "Banana"];
const fruitsString = fruits.join(", ");
console.log(fruitsString);
// "Apple, Banana"

const fruits = ["Apple", "Banana"];

// 数组第一个元素的索引始终为 0。
fruits[0]; // Apple

// 数组第二个元素的索引始终为 1。
fruits[1]; // Banana

// 数组最后一个元素的索引总是比数组的长度小 1。
fruits[fruits.length - 1]; // Banana

// 使用大于数组长度的索引会返回"undefined"
fruits[99]; // undefined

const fruits = ["Apple", "Banana"];
console.log(fruits.indexOf("Banana"));
// 1

const fruits = ["Apple", "Banana"];

fruits.includes("Banana"); // true
fruits.includes("Cherry"); // false

// 如果 indexOf() 不返回 -1，则数组包含给定的元素。
fruits.indexOf("Banana") !== -1; // true
fruits.indexOf("Cherry") !== -1; // false

const fruits = ["Apple", "Banana"];
const newLength = fruits.push("Orange");
console.log(fruits);
// ["Apple", "Banana", "Orange"]
console.log(newLength);
// 3

const fruits = ["Apple", "Banana", "Orange"];
const removedItem = fruits.pop();
console.log(fruits);
// ["Apple", "Banana"]
console.log(removedItem);
// Orange

const fruits = ["Apple", "Banana", "Strawberry", "Mango", "Cherry"];
const start = -3;
const removedItems = fruits.splice(start);
console.log(fruits);
// ["Apple", "Banana"]
console.log(removedItems);
// ["Strawberry", "Mango", "Cherry"]

const fruits = ["Apple", "Banana", "Strawberry", "Mango", "Cherry"];
const start = 2;
const removedItems = fruits.splice(start);
console.log(fruits);
// ["Apple", "Banana"]
console.log(removedItems);
// ["Strawberry", "Mango", "Cherry"]

const fruits = ["Apple", "Banana"];
const removedItem = fruits.shift();
console.log(fruits);
// ["Banana"]
console.log(removedItem);
// Apple

const fruits = ["Apple", "Strawberry", "Cherry", "Banana", "Mango"];
const start = 0;
const deleteCount = 3;
const removedItems = fruits.splice(start, deleteCount);
console.log(fruits);
// ["Banana", "Mango"]
console.log(removedItems);
// ["Apple", "Strawberry", "Cherry"]

const fruits = ["Banana", "Mango"];
const newLength = fruits.unshift("Strawberry");
console.log(fruits);
// ["Strawberry", "Banana", "Mango"]
console.log(newLength);
// 3

const fruits = ["Strawberry", "Banana", "Mango"];
const start = fruits.indexOf("Banana");
const deleteCount = 1;
const removedItems = fruits.splice(start, deleteCount);
console.log(fruits);
// ["Strawberry", "Mango"]
console.log(removedItems);
// ["Banana"]

const fruits = ["Apple", "Banana", "Strawberry", "Mango"];
const start = 1;
const deleteCount = 2;
const removedItems = fruits.splice(start, deleteCount);
console.log(fruits);
// ["Apple", "Mango"]
console.log(removedItems);
// ["Banana", "Strawberry"]

const fruits = ["Apple", "Banana", "Strawberry"];
const start = -2;
const deleteCount = 2;
const removedItems = fruits.splice(start, deleteCount, "Mango", "Cherry");
console.log(fruits);
// ["Apple", "Mango", "Cherry"]
console.log(removedItems);
// ["Banana", "Strawberry"]

const fruits = ["Apple", "Mango", "Cherry"];
for (const fruit of fruits) {
  console.log(fruit);
}
// Apple
// Mango
// Cherry

const fruits = ["Apple", "Mango", "Cherry"];
fruits.forEach((item, index, array) => {
  console.log(item, index);
});
// Apple 0
// Mango 1
// Cherry 2

const fruits = ["Apple", "Banana", "Strawberry"];
const moreFruits = ["Mango", "Cherry"];
const combinedFruits = fruits.concat(moreFruits);
console.log(combinedFruits);
// ["Apple", "Banana", "Strawberry", "Mango", "Cherry"]

// The 'fruits' array remains unchanged.
console.log(fruits);
// ["Apple", "Banana", "Strawberry"]

// The 'moreFruits' array also remains unchanged.
console.log(moreFruits);
// ["Mango", "Cherry"]

const fruits = ["Strawberry", "Mango"];

// Create a copy using spread syntax.
const fruitsCopy = [...fruits];
// ["Strawberry", "Mango"]

// Create a copy using the from() method.
const fruitsCopy2 = Array.from(fruits);
// ["Strawberry", "Mango"]

// Create a copy using the slice() method.
const fruitsCopy3 = fruits.slice();
// ["Strawberry", "Mango"]

const fruitsDeepCopy = JSON.parse(JSON.stringify(fruits));

const fruits = ["Strawberry", "Mango"];
const fruitsAlias = fruits;
// 'fruits' 和 'fruitsAlias' 是同一个对象，严格相等。
fruits === fruitsAlias; // true
// 对 'fruits' 数组的任何更改也会更改 'fruitsAlias'。
fruits.unshift("Apple", "Banana");
console.log(fruits);
// ['Apple', 'Banana', 'Strawberry', 'Mango']
console.log(fruitsAlias);
// ['Apple', 'Banana', 'Strawberry', 'Mango']

const board = [
  ["R", "N", "B", "Q", "K", "B", "N", "R"],
  ["P", "P", "P", "P", "P", "P", "P", "P"],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  [" ", " ", " ", " ", " ", " ", " ", " "],
  ["p", "p", "p", "p", "p", "p", "p", "p"],
  ["r", "n", "b", "q", "k", "b", "n", "r"],
];

console.log(`${board.join("\n")}\n\n`);

// 将国王的兵向前移动 2
board[4][4] = board[6][4];
board[6][4] = " ";
console.log(board.join("\n"));

const values = [];
for (let x = 0; x < 10; x++) {
  values.push([2 ** x, 2 * x ** 2]);
}
console.table(values);

// 匹配一个 d 后跟一个或多个 b 后跟一个 d
// 记住匹配的 b 和后面的 d
// 忽略大小写

const myRe = /d(b+)(d)/i;
const execResult = myRe.exec("cdbBdbsbz");

console.log(execResult.input); // 'cdbBdbsbz'
console.log(execResult.index); // 1
console.log(execResult); // [ "dbBd", "bB", "d" ]

function testSideEffect(effect) {
  const arr = ["e1", "e2", "e3", "e4"];
  arr.forEach((elem, index, arr) => {
    console.log(`数组：[${arr.join(", ")}]，索引：${index}，元素：${elem}`);
    effect(arr, index);
  });
  console.log(`最终数组：[${arr.join(", ")}]`);
}

testSideEffect((arr, index) => {
  if (index + 1 < arr.length) arr[index + 1] += "*";
});
// 数组：[e1, e2, e3, e4]，索引：0，元素：e1
// 数组：[e1, e2*, e3, e4]，索引：1，元素：e2*
// 数组：[e1, e2*, e3*, e4]，索引：2，元素：e3*
// 数组：[e1, e2*, e3*, e4*]，索引：3，元素：e4*
// 最终数组：[e1, e2*, e3*, e4*]

testSideEffect((arr, index) => {
  if (index > 0) arr[index - 1] += "*";
});
// 数组：[e1, e2, e3, e4]，索引：0，元素：e1
// 数组：[e1, e2, e3, e4]，索引：1，元素：e2
// 数组：[e1*, e2, e3, e4]，索引：2，元素：e3
// 数组：[e1*, e2*, e3, e4]，索引：3，元素：e4
// 最终数组：[e1*, e2*, e3*, e4]

testSideEffect((arr, index) => {
  if (index === 1) arr.splice(2, 0, "new");
});
// 数组：[e1, e2, e3, e4]，索引：0，元素：e1
// 数组：[e1, e2, e3, e4]，索引：1，元素：e2
// 数组：[e1, e2, new, e3, e4]，索引：2，元素：new
// 数组：[e1, e2, new, e3, e4]，索引：3，元素：e3
// 最终数组：[e1, e2, new, e3, e4]
// e4 不会被访问因为它的索引是 4

testSideEffect((arr) => arr.push("new"));
// 数组：[e1, e2, e3, e4]，索引：0，元素：e1
// 数组：[e1, e2, e3, e4, new]，索引：1，元素：e2
// 数组：[e1, e2, e3, e4, new, new]，索引：2，元素：e3
// 数组：[e1, e2, e3, e4, new, new, new]，索引：3，元素：e4
// 最终数组：[e1, e2, e3, e4, new, new, new, new]

testSideEffect((arr, index) => arr.splice(index, 0, "new"));
// 数组：[e1, e2, e3, e4]，索引：0，元素：e1
// 数组：[new, e1, e2, e3, e4]，索引：1，元素：e1
// 数组：[new, new, e1, e2, e3, e4]，索引：2，元素：e1
// 数组：[new, new, new, e1, e2, e3, e4]，索引：3，元素：e1
// 最终数组：[new, new, new, new, e1, e2, e3, e4]
// e1 不断被访问，因为它不断被移回

testSideEffect((arr, index) => {
  if (index === 1) arr.splice(2, 1);
});
// 数组：[e1, e2, e3, e4]，索引：0，元素：e1
// 数组：[e1, e2, e3, e4]，索引：1，元素：e2
// 数组：[e1, e2, e4]，索引：2，元素：e4
// 最终数组：[e1, e2, e4]
// 不会访问索引 3 因为它越界

// 与 find() 比较，后者将不存在的索引视为未定义：
const arr2 = ["e1", "e2", "e3", "e4"];
arr2.find((elem, index, arr) => {
  console.log(`数组：[${arr.join(", ")}]，索引：${index}，元素：${elem}`);
  if (index === 1) arr.splice(2, 1);
  return false;
});
// 数组：[e1, e2, e3, e4]，索引：0，元素：e1
// 数组：[e1, e2, e3, e4]，索引：1，元素：e2
// 数组：[e1, e2, e4]，索引：2，元素：e4
// 数组：[e1, e2, e4]，索引：3，元素：undefined

testSideEffect((arr, index) => arr.splice(index, 1));
// 数组：[e1, e2, e3, e4]，索引：0，元素：e1
// 不会范围内 e2 因为 e2 现在的索引是 0，索引 0 已经被访问过
// 数组：[e2, e3, e4]，索引：1，元素：e3
// 不会范围内 e4 因为 e4 现在的索引是 1，索引 1 已经被访问过
// 最终数组：[e2, e4]
// 索引 2 越界，索引它不会被访问

// 与 find() 比较，后者将不存在的索引视为未定义：
const arr2 = ["e1", "e2", "e3", "e4"];
arr2.find((elem, index, arr) => {
  console.log(`数组：[${arr.join(", ")}]，索引：${index}，元素：${elem}`);
  arr.splice(index, 1);
  return false;
});
// 数组：[e1, e2, e3, e4]，索引：0，元素：e1
// 数组：[e2, e3, e4]，索引：1，元素：e3
// 数组：[e2, e4]，索引：2，元素：undefined
// 数组：[e2, e4]，索引：3，元素：undefined