// 1. 字面量創(chuàng)建
const arr1 = [1, 2, 3, 4, 5];
const arr2 = ['a', 'b', 'c'];
// 2. 構(gòu)造函數(shù)創(chuàng)建
const arr3 = new Array(5);        // 創(chuàng)建長(zhǎng)度為5的空數(shù)組
const arr4 = new Array(1, 2, 3);  // 創(chuàng)建包含元素的數(shù)組
// 3. Array.of() - 解決構(gòu)造函數(shù)歧義
Array.of(7);       // [7]
Array.of(1, 2, 3); // [1, 2, 3]
// 4. Array.from() - 從類數(shù)組或可迭代對(duì)象創(chuàng)建
Array.from('hello');           // ['h', 'e', 'l', 'l', 'o']
Array.from({ length: 5 });     // [undefined, undefined, ...]
Array.from({ length: 5 }, (_, i) => i); // [0, 1, 2, 3, 4]
// 5. 填充數(shù)組
const filled1 = new Array(5).fill(0);        // [0, 0, 0, 0, 0]
const filled2 = Array.from({ length: 5 }, () => 1); // [1, 1, 1, 1, 1]

const arr = [1, 2, 3];
// push - 尾部添加元素
arr.push(4);        // 返回新長(zhǎng)度: 4, arr: [1, 2, 3, 4]
arr.push(5, 6);     // 可添加多個(gè): [1, 2, 3, 4, 5, 6]
// pop - 尾部刪除元素
const last = arr.pop(); // last = 6, arr: [1, 2, 3, 4, 5]

// unshift - 頭部添加元素
arr.unshift(0);     // 返回新長(zhǎng)度: 6, arr: [0, 1, 2, 3, 4, 5]
arr.unshift(-2, -1); // [-2, -1, 0, 1, 2, 3, 4, 5]

// shift - 頭部刪除元素
const first = arr.shift(); // first = -2, arr: [-1, 0, 1, 2, 3, 4, 5]

const arr = [1, 2, 3, 4, 5];
// splice - 多功能修改
// 刪除：從索引2開始刪除1個(gè)元素
arr.splice(2, 1);   // 返回刪除元素: [3], arr: [1, 2, 4, 5]
// 添加：從索引1開始刪除0個(gè)元素，添加新元素
arr.splice(1, 0, 'a', 'b'); // arr: [1, 'a', 'b', 2, 4, 5]
// 替換：從索引3開始刪除2個(gè)元素，添加新元素
arr.splice(3, 2, 'c', 'd'); // 返回刪除元素: [2, 4], arr: [1, 'a', 'b', 'c', 'd']

let arr = [1, 2, 3];
// 方法1: 重新賦值 (推薦)
arr = [];
// 方法2: 修改length屬性
arr.length = 0;
// 方法3: splice
arr.splice(0, arr.length);

const numbers = [1, 2, 3, 4, 5];
// 1. for循環(huán) (最基礎(chǔ))
for (let i = 0; i < numbers.length; i++) {
    console.log(numbers[i]);
}
// 2. for...of循環(huán) (推薦)
for (const num of numbers) {
    console.log(num);
}
// 3. forEach方法
numbers.forEach((num, index, array) => {
    console.log(`索引 ${index}: 值 ${num}`);
});
// 4. for...in (不推薦用于數(shù)組，會(huì)遍歷所有可枚舉屬性)
for (const index in numbers) {
    console.log(numbers[index]);
}
// 5. entries() 獲取索引和值
for (const [index, value] of numbers.entries()) {
    console.log(index, value);
}

const users = [
    { id: 1, name: 'Alice', age: 25 },
    { id: 2, name: 'Bob', age: 30 },
    { id: 3, name: 'Charlie', age: 25 }
];
// find - 查找第一個(gè)符合條件的元素
const user = users.find(u => u.age === 25); // { id: 1, name: 'Alice', age: 25 }
// findIndex - 查找第一個(gè)符合條件的元素索引
const index = users.findIndex(u => u.name === 'Bob'); // 1
// findLast / findLastIndex (ES2023)
const last25 = users.findLast(u => u.age === 25); // { id: 3, name: 'Charlie', age: 25 }
// includes - 檢查是否包含某元素
[1, 2, 3].includes(2); // true
// indexOf / lastIndexOf - 查找元素位置
['a', 'b', 'c', 'b'].indexOf('b');    // 1
['a', 'b', 'c', 'b'].lastIndexOf('b'); // 3

