JavaScript Glossary
Key terms from the JavaScript course, linked to the lesson that introduces each one.
405 terms.
A
- Abstract Syntax Tree
- The result of parsing is called an Abstract Syntax Tree (AST).
- Lesson 13 — Parsing and the Abstract Syntax Tree
- access
- An object with get and/or set methods for reading/writing the decorated element (not available for all kinds)
- Lesson 2070 — The Decorator Function Signature
- Accidental breaking changes
- A maintainer renames an "internal" function that users were actually importing
- Lesson 2526 — Semver in Practice: Trust and Reality
- accumulator
- The partially completed product moving down the line
- Lesson 454 — The Reducer Function Signature
- Actions
- Actions are side effects that occur during a transition or while in a particular state.
- Lesson 2426 — State and Transition Vocabulary
- Allocation Instrumentation on Timeline
- While heap snapshots give you static pictures of memory, Allocation Instrumentation on Timeline is like a video recording.
- Lesson 1890 — Using Allocation Instrumentation on Timeline
- Allocation sampling
- A lighter-weight version that samples allocations periodically
- Lesson 1884 — Opening DevTools Memory Profiler
- Analogy
- If Blob is like a sealed envelope containing data, File is that same envelope with a return address, postmark date, and label describing its contents.
- Lesson 1295 — Chaining vs NestingLesson 1927 — Common Measurement PitfallsLesson 2367 — The File Interface
- anonymous function
- An anonymous function is simply a function without a name.
- Lesson 382 — Anonymous Functions
- any
- You eat the first edible pizza; only panic if all are inedible
- Lesson 1316 — Comparing any, race, all, and allSettled
- Arguments
- Arguments are the actual values you provide when calling that function.
- Lesson 403 — Parameters vs Arguments: The Difference
- Arity
- Arity is simply the number of parameters a function expects.
- Lesson 483 — Composition with Arity and CurryingLesson 1771 — Arity and Curry Depth
- array literal
- An array literal is the straightforward way to create an array in JavaScript.
- Lesson 799 — Creating Arrays with Array Literals
- Array of paths
- Array of paths means "only these files have side effects; everything else is safe to tree shake."
- Lesson 2469 — Side Effects and 'sideEffects' Field
- Array-likes
- Array-likes are objects that have a length property and numbered indices (like {0: 'a', 1: 'b', length: 2}), but don't necessarily have Symbol.iterator.
- Lesson 1083 — Iterators vs Array-likes
- ArrayBuffer
- An ArrayBuffer is a fixed-length container that holds raw binary data in memory.
- Lesson 2332 — What is an ArrayBuffer?
- assertion
- An assertion is a statement in your test code that declares what you expect to be true.
- Lesson 2672 — What Are Assertions?
- Associativity
- Associativity is the rule that determines whether operators group from left-to-right or right-to-left when they share the same precedence level.
- Lesson 271 — Associativity: Left-to-Right vs Right-to-Left
- async generator
- An async generator is a special function that combines two powerful features you already know:
- Lesson 2038 — What Are Async Generators?
- Asynchronous callbacks
- Asynchronous callbacks are different: they're stored by the JavaScript environment and invoked later, after some event occurs (like a timer finishing or data arriving).
- Lesson 1224 — Asynchronous CallbacksLesson 1225 — Callback Execution Context
- auto-boxing
- Behind the scenes, JavaScript performs a clever trick called auto-boxing.
- Lesson 43 — Primitive Wrapper Objects
B
- backpressure
- Backpressure is the mechanism that solves this: it tells the producer to slow down or pause when the consumer can't keep up.
- Lesson 1557 — Handling Write BackpressureLesson 1575 — What is Backpressure?
- Batching
- Batching means collecting multiple signal updates into a single transaction, then propagating changes once at the end.
- Lesson 2123 — Batching and Glitch-Free Updates
- Best practice
- Explicit function calls are more maintainable
- Lesson 719 — Why __proto__ Is Deprecated in Modern Code
- Better performance
- Maps are optimized for frequent additions and deletions
- Lesson 1031 — What is a Map and Why Use It?
- BigInt
- BigInt is like a bank vault—handles any amount but requires more ceremony to use.
- Lesson 1972 — When to Use BigInt vs Number
- Bitwise operators
- Bitwise operators are special operators that work at the lowest level of how computers store numbers: as sequences of 1s and 0s (binary).
- Lesson 253 — What Are Bitwise Operators?
- block
- A block is any pair of curly braces that isn't part of a function or object.
- Lesson 80 — Block Scope BasicsLesson 81 — Blocks vs Functions
- blocking
- This is called blocking behavior because each operation blocks (prevents) the next one from starting until it finishes.
- Lesson 1170 — What 'Synchronous' Means in JavaScript
- Blocking behavior
- require() freezes your program until loading completes. Dynamic import() never blocks — perfect for web applications where freezing the UI is unacceptable.
- Lesson 1429 — Dynamic Import vs require()
- Blocks
- Blocks are like rooms in a building — let and const can't leave the room they're declared in
- Lesson 81 — Blocks vs Functions
- Boolean
- In JavaScript, a Boolean is the simplest data type — it can only be one of two values: true or false.
- Lesson 192 — The Boolean Type and Its Two Values
- Breaks assumptions
- You think variables are independent when they're not
- Lesson 52 — Pitfall: Unintended Shared State
- browser runtime
- The browser runtime is the complete environment where your code runs, and it includes the engine plus a collection of powerful tools called Web APIs.
- Lesson 17 — Browser Runtime: DOM and Web APIs
- Buffer
- Buffer is Node.js-specific and includes additional methods for common binary operations (like toString() with various encodings, readInt32LE(), etc.).
- Lesson 1582 — What is a Buffer?Lesson 1591 — Buffer and TypedArraysLesson 2326 — Buffer, ByteOffset, and BYTES_PER_ELEMENT
- Building predictable functions
- Functions that don't mutate their inputs are easier to test, reason about, and reuse. They're "pure" — same input always produces same output without side effects.
- Lesson 837 — When to Prefer Non-Mutating Methods
- Bun
- Deno and Bun are newer runtimes built to address some of Node.js's limitations while adding modern conveniences.
- Lesson 19 — Deno and Bun: Alternative Runtimes
- bundler
- A bundler is a build tool that takes multiple JavaScript files (modules) and combines them into one or more optimized output files that browsers can efficiently load and execute.
- Lesson 2453 — What is a bundler and why do we need one?
- byteLength
- The total number of bytes the array occupies in memory
- Lesson 2325 — Length and ByteLength Properties
C
- Caching
- Caching means storing that value once before the loop starts:
- Lesson 373 — Caching Array Length in For LoopsLesson 1899 — Caching and Memoization for Repeated Work
- call stack
- The call stack is JavaScript's internal to-do list for functions.
- Lesson 1181 — What is the Call Stack?
- callback
- a function you call when processing is complete (or with an error)
- Lesson 1221 — What is a Callback?Lesson 1231 — Callback Pattern SummaryLesson 1555 — Creating a Writable Stream
- callback pattern
- This is called a callback pattern — the function you pass gets "called back" by the outer function.
- Lesson 429 — Passing Functions as Arguments
- callback queue
- A callback queue is an array of functions maintained in closure scope that you accumulate over time and then execute all at once (or in a controlled sequence).
- Lesson 519 — Callback Queues
- Callback-based async
- Callback-based async is like giving them your number and continuing your day—they'll call when ready.
- Lesson 1517 — FS Module Overview: Sync vs Async vs Promises API
- catastrophic backtracking
- This is called catastrophic backtracking.
- Lesson 1688 — Common Quantifier Pitfalls
- Catch block
- Handles the error if one is thrown. The error object contains details about what went wrong.
- Lesson 2435 — The Traditional Throw/Try-Catch Pattern
- Clarity
- The double underscores suggest it's internal/private
- Lesson 719 — Why __proto__ Is Deprecated in Modern Code
- Class declarations
- Class declarations are named and exist in their entire scope, but unlike function declarations, they're not hoisted — you can't use them before the line they're declared.
- Lesson 756 — When to Use Class Declarations vs Expressions
- Class decorator returns a class
- The returned class replaces the original entirely
- Lesson 2077 — Returning Values from Decorators
- Clear communication
- Signals which properties are stable public API vs implementation details
- Lesson 1829 — Convention-Based Privacy with Underscore Prefix
- Clearer intent
- The code shows you're extracting specific values
- Lesson 915 — What is Array Destructuring?
- closure
- A closure is a function that retains access to variables from its outer (enclosing) scope, even after that outer scope has finished executing and "exited."
- Lesson 496 — What a Closure Actually Is
- Combining comparison and logical operators
- x > 5 && y < 10 is clear, but x > 5 && y < 10 || z === 0 benefits from grouping
- Lesson 273 — When to Rely on Precedence vs Parentheses
- Compact notation
- Compact notation is perfect for dashboards and social media (showing "2.4K likes" instead of "2,400 likes").
- Lesson 2205 — Grouping and Notation Options
- comparator function
- A comparator function is your solution: it's a custom function you pass to sort() that compares two elements and tells sort() which should come first.
- Lesson 819 — sort() with Comparator FunctionsLesson 898 — Writing a Numeric Comparator
- Compilation
- Compilation means translating all the code into machine language before running it.
- Lesson 14 — Interpretation vs Compilation
- Composition
- Composition means creating functionality by combining simple, focused objects or functions together, rather than forcing objects to inherit behavior from parent classes.
- Lesson 1817 — What Composition Means
- computed property
- A computed property is a value that's derived from other properties instead of being stored directly.
- Lesson 663 — Using Getters for Computed Properties
- Configuration Structure
- .eslintrc used nested objects with special keys like extends, env, and plugins. Flat config uses a flat array where each object represents a configuration layer you explicitly compose.
- Lesson 2573 — Migrating from .eslintrc to Flat Config
- Consistent Style Within a Project
- Some teams prefer all declarations at the top. Others like definitions near their first use. What matters most is consistency across your codebase.
- Lesson 426 — Best Practices for Function Ordering
- Const
- Const is a locked drawer—you can't swap out what's inside, but if it's a container of items, you can still rearrange those items.
- Lesson 76 — Var vs Let vs Const Summary
- constructor method
- The constructor method is a special method inside a class that runs automatically whenever you create a new instance using the new operator.
- Lesson 747 — The Constructor Method
- Content-Type
- Tells the server what format your request body is in (like application/json when sending JSON data).
- Lesson 2262 — Setting Request Headers
- counter factory
- A counter factory is a function that returns a new counter object (or function) every time you call it.
- Lesson 510 — Counter Factories
- CPU Cache Efficiency
- Contiguous memory means better CPU cache utilization. When you access one element, nearby elements are likely already in cache—critical for loops processing large datasets.
- Lesson 2330 — Performance Characteristics
- Current
- The version you have installed in node_modules
- Lesson 2484 — Installing Node.js and NPMLesson 2493 — npm outdated and Version Checking
- Curry depth
- Curry depth refers to how many nested function calls are needed before you get the final result.
- Lesson 1771 — Arity and Curry Depth
- Currying
- Currying is a functional programming technique that converts a function taking multiple arguments into a sequence of functions, each taking a single argument.
- Lesson 1764 — What Is Currying?
D
- data URL
- A data URL is a special type of URL that contains the actual file content inline, rather than pointing to an external resource.
- Lesson 2359 — Data URLs with Base64
- Debugging
- Identifying which specific process instance is misbehaving
- Lesson 1501 — Process.pid and Process.ppid
- declarations
- Hoisting is JavaScript's behavior during the compilation phase where declarations are processed before any code executes.
- Lesson 90 — What is Hoisting?Lesson 381 — Function Expressions
- Decorators
- Decorators are a way to augment (modify or enhance) classes, methods, properties, and other class members by attaching metadata or wrapping them with additional behavior—without editing their original code.
- Lesson 2067 — What Decorators Are and Why They Exist
- Deduplication
- Deduplication means npm identifies when multiple packages require compatible versions of the same dependency.
- Lesson 2505 — Dependency Hoisting and Deduplication
- Deep copies
- Deep copies are essential when you have nested objects/arrays and need true independence
- Lesson 2396 — Shallow vs Deep Copy
- Deep dependency chains
- A changes B, B changes C, C changes D
- Lesson 2143 — Derived State and Automatic Recalculation
- Default values or normalization
- Automatically clean or format data as objects are created, keeping your constructor logic clean and declarative.
- Lesson 2073 — Field Decorators
- delimiter
- The split() method transforms a string into an array by dividing it wherever a specific character or substring (called a delimiter) appears.
- Lesson 173 — Splitting Strings into Arrays with split
- dependency graph
- Dependency resolution is the process of walking through your code's import/require statements and building a complete map—called a dependency graph—of every module your application uses.
- Lesson 2446 — Dependency Resolution
- Derived state
- Derived state is data calculated from other data sources.
- Lesson 2143 — Derived State and Automatic Recalculation
- Detached DOM trees
- Detached DOM trees are referenced in JavaScript but removed from the page
- Lesson 1870 — What Qualifies as a Memory Leak in JavaScript
- Distance calculations
- Distance calculations are the classic example.
- Lesson 1596 — Math.abs for Absolute Values
- done
- a boolean—true when the stream is complete, false otherwise
- Lesson 1073 — What Is the Iterator Protocol?Lesson 1075 — The Iterator Result ObjectLesson 1078 — Manually Calling next() on an IteratorLesson 1085 — Implementing the Iterator ProtocolLesson 2009 — The Iterator Object ContractLesson 2293 — Reading Chunks with read()Lesson 2294 — Processing Stream Data in a Loop
- dot notation
- The dot notation is the most straightforward syntax: you write the object's name, followed by a dot (.), followed by the property name you want to access.
- Lesson 591 — Accessing Properties with Dot Notation
- duplex stream
- A duplex stream is a stream that is both readable and writable at the same time.
- Lesson 1561 — What Are Duplex Streams?
- Dynamic import
- Dynamic import is different: it's a function-like syntax (import()) that loads modules on demand, during runtime, whenever and wherever you call it.
- Lesson 1420 — What is Dynamic Import?
- Dynamic Scope
- The variable's location is determined by where the function is called from. The scope chain changes based on the call stack at runtime.
- Lesson 490 — Static vs Dynamic Scope
E
- e-notation
- JavaScript lets you use scientific notation (also called e-notation) to express these values more clearly.
- Lesson 102 — Scientific Notation (e-notation)
- EACCES
- EACCES (Error ACCESs) means you lack permission to read, write, or execute the file.
- Lesson 1530 — Error Handling Patterns in FS Operations
- early exit
- This is called early exit and short-circuiting.
- Lesson 377 — Early Exit and Short-Circuiting
- early return
- An early return means exiting a function before reaching its end.
- Lesson 420 — Early Returns for Control Flow
- early returning
- This is called early returning in functions and short-circuiting in loops.
- Lesson 1898 — Early Returns and Short-Circuiting
- Easier to learn
- The syntax (how you write code) reads more naturally
- Lesson 1 — JavaScript: A High-Level Programming Language
- Ecosystem Support
- NPM is the default—every package works with it, every tutorial assumes it, and CI/CD pipelines support it without configuration. Yarn and PNPM have excellent compatibility, but you might occasionally hit edge cases with obscure packages or corporate proxies. If you're joining an existing project or using bleeding-edge tools, check their documentation for package manager requirements.
- Lesson 2536 — Choosing the Right Package Manager
- EEXIST
- EEXIST means a file or directory already exists when you tried to create it.
- Lesson 1530 — Error Handling Patterns in FS Operations
- effect
- In reactive systems, an effect is a function that runs automatically when the signals it depends on change.
- Lesson 2120 — Effects and Side Effects
- either switch
- Think of it like two light switches controlling the same bulb — if either switch (or both) is flipped on, the light turns on.
- Lesson 256 — Bitwise OR (|)
- Encapsulate logic
- the calculation stays hidden inside the object
- Lesson 659 — Defining Getters with the 'get' Keyword
- Encapsulation
- Encapsulation is the practice of bundling data (properties) and behavior (methods) together while controlling what the outside world can see and modify.
- Lesson 1827 — What Encapsulation Means in JavaScript
- end
- The byte index where your slice ends, exclusive (default: blob.size)
- Lesson 821 — copyWithin(): Copying Elements Within the Same ArrayLesson 2366 — Slicing Blobs
- Endianness
- Endianness refers to the order in which these bytes are stored.
- Lesson 2329 — Byte Order and Endianness
- ENOENT
- ENOENT (Error NO ENTry) means "file or directory not found"—the path you specified doesn't exist.
- Lesson 1530 — Error Handling Patterns in FS Operations
- Environment
- require() is Node.js (CommonJS). Dynamic import() works in both browsers and modern Node.js (ES Modules).
- Lesson 1429 — Dynamic Import vs require()
- Error handling context
- If you return await, errors are caught within the current function's scope. If you just return the promise, errors bubble up directly to the caller.
- Lesson 1350 — Await and Return Values
- Error identification
- The toString() output is more descriptive
- Lesson 1153 — Setting the Error Name Property
- Error path testing
- Testing the failure case at each level means creating separate test scaffolds for errors at level 1, level 2, level 3, etc. That's exponential test case growth.
- Lesson 1251 — Testing Callback Hell Code
- ES Modules
- CommonJS (require) is dynamic and harder to analyze
- Lesson 1396 — What Are ES Modules?Lesson 1540 — CommonJS require() vs ES Module importLesson 2447 — Dead Code Elimination
- ES Modules load asynchronously
- the browser or runtime can fetch and parse multiple files in parallel before executing any code. This is why ESM needs the type="module" attribute in HTML.
- Lesson 1450 — CJS and ESM: Two Module Systems
- ES Modules use live bindings
- imports stay connected to their source, so changes in the exporting module are reflected in all importing modules.
- Lesson 1450 — CJS and ESM: Two Module Systems
- event
- An event is a trigger or signal that may cause a state change.
- Lesson 2426 — State and Transition Vocabulary
- event channel
- Instead, they communicate through an intermediary called an event channel or event bus.
- Lesson 1844 — The Pub/Sub Pattern
- Example scenario
- An e-commerce site showing product prices in different locales—Intl.NumberFormat is perfect.
- Lesson 1653 — When to Use Intl vs Third-Party Libraries
- Expensive operations
- If each transformation is costly (API calls, heavy computation), lazy evaluation only pays that cost for items you actually consume.
- Lesson 2055 — When Lazy Evaluation Wins
- Explicit coercion
- Explicit coercion is when you deliberately convert types using constructors like Number(), String(), or Boolean().
- Lesson 274 — What is Type Coercion?
- Expressing intent
- the matcher name documents what you're actually testing
- Lesson 2681 — Custom Matchers
- Expressions
- Expressions are not hoisted—the variable exists, but it's undefined until the assignment runs
- Lesson 381 — Function Expressions
F
- factory function
- A factory function is just a regular function that returns a new object every time you call it.
- Lesson 668 — What Are Factory Functions?Lesson 1806 — Factory Functions: Return Plain Objects
- Factory functions
- Factory functions are plain functions that build and return new objects.
- Lesson 671 — Factory Functions vs Constructor Functions
- false
- The internal buffer is full or exceeds the high water mark. This is your signal to stop writing and wait.
- Lesson 1557 — Handling Write BackpressureLesson 1577 — The write() Return ValueLesson 2469 — Side Effects and 'sideEffects' Field
- file descriptor
- A file descriptor is a numeric identifier that the operating system assigns to an open file.
- Lesson 1526 — File Descriptors and fs.open()/fs.close()
- File Matching
- The old system used overrides arrays with files patterns. Flat config makes every configuration object potentially file-specific using top-level files and ignores keys.
- Lesson 2573 — Migrating from .eslintrc to Flat Config
- File size matters
- Sending large images, videos, or files where bandwidth is limited
- Lesson 2360 — Base64 Overhead and When to Avoid It
- Financial calculations
- Financial calculations are the classic example.
- Lesson 126 — When to Use BigInt Instead
- flat config
- Starting with ESLint 8.21.0, a new configuration system called flat config was introduced (and became the default in ESLint 9.0).
- Lesson 2570 — Introduction to Flat Config (eslint.config.js)
- Flexibility over security
- Privacy is about organization, not protection
- Lesson 1991 — When to Use Private Fields
- forEach
- forEach is like a tour guide: you visit each stop to do something, but you're not building anything new
- Lesson 858 — When to Use forEach vs map
- forEach arrays method
- forEach arrays method is slightly slower.
- Lesson 374 — For vs ForEach vs For...of Performance
- Frequent membership checks
- has() is much faster than includes()
- Lesson 1066 — Array vs Set: Handling Unique Values
- Fulfilled
- The food arrives successfully at your door. Order complete!
- Lesson 1263 — What is a Promise?Lesson 1264 — Promise States
- function
- A function is a reusable piece of code you define with the function keyword.
- Lesson 81 — Blocks vs Functions
- function declaration
- A function declaration is the most traditional way to define a named function in JavaScript.
- Lesson 379 — Function Declaration Syntax
- function declarations
- You've already learned that function declarations are fully hoisted — meaning you can call them before they appear in your code.
- Lesson 96 — Function Expressions vs DeclarationsLesson 423 — Function Expression Hoisting Behavior
- function expression
- A function expression is when you create a function and assign it to a variable, just like you'd assign a number or string.
- Lesson 381 — Function Expressions
- Function inlining
- Function inlining is an optimization where the JavaScript engine replaces a function call with the actual body of the function itself.
- Lesson 1913 — What Is Function Inlining?
- Function name
- A descriptive identifier (follows variable naming rules)
- Lesson 379 — Function Declaration Syntax
- function signatures
- While the application syntax looks identical (@decorator), the decorator function signatures are completely different.
- Lesson 2102 — Legacy Class and Method Decorators
- Functions
- Functions are like entire separate buildings — var, let, and const all stay inside their function
- Lesson 81 — Blocks vs Functions
- functor
- A functor is a container that implements a map method, while a monad adds flatMap (or chain) for flattening nested containers.
- Lesson 1799 — Functor/Monad Pattern Mismatch in JS
G
- Garbage collection
- Garbage collection is the automatic process by which JavaScript identifies and reclaims memory that's no longer needed.
- Lesson 1860 — What is Garbage Collection?
- Garbage collection roots
- Garbage collection roots are the starting points the engine uses to determine reachability.
- Lesson 1862 — Roots and Reference Chains
- generator function
- A generator function is different—it's like a road trip with rest stops.
- Lesson 1096 — What Are Generator Functions?
- getter
- A getter is a special type of object property that looks like a regular property when you access it, but actually executes a function behind the scenes.
- Lesson 659 — Defining Getters with the 'get' Keyword
- Glob patterns
- Glob patterns are wildcard expressions that match file paths.
- Lesson 2595 — Configuring File Patterns
- global object
- The global object is a special, always-available object that sits at the top of JavaScript's scope chain.
- Lesson 1459 — The Global Object Concept
- guard
- A guard is a boolean condition that checks whether a transition should proceed.
- Lesson 2430 — Guarded Transitions
- guard clause
- A guard clause is an if statement at the beginning of your code that checks for invalid conditions and exits early using return.
- Lesson 315 — Guard Clauses and Early Returns
H
- Hard to test
- isolating individual operations is nearly impossible
- Lesson 1242 — What is Callback Hell?
- headers
- A Headers object containing all response headers. Use methods like get('content-type') to inspect server-provided metadata about caching, content types, or authentication tokens.
- Lesson 2256 — The Response ObjectLesson 2267 — The Request Constructor and OptionsLesson 2274 — The Response Object Structure
- Hidden dependencies
- A MINOR update pulls in a transitive dependency with breaking changes
- Lesson 2526 — Semver in Practice: Trust and Reality
- high-level programming language
- A high-level programming language means JavaScript handles the complicated, technical details automatically so you can focus on solving problems.
- Lesson 1 — JavaScript: A High-Level Programming Language
- higher-order function
- A higher-order function is simply a function that does at least one of these two things:
- Lesson 435 — The Higher-Order Function ConceptLesson 439 — What Makes a Function Higher-Order
- Hoisting
- Hoisting is npm's solution: it "lifts" shared dependencies up to the top level of node_modules whenever possible.
- Lesson 2505 — Dependency Hoisting and Deduplication
- Husky
- Husky is a tool that makes Git hooks easy to install, configure, and share across your entire team.
- Lesson 2598 — Git Hooks and Husky
I
- implicit binding
- This is called implicit binding — you don't have to manually pass the object in; JavaScript does it for you.
- Lesson 649 — How 'this' Works in Method Calls
- implicit block
- This is called an implicit block or braceless syntax.
- Lesson 316 — Implicit Blocks vs Explicit Braces
- independent operations
- Identifying these independent operations is the first step toward writing faster async code.
- Lesson 1365 — Identifying Independent Async Operations
- Infinite or unknown-length data
- Generate values indefinitely or until a condition is met
- Lesson 1127 — When to Choose Lazy vs. Eager
- Infinity
- Infinity represents a value larger than any other number—essentially, mathematical infinity.
- Lesson 36 — Special Number Values: NaN, Infinity
- Initialization
- Initialization is the moment you give a variable its first value.
- Lesson 70 — Variable Initialization
- Interpretation
- Interpretation means reading and executing code line-by-line, on the fly.
- Lesson 14 — Interpretation vs Compilation
- invariant
- An invariant is something that doesn't change.
- Lesson 372 — Minimizing Work Inside the Loop Body
- iterable
- An iterable is an object that has the ability to be iterated over—it contains a [Symbol.iterator] method that returns an iterator.
- Lesson 2010 — Making Your Own Iterable ObjectLesson 2011 — Iterables vs Iterators
- iterables
- The ones that can are called iterables—they follow a special contract called the Iterator Protocol.
- Lesson 360 — Iterables and the Iterator ProtocolLesson 1083 — Iterators vs Array-likes
- iterator
- An iterator is the object doing the actual work—it has a next() method that returns {value, done} objects one at a time.
- Lesson 2011 — Iterables vs Iterators
- iterator protocol
- The iterator protocol is JavaScript's formal agreement about how objects can be looped over.
- Lesson 1073 — What Is the Iterator Protocol?
- Iterator Reuse Patterns
- The iterable-iterator pattern (where an object can spawn fresh iterators) is more explicit and debuggable when written manually.
- Lesson 1095 — When Custom Iterators Beat Generators
J
- JavaScript engine
- A JavaScript engine is a special program that reads your JavaScript code and executes it.
- Lesson 9 — What is a JavaScript Engine?
- JavaScript objects
- JavaScript objects are live data structures in memory.
- Lesson 687 — JSON vs JavaScript Objects
- JS heap size
- Total memory your JavaScript is using
- Lesson 1893 — Performance Monitor for Memory Trends
- JSON
- JSON is a text format for data exchange.
- Lesson 687 — JSON vs JavaScript ObjectsLesson 2270 — Request Body and Body Types
K
- Key type limitations
- Object keys are always converted to strings (or symbols). If you try to use a number or object as a key, JavaScript silently stringifies it:
- Lesson 1065 — Object vs Map: When Objects Fall Short
- kind
- A string telling you what is being decorated: "class", "method", "getter", "setter", "field", or "accessor"
- Lesson 2070 — The Decorator Function Signature
L
- label
- A label is a name you attach to a loop, letting you specifically target that loop with break or continue statements—even from inside nested loops.
- Lesson 366 — Labeled statements: Targeting specific loops
- labeled statement
- A labeled statement is simply a statement preceded by an identifier and a colon.
- Lesson 330 — What Are Labeled Statements?
- lastModified
- A timestamp in milliseconds since the Unix epoch, indicating when the file was last changed
- Lesson 2367 — The File Interface
- Latest
- The absolute newest published version, regardless of your version constraints
- Lesson 2493 — npm outdated and Version Checking
- Lazy loading
- Lazy loading means these chunks only download when actually needed—like when a user navigates to a specific page or clicks a button to open a feature.
- Lesson 2444 — Code Splitting and Lazy Loading
- Let
- Let is a labeled drawer that only opens in the right room.
- Lesson 76 — Var vs Let vs Const Summary
- lexical scope
- Lexical scope means that variable accessibility is determined by the physical structure of your code — by where functions are written in the source code.
- Lesson 88 — Scope and Closures PreviewLesson 486 — What is Lexical Scope?
- lineNumber
- The line number where the error occurred (Mozilla-specific)
- Lesson 1148 — Error Object Properties
- Lint-staged
- Lint-staged is a tool that runs linters (like ESLint) and formatters (like Prettier) only on Git-staged files—the ones you're about to commit.
- Lesson 2593 — What is Lint-Staged?
- Local scope operations
- If you create an array within a function and manipulate it before returning, mutation is safe because no external code can access that intermediate state:
- Lesson 914 — When to Mutate: Performance Trade-Offs
- Locale
- A BCP 47 language tag like 'en-US', 'de-DE', or an array of locales.
- Lesson 2234 — Intl.Collator Constructor and Options
- Logging
- Track when properties are read or modified for debugging.
- Lesson 2080 — Accessor Decorators (Getters and Setters)
- lookbehind
- Lookahead and lookbehind are zero-width assertions.
- Lesson 1711 — What Are Lookahead and Lookbehind?
M
- Maintenance and Stability
- Node's test runner is stable but still maturing. Jest is battle-tested but slower to adopt modern features. Vitest is modern but younger with a smaller ecosystem.
- Lesson 2661 — Choosing the Right Test Runner
- Maintenance nightmares
- Tracking down which script owns which global is painful
- Lesson 1466 — Global Namespace Pollution
- MAJOR
- Breaking changes (18 → 20 means incompatible updates)
- Lesson 2484 — Installing Node.js and NPMLesson 2518 — What is Semantic Versioning?
- Major Framework Ecosystems
- Popular libraries like Angular, NestJS, and TypeORM were built entirely on legacy decorators. Migrating millions of lines of code is a massive undertaking, so these ecosystems continue using the old syntax while planning gradual transitions.
- Lesson 2105 — When You Might Still See Legacy Decorators
- map
- A Map is a built-in JavaScript data structure that stores key-value pairs, similar to objects.
- Lesson 858 — When to Use forEach vs mapLesson 1031 — What is a Map and Why Use It?
- mappings
- The magic string! A Base64 VLQ-encoded sequence that maps each position in the minified code to positions in the original sources. Think of it as GPS coordinates connecting every semicolon and variable in the bundle back to its birthplace.
- Lesson 2476 — Source Map File Structure
- Memoization
- Memoization is a specific form where you cache function results based on their arguments.
- Lesson 1899 — Caching and Memoization for Repeated Work
- message
- The data you want to send (will be cloned using structured clone algorithm)
- Lesson 1142 — The Error ConstructorLesson 1148 — Error Object PropertiesLesson 2169 — Basic PostMessage Syntax: Sender and Receiver
- method chaining
- This pattern is called method chaining or a fluent interface.
- Lesson 656 — Method Chaining and Returning 'this'
- microtask starvation
- This condition is called microtask starvation — tasks are "starved" of execution time because microtasks hog the event loop.
- Lesson 1198 — Microtask Starvation
- Migration Complexity
- The two decorator systems have different signatures and behaviors. Automated migration isn't always possible, requiring careful manual review of each decorator.
- Lesson 2105 — When You Might Still See Legacy Decorators
- minimist
- minimist is a lightweight library that transforms raw command-line arguments into a friendly JavaScript object.
- Lesson 1513 — Argument Parsing Libraries: minimist
- mixin
- A mixin is an object or function that provides reusable methods which can be copied into other objects.
- Lesson 1808 — Mixins: Sharing Behavior Without InheritanceLesson 1820 — The Mixin Pattern
- Mocha
- Mocha is the veteran—flexible, minimal, and unopinionated.
- Lesson 2652 — The Test Runner Landscape
- Multiple statements
- If either branch needs to do more than return a value, if/else is cleaner.
- Lesson 233 — Ternary Pitfalls and Readability
N
- name
- The filename as a string (e.g., "document.pdf")
- Lesson 1142 — The Error ConstructorLesson 1148 — Error Object PropertiesLesson 2070 — The Decorator Function SignatureLesson 2367 — The File Interface
- named export syntax
- In ES Modules, named export syntax is the mechanic that lets you explicitly mark which variables, functions, or classes should be available to other modules.
- Lesson 1409 — Named Export Syntax
- Named exports
- Named exports are the gold standard for tree shaking.
- Lesson 2447 — Dead Code EliminationLesson 2468 — Export Patterns That Enable Tree Shaking
- names
- An array of original variable and function names before minification. For example, ["calculateTotal", "userInput"] instead of ["a", "b"].
- Lesson 2476 — Source Map File Structure
- NaN's unique inequality
- NaN is the only JavaScript value that doesn't equal itself (NaN !== NaN). A simple === check will incorrectly report two NaN values as unequal, even though they're conceptually the same special value.
- Lesson 2410 — Edge Cases: Null, Undefined, and NaN
- nested if statement
- A nested if statement is simply an if statement placed inside another if statement's block.
- Lesson 314 — Nested If Statements
- nested state
- A nested state is a state within another state.
- Lesson 2431 — Nested and Hierarchical States
- Nitro
- JavaScriptCore (also called Nitro) is Apple's JavaScript engine that runs code in Safari and any browser built with WebKit on macOS and iOS.
- Lesson 12 — JavaScriptCore: Safari's Engine
- No arguments
- The callback receives nothing—it can't access resolve values or rejection reasons
- Lesson 1282 — The .finally() Method
- No context
- The error appears isolated, disconnected from the larger operation
- Lesson 1250 — Debugging Nested Callbacks
- No inherited properties
- Maps are clean; they only contain what you put in them
- Lesson 1031 — What is a Map and Why Use It?
- No text translation needed
- Your UI labels are fixed in one language, or you have only a handful of static strings
- Lesson 2247 — Identifying Simple i18n Requirements
- no-unused-vars
- no-unused-vars is the rule identifier you can look up
- Lesson 2564 — Interpreting ESLint Error Messages
- Non-zero
- Non-zero (typically 1) means "something went wrong" (error)
- Lesson 1500 — Process.exit() and Exit Codes
- none
- Fully mutable; you can add, modify, or delete any header. This is the default for headers you create yourself with new Headers().
- Lesson 2283 — Headers Immutability and Guards
- Nullish values
- Nullish values are only null and undefined — values that represent the absence of a value.
- Lesson 1948 — Nullish vs Falsy Values
- nyc
- nyc is the older, battle-tested option (especially with Babel/transpiled code):
- Lesson 2717 — Generating Coverage Reports
O
- object itself
- Even though 0 and "" are falsy primitives, their wrapper objects are truthy because the object itself is what gets evaluated, not its wrapped value.
- Lesson 291 — Truthy Objects That Seem Falsy
- object literal
- An object literal is a way to create an object by writing it directly in your code using curly braces {} and listing its properties as key-value pairs.
- Lesson 589 — What is an Object Literal?
- Object literals and constructor functions
- Object literals and constructor functions are generally the fastest for creating objects.
- Lesson 730 — Performance Considerations
- Object URL
- An Object URL is a special temporary URL (starting with blob:) that points to that in-memory data.
- Lesson 2369 — Creating Object URLs
- Observable
- An Observable is like a stream that can emit multiple values over time, and it gives you fine-grained control over when and how that stream operates.
- Lesson 2128 — Observables vs Promises
- ok
- A boolean shortcut: true if status is in the range 200–299, false otherwise. Perfect for quick success checks without memorizing status codes.
- Lesson 2256 — The Response ObjectLesson 2274 — The Response Object Structure
- On-demand computation
- Expensive operations run only when values are needed, not before.
- Lesson 1119 — What Makes a Sequence Lazy?
- One-time use
- Once iterated, the iterator is exhausted
- Lesson 162 — matchAll(): Iterating Over All Matches
- Only synchronous code
- Only synchronous code is allowed—no async operations, Promises, or callbacks
- Lesson 1504 — Process Event: 'exit'
- only-if-cached
- Only use cached responses, fail if nothing is cached (requires mode: 'same-origin').
- Lesson 2273 — Request Cache Control
- operators
- In RxJS, operators are functions that take an observable and return a new observable with modified behavior.
- Lesson 2132 — Operators: Map and Filter
- OptionalDependencies
- OptionalDependencies are packages that enhance functionality but aren't required.
- Lesson 2541 — PeerDependencies and Optional Dependencies
- Options
- Options is an object with three key properties:
- Lesson 2220 — Creating a RelativeTimeFormat Instance
- Own properties
- Own properties are fastest because they're found on the first lookup.
- Lesson 704 — Property Lookup Performance
P
- Parallel execution
- If tasks are independent and can run simultaneously, use Promise.all instead
- Lesson 2037 — When to Prefer For-Await-Of
- Parameter decorators
- Parameter decorators are even more limited.
- Lesson 2103 — Property and Parameter Decorators in Legacy Syntax
- Parameters
- Parameters are the variable names you define when creating a function.
- Lesson 403 — Parameters vs Arguments: The Difference
- partial application
- This is called partial application—you're applying part of the arguments now, leaving the rest for later.
- Lesson 563 — Partial Application with bind()
- pathname
- The path portion (e.g., /products/shoes)
- Lesson 2311 — Accessing and Modifying URL Components
- PeerDependencies
- PeerDependencies are packages your library expects the host application to provide, not packages you install yourself.
- Lesson 2541 — PeerDependencies and Optional Dependencies
- Pending
- Your order is placed and the restaurant is preparing it. You're waiting.
- Lesson 1263 — What is a Promise?Lesson 1264 — Promise States
- Performance
- Object literals are slightly faster because they don't require a constructor function call. Modern engines optimize both, but literals have the edge.
- Lesson 387 — Function Constructor (Rarely Used)Lesson 599 — Object Literals vs. new Object()
- Performance benefits
- Streams enable pipelining. While one chunk is being read from disk, the previous chunk can be processed or sent over the network. No waiting for everything to complete before starting — operations happen concurrently.
- Lesson 1549 — Why Use Streams?
- performance budget
- A performance budget is a set of numerical limits you decide on before you start optimizing.
- Lesson 1932 — Setting Performance Budgets
- Performance critical
- Avoiding copy overhead is essential
- Lesson 2179 — PostMessage vs Shared Memory: When to Use Each
- Performance Monitor
- The Performance Monitor is a live dashboard in Chrome DevTools that shows real-time metrics while your application runs.
- Lesson 1893 — Performance Monitor for Memory Trends
- Performance-critical loops
- The sequential nature may be slower than parallel approaches
- Lesson 2037 — When to Prefer For-Await-Of
- Piping
- Piping is a mechanism that connects a readable stream directly to a writable stream, automatically handling the flow of data between them.
- Lesson 1572 — What is Piping?
- Plain properties
- Plain properties are perfect for simple data storage—when you just need to hold a value without any special behavior.
- Lesson 667 — When to Use Getters/Setters vs Plain Properties
- Plugins
- Plugins are npm packages that bundle additional rules, configurations, and sometimes custom parsers for specialized code scenarios.
- Lesson 2567 — What Are ESLint Plugins?
- Practical mismatch
- JavaScript's strength is pragmatic, imperative-functional hybrids. Forcing pure functional patterns adds complexity without the compile-time guarantees that justify it in other languages. You end up with abstraction overhead and little benefit.
- Lesson 1799 — Functor/Monad Pattern Mismatch in JS
- predicate function
- A predicate function is simply a function that returns true or false based on some test.
- Lesson 467 — Every with Predicate FunctionsLesson 470 — Some with Predicate Functions
- Predictable Memory
- A Float64Array with 1000 elements always uses exactly 8,000 bytes. Regular arrays have unpredictable overhead that varies by JavaScript engine.
- Lesson 2330 — Performance Characteristics
- Preserving context
- You need to lock in this before the function gets called in an unpredictable context
- Lesson 557 — Why Manual 'this' Binding Exists
- Prettier
- Prettier is like an auto-formatter in a word processor—it just makes everything neat and aligned, but it doesn't check if your sentences make sense.
- Lesson 2576 — What Prettier Is and Isn't
- Profiling
- Profiling means measuring where your code actually spends its time, so you know what's worth fixing.
- Lesson 378 — Profiling Before Optimizing Loops
- Progressive enhancement
- Progressive enhancement means building your application so it works without workers but benefits from them when available.
- Lesson 2197 — Progressive Enhancement with Workers
- Promise
- A Promise is a special object in JavaScript that represents the eventual completion (or failure) of an asynchronous operation.
- Lesson 1263 — What is a Promise?Lesson 2128 — Observables vs Promises
- Promise chaining
- Promise chaining is the technique of calling .then() on a promise, which itself returns a new promise, allowing you to attach another .then() to that result.
- Lesson 1288 — What Promise Chaining Is
- Promisifying
- Promisifying means wrapping these callback-based functions in a Promise, transforming them into cleaner, chainable code that works beautifully with async/await.
- Lesson 1260 — Promisifying Callback-Based APIs
- prop
- prop is similar but designed for single objects:
- Lesson 1792 — Creating Point-Free Helper Functions
- prototype
- In JavaScript, a prototype is a special object that acts as a template or blueprint from which other objects can inherit properties and methods.
- Lesson 697 — What is a Prototype?
- Prototypes
- only plain object structure is cloned
- Lesson 694 — structuredClone LimitationsLesson 2004 — What structuredClone Can and Cannot Clone
- Pull Model
- The subject only sends a notification (or a reference to itself). Observers then query the subject for the specific data they need.
- Lesson 2111 — Push vs Pull Models
- pure annotation
- A pure annotation is a special comment (/#__PURE__/) placed directly before a function call.
- Lesson 2470 — Pure Annotations
- pure function
- A pure function is like a reliable vending machine: you put in the same coins, you always get the same snack, and the machine doesn't randomly redecorate your office while you wait.
- Lesson 1741 — What Makes a Function Pure
- Push Model
- The subject sends complete data to observers when notifying them. When something changes, the subject packages up all relevant information and delivers it directly to each observer's update method.
- Lesson 2111 — Push vs Pull Models
R
- Re-exporting
- Re-exporting means importing something from one module and immediately exporting it from your current module.
- Lesson 1414 — Export Lists and Re-exporting
- read-modify-write race
- This is called a read-modify-write race.
- Lesson 2183 — Race Conditions Without Atomics
- Readability
- The literal syntax {} is clean, concise, and instantly recognizable. new Object() is verbose and looks like legacy code.
- Lesson 387 — Function Constructor (Rarely Used)Lesson 599 — Object Literals vs. new Object()
- Readable
- Variables are defined where someone naturally looks first
- Lesson 99 — Best Practices: Declare Before Use
- Recursive custom implementations
- Recursive custom implementations are the slowest but most flexible.
- Lesson 2402 — Performance Considerations
- Regular methods work fine
- if .toArray() is clear enough, don't overcomplicate with Symbol.iterator
- Lesson 1022 — When to Use Well-Known Symbols
- Rejected
- The restaurant cancels your order due to an ingredient shortage. Order failed.
- Lesson 1263 — What is a Promise?Lesson 1264 — Promise States
- Relative time formatting
- Relative time formatting means displaying time differences in natural, conversational language relative to now—like "5 minutes ago," "tomorrow," or "in 3 weeks."
- Lesson 1654 — Intl.RelativeTimeFormat Overview
- request
- Headers attached to a Request object. Certain headers (like Host) are forbidden because the browser controls them for security.
- Lesson 2283 — Headers Immutability and Guards
- Result type
- This is called a Result type or Either pattern.
- Lesson 1167 — Result Types and Either Pattern
- Returns
- the original value at that index (before any change)
- Lesson 2186 — Atomics.compareExchange for Lock-Free Updates
- Reusability
- Named functions can be called from multiple places
- Lesson 1254 — Naming Callbacks for Clarity
- Reusing results
- Arrays can be iterated multiple times; generators are one-time-use
- Lesson 1127 — When to Choose Lazy vs. Eager
- reviver parameter
- The reviver parameter is an optional second argument to JSON.parse().
- Lesson 683 — The Reviver Parameter
- roots
- The GC starts from special starting points called roots (like global variables, currently executing functions, and their local variables) and traces all references outward.
- Lesson 1861 — Reachability: The Core Concept
- Rule of thumb
- Tasks taking more than 50ms risk causing dropped frames (at 60 FPS, each frame has ~16ms). These are prime candidates for worker offloading.
- Lesson 2192 — Measuring Task Duration with Performance APIs
S
- Safe copying
- Data is cloned by default, preventing shared-state bugs
- Lesson 2168 — PostMessage Overview: Sending Data Between Contexts
- Safety matters most
- No risk of race conditions since data is copied
- Lesson 2179 — PostMessage vs Shared Memory: When to Use Each
- SameValueZero
- Maps use an internal algorithm called SameValueZero for this comparison.
- Lesson 1040 — Key Equality and Reference
- Scientific notation
- Scientific notation is useful for extremely large or small numbers in technical contexts.
- Lesson 2205 — Grouping and Notation Options
- Scope
- Scope is the set of rules that determines where in your code a variable can be accessed.
- Lesson 77 — What is Scope?
- scope chain lookup
- Instead, it follows a systematic search process called scope chain lookup.
- Lesson 84 — Scope Chain Lookup
- Security risks
- Global variables are accessible everywhere, including third-party scripts
- Lesson 387 — Function Constructor (Rarely Used)Lesson 1465 — Implicit Global Access
- Separation of concerns
- The algorithm (process and sort) is separate from the policy (how to sort)
- Lesson 437 — Functions as Configuration
- setter
- A setter is a special method that intercepts property assignments.
- Lesson 660 — Defining Setters with the 'set' Keyword
- setters
- Getters and setters are special methods that look like regular properties from the outside, but execute functions behind the scenes.
- Lesson 658 — What Are Getters and Setters?
- setTimeout
- setTimeout is best for general-purpose delays where precise timing isn't critical:
- Lesson 1212 — When to Use setTimeout vs Alternatives
- Shared mutable state
- Shared mutable state is the primary culprit.
- Lesson 2670 — Avoiding Test Interdependence
- Short
- Compact dashboards, where space is limited but clarity matters
- Lesson 1658 — Style Options: Long, Short, and NarrowLesson 2225 — Style: long, short, and narrow
- short-circuit evaluation
- This behavior is called short-circuit evaluation.
- Lesson 218 — Short-Circuit Evaluation with ||
- short-circuiting
- This is called short-circuiting—like a circuit breaker tripping at the first sign of trouble.
- Lesson 1328 — Promise.all and Error Short-Circuiting
- side effect
- In bundling terms, a side effect is code that does something beyond just exporting values—it modifies global state, patches prototypes, imports CSS, or runs code immediately when imported.
- Lesson 2120 — Effects and Side EffectsLesson 2469 — Side Effects and 'sideEffects' Field
- side effects
- Actions (also called side effects) are functions that run:
- Lesson 2429 — Adding Side Effects and Actions
- signal
- A signal is a reactive container that holds a single value and automatically notifies any dependent code when that value changes.
- Lesson 2117 — What Are Signals?Lesson 2118 — Signal Creation and Reading
- Signed
- Signed means it can represent both positive and negative numbers
- Lesson 254 — The Binary Number System Refresher
- Simplicity matters
- Arrays are familiar, easier to debug, and work with existing array methods
- Lesson 1127 — When to Choose Lazy vs. Eager
- Single async operation
- Plain await is simpler for one-off promises
- Lesson 2037 — When to Prefer For-Await-Of
- Single asynchronous operations
- Single asynchronous operations are best handled with Promises:
- Lesson 2145 — When Simple Callbacks or Promises Are Better
- Single-use iterables
- The iterator exhausts after one pass, and subsequent iterations yield nothing
- Lesson 2014 — Reusable vs Single-Use Iterators
- Size Comparison
- Size Comparison means tracking bundle size over time.
- Lesson 2473 — Verifying Tree Shaking Results
- Source code
- Source code is written with modern syntax (const, arrow functions, etc.)
- Lesson 2445 — Transpilation for Browser Compatibility
- source map
- A source map is a special file (usually .map) that acts as a bridge between transformed code and your original source.
- Lesson 2475 — What Are Source Maps?
- sourceContent
- An optional array containing the actual text of your original files. This lets debuggers show your source code even if the original files aren't deployed to production.
- Lesson 2476 — Source Map File Structure
- sources
- An array of original file paths (e.g., ["src/utils.js", "src/main.js"]). These are the files you actually wrote, before bundling.
- Lesson 2476 — Source Map File Structure
- Speed
- Real network calls, database queries, and file operations are slow. Mocked versions return instantly, making your test suite run in seconds instead of minutes.
- Lesson 2059 — Iterator Memory Overhead vs Direct Array AccessLesson 2694 — What is Mocking and Why Mock?
- spread operator
- The spread operator is your best friend here:
- Lesson 1758 — Immutable Array Updates: Adding Elements
- stack
- A string containing the call stack trace (you've seen this before!)
- Lesson 1148 — Error Object Properties
- stack overflow
- JavaScript throws a "Maximum call stack size exceeded" error, commonly known as a stack overflow.
- Lesson 1186 — Stack Overflow Errors
- Stage 3 Decorators Proposal
- The Stage 3 Decorators Proposal represents the current, near-final specification for decorators in JavaScript.
- Lesson 2068 — The Stage 3 Decorators Proposal
- standard
- The "JavaScript Standard Style" with no semicolons
- Lesson 2568 — Using Shareable Configs with 'extends'
- start
- The byte index where your slice begins (default: 0)
- Lesson 821 — copyWithin(): Copying Elements Within the Same ArrayLesson 2366 — Slicing Blobs
- state
- A state represents a distinct condition or mode your system can be in at any given moment.
- Lesson 2426 — State and Transition Vocabulary
- Statement Coverage
- Statement Coverage is similar to line coverage but counts logical statements rather than physical lines.
- Lesson 2716 — What Code Coverage Measures
- Static imports
- Static imports are declarations like import { foo } from './module.js'.
- Lesson 2467 — Static vs Dynamic Imports
- static initialization block
- A static initialization block is a special static {} block inside a class that runs automatically when the class itself is loaded—not when you create instances.
- Lesson 796 — Class Static Initialization Blocks
- static method
- A static method is a function defined on a class that belongs to the class itself, not to individual instances.
- Lesson 780 — What Are Static Methods?
- static properties
- Just as static methods belong to the class rather than instances, static properties are variables stored on the class itself.
- Lesson 785 — Static Properties
- static scope
- Lexical scope (also called static scope) means that a function's access to variables is determined by its physical location in the code when you write it, not where you call it.
- Lesson 82 — Lexical Scope
- status
- The numeric HTTP status code (e.g., 200, 404, 500). This tells you the outcome category: success (2xx), redirection (3xx), client error (4xx), or server error (5xx).
- Lesson 2256 — The Response ObjectLesson 2274 — The Response Object Structure
- statusText
- A human-readable phrase matching the status code (e.g., "OK", "Not Found"). While descriptive, it's less reliable than status since servers can customize it.
- Lesson 2274 — The Response Object Structure
- strictNullChecks
- Treats null and undefined as distinct types that must be handled explicitly. You can't accidentally pass null where only a string is expected.
- Lesson 2628 — Understanding Strict Mode in @ts-check
- string coercion
- This automatic conversion is called string coercion.
- Lesson 275 — String Coercion with the + Operator
- string literal
- A string literal is simply the way you write text values directly in your code.
- Lesson 145 — String Literals: Single and Double Quotes
- Style preference
- return await makes it explicit that you're waiting for an async operation. Direct return is more concise when you don't need to do anything with the value.
- Lesson 1350 — Await and Return Values
- Subscribing
- Subscribing is what starts the Observable, like pressing "play" on a streaming service.
- Lesson 2130 — Subscribing to Observables
- symbol
- A symbol is a primitive data type in JavaScript that represents a unique, immutable identifier.
- Lesson 1001 — What Are Symbols?
- Symbols
- Symbol properties are completely ignored during cloning. They simply won't appear in the cloned object.
- Lesson 57 — Comparing PrimitivesLesson 694 — structuredClone Limitations
- Synchronous
- Synchronous means that JavaScript executes your code sequentially, one statement at a time, in the order it appears.
- Lesson 1170 — What 'Synchronous' Means in JavaScriptLesson 1517 — FS Module Overview: Sync vs Async vs Promises API
- Syntax Complexity
- Nested generics and complex conditional types become unreadable. A TypeScript interface is elegant; the JSDoc equivalent can span multiple lines of comment syntax.
- Lesson 2621 — Editor Support and Limitations
T
- tabWidth
- Number of spaces per indentation level (default: 2). Controls how far code is indented when nested.
- Lesson 2578 — Core Configuration Options
- target
- The index where you want to paste the copied elements
- Lesson 821 — copyWithin(): Copying Elements Within the Same Array
- Team Experience
- A team familiar with Jest will be productive faster than forcing them to learn something "better." Migration costs are real.
- Lesson 2661 — Choosing the Right Test Runner
- ternary operator
- The ternary operator is JavaScript's only operator that takes three operands.
- Lesson 227 — The Ternary Operator Syntax
- Test Isolation
- You want to test your code, not someone else's API or the reliability of your network connection. If your function processes data from an API, mocking that API ensures you're testing your processing logic, not whether the API is up.
- Lesson 2694 — What is Mocking and Why Mock?
- test runner
- A test runner is a specialized tool that automatically discovers, executes, and reports on your test suites.
- Lesson 2651 — What is a Test Runner?
- Testing
- Testing is difficult due to tangled callback chains
- Lesson 1262 — Balancing Pragmatism and Refactoring
- Think of it like this
- You're handing the test runner a "ticket" (the Promise) and saying, "Don't mark this test complete until you can redeem this ticket." The runner patiently waits for redemption (resolution) or learns the ticket is invalid (rejection).
- Lesson 2686 — Returning Promises from Tests
- Think of it this way
- Generators are like automatic transmission—easy and sufficient for most driving. Custom iterators are manual transmission—more work, but you get precise control when performance or special handling matters.
- Lesson 1095 — When Custom Iterators Beat Generators
- third number
- In semantic versioning (like 2.4.7), the third number is the patch version.
- Lesson 2521 — PATCH: Bug Fixes and Safe Updates
- Third-party code patterns
- A library requires a specific structure that triggers warnings (e.g., console statements in a debug wrapper)
- Lesson 2607 — When to Disable Rules
- throttle
- Debounce and throttle are patterns that use closures to track timing state and limit execution frequency.
- Lesson 517 — Debounce and Throttle Functions
- tilde
- The caret opens a wider gate: "Let in anything that promises backward compatibility (minors and patches)." The tilde is more conservative: "Only let in the safest fixes (patches only)."
- Lesson 2524 — Caret (^) vs Tilde (~) Ranges
- Traditional for loops
- Traditional for loops are typically the fastest.
- Lesson 374 — For vs ForEach vs For...of Performance
- trailing comma
- Interestingly, JavaScript permits you to place a comma after the last element as well—this is called a trailing comma (or "dangling comma").
- Lesson 808 — Trailing Commas in Array Literals
- transform stream
- A transform stream is a special type of duplex stream that sits between a readable and writable stream, actively modifying or transforming the data as it passes through.
- Lesson 1564 — Transform Streams Explained
- transition
- A transition is the rule that defines moving from one state to another in response to an event.
- Lesson 2426 — State and Transition Vocabulary
- transition function
- A transition function is the heart of a finite-state machine.
- Lesson 2428 — Transition Functions and Event Handling
- Tree shaking
- Tree shaking is a dead code elimination technique that removes exports you've defined but never actually import or use anywhere in your application.
- Lesson 2466 — What is Tree Shaking?
- true
- The data was successfully written to the internal buffer, and there's still room for more. Keep writing if you want!
- Lesson 1557 — Handling Write BackpressureLesson 1577 — The write() Return Value
- type
- The MIME type (inherited from Blob, but more meaningful for actual files)
- Lesson 2367 — The File Interface
- type coercion
- Type coercion is JavaScript's way of automatically converting a value from one type to another when needed.
- Lesson 56 — When == Performs Type CoercionLesson 210 — Comparing Different TypesLesson 274 — What is Type Coercion?
U
- Uint8Array
- Uint8Array is standard JavaScript available in browsers and all JavaScript environments.
- Lesson 1591 — Buffer and TypedArrays
- Undeclared
- Undeclared means the variable doesn't exist at all—you never created it
- Lesson 32 — undefined: The Default Value
- undefined
- undefined means the variable exists but has no value (yet)
- Lesson 32 — undefined: The Default Value
- Unicode
- Unicode is a universal standard that assigns a unique number (called a "code point") to every character from every writing system—including letters, numbers, symbols, and even emojis.
- Lesson 183 — What is Unicode and Why It Matters
- User navigation
- A user clicks away while data is still loading
- Lesson 2300 — Why AbortController Exists
V
- value
- A Uint8Array containing the actual chunk of data (only present when done is false)
- Lesson 820 — fill(): Replacing Elements with a Static ValueLesson 890 — The Array.prototype.fill() MethodLesson 1073 — What Is the Iterator Protocol?Lesson 1075 — The Iterator Result ObjectLesson 1085 — Implementing the Iterator ProtocolLesson 2009 — The Iterator Object ContractLesson 2293 — Reading Chunks with read()Lesson 2294 — Processing Stream Data in a Loop
- Vitest
- Vitest is the modern challenger, designed for projects using Vite.
- Lesson 2652 — The Test Runner Landscape
W
- Wanted
- The latest version that satisfies your package.json version range (e.g., if you specified ^1.2.0, it might show 1.5.0 but not 2.0.0)
- Lesson 2493 — npm outdated and Version Checking
- WeakMap
- A WeakMap is a special collection similar to Map, but with strict limitations on what can be used as keys.
- Lesson 1056 — WeakMap Basics and Key RestrictionsLesson 1831 — WeakMap for Private Data
- WeakSet
- A WeakSet is perfect when you need to keep track of which objects you've already seen or processed, but you don't want to prevent those objects from being cleaned up when they're no longer needed elsewhere in your code.
- Lesson 1061 — WeakSet Use Case: Tracking Object Sets
- Web APIs
- The browser runtime is the complete environment where your code runs, and it includes the engine plus a collection of powerful tools called Web APIs.
- Lesson 17 — Browser Runtime: DOM and Web APIsLesson 2343 — Why TextEncoder and TextDecoder Exist
- well-known symbols
- Well, JavaScript reserves a special set of symbols—called well-known symbols—that act like "configuration hooks" for built-in operations.
- Lesson 1011 — What Are Well-Known Symbols?
- When it matters
- For large modules in browsers, dynamic import() prevents blocking the main thread. For small Node.js scripts, require() is simpler if you don't mind blocking.
- Lesson 1429 — Dynamic Import vs require()
- Window object
- The Window object is the global browser environment.
- Lesson 1490 — The DOM and Window as Browser-Specific APIs
- Worker threads
- Worker threads are Node.js's answer to parallel computation.
- Lesson 2158 — What Are Worker Threads in Node.js?
- Wrapping and rethrowing
- Wrapping and rethrowing means catching an error, creating a new error with additional information, and throwing that new error instead.
- Lesson 1166 — Wrapping and Rethrowing Errors
X
- XState
- XState is the most popular JavaScript FSM library.
- Lesson 2433 — FSM Libraries: XState Overview