When you’re learning JavaScript, the hardest part is often the vocabulary, not the typing. This plain-English glossary translates the terms you’ll see in tutorials, error messages, and code reviews into “what it means” and “why you should care.”
Think of it like learning street signs before you try to drive.
Use this like a lookup table: jump to the word that’s blocking you, then come back later for the rest.
Values, types, and “what is this thing?”
In JavaScript, most confusion starts with what a value is, what type it has, and how it behaves when you try to combine it with other values.
- Value: The actual “thing” you have, like 3, "hi", or true. Analogy: an item on a desk.
- Type: The category of a value (number, string, boolean, object, etc.). Analogy: a label on the item’s box.
- Primitive: Simple values like numbers and strings. They’re not containers for other values. Analogy: a single coin.
- Object: A container that can hold multiple values (properties). Arrays and functions are objects too. Analogy: a toolbox with compartments.
- Array: An ordered list (indexes 0, 1, 2...). Analogy: a line of numbered bins.
- null: “Intentionally empty.” You (or a library) set it to mean “nothing here.” Analogy: a reserved parking spot that’s currently empty.
- undefined: “Not set / not found.” Often means you tried to access something that doesn’t exist. Analogy: you looked for a key in a drawer that was never installed.
- NaN: “Not a Number” (but it’s a number type). Usually the result of a failed numeric conversion. Analogy: you asked a calculator to measure a color.
- Truthy / Falsy: Values that act like true/false in conditions. Analogy: a bouncer’s quick yes/no rule. (Example: 0 is falsy; "0" is truthy.)
If you learn just one thing here, learn that null and undefined are different “kinds of empty.”
Variables: let, const, and “where did my value go?”
Variables are names that point to values. Beginners often think the name “contains” the value, but it’s closer to a label that leads you to it.
- Variable: A named reference to a value. Analogy: a sticky note pointing at an item.
- let: A variable you can reassign. Analogy: a reusable label.
- const: A variable you can’t reassign (the label can’t be moved), but the value it points to might still be mutable if it’s an object. Analogy: a label glued to one box; the box’s contents can still change.
- Reassignment: Making the variable point to a different value (e.g., x = 2 after x = 1).
- Mutation: Changing an object/array itself (e.g., pushing into an array). The variable still points to the same container.
A common beginner trap: const doesn’t mean “unchangeable value,” it means “unchangeable binding.”
Functions: parameters, arguments, return, and “what comes out?”
Functions are reusable actions. The key idea is that a function takes input and produces output, even if the output is “do a side effect.”
- Function: A reusable block of code you can run. Analogy: a recipe card.
- Call / Invoke: Running the function (e.g., doThing()).
- Parameter: The input variable name in the function definition. Analogy: a blank line on a form.
- Argument: The actual value you pass in when calling. Analogy: what you wrote on the form.
- Return: The value the function gives back. Analogy: the dish that comes out of the kitchen.
- Side effect: Something the function changes outside itself (DOM update, network call, logging). Analogy: the recipe also cleans the kitchen or turns off the lights.
- Arrow function: A shorter syntax for functions; it also behaves differently with this. Analogy: shorthand notes that sometimes follow different grammar rules.
If you’re stuck, ask: “Is this function returning a value I should use, or only causing a side effect?”
Scope, closures, and “who can see this variable?”
Scope is basically visibility. Closures are what happens when a function “remembers” the variables it could see when it was created.
- Scope: Where a variable is accessible. Analogy: which rooms in a building can see a notice on the wall.
- Global scope: Variables available almost everywhere. Analogy: a billboard outside.
- Block scope: Variables inside { } (typically with let and const). Analogy: a note taped inside one room.
- Function scope: Variables inside a function. Analogy: a note inside a locked office.
- Closure: A function bundled with the variables from its surrounding scope that it still has access to later. Analogy: you leave the office, but you kept a key that still opens that office’s filing cabinet.
Closures feel spooky until you treat them as “a function carrying its backpack of remembered variables.”
Objects, prototypes, and “why does this method exist?”
JavaScript objects can inherit behavior from other objects. That inheritance chain is powered by prototypes.
- Property: A value stored on an object (e.g., user.name). Analogy: a labeled drawer in a cabinet.
- Method: A function stored as a property (e.g., arr.push). Analogy: a tool attached to the toolbox.
- Prototype: Another object that your object can look at when it doesn’t have a property itself. Analogy: if your desk doesn’t have a stapler, you check the shared supply closet.
- Prototype chain: The “check here, then check there” lookup path. Analogy: desk → closet → building storage.
- Class: Syntactic sugar over prototypes in JavaScript. Analogy: a convenient template that still uses the same underlying supply-closet system.
If you’ve ever wondered why arrays “already have” methods like map, it’s because of the prototype chain.
Async JavaScript: promises, await, and “why didn’t this run yet?”
Async code is JavaScript’s way of saying: “I started something that will finish later (like a network request), and I’ll deal with the result when it’s ready.”
- Synchronous: Runs line-by-line; each step finishes before the next starts. Analogy: one cashier serving one customer fully before the next.
- Asynchronous: Starts a task and continues; handles the result later. Analogy: take-a-number tickets for orders that finish later.
- Promise: An object representing a future result (success or failure). Analogy: a claim ticket you’ll redeem later.
- resolve / reject: Promise success/failure outcomes. Analogy: “your order is ready” vs “we’re out of stock.”
- then / catch / finally: Promise handlers. Analogy: instructions for what to do when the ticket is redeemable, or if something goes wrong.
- async / await: Syntax that makes promise-based code read more like synchronous code. Analogy: pausing your part of the workflow until the kitchen hands you the dish.
- Event loop: The scheduler that decides what runs now vs later. Analogy: a dispatcher choosing which queued task gets the next time slot.
Beginner checkpoint: If a function is marked async, it always returns a promise (even if it looks like it returns a plain value).
A tiny checklist for reading JavaScript docs without spiraling
When docs feel dense, you don’t need to understand everything at once. You just need to answer a few practical questions.
- What type goes in? (number, string, array, object, function?)
- What type comes out? (especially: does it return a promise?)
- Does it mutate something? (does it change the array/object you already have?)
- When does it run? (now, later, on an event?)
- What does failure look like? (throws error, returns null, rejects promise?)
These five questions cover most “wait, what?” moments.
Takeaway: learn the nouns, then the verbs
If you’re new, focus first on the nouns: values, types, variables, functions. Then add the verbs: scope rules, prototype lookup, and async flow.
You don’t need to memorize JavaScript. You just need enough vocabulary to ask the next good question.