# The Three Pillars of JavaScript According to YDKJS

> Master JavaScript essentials with YDKJS. Explore Scope Closures, Prototypes Objects, and Types Coercion the three core pillars for deeper understanding and better code.

- Repository: [Kyle Simpson/You-Dont-Know-JS](https://github.com/getify/You-Dont-Know-JS)
- Tags: deep-dive
- Published: 2026-02-24

---

**According to the *You Don’t Know JS* (2nd Edition) series by Kyle Simpson, the three pillars of JavaScript are Scope & Closures, Prototypes & Objects, and Types & Coercion.**

The `getify/You-Dont-Know-JS` repository organizes its entire curriculum around three foundational language mechanisms. These pillars—introduced in [`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md)—represent the lexical scope system, the object prototype chain, and the type coercion mechanics. Mastering these concepts provides the deep mental model necessary to predict JavaScript behavior accurately and move beyond surface-level syntax.

## Scope & Closures (The First Pillar)

The first pillar encompasses the lexical scope system and the closure mechanism. As stated in [`scope-closures/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/scope-closures/ch1.md), this pillar explains how the JavaScript engine resolves variable identifiers during compilation and how functions retain access to their originating scope even when executed elsewhere.

**Lexical scope** determines where variables and functions are accessible based on their physical location in the source code. **Closures** occur when a function remembers and accesses variables from its outer scope even after that outer scope has finished executing.

```javascript
/* Scope & Closures ------------------------------------------------------- */
// A function that captures a variable from its outer lexical scope.
function makeCounter() {
  let count = 0;          // ← lexical variable (scope)
  return () => ++count;   // ← closure retains access to `count`
}
const inc = makeCounter();
console.log(inc()); // 1
console.log(inc()); // 2

```

In this example, the arrow function forms a closure over the `count` variable declared in `makeCounter`'s scope. Each call to `inc()` accesses that same preserved variable, demonstrating how closures enable stateful functions.

## Prototypes & Objects (The Second Pillar)

The second pillar covers the object model, prototype inheritance, and the `this` binding mechanism. According to [`objects-classes/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/objects-classes/ch1.md), objects serve as the foundation for prototype-based delegation, which differs fundamentally from classical class inheritance.

Unlike class-based languages that copy behavior down inheritance chains, JavaScript uses **prototypal delegation**. When accessing a property, the engine traverses the `[[Prototype]]` chain until it finds a match or reaches the end of the chain.

```javascript
/* Prototypes & Objects --------------------------------------------------- */
// A simple prototype chain using `Object.create`.
const animal = {
  speak() { console.log(`${this.name} makes a noise.`); }
};

const dog = Object.create(animal);
dog.name = 'Rex';
dog.speak(); // "Rex makes a noise."

```

Here, `dog` delegates the `speak` method to `animal` through its internal prototype linkage. The `this` binding dynamically points to `dog` during invocation, illustrating how the prototype pillar governs object behavior sharing.

## Types & Coercion (The Third Pillar)

The third pillar addresses the primitive type system and implicit type conversion (coercion). As emphasized in [`types-grammar/ch2.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/types-grammar/ch2.md), coercion is an inherent part of JavaScript's type system rather than a flaw to avoid.

Understanding **abstract equality** (`==`) versus **strict equality** (`===`) requires knowledge of the coercion rules that convert values between types during comparisons. The `==` operator allows coercion before comparison, while `===` disallows it.

```javascript
/* Types & Coercion ------------------------------------------------------- */
// Demonstrating the “coercive” `==` operator.
console.log('42' == 42);      // true – string coerced to number
console.log('0' == false);    // true – both coerced to 0
console.log('' == 0);         // true – empty string → 0
// Using strict equality avoids coercion.
console.log('42' === 42);     // false

```

These examples show the ToNumber and ToPrimitive abstract operations at work. Mastering this pillar means predicting when and how JavaScript will coerce values, enabling intentional use of flexible type comparisons.

## Summary

The three pillars of JavaScript according to YDKJS form a complete mental model for the language:

- **Scope & Closures** govern how variables are stored, retrieved, and preserved across function executions through lexical environment recording.
- **Prototypes & Objects** establish the delegation-based object system and dynamic `this` binding that powers JavaScript's object-oriented patterns.
- **Types & Coercion** define the primitive type behaviors and conversion rules that underpin every operation, comparison, and expression evaluation.

Each pillar is explored in depth in its respective book within the `getify/You-Dont-Know-JS` repository, starting with the foundational concepts in [`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md).

## Frequently Asked Questions

### What are the three pillars of JavaScript in YDKJS?

The three pillars are **Scope & Closures**, **Prototypes & Objects**, and **Types & Coercion**. These concepts are introduced in the "Get Started" book and expanded across the `scope-closures`, `objects-classes`, and `types-grammar` books in the repository.

### Why does YDKJS consider coercion a pillar instead of an anti-pattern?

Unlike common advice to avoid `==`, the YDKJS series argues that coercion is an **inherent and useful mechanism** of the language. Understanding the explicit conversion rules in [`types-grammar/ch2.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/types-grammar/ch2.md) allows developers to write cleaner code that leverages JavaScript's type flexibility intentionally rather than fearing it.

### How do the three pillars relate to the `this` keyword in JavaScript?

The `this` keyword belongs to the **Prototypes & Objects** pillar. According to [`objects-classes/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/objects-classes/ch1.md), `this` binding is determined by the call site of a function and supports the prototype delegation model by allowing shared methods to operate on different receiving objects contextually.

### Where should I start reading about these pillars in the repository?

Begin with [`get-started/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/get-started/ch1.md) for the high-level overview, then proceed to [`scope-closures/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/scope-closures/ch1.md) for the first pillar, [`objects-classes/ch1.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/objects-classes/ch1.md) for the second, and [`types-grammar/ch2.md`](https://github.com/getify/You-Dont-Know-JS/blob/main/types-grammar/ch2.md) for the third. These files contain the canonical explanations and code examples that define the YDKJS curriculum.