const numbers = [1, 2, 3, 4, 5, 6];
// filter - 篩選符合條件的元素
const even = numbers.filter(n => n % 2 === 0); // [2, 4, 6]
const adults = users.filter(u => u.age >= 18);
// 鏈?zhǔn)秸{(diào)用
const result = users
    .filter(u => u.age > 20)
    .map(u => u.name); // ['Bob', 'Charlie']

const numbers = [1, 2, 3];
// map - 將數(shù)組映射為新數(shù)組
const doubled = numbers.map(n => n * 2); // [2, 4, 6]
const userNames = users.map(u => u.name); // ['Alice', 'Bob', 'Charlie']
// flatMap - 映射后扁平化 (ES2019)
const phrases = ['hello world', 'good morning'];
const words = phrases.flatMap(phrase => phrase.split(' ')); 
// ['hello', 'world', 'good', 'morning']

const nested = [1, [2, [3, [4]]]];
// flat - 扁平化數(shù)組 (ES2019)
nested.flat();      // [1, 2, [3, [4]]]
nested.flat(2);     // [1, 2, 3, [4]]
nested.flat(Infinity); // [1, 2, 3, 4]
// 替代方案 (ES6)
const flatten = arr => arr.reduce((acc, val) => 
    acc.concat(Array.isArray(val) ? flatten(val) : val), []);

const numbers = [1, 2, 3, 4, 5];
// reduce - 從左到右歸約
const sum = numbers.reduce((acc, curr) => acc + curr, 0); // 15
const max = numbers.reduce((acc, curr) => Math.max(acc, curr), -Infinity); // 5
// reduceRight - 從右到左歸約
const reversed = numbers.reduceRight((acc, curr) => [...acc, curr], []); // [5, 4, 3, 2, 1]
// 復(fù)雜示例：統(tǒng)計(jì)字符出現(xiàn)次數(shù)
const chars = ['a', 'b', 'a', 'c', 'b', 'a'];
const count = chars.reduce((acc, char) => {
    acc[char] = (acc[char] || 0) + 1;
    return acc;
}, {}); // { a: 3, b: 2, c: 1 }

const numbers = [3, 1, 4, 1, 5, 9];
const names = ['John', 'Alice', 'Bob'];
// sort - 排序 (會(huì)修改原數(shù)組)
numbers.sort(); // [1, 1, 3, 4, 5, 9] - 默認(rèn)按字符串排序
numbers.sort((a, b) => a - b); // 數(shù)字升序
numbers.sort((a, b) => b - a); // 數(shù)字降序
names.sort(); // ['Alice', 'Bob', 'John'] - 字符串排序
// 對(duì)象數(shù)組排序
users.sort((a, b) => a.age - b.age); // 按年齡升序
users.sort((a, b) => a.name.localeCompare(b.name)); // 按姓名排序
// reverse - 反轉(zhuǎn)數(shù)組
numbers.reverse(); // [9, 5, 4, 3, 1, 1]
// 創(chuàng)建排序副本 (不修改原數(shù)組)
const sorted = [...numbers].sort();
const sorted2 = numbers.slice().sort(); // 等效

const arr = [1, 2, 3, 4, 5];
// slice - 切片 (不修改原數(shù)組)
arr.slice(1, 3);    // [2, 3] - 索引1到3(不含)
arr.slice(2);       // [3, 4, 5] - 從索引2到最后
arr.slice(-2);      // [4, 5] - 最后兩個(gè)元素
arr.slice(1, -1);   // [2, 3, 4] - 從1到倒數(shù)第1個(gè)
// concat - 連接數(shù)組
const arr1 = [1, 2];
const arr2 = [3, 4];
const combined = arr1.concat(arr2); // [1, 2, 3, 4]
const combined2 = [...arr1, ...arr2]; // ES6擴(kuò)展運(yùn)算符 (推薦)
// join - 數(shù)組轉(zhuǎn)字符串
['Hello', 'World'].join(' '); // "Hello World"
[1, 2, 3].join('-');          // "1-2-3"

const numbers = [1, 2, 3, 4, 5];
// every - 所有元素都滿足條件
numbers.every(n => n > 0); // true
// some - 至少一個(gè)元素滿足條件
numbers.some(n => n > 4); // true
// 實(shí)用示例
const formFields = [{ value: 'abc' }, { value: '' }, { value: 'def' }];
const allFilled = formFields.every(field => field.value.trim() !== ''); // false
const anyFilled = formFields.some(field => field.value.trim() !== ''); // true

