Mảng, iterable và giao thức lặp

// 1. Literal — cách dùng 99% trường hợp
const a = [1, 2, 3];

// 2. new Array(n) — tạo array length n nhưng RỖNG (sparse) 🔥
const b = new Array(3);
console.log(b);          // [ <3 empty items> ]
console.log(b.length);   // 3
console.log(b[0]);     // undefined — nhưng KHÔNG phải undefined thật

// 3. Array.of — fix bug new Array(n)
Array.of(3);          // [3]   — luôn coi arg như phần tử
Array.of(1, 2, 3);    // [1, 2, 3]

// 4. Array.from — convert iterable hoặc array-like sang array thật
Array.from('abc');                   // ['a', 'b', 'c']
Array.from({ length: 3 });            // [undefined, undefined, undefined]
Array.from({ length: 3 }, (_, i) => i);  // [0, 1, 2]

// 5. Spread cho iterable → array
[...'abc'];                // ['a', 'b', 'c']
[...new Set([1, 2, 2])];   // [1, 2]  ← dedupe trick

const arr = [1, 2, 3, 4, 5];
arr.length = 2;          // truncate
console.log(arr);       // [1, 2]

arr.length = 5;          // extend với empty slots — TẠO SPARSE!
console.log(arr);       // [1, 2, <3 empty>]

const a = [3, 1, 2];

// ❌ mutate: thay đổi a
a.sort();
console.log(a);  // [1, 2, 3]  ← a đã bị đổi!

// ✅ immutable: a giữ nguyên
const b = [3, 1, 2];
const sorted = b.toSorted();
console.log(b);       // [3, 1, 2]
console.log(sorted);  // [1, 2, 3]

// with(i, v) — replace 1 phần tử, trả mảng mới
const c = ['a', 'b', 'c'];
const d = c.with(1, 'B');   // ['a', 'B', 'c']
console.log(c);             // ['a', 'b', 'c'] — c không đổi

// arr.map(callback(element, index, array)) → array mới CÙNG length

const nums = [1, 2, 3, 4];

nums.map((x) => x * 2);              // [2, 4, 6, 8]
nums.map((x, i) => `${i}: ${x}`);  // ['0: 1', '1: 2', ...]

// Map object → property
const users = [{ name: 'An', age: 20 }, { name: 'Bình', age: 25 }];
users.map((u) => u.name);  // ['An', 'Bình']

// arr.filter(predicate(element, index, array)) → array mới (length ≤ gốc)

[1, 2, 3, 4, 5].filter((x) => x % 2 === 0);  // [2, 4]

users.filter((u) => u.age >= 21);  // [{ name: 'Bình', age: 25 }]

// Boolean shortcut — bỏ falsy
[1, 0, 'a', '', null, 5].filter(Boolean);  // [1, 'a', 5]

// arr.reduce(callback(accumulator, element, index, array), initialValue)

// Sum
[1, 2, 3, 4].reduce((acc, x) => acc + x, 0);  // 10

// Max
[3, 7, 1, 9, 4].reduce((m, x) => x > m ? x : m, -Infinity);  // 9

const orders = [
  { id: 1, total: 120 },
  { id: 2, total: 80 },
  { id: 3, total: 200 },
];

const revenue = orders.reduce((acc, o) => acc + o.total, 0);
// 400

const people = [
  { name: 'An',   city: 'HN' },
  { name: 'Bình', city: 'HCM' },
  { name: 'Cường', city: 'HN' },
];

const byCity = people.reduce((acc, p) => {
  (acc[p.city] ??= []).push(p);
  return acc;
}, {});
// { HN: [{...An}, {...Cường}], HCM: [{...Bình}] }

// ES2024 có Object.groupBy built-in:
Object.groupBy(people, (p) => p.city);  // same result

const votes = ['A', 'B', 'A', 'C', 'A', 'B'];

const tally = votes.reduce((acc, v) => {
  acc[v] = (acc[v] ?? 0) + 1;
  return acc;
}, {});
// { A: 3, B: 2, C: 1 }

const pairs = [['a', 1], ['b', 2], ['c', 3]];

const obj = pairs.reduce((acc, [k, v]) => {
  acc[k] = v;
  return acc;
}, {});
// { a: 1, b: 2, c: 3 }

// Built-in tương đương:
Object.fromEntries(pairs);  // { a: 1, b: 2, c: 3 }

