Fundamentals

const name = "Ada"
let count = 0
count = count + 1      // fine: let can be reassigned
count += 1              // shorthand
console.log(name, count)

// const means the NAME is fixed, not the value inside an object
const user = { name: "Ada" }
user.name = "Grace"     // allowed: we changed a property, not the binding
console.log(user)

// Block scope: let/const live only inside their { }
if (true) {
  let inside = "here"
  var leaky = "everywhere"   // var ignores the block
}
console.log(typeof inside, leaky)

// Naming: camelCase for variables and functions, PascalCase for classes,
// SCREAMING_CASE for true constants
const MAX_RETRIES = 3
const firstName = "Ada"
console.log(MAX_RETRIES, firstName)

console.log(typeof 42, typeof 3.14, typeof -1)   // one number type, all floating point
console.log(typeof "hi", typeof 'hi', typeof `hi`)
console.log(typeof true, typeof undefined, typeof 10n, typeof Symbol("id"))
console.log(typeof null)                            // "object" — the historical bug
console.log(typeof [], typeof {}, typeof (() => 1))
console.log(Array.isArray([]), Array.isArray({}))  // the real array check

// undefined vs null: "not assigned yet" vs "deliberately empty"
let notYet
const nothing = null
console.log(notYet, nothing, notYet == null, notYet === null)

// Numbers: one type, with three special values
console.log(1 / 0, -1 / 0, 0 / 0)
console.log(0.1 + 0.2, 0.1 + 0.2 === 0.3)         // binary floats — every language
console.log(Number.MAX_SAFE_INTEGER, 2 ** 53 + 1)  // beyond this, use BigInt
console.log(9007199254740993n + 1n)

// + is string concatenation if EITHER side is a string
console.log("5" + 3, 5 + "3", "5" + "3", 1 + 2 + "3", "1" + 2 + 3)
// every other arithmetic operator converts to number
console.log("5" - 3, "5" * "2", "10" / 2, "abc" - 1)

// Explicit conversion — do this instead
console.log(Number("42"), Number("42px"), Number(""), Number(null), Number(undefined))
console.log(parseInt("42px"), parseFloat("3.5kg"), parseInt("0x1F", 16))
console.log(String(42), (42).toString(), 42 + "", (3.14159).toFixed(2))
console.log(Boolean(0), Boolean(""), Boolean("0"), Boolean([]), Boolean(null))

// Truthy and falsy: exactly 8 falsy values, everything else is truthy
const falsy = [false, 0, -0, 0n, "", null, undefined, NaN]
console.log(falsy.map(v => Boolean(v)).every(b => b === false))
console.log(Boolean("false"), Boolean({}), Boolean(-1))   // all truthy!

// == vs ===: always use ===
console.log(0 == "", null == undefined, "1" == 1, [] == false)   // coercion surprises
console.log(0 === "", null === undefined, "1" === 1)              // what you meant

const name = "Ada", age = 36, langs = ["JS", "Python"]

console.log("Name:", name, "Age:", age)          // values, space-separated
console.log(`${name} is ${age} and knows ${langs.length} languages`)
console.log(`Next year: ${age + 1}. Upper: ${name.toUpperCase()}`)   // any expression

// Multi-line strings without \n
console.log(`Line one
Line two`)

// Objects and arrays are shown structurally
console.log({ name, age }, langs)                 // { name } is shorthand for { name: name }

// The other console methods
console.error("goes to stderr")                   // same text, different stream
console.warn("a warning")
console.table([{ a: 1, b: 2 }, { a: 3, b: 4 }])   // a table in DevTools

// Escapes
console.log("Tab:\tQuote:\" Backslash:\\ Unicode: \u00e9")
console.log('single "with" double', "double 'with' single")

// Arithmetic
console.log(7 + 2, 7 - 2, 7 * 2, 7 / 2, 7 % 2, 7 ** 2)     // % is remainder, ** is power
console.log(Math.floor(7 / 2), Math.trunc(-7 / 2), -7 % 2)  // no integer division operator
let n = 5
n++; n += 10; n *= 2
console.log(n)

// Comparison — always ===
console.log(3 > 2, 3 >= 3, 3 !== "3", "b" > "a", "10" < "9")  // strings compare char by char!

// Logical: && and || return one of their OPERANDS, not just true/false
console.log(true && "yes", false && "yes", null || "default", "" || "empty")
console.log(!true, !!"text", !!0)

// ?? (nullish) — only null/undefined trigger the fallback; 0 and "" are kept
console.log(0 || 10, 0 ?? 10, "" ?? "fallback", null ?? "fallback")

// ?. (optional chaining) — stop and give undefined instead of throwing
const user = { profile: { name: "Ada" } }
console.log(user.profile?.name, user.address?.city, user.getName?.())

// Ternary: an if/else that is an expression
const age = 20
console.log(age >= 18 ? "adult" : "minor")

// Assignment shortcuts with logic
let cfg = {}
cfg.retries ??= 3       // set only if null/undefined
cfg.debug ||= false
console.log(cfg)

// typeof, instanceof, in, delete, spread
console.log(typeof 1, [] instanceof Array, "name" in user.profile)
const copy = { ...user.profile, role: "admin" }
console.log(copy)

console.log(2 + 3 * 4, (2 + 3) * 4)
console.log(2 ** 3 ** 2, (2 ** 3) ** 2)         // ** is right-associative: 2 ** 9
console.log(10 - 4 - 3, 10 - (4 - 3))            // left-to-right
console.log(1 < 2 < 3, 3 > 2 > 1)                // (true) < 3 → 1 < 3; (true) > 1 → 1 > 1
console.log(true || false && false)              // && binds tighter than ||
console.log(!"" + 1, typeof 1 + "")              // unary operators bind tightest
let a, b
a = b = 5                                        // assignment is right-to-left
console.log(a, b)
console.log(1 + 2 + "3", "1" + 2 * 3)

"use strict"

const $el = "dollar is allowed", _private = "so is underscore", camelCase2 = "digits after"
console.log($el, _private, camelCase2)

// Reserved words fail to parse: try uncommenting
// const class = 1

// What strict mode catches (in a real engine): assigning to an undeclared name
try {
  undeclared = 5          // ReferenceError in strict mode; a silent global without it
} catch (e) {
  console.log(e.name)
}

// Case matters
const total = 1, Total = 2
console.log(total, Total)