// 管道操作模擬
const pipe = (...fns) => (initialValue) => 
    fns.reduce((acc, fn) => fn(acc), initialValue);
// 組合函數(shù)
const processNumbers = pipe(
    arr => arr.filter(n => n % 2 === 0),  // 篩選偶數(shù)
    arr => arr.map(n => n * 2),           // 乘以2
    arr => arr.reduce((a, b) => a + b, 0) // 求和
);
processNumbers([1, 2, 3, 4, 5]); // 12 (2*2 + 4*2 = 4 + 8)

// 數(shù)組復(fù)制
const original = [1, 2, 3];
const copy = [...original];
// 數(shù)組合并
const arr1 = [1, 2];
const arr2 = [3, 4];
const merged = [...arr1, ...arr2]; // [1, 2, 3, 4]
// 函數(shù)參數(shù)
const numbers = [1, 2, 3];
Math.max(...numbers); // 3
// 添加元素
const newArr = [0, ...numbers, 4]; // [0, 1, 2, 3, 4]

const arr = [1, 2, 3, 4, 5];
// 基本解構(gòu)
const [first, second] = arr; // first = 1, second = 2
// 跳過元素
const [a, , c] = arr; // a = 1, c = 3
// 剩余元素
const [x, y, ...rest] = arr; // x = 1, y = 2, rest = [3, 4, 5]
// 默認(rèn)值
const [p = 10, q = 20] = [1]; // p = 1, q = 20
// 交換變量
let m = 1, n = 2;
[m, n] = [n, m]; // m = 2, n = 1

// Array.isArray() - 類型檢查
Array.isArray([1, 2, 3]); // true
Array.isArray({});        // false
// Array.from() 的高級(jí)用法
const unique = Array.from(new Set([1, 2, 2, 3])); // 去重: [1, 2, 3]
// 創(chuàng)建范圍數(shù)組
const range = (start, end) => 
    Array.from({ length: end - start + 1 }, (_, i) => start + i);
range(1, 5); // [1, 2, 3, 4, 5]

// 1. 遍歷時(shí)不需要返回新數(shù)組：forEach > map
// 正確
numbers.forEach(n => console.log(n));
// 2. 需要返回新數(shù)組：map > forEach + push
// 推薦
const doubled = numbers.map(n => n * 2);
// 不推薦
const doubled2 = [];
numbers.forEach(n => doubled2.push(n * 2));
// 3. 查找元素：find > filter[0]
// 推薦
users.find(u => u.id === 1);
// 不推薦
users.filter(u => u.id === 1)[0];
// 4. 檢查存在性：some > find + Boolean
// 推薦
users.some(u => u.age > 30);
// 不推薦
Boolean(users.find(u => u.age > 30));

// 1. 稀疏數(shù)組
const sparse = new Array(5); // [empty × 5]
sparse.map(() => 1);         // 仍然 [empty × 5]
// 解決方案
const dense = Array.from({ length: 5 }, () => 1); // [1, 1, 1, 1, 1]
// 2. 修改原數(shù)組的方法
const arr = [1, 2, 3];
const sorted = arr.sort(); // arr也被修改了！
// 解決方案
const sortedSafe = [...arr].sort(); // 或 arr.slice().sort()
// 3. 浮點(diǎn)數(shù)精度
[0.1, 0.2].reduce((a, b) => a + b); // 0.30000000000000004
// 解決方案
[0.1, 0.2].reduce((a, b) => a + b).toFixed(1); // "0.3"

// 數(shù)組去重
const unique = arr => [...new Set(arr)];
unique([1, 2, 2, 3, 1]); // [1, 2, 3]
// 數(shù)組分組
const groupBy = (arr, key) => 
    arr.reduce((groups, item) => {
        const group = groups[item[key]] || [];
        return { ...groups, [item[key]]: [...group, item] };
    }, {});
// 數(shù)組分塊
const chunk = (arr, size) => 
    Array.from({ length: Math.ceil(arr.length / size) }, (_, i) =>
        arr.slice(i * size, i * size + size)
    );
// 數(shù)組隨機(jī)排序
const shuffle = arr => 
    [...arr].sort(() => Math.random() - 0.5);