JavaScript Type Coercion — Why '149.99' + Tax Broke It

// Primitives — immutable values
const str     = 'TheCodeForge'          // string
const num     = 42                       // number (no separate int/float)
const float   = 3.14                     // also number
const bool    = true                     // boolean
const nothing = null                     // null (intentional absence)
let  undef                               // undefined (not yet assigned)
const sym     = Symbol('id')             // Symbol (unique, no two are equal)
const big     = 9007199254740993n        // BigInt (integers beyond 2^53)

// Object — everything else
const obj  = { name: 'Alice', age: 30 } // plain object
const arr  = [1, 2, 3]                  // array (is an object)
const fn   = function() {}              // function (is an object)
const date = new Date()                 // Date (is an object)

console.log(typeof str)   // 'string'
console.log(typeof num)   // 'number'
console.log(typeof null)  // 'object'  ← historic bug, not a real object
console.log(typeof arr)   // 'object'
console.log(typeof fn)    // 'function' ← special case for functions

// undefined — the JS engine's default for 'not assigned'
let user;
console.log(user);             // undefined
console.log(user === undefined); // true

function greet(name) {
  console.log(name);           // undefined if called with no argument
}
greet();                       // undefined

// null — your code saying 'intentionally empty'
let currentUser = null;        // logged out — no user

// The null check gotcha
console.log(null == undefined);  // true  — loose equality
console.log(null === undefined); // false — strict equality (different types)

// Best practice: always use === and check explicitly
if (currentUser === null) {
  console.log('User logged out');
} else if (currentUser === undefined) {
  console.log('User state not initialised');
}

// + operator: if either operand is a string, concatenates
console.log(1 + '2')    // '12' — number coerced to string
console.log('3' - 1)    // 2    — string coerced to number
console.log(true + 1)   // 2    — true coerced to 1
console.log(false + 1)  // 1    — false coerced to 0

// == (loose) vs === (strict)
console.log(0 == false)  // true  — coercion
console.log(0 === false) // false — no coercion
console.log('' == false) // true  — both coerce to 0
console.log('' === false)// false

// The fix: always use === for comparisons
// Use explicit conversion when you mean to convert
const input = '42';  // string from a form input
const value = Number(input);  // explicit — clear intent
console.log(value + 1);  // 43, not '421'

// For primitives: typeof works (except null)
function typeOf(val) {
  if (val === null)            return 'null';     // fix the null bug
  if (Array.isArray(val))     return 'array';    // typeof [] === 'object'
  return typeof val;
}

console.log(typeOf(null))      // 'null'
console.log(typeOf([1,2,3]))   // 'array'
console.log(typeOf('hello'))   // 'string'
console.log(typeOf(42))        // 'number'
console.log(typeOf({}))        // 'object'

// For objects: instanceof or Object.prototype.toString
console.log([] instanceof Array)    // true
console.log({} instanceof Object)   // true
console.log(Object.prototype.toString.call([]))  // [object Array]

// Symbol — guaranteed unique
const sym1 = Symbol('id');
const sym2 = Symbol('id');
console.log(sym1 === sym2); // false — even with same description

// Use case: metadata on objects without collision
const metadataKey = Symbol('metadata');
const user = { name: 'Alice', [metadataKey]: { created: '2025-01-01' } };
console.log(user[metadataKey]); // { created: '2025-01-01' }

// BigInt — large integers
const big1 = 9007199254740993n;          // n suffix
const big2 = BigInt('9007199254740993'); // from string
const sum = big1 + 1n;                  // 9007199254740994n
// Mixing BigInt and Number throws TypeError
// BigInt('1') + 1  // TypeError: Cannot mix BigInt and other types

// BigInt is not strictly equal to Number
console.log(1n == 1);  // true  (loose, coercion allowed? Actually 1n == 1 is true)
console.log(1n === 1); // false (different types)