// ❌ forEach không break được
[1, 2, 3, 4].forEach((x) => {
  if (x === 3) return;  // chỉ skip phần tử này, không stop loop
  console.log(x);
});

// ✅ for/of break được
for (const x of [1, 2, 3, 4]) {
  if (x === 3) break;
  console.log(x);
}

// ❌ forEach KHÔNG await tuần tự
async function bad() {
  [url1, url2, url3].forEach(async (u) => {
    await fetch(u);  // 3 request chạy đồng thời, "bad" return trước khi xong
  });
}

// ✅ for/of await tuần tự
async function good() {
  for (const u of [url1, url2, url3]) {
    await fetch(u);  // chạy lần lượt
  }
}

const items = ['a', 'b', 'c'];

for (const [i, v] of items.entries()) {
  console.log(i, v);  // 0 'a', 1 'b', 2 'c'
}

const nums = [1, 2, 3, 4, 5];

nums.find((x) => x > 3);        // 4
nums.findIndex((x) => x > 3);   // 3
nums.findLast((x) => x < 4);    // 3

nums.some((x) => x > 10);       // false
nums.every((x) => x > 0);        // true

nums.includes(3);                // true
nums.includes(NaN);              // (nếu array có NaN: true, vì SameValueZero)
[NaN].indexOf(NaN);             // -1 🔥 (indexOf dùng ===)

[1, [2, [3, [4]]]].flat();           // [1, 2, [3, [4]]]   (depth=1)
[1, [2, [3, [4]]]].flat(2);          // [1, 2, 3, [4]]
[1, [2, [3, [4]]]].flat(Infinity);   // [1, 2, 3, 4]

// flatMap — phổ biến: 1 element → nhiều element
const sentences = ['I love JS', 'You too'];
sentences.flatMap((s) => s.split(' '));
// ['I', 'love', 'JS', 'You', 'too']

// Filter + map gộp 1 lần:
[1, 2, 3, 4].flatMap((x) => x % 2 ? [x * 10] : []);
// [10, 30]   ← chỉ giữ odd, nhân 10

[10, 1, 2, 25, 3].sort();
// [1, 10, 2, 25, 3]   🔥 SAI! sort by string

// Vì sao? Default sort convert mỗi phần tử sang string, so sánh code point.
// '10' < '2' khi so chuỗi (ký tự đầu '1' < '2').

// Cách đúng — truyền comparator:
[10, 1, 2, 25, 3].sort((a, b) => a - b);
// [1, 2, 3, 10, 25]  ✅

// Comparator rule:
//   trả < 0  → a đứng trước b
//   trả > 0  → b đứng trước a
//   trả = 0  → giữ nguyên thứ tự tương đối (stable từ 2019)

// Sort theo property:
users.sort((a, b) => a.age - b.age);  // asc
users.sort((a, b) => b.age - a.age);  // desc

// Sort string đúng locale (tiếng Việt có dấu):
['Đào', 'An', 'Bình'].sort((a, b) => a.localeCompare(b, 'vi'));

// Spread trong function call: array → individual args
Math.max(...[3, 1, 4, 1, 5]);   // 5

// Spread trong array literal: clone / merge
const a = [1, 2];
const b = [3, 4];
const merged = [...a, ...b];      // [1, 2, 3, 4]
const cloned = [...a];            // shallow clone

// Spread trong object literal (ES2018):
const o1 = { a: 1, b: 2 };
const o2 = { ...o1, c: 3 };    // { a: 1, b: 2, c: 3 }
const o3 = { ...o1, b: 99 };   // { a: 1, b: 99 }  ← override

// Rest trong function param: gom args còn lại vào array
function sum(...nums) {
  return nums.reduce((a, b) => a + b, 0);
}
sum(1, 2, 3, 4);  // 10

// Rest sau named param
function log(level, ...messages) {
  console.log(`[${level}]`, ...messages);
}
log('INFO', 'a', 'b', 'c');  // [INFO] a b c

// Rest trong destructuring
const [first, ...others] = [1, 2, 3, 4];
// first = 1, others = [2, 3, 4]

const { a, ...restObj } = { a: 1, b: 2, c: 3 };
// a = 1, restObj = { b: 2, c: 3 }

const [a, b, c] = [1, 2, 3];
// a=1, b=2, c=3

// Skip phần tử
const [, , third] = [1, 2, 3];  // third=3

// Default value khi undefined
const [x = 10, y = 20] = [1];  // x=1, y=20

// Rest
const [head, ...tail] = [1, 2, 3, 4];
// head=1, tail=[2,3,4]

// Swap không cần biến temp
let p = 1, q = 2;
[p, q] = [q, p];  // p=2, q=1

const user = { name: 'An', age: 20, city: 'HN' };

// Cơ bản
const { name, age } = user;

// Rename — y trong object → newName trong scope
const { name: userName } = user;  // userName = 'An'

// Default
const { phone = 'N/A' } = user;  // phone = 'N/A'

// Rename + default
const { phone: tel = 'N/A' } = user;

// Nested
const obj = { a: { b: { c: 42 } } };
const { a: { b: { c } } } = obj;  // c = 42

// Destructure trong param + default
function greet({ name = 'guest', lang = 'vi' } = {}) {
  console.log(name, lang);
}
greet();                       // 'guest' 'vi'
greet({ name: 'An' });          // 'An' 'vi'
greet({ name: 'An', lang: 'en' });

const arr = ['a', 'b', 'c'];
const it = arr[Symbol.iterator]();

it.next();  // { value: 'a', done: false }
it.next();  // { value: 'b', done: false }
it.next();  // { value: 'c', done: false }
it.next();  // { value: undefined, done: true }

const range = {
  from: 1,
  to: 5,
  [Symbol.iterator]() {
    let current = this.from;
    const last = this.to;
    return {
      next() {
        return current <= last
          ? { value: current++, done: false }
          : { value: undefined, done: true };
      }
    };
  }
};

for (const n of range) console.log(n);  // 1 2 3 4 5
[...range];                              // [1, 2, 3, 4, 5]
Array.from(range);                       // [1, 2, 3, 4, 5]

function* simple() {
  yield 1;
  yield 2;
  yield 3;
}

const g = simple();
g.next();  // { value: 1, done: false }
g.next();  // { value: 2, done: false }
g.next();  // { value: 3, done: false }
g.next();  // { value: undefined, done: true }

// Generator object là iterable
[...simple()];          // [1, 2, 3]
for (const v of simple()) console.log(v);

function* range(from, to, step = 1) {
  for (let i = from; i <= to; i += step) {
    yield i;
  }
}

[...range(1, 5)];           // [1, 2, 3, 4, 5]
[...range(0, 10, 2)];        // [0, 2, 4, 6, 8, 10]

function* naturals() {
  let n = 1;
  while (true) yield n++;
}

// Lấy 5 số đầu — KHÔNG vô hạn loop vì generator lazy
function* take(iter, n) {
  for (const v of iter) {
    if (n-- <= 0) return;
    yield v;
  }
}

[...take(naturals(), 5)];  // [1, 2, 3, 4, 5]

const s = new Set();
s.add(1); s.add(2); s.add(2); s.add(3);
s.size;            // 3
s.has(2);          // true
s.delete(2);
[...s];            // [1, 3]

// Dedupe array đơn giản:
const uniq = [...new Set([1, 2, 2, 3, 3, 3])];  // [1, 2, 3]

// So sánh performance: includes O(n) vs Set.has O(1)
const bigArr = Array.from({ length: 100000 }, (_, i) => i);
const bigSet = new Set(bigArr);

bigArr.includes(99999);   // chậm — duyệt 100k phần tử
bigSet.has(99999);        // nhanh — hash lookup

const m = new Map();
m.set('name', 'An');
m.set(42, 'số 42');
m.set(Symbol('id'), 1);

const obj = {};
m.set(obj, 'value cho object');   // Map dùng object làm key — khác plain Object!

m.get('name');   // 'An'
m.has(42);       // true
m.size;          // 4

// Iterate theo INSERTION ORDER
for (const [k, v] of m) { }
for (const k of m.keys()) { }
for (const v of m.values()) { }

// Khởi tạo từ array of pairs
const m2 = new Map([
  ['a', 1],
  ['b', 2],
]);

let user = { name: 'An' };
const wm = new WeakMap();
wm.set(user, 'metadata');

user = null;   // không còn strong ref → entry trong WeakMap sẽ bị GC

// WeakMap KHÔNG iterable, không size, không keys() — vì entries có thể biến mất bất kỳ lúc nào
// Chỉ có: set / get / has / delete