타입과 형변환 — == 대신 ===를 쓰는 진짜 이유

let str = 'hello';
str[0] = 'H';       // 무시됨
console.log(str);    // 'hello' — 변하지 않음

str = 'Hello';       // 새 문자열을 할당한 것

const a = { name: 'Alice' };
const b = a;            // 참조 복사
b.name = 'Bob';
console.log(a.name);    // 'Bob' — 같은 객체를 가리킴

typeof 'hello'     // 'string'
typeof 42          // 'number'
typeof true        // 'boolean'
typeof undefined   // 'undefined'
typeof Symbol()    // 'symbol'
typeof 42n         // 'bigint'
typeof {}          // 'object'
typeof []          // 'object' — 배열도 객체
typeof null        // 'object' — 유명한 버그!
typeof function(){} // 'function'

const value = null;

// 잘못된 방법
typeof value === 'null' // 이런 타입은 없음

// 올바른 방법
value === null // true

[] instanceof Array   // true
[] instanceof Object  // true — Array의 프로토타입 체인에 Object가 있음
'' instanceof String  // false — 원시 타입은 객체가 아님

Object.prototype.toString.call('hello')    // '[object String]'
Object.prototype.toString.call([])         // '[object Array]'
Object.prototype.toString.call(null)       // '[object Null]'
Object.prototype.toString.call(undefined)  // '[object Undefined]'

Array.isArray([]);  // true
Array.isArray({});  // false

'5' + 3      // '53' — 숫자가 문자열로 변환
'5' + true   // '5true'
'5' + null   // '5null'
'5' + undefined // '5undefined'

'5' - 3      // 2
'5' * '3'    // 15
true + 1     // 2 — true → 1
false + 1    // 1 — false → 0
null + 1     // 1 — null → 0
undefined + 1 // NaN — undefined → NaN

false
0
-0
0n       // BigInt의 0
''       // 빈 문자열
null
undefined
NaN

// 전부 truthy!
Boolean('0')        // true — 비어 있지 않은 문자열
Boolean('false')    // true
Boolean([])         // true — 빈 배열
Boolean({})         // true — 빈 객체
Boolean(new Boolean(false)) // true — 객체는 항상 truthy

5 === 5      // true
5 === '5'    // false — 타입이 다름
null === undefined // false

5 == '5'     // true — '5' → 5로 변환
null == undefined // true — 특수 규칙
0 == false   // true — false → 0
'' == false  // true — '' → 0, false → 0

[] == false   // true
// [] → '' → 0, false → 0 → 0 == 0 → true

[] == ![]     // true (!)
// ![] → false (빈 배열은 truthy이므로 !truthy → false)
// [] == false → 위와 동일 → true

'' == 0       // true
// '' → 0

'0' == false  // true
// false → 0, '0' → 0

' \t\n' == 0  // true
// 공백 문자열 → 0

// null 또는 undefined 체크 — 유일하게 == null이 유용한 경우
if (value == null) {
  // value === null || value === undefined
}

// 문자열로
String(123)     // '123'
(123).toString() // '123'

// 숫자로
Number('123')   // 123
parseInt('123') // 123
+'123'          // 123 — 단항 + 연산자

// 불리언으로
Boolean(1)      // true
!!1             // true — 이중 부정

Number('123abc')    // NaN — 전체가 숫자가 아니면 NaN
parseInt('123abc')  // 123 — 앞에서부터 파싱

Number('')          // 0
parseInt('')        // NaN

Number('0x1A')      // 26
parseInt('0x1A', 16) // 26

const s1 = Symbol('id');
const s2 = Symbol('id');
console.log(s1 === s2); // false — 설명이 같아도 다른 값

const ID = Symbol('id');
const user = {
  [ID]: 1234,
  name: 'Alice'
};

console.log(user[ID]);         // 1234
console.log(Object.keys(user)); // ['name'] — Symbol은 열거되지 않음

// Symbol.iterator — 이터러블 프로토콜
const iterable = {
  [Symbol.iterator]() {
    let i = 0;
    return {
      next() {
        return { value: i++, done: i > 3 };
      }
    };
  }
};

for (const v of iterable) {
  console.log(v); // 0, 1, 2
}

// Number의 한계
console.log(9007199254740992 === 9007199254740993); // true — 정밀도 손실!

// BigInt로 해결
console.log(9007199254740992n === 9007199254740993n); // false — 정확!

// Number와 혼합 연산 불가
1n + 1;        // TypeError

// 명시적 변환 필요
1n + BigInt(1); // 2n
Number(1n) + 1; // 2

// 비교는 가능
1n == 1;  // true (==는 형변환)
1n === 1; // false (타입이 다름)