# JavaScript Glossary: Essential JS Terms Explained

Source: https://devdocs10.com/articles/javascript/js-glossary  
By Murat Bo · Published 2026-08-10 · DevDocs10 (https://devdocs10.com)

This glossary explains the most important JavaScript terms you will see in documentation, tutorials, error messages, and code reviews. It is designed to help you read JS code more confidently and understand the language’s core vocabulary in practical, beginner-friendly language.

> **Quick answer:** A JavaScript glossary is a reference list of common JS words and concepts, such as `scope`, `closure`, `hoisting`, `callback`, and `promise`. Use it when you need fast, accurate definitions and want to avoid confusing similar terms.

> **Difficulty:** Beginner
>
> **You'll understand this better if you know:** basic JavaScript syntax, variables, functions, and how to read simple code examples.

## 1. What Is a JavaScript Glossary?

A JavaScript glossary is a reference collection of terms used to describe the language, its syntax, and its runtime behavior. Instead of teaching one feature in depth, it gives you clear definitions so you can quickly look up a concept and understand how it fits into JavaScript.

- `Term` means a word or phrase commonly used in JavaScript discussions.
- `Definition` explains what the term means in plain language.
- `Context` shows when the term matters in real code.
- `Related terms` help you avoid confusing similar ideas.

This kind of reference is especially useful because JavaScript has many words that sound similar but behave differently, such as `undefined` and `null`, or `function` and `method`.

## 2. Why JavaScript Glossary Terms Matter

JavaScript documentation often assumes you already know common vocabulary. If you do not, even a short explanation can feel difficult to follow. Learning these terms makes it easier to read error messages, understand API docs, and communicate with other developers.

Many bugs are really misunderstandings of terminology. For example, if you know what `scope` means, you are less likely to expect a variable to exist outside the place where it was declared. If you know what a `promise` is, you can better understand why async code does not run in the same order as synchronous code.

## 3. Basic Syntax

This article is not about one syntax rule. Instead, it explains the core ideas behind important terms you will see throughout JavaScript.

### Example of how glossary terms appear in code discussions

The following snippet shows a few common terms in context: a variable, a function, a callback, and a promise.

```javascript
const message = "Hello";

function greet(name) {
  return `Hello, ${name}`;
}

const result = Promise.resolve(42);

setTimeout(() => {
  console.log(greet(message));
}, 1000);
```

Output (tested with Node 24.21.0):

```text
Hello, Hello
```

These words do not all mean the same thing. The glossary helps you separate the language features from the code that uses them.

## 4. Step-by-Step Examples

### Common term: variable

A `variable` is a named container for a value. You use it when you want to store data and use it later.

```javascript
let count = 1;
```

This line declares a variable named `count` and stores the number `1` in it.

### Common term: function

A `function` is reusable code you can call by name. Functions often accept inputs and return outputs.

```javascript
function square(n) {
  return n * n;
}
```

This function takes one input and returns its square.

### Common term: callback

A `callback` is a function passed into another function so it can be called later.

```javascript
setTimeout(() => {
  console.log("Done");
}, 500);
```

Output (tested with Node 24.21.0):

```text
Done
```

Here, the arrow function is the callback. setTimeout stores it and runs it after the delay.

### Common term: promise

A `promise` represents a value that may be available now, later, or never. It is central to asynchronous JavaScript.

```javascript
const dataPromise = Promise.resolve("ready");
```

This promise is already resolved, but in real code promises often come from network requests or timers.

## 5. Practical Use Cases

- Reading documentation for browser APIs, Node.js APIs, and third-party libraries.
- Understanding error messages such as `TypeError` or `ReferenceError`.
- Explaining code reviews clearly, especially when discussing scope, mutation, or async behavior.
- Learning advanced topics like closures, prototypes, and event handling without getting lost in vocabulary.
- Comparing similar features such as `==` versus `===` or `undefined` versus `null`.

## 6. Common Mistakes

### Mistake 1: Confusing undefined and null

These values both mean “no useful value,” but they are not identical. `undefined` usually means a variable exists but has not been assigned, while `null` means you intentionally set a value to empty.

**Problem:** Treating them as the same can lead to weak checks and confusing logic, especially when testing for missing data.

```javascript
let userName;

if (userName == null) {
  console.log("No name");
}
```

Output (tested with Node 24.21.0):

```text
No name
```

**Fix:** Be explicit about what state you are checking for and use strict comparisons when possible.

```javascript
let userName = null;

if (userName === null) {
  console.log("No name was assigned intentionally");
}
```

Output (tested with Node 24.21.0):

```text
No name was assigned intentionally
```

The corrected version makes the intent clear and avoids loose equality surprises.

### Mistake 2: Using callback to mean any function

Not every function is a callback. A callback is specifically a function passed into another function to be called later.

**Problem:** Calling every function a callback can make documentation harder to understand and hide the real control flow.

```javascript
function add(a, b) {
  return a + b;
}

const sum = add(2, 3);
```

**Fix:** Reserve the word callback for functions passed as arguments to be invoked by another function.

```javascript
function runLater(callback) {
  setTimeout(callback, 100);
}

runLater(() => {
  console.log("Now this is a callback");
});
```

Output (tested with Node 24.21.0):

```text
Now this is a callback
```

The fixed example shows the function being passed for later execution, which is what makes it a callback.

### Mistake 3: Thinking hoisting means everything moves to the top

`Hoisting` is often described too casually. In practice, declarations are handled differently depending on whether you use `var`, `let`, `const`, or a function declaration.

**Problem:** Assuming all declarations behave the same can cause `ReferenceError` messages when code reads a variable before initialization.

```javascript
console.log(value);
let value = 10;
```

Output (tested with Node 24.21.0):

```text
Uncaught ReferenceError: Cannot access 'value' before initialization
```

**Fix:** Declare variables before using them, especially with block-scoped declarations.

```javascript
let value = 10;
console.log(value);
```

Output (tested with Node 24.21.0):

```text
10
```

This works because the variable is initialized before the read occurs.

## 7. Best Practices

### Use precise terms in code reviews

When discussing code, saying “this value is `undefined`” is more helpful than saying “it is empty.” Precision reduces misunderstanding and speeds up debugging.

```javascript
if (typeof input === "undefined") {
  console.log("Input was not provided");
}
```

Output (tested with Node 24.21.0):

```text
Input was not provided
```

Using exact terms helps other developers map the discussion to the actual language behavior.

### Separate syntax from runtime behavior

Some glossary terms describe source code structure, while others describe what happens when the code runs. Keeping them separate makes concepts easier to learn.

```javascript
const items = [1, 2, 3];
const first = items[0];
```

The array syntax is visible in the code, but the behavior of reading from the array happens at runtime.

### Use glossary terms consistently

If you call something a `method`, make sure it is actually a function attached to an object. If you call something a `property`, it should be a value, not a callable operation.

```javascript
const person = {
  name: "Ava",
  sayHi() {
    return "Hi";
  }
};
```

This distinction matters because it changes how you access the member and how you describe the object’s API.

## 8. Limitations and Edge Cases

- Some terms have slightly different meanings depending on context. For example, `module` can mean an ES module file, a Node.js module, or a package entry point.
- Different tutorials may use older language around `hoisting`, `scope`, or `prototype`. Always verify the behavior in modern JavaScript.
- Words like `native` and `built-in` are often used loosely, even though they may not mean exactly the same thing in every article.
- Browser APIs and JavaScript language features are related but not identical. For example, `document` is not part of the core language; it is a web API.
- Some terms, such as `truthy` and `falsy`, describe value behavior in conditionals rather than fixed value types.

## 9. Practical Mini Project

This small reference object demonstrates how a glossary page might store a term, a definition, and an example. It is a simple pattern you can reuse for note-taking or learning tools.

```javascript
const glossaryEntry = {
  term: "closure",
  definition: "A function that remembers variables from its outer scope.",
  example() {
    function makeCounter() {
      let count = 0;

      return function () {
        count += 1;
        return count;
      };
    }

    const counter = makeCounter();
    return counter();
  }
};

console.log(glossaryEntry.term);
console.log(glossaryEntry.definition);
console.log(glossaryEntry.example());
```

Output (tested with Node 24.21.0):

```text
closure
A function that remembers variables from its outer scope.
1
```

This example shows how a term and its meaning can be stored alongside a working code sample that demonstrates the idea.

## 10. Key Points

- A JavaScript glossary helps you understand the language’s vocabulary quickly and accurately.
- Many terms are easy to confuse, especially when they describe similar values or behaviors.
- Knowing glossary terms makes documentation, debugging, and code reviews easier.
- Some words describe syntax, while others describe runtime behavior or language semantics.
- Good terminology leads to better communication and fewer misunderstandings.

## 11. Practice Exercise

Use the glossary idea to test your understanding of common JS terms.

- Write a short definition for `variable`, `function`, `callback`, `promise`, and `closure`.
- For each term, write one code example that shows it in use.
- Explain the difference between `undefined` and `null` in your own words.
- Identify one place where `hoisting` can surprise beginners.

**Expected output:** A short glossary note with five terms, each followed by a simple example and a one-sentence explanation.

**Hint:** Keep the definitions short and practical. Focus on what the term means in real code, not on memorizing a textbook phrase.

**Solution:**

```javascript
const glossary = [
  {
    term: "variable",
    definition: "A named place to store a value.",
    example: "let age = 25;"
  },
  {
    term: "function",
    definition: "Reusable code you can call by name.",
    example: "function greet() { return 'Hi'; }"
  },
  {
    term: "callback",
    definition: "A function passed into another function to run later.",
    example: "setTimeout(() => console.log('Done'), 1000);"
  },
  {
    term: "promise",
    definition: "An object representing a future result.",
    example: "Promise.resolve('ready').then(console.log);"
  },
  {
    term: "closure",
    definition: "A function that remembers outer variables.",
    example: "function outer() { let x = 1; return () => x; }"
  }
];

glossary.forEach((entry) => {
  console.log(entry.term, "-", entry.definition);
  console.log(entry.example);
});
```

Output (tested with Node 24.21.0):

```text
variable - A named place to store a value.
let age = 25;
function - Reusable code you can call by name.
function greet() { return 'Hi'; }
callback - A function passed into another function to run later.
setTimeout(() => console.log('Done'), 1000);
promise - An object representing a future result.
Promise.resolve('ready').then(console.log);
closure - A function that remembers outer variables.
function outer() { let x = 1; return () => x; }
```

This solution gives you a reusable glossary structure and reinforces the terms with examples you can actually run.

## 12. Final Summary

A JavaScript glossary is one of the fastest ways to build confidence with the language. It helps you translate unfamiliar words into clear ideas, especially when reading documentation or debugging code.

The most useful glossary terms are the ones that describe how JavaScript really behaves: `scope`, `closure`, `hoisting`, `callback`, `promise`, `undefined`, and `null`. Once these feel familiar, many other topics become easier to learn.

If you want a good next step, read a deeper guide on JavaScript functions, scope, and asynchronous programming so you can connect these terms to real code patterns.