This section dissects the fundamental building blocks of JavaScript, focusing on the nuances of scope, types, coercion, and operators that are critical for writing professional-grade code.

Variables, Scope, and the Temporal Dead Zone (TDZ)

JavaScript's variable scoping has evolved significantly. Understanding the differences between var, let, and const is crucial.

var:

• Scope: Function-scoped. A var declared inside a function is available anywhere in that function. If declared outside any function, it becomes a global variable.
• Hoisting: var declarations are "hoisted" to the top of their scope, but their assignments are not. This means you can reference a var before its declaration without a ReferenceError, but its value will be undefined.

function checkVar() {
    console.log(myVar); // Outputs: undefined
    var myVar = "I am hoisted";
    console.log(myVar); // Outputs: "I am hoisted"
}

let and const:

Scope:

• Block-scoped. They are only accessible within the {} block they are defined in (e.g., inside an if statement, for loop, or a standalone block).

Temporal Dead Zone (TDZ):

• let and const are also hoisted, but they are not initialized. The period from the start of the block until the declaration is reached is the TDZ. Accessing a variable in its TDZ results in a ReferenceError. This prevents bugs caused by using a variable before it's declared.

Immutability:

• const creates an immutable binding. For primitive types, this means the value cannot change. For objects and arrays, the reference cannot be changed, but the contents of the object or array can be modified.

Types, Coercion, and Equality Deep Dive

JavaScript is a dynamically typed language, but its type system has important rules.

Primitives vs. Reference Types

• Primitives: string, number, boolean, null, undefined, symbol, bigint. They are passed by value. When you assign a primitive to another variable, a copy is made.
• Reference Types: object (which includes array, function, etc.). They are passed by reference. When you assign an object to another variable, both variables point to the same location in memory.

Implicit vs. Explicit Coercion

• Implicit Coercion: JavaScript automatically converts types in certain operations (e.g., 5 + '5' results in the string '55'). This is often the source of bugs. The == operator is a prime example.
• Explicit Coercion: Manually converting a type using functions like Number(), String(), or Boolean(). This is considered a best practice for predictable code.

const numString = "123";
const num = Number(numString); // Explicitly convert string to number

`null` vs. `undefined`

• undefined typically means a variable has been declared but not yet assigned a value.
• null is an explicit assignment value that means "no value." It is intentionally set by the developer.
• A key quirk: typeof undefined is "undefined", but typeof null is "object". This is a long-standing bug in the language.

Modern Operators and Advanced Logic

Modern JavaScript provides powerful operators for writing more concise and safe code.

Logical Operator Short-Circuiting:

• || (OR): Evaluates expressions from left to right and returns the first truthy value it finds. If no truthy value is found, it returns the last falsy value. It stops as soon as it finds a truthy value.
• && (AND): Evaluates from left to right and returns the first falsy value it finds. If all values are truthy, it returns the last truthy value. It stops as soon as it finds a falsy value.

// Use case: setting a default value (pre-ES2020)
const name = providedName || "Guest";

// Use case: conditionally calling a function
user.isLoggedIn && user.logOut(); // logOut() only called if isLoggedIn is true

Nullish Coalescing Operator (??): This is a safer alternative to || for setting defaults. It only returns the right-hand side value if the left-hand side is null or undefined, ignoring other falsy values like 0, '', or false.

Optional Chaining (?.): Prevents errors when trying to access properties of a potentially null or undefined object. If any part of the chain is null or undefined, the expression short-circuits and returns undefined.

const user = { getProfile: () => ({ name: "Alex" }) };

// Safely access a nested property
const street = user.address?.street; // undefined

// Safely call a function that might not exist
const data = user.getData?.(); // undefined

Changelog

8/5/25, 2:00 PM

View All Changelog

• 27885-feat: add new notes on Modern ES6+ Features, Objects and Prototypal Inheritance, and Functionson 8/5/25

Copyright

Copyright Ownership:WARREN Y.F. LONG

License under:Attribution-NonCommercial-NoDerivatives 4.0 International (CC-BY-NC-ND-4.0)