Biến, kiểu dữ liệu và type coercion

if (true) {
  var a = 1;
  let b = 2;
  const c = 3;
}

console.log(a); // 1   ← var "leak" ra ngoài block
console.log(b); // ReferenceError: b is not defined
console.log(c); // ReferenceError: c is not defined

// var — hoisted với value = undefined
console.log(x); // undefined (không lỗi)
var x = 5;

// let — hoisted nhưng ở TDZ → lỗi khi truy cập
console.log(y); // ReferenceError: Cannot access 'y' before initialization
let y = 5;

typeof 42;        // 'number'
typeof 3.14;      // 'number' — không có 'float' riêng
typeof NaN;       // 'number' 🔥 (NaN là một loại number)
typeof Infinity;  // 'number'

Number.MAX_SAFE_INTEGER;  // 9007199254740991 (2^53 - 1)
Number.MIN_SAFE_INTEGER;  // -9007199254740991
Number.EPSILON;           // 2.220446049250313e-16

// Vượt MAX_SAFE_INTEGER → mất độ chính xác
9007199254740993 === 9007199254740992;  // true (!!)

const big = 9007199254740993n;  // hậu tố `n`
const big2 = BigInt("9007199254740993");

// Không thể trộn BigInt với Number
big + 1;     // ❌ TypeError
big + 1n;    // ✅ 9007199254740994n

const a = 'single quote';
const b = "double quote";
const c = `template literal`;

// Template literal hỗ trợ:
// 1. Interpolation
const name = 'Việt';
const greet = `Xin chào, ${name}!`;  // 'Xin chào, Việt!'

// 2. Multiline
const text = `Dòng 1
Dòng 2
Dòng 3`;

// 3. Expression bên trong
const sum = `${2 + 3}`;  // '5'

// 4. Function call
const upper = `${name.toUpperCase()}`;  // 'VIỆT'

const s = 'abc';
s[0] = 'z';  // silent fail (strict mode: lỗi)
console.log(s); // 'abc' — không đổi

// Phải tạo mới:
const s2 = 'z' + s.slice(1);  // 'zbc'

let x;
console.log(x); // undefined (chưa init)

function foo(a, b) { return [a, b]; }
foo(1);          // [1, undefined] — missing arg

const obj = { a: 1 };
console.log(obj.b); // undefined — missing property

function noReturn() {}
noReturn();          // undefined — implicit return

// document.getElementById trả null nếu không tìm thấy
const el = document.getElementById('foo');
if (el === null) { /* xử lý */ }

// Explicit set: "tôi cố ý không có value"
let selectedUser = null;
// ... sau này:
selectedUser = { id: 1, name: 'An' };

// x == null match cả null và undefined
if (x == null) { /* x là null hoặc undefined */ }

// Tương đương:
if (x === null || x === undefined) { }

Boolean([]);        // true 🔥 (array rỗng vẫn truthy)
Boolean({});        // true 🔥 (object rỗng vẫn truthy)
Boolean('0');       // true (string '0' truthy, khác number 0)
Boolean('false');   // true (string 'false' truthy)
Boolean(Infinity);  // true
Boolean(function(){});  // true (function là object)

1 + 2;         // 3
1 + '2';       // '12' 🔥 (number → string, concat)
'1' + 2;       // '12'
'1' + '2';     // '12'

1 + true;      // 2  (true → 1)
1 + false;     // 1  (false → 0)
1 + null;      // 1  (null → 0)
1 + undefined; // NaN (undefined → NaN)

// Trick: convert sang number bằng `+`
+'42';          // 42 (number)
+'42px';        // NaN

'5' - 3;     // 2  ('5' → 5)
'5' * '2';   // 10 (cả 2 → number)
'10' / 2;    // 5
'abc' - 1;   // NaN (abc không là number hợp lệ)

1 === 1;      // true
1 === '1';    // false (type khác)
1 == '1';     // true ('1' → 1, sau đó 1 == 1)

0 == false;   // true (false → 0)
0 == '';      // true ('' → 0)
0 == '0';     // true

null == undefined;  // true (chỉ 2 cái này == nhau)
null === undefined; // false
null == 0;         // false 🔥 (null không coerce sang 0 trong ==)

// String() — convert sang string
String(42);          // '42'
String(true);        // 'true'
String(null);        // 'null'
String(undefined);   // 'undefined'
String([1,2,3]);     // '1,2,3'
String({a:1});       // '[object Object]' 🔥

// Number() — convert sang number
Number('42');        // 42
Number('42.5');      // 42.5
Number('42px');      // NaN (không parse partial)
Number('');          // 0 🔥
Number(' ');         // 0 🔥 (whitespace → 0)
Number(null);        // 0
Number(undefined);   // NaN
Number([]);          // 0 🔥
Number([42]);        // 42 (array 1 phần tử)
Number([1,2]);       // NaN

// Boolean() — convert sang boolean (theo rule truthy/falsy)
Boolean(0);         // false
Boolean('');        // false
Boolean('0');       // true (string '0' truthy)

// parseInt / parseFloat — parse partial
parseInt('42px');     // 42 (parse số đầu, ignore phần còn lại)
parseFloat('3.14em'); // 3.14
parseInt('abc');      // NaN

NaN === NaN;    // false 🔥
NaN == NaN;     // false
typeof NaN;     // 'number' 🔥

// Khi NaN xuất hiện
0 / 0;            // NaN
Math.sqrt(-1);    // NaN
Number('abc');    // NaN
undefined + 1;    // NaN

// Check NaN — dùng Number.isNaN (chính xác hơn isNaN cũ)
Number.isNaN(NaN);          // true
Number.isNaN('abc');        // false 🔥 ('abc' không phải NaN, nó là string)
isNaN('abc');              // true ❌ (global isNaN coerce trước → bug)

const user = { name: 'An', address: { city: 'Hà Nội' } };
const user2 = { name: 'Bình' };

// Cũ (verbose):
const city = user2 && user2.address && user2.address.city;

// Mới:
const city2 = user2?.address?.city;  // undefined (không throw)

// Áp dụng cho method call
user.greet?.();          // nếu greet không tồn tại, không lỗi

// Áp dụng cho array index
const arr = null;
const first = arr?.[0];     // undefined

// Default value pattern
const count = userInput ?? 0;
const name = userName ?? 'Anonymous';

// Khác || ở case 0, '', false:
0 || 5;       // 5  (0 falsy)
0 ?? 5;       // 0  (0 không phải null/undefined)

'' || 'x';   // 'x'
'' ?? 'x';   // ''

false || true; // true
false ?? true; // false