
<Image src="exit.jpg" alt="Glowing green EXIT sign hanging from a ceiling, representing how early return pattern lets functions exit before reaching the end" />

**The early return pattern** (also called guard clauses or the bouncer pattern) is a technique where you exit a function as soon as a precondition fails, instead of wrapping your main logic in nested `if` blocks. It reduces nesting, lowers cognitive load, and makes your functions dramatically easier to read.

## What Is the Early Return Pattern?

Today, while wrestling with some code, I caught myself smiling at something small but powerful. I was deep in a function that was starting to look like a staircase of if statements. Halfway through, I stopped and thought: _why am I dragging all these checks down the page when I could just step out early_?

That's when it clicked — again 🥳. Early return isn't just a coding pattern; it's a way of freeing your own brain. You handle the simplest, most obvious cases first and politely bow out of the function. Then the rest of the logic can flow without carrying the weight of those initial conditions.

```javascript
function processUser(user) {
  if (!user) return;          // nothing to process
  if (!user.isActive) return; // skip inactive users

  sendWelcomeEmail(user);
  updateAnalytics(user);
}
```

Each of those `if` lines is a **guard clause** — a check that says "if this condition isn't right, leave now." Some people call this the **fail-fast approach**: deal with the problems up front, then focus on the happy path. Others use the term **bouncer pattern** — like a bouncer checking IDs before letting you into a club.

## Before and After: Nested If vs Guard Clauses

Before I got into this habit, my functions often looked like a pile of _stacked boxes — each_ if wrapped inside another. It worked, but it forced every reader (including future me) to carry all those checks in their head all the way down.

```javascript
// ❌ Nested approach
function processUser(user) {
  if (user) {
    if (user.isActive) {
      if (user.hasProfile) {
        sendWelcomeEmail(user);
        updateAnalytics(user);
      }
    }
  }
}
```

This still runs fine, but it makes you think about conditions long after you should've moved on. Now compare:

```javascript
// ✅ Early return approach
function processUser(user) {
  if (!user) return;
  if (!user.isActive) return;
  if (!user.hasProfile) return;

  sendWelcomeEmail(user);
  updateAnalytics(user);
}
```

Once those guard clauses are in place, I don't have to `mentally juggle` those "what ifs" anymore. They're dealt with. The rest of the code reads like a straight road.

> You make the easy decisions first, exit where needed, and leave the interesting logic standing in the light. It's not just about fewer braces — it's about respecting your own attention span.

## The Arrow Anti-Pattern and the Pyramid of Doom

When nested if statements stack up, the code starts forming a visual arrow pointing to the right — this is called the **arrow anti-pattern** (or the **pyramid of doom**). Here's an extreme but not unrealistic example:

```javascript
// ❌ Arrow anti-pattern
function handlePayment(order) {
  if (order) {
    if (order.items.length > 0) {
      if (order.paymentMethod) {
        if (order.paymentMethod.isValid) {
          if (order.shippingAddress) {
            processPayment(order);
            sendConfirmation(order);
          }
        }
      }
    }
  }
}
```

Every condition pushes the real logic further to the right. By the time you reach `processPayment`, you're five levels deep. Early return flattens this completely:

```javascript
// ✅ Flat with guard clauses
function handlePayment(order) {
  if (!order) return;
  if (order.items.length === 0) return;
  if (!order.paymentMethod) return;
  if (!order.paymentMethod.isValid) return;
  if (!order.shippingAddress) return;

  processPayment(order);
  sendConfirmation(order);
}
```

Same logic, zero nesting. The intent is immediately clear: handle the edge cases, then do the work.

## Guard Clauses in Real-World JavaScript

Trivial examples are easy to agree with. Where early return really shines is in production code.

### Express.js API Handler

```javascript
app.post('/api/orders', async (req, res) => {
  if (!req.body.items?.length) {
    return res.status(400).json({ error: 'Cart is empty' });
  }

  if (!req.user) {
    return res.status(401).json({ error: 'Not authenticated' });
  }

  if (!req.user.hasPermission('create_order')) {
    return res.status(403).json({ error: 'Forbidden' });
  }

  const order = await createOrder(req.body, req.user);
  return res.status(201).json(order);
});
```

Notice the `return` before each `res.status(...)`. This is critical in Express — without it, the function keeps executing and you'll get "headers already sent" errors. More on this in the [common mistakes](#common-mistakes-with-early-return) section below.

### Form Validation

```javascript
function validateForm(data) {
  if (!data.email) return { valid: false, error: 'Email is required' };
  if (!data.email.includes('@')) return { valid: false, error: 'Invalid email' };
  if (!data.password) return { valid: false, error: 'Password is required' };
  if (data.password.length < 8) return { valid: false, error: 'Password too short' };

  return { valid: true, error: null };
}
```

Each guard returns a clear error. No nested if-else chains, no accumulated error variables.

### React Component

```jsx
function UserProfile({ user, isLoading, error }) {
  if (isLoading) return <Spinner />;
  if (error) return <ErrorMessage message={error} />;
  if (!user) return <EmptyState />;

  return (
    <div>
      <h1>{user.name}</h1>
      <p>{user.bio}</p>
    </div>
  );
}
```

React developers use this pattern constantly. Each guard clause handles a specific UI state, keeping the main render clean.

## Early Return in TypeScript

Guard clauses in TypeScript do more than improve readability — they **narrow types**. TypeScript understands that after a guard, the remaining code can assume a more specific type.

```typescript
function formatUserName(user: User | null | undefined): string {
  if (!user) return 'Anonymous';
  if (!user.firstName) return user.email;

  // TypeScript knows user is non-null and firstName exists here
  return `${user.firstName} ${user.lastName ?? ''}`.trim();
}
```

This is especially useful with [discriminated unions](/blog/discriminated-unions):

```typescript
type Result =
  | { status: 'success'; data: Order }
  | { status: 'error'; message: string }
  | { status: 'loading' };

function renderResult(result: Result) {
  if (result.status === 'loading') return <Spinner />;
  if (result.status === 'error') return <Error message={result.message} />;

  // TypeScript narrows to { status: 'success'; data: Order }
  return <OrderDetails order={result.data} />;
}
```

No type assertions needed. The guard clauses do the narrowing for you. For reusable checks, you can extract them into [type predicates](/snippets/type-predicates) — custom type guards that make the narrowing explicit.

## Early Return with Async/Await

Early return works just as well in async functions. This is an area where surprisingly few articles give concrete examples, but it's where I find guard clauses most valuable — async code is already hard enough to read without adding nesting.

```javascript
async function fetchUserOrders(userId) {
  if (!userId) return [];

  const user = await getUser(userId);
  if (!user) return [];
  if (!user.isActive) return [];

  const orders = await getOrders(user.id);
  if (!orders.length) return [];

  return orders.map(formatOrder);
}
```

Each guard prevents unnecessary `await` calls. If the user doesn't exist, we skip the orders fetch entirely. This matters for performance — not just readability.

You can combine early returns with `try/catch` as well:

```javascript
async function processWebhook(payload) {
  if (!payload?.event) return { status: 'ignored' };
  if (!isValidSignature(payload)) return { status: 'unauthorized' };

  try {
    const result = await handleEvent(payload.event, payload.data);
    return { status: 'processed', result };
  } catch (error) {
    return { status: 'failed', error: error.message };
  }
}
```

The guard clauses stay clean and outside the `try/catch` — no need to catch errors for validations that won't throw.

## Early Return vs Nested If Statements

Some developers argue that early return "splits" the function into multiple exit points, making it harder to trace. Let me address that honestly.

Nested if statements have **one** exit point — the end of the function. Early return can have **many**. So which is better?

In practice, **multiple early exits are easier to reason about** because each one is self-contained. When you see `if (!user) return;`, you know exactly what happens for that case. With nested ifs, you have to trace through the entire tree to understand every path.

That said, if your function has only one or two conditions, nesting is perfectly fine:

```javascript
// This is perfectly readable as-is
function greet(name) {
  if (name) {
    return `Hello, ${name}!`;
  }
  return 'Hello, stranger!';
}
```

Early return shines most when you have **three or more preconditions** to check.

## When NOT to Use Early Return

Early return isn't always the answer. Here are cases where I'd think twice.

**Single-expression functions.** If your function is a one-liner, a ternary or null coalesce is simpler:

```javascript
// A guard clause would be overkill here
const getDisplayName = (user) => user?.name ?? 'Anonymous';
```

**Functions with required cleanup.** If you need to release a resource — close a file handle, release a lock, clear a timer — multiple return points make it easy to forget the cleanup. Use `try/finally` to guarantee it runs:

```javascript
function readConfig(path) {
  const handle = openFile(path);
  if (!handle) return null;

  try {
    return parseFile(handle);
  } finally {
    closeFile(handle); // Always runs, even after early return
  }
}
```

**Complex state machines.** When a function has many interacting states rather than simple preconditions, a `switch` statement or a [dispatch table](/blog/dispatch-tables) is often clearer than a chain of early returns.

## Common Mistakes with Early Return

### Forgetting `return` in Express.js

This is the #1 gotcha I see in code reviews:

```javascript
// ❌ Bug: missing return
app.get('/user', async (req, res) => {
  if (!req.user) {
    res.status(401).json({ error: 'Unauthorized' });
    // Execution continues! 💥
  }

  const profile = await getProfile(req.user.id); // Crashes
  res.json(profile);
});
```

`res.json()` does **not** stop function execution. You must add `return`:

```javascript
// ✅ Fixed
if (!req.user) {
  return res.status(401).json({ error: 'Unauthorized' });
}
```

### Over-Guarding

Don't guard against things that can't happen:

```javascript
// ❌ Unnecessary — array.map always returns an array
function formatItems(items) {
  if (!items) return [];
  return items.map(format);
}
```

Only validate at system boundaries (user input, external APIs). Trust your internal code.

## Enforcing Guard Clauses with ESLint

You can configure ESLint to encourage early returns automatically:

```json
{
  "rules": {
    "no-else-return": "warn",
    "max-depth": ["warn", 3]
  }
}
```

`no-else-return` flags unnecessary `else` blocks after a `return`. `max-depth` warns when nesting exceeds 3 levels — a good nudge toward flattening your code with guard clauses.

It's funny how these little patterns sneak up on you. Today's code reminded me that writing for humans — including future me — is just as important as writing for the machine.

## Related

- [Expressions vs Statements](/blog/expressions-statements) - understand the building blocks behind guard clauses and control flow
- [Check if a URL is absolute](/snippets/is-absolute-url) - a concise example of early return for URL validation


Learn the early return pattern (guard clauses) in JavaScript and TypeScript. Reduce nesting, improve readability, and write cleaner functions with real-world examples.

Early Return Pattern in JavaScript — Guard Clauses Guide


### Understanding the Hidden Pitfalls of Custom Hooks in React

In a previous post we covered [How React Re-Renders Work](/blog/react-rerender). But today, we'll take a closer look at
the hidden pitfalls of custom hooks in React.

<Image alt="Hand-drawn cover image with 'Custom React Hooks' title, useEffect() in blue, fishing hook illustrations, and the React logo" src="hooks.jpg" priority={true} />

When we handle state, component re-renders, and application performance in React, custom hooks are a powerful tool that
help us keep our components clean and manageable. However, this simplicity can sometimes hide performance issues that we
may not immediately notice.

Consider a basic custom hook for managing a dropdown menu:

```jsx
const useDropdown = () => {
  const [isOpen, setIsOpen] = useState(false);

  return {
    isOpen,
    open: () => setIsOpen(true),
    close: () => setIsOpen(false),
    toggle: () => setIsOpen(prev => !prev),
  };
};
```

Using this hook in a component might look neat and clean:

```jsx
const App = () => {
  const { isOpen, toggle, close } = useDropdown();

  return (
    <div className="app-container">
      <button onClick={toggle}>Menu</button>
      {isOpen && <DropdownMenu onSelect={close} />}
      <ExpensiveChart />
      <DataGrid rows={1000} />
    </div>
  );
};
```

At first glance, this setup appears elegant—state logic neatly wrapped in the `useDropdown` hook. However, this
approach hides a subtle performance issue: whenever the dropdown visibility state changes, React re-renders the entire
`App` component, despite the state being limited to a small interaction.

> Why? You can read more about react rerenders [here](/blog/react-rerender).

### Hidden States and Re-rendering Pitfalls

Let's extend our custom hook to listen for window resize events:

```jsx
const useDropdown = () => {
  const [windowWidth, setWindowWidth] = useState(window.innerWidth);

  useEffect(() => {
    const handleResize = () => setWindowWidth(window.innerWidth);
    window.addEventListener('resize', handleResize);

    return () => window.removeEventListener('resize', handleResize);
  }, []);

  return {
    // For example, this part of the code was simplified
    isOpen: false,
    open: () => {},
    close: () => {},
    toggle: () => {},
  };
};
```

Now, every time the user resizes the window, this hook updates the state internally. Even though the window width isn't
returned or directly used, it **triggers state changes**, causing the entire `App` to re-render unnecessarily.

### Nested Hooks Can Multiply Issues

The problem worsens when custom hooks depend on other hooks indirectly. For example, consider another hook for tracking
keyboard input:

```jsx
const useKeyboardListener = () => {
  const [lastKey, setLastKey] = useState(null);

  useEffect(() => {
    const handleKeyDown = (e) => setLastKey(e.key);
    window.addEventListener('keydown', handleKeyDown);

    return () => window.removeEventListener('keydown', handleKeyDown);
  }, []);

  return lastKey;
};

const useDropdown = () => {
  useKeyboardListener();

  return {
    // For example, this part of the code was simplified
    isOpen: false,
    open: () => {},
    close: () => {},
    toggle: () => {},
  };
};
```

Even if `useDropdown` does not directly use the last key pressed, the `App` component still re-renders each time
a key is pressed, since the state is updated inside the nested hook.

> Hiding stateful logic within hooks doesn't remove their performance impact. The
> solution isn’t hiding complexity but smartly managing and isolating the state.

### How to Solve This

To avoid such issues, encapsulate state logic in smaller components:

```jsx
const Dropdown = () => {
  const { isOpen, toggle, close } = useDropdown();

  return (
    <>
      <button onClick={toggle}>Menu</button>
      {isOpen && <DropdownMenu onSelect={close} />}
    </>
  );
};
```

This ensures that the minimal required area re-renders, preventing unnecessary updates across the entire app.

> In this solution, the `Dropdown` logic moved down from `App` to its own component. I described this approach in
> [this article](/blog/react-rerender#moving-state-down).

### Key Takeaway

The key lesson: carefully handle state encapsulation within custom hooks. Keep state management local and focused to
optimize your React application's performance and responsiveness.

> P.S. Memoization and other performance optimizations will be covered in future posts. Meanwhile, you can read about [Elements, Children as Props, and Re-Renders](/blog/react-elements-children).

## Related

- [useClickOutside Hook](/snippets/use-click-outside) - a practical custom hook example that applies the patterns discussed above
- [useMediaQuery Hook](/snippets/use-media-query) - another commonly used custom hook with proper cleanup


Learn about performance risks in React custom hooks, how they cause unexpected re-renders, and strategies to manage state efficiently.

Understanding the Hidden Pitfalls of Custom Hooks in React


<Image alt="Cartoon React atom character pointing at three components and saying 'You need to re-render'" src="react-rerender.png" priority={true} />

Hi, react [Andy](https://en.wiktionary.org/wiki/react_Andy)!

I’ve used React for over six years. I’ve noticed that even skilled programmers often struggle to grasp how React
operates behind the scenes. This can lead to inefficiencies. It affects code quality, speed, and user experience.

The documentation is great for starting with React. Many [books](https://www.roadtoreact.com/), courses, and blogs focus
on beginners. But what comes next? How can you dive deeper and really understand how it works? If you’ve been writing
React for a while, basic or
even intermediate courses may not be enough. Sadly, resources for advanced learning are limited.

That’s why I’m launching a [series of articles](/blog/category/advanced-react) to fill this knowledge gap.

## Intro to re-renders

Understanding re-renders in React is crucial for performance. You need to understand what triggers them. Know how they
move through the app. Learn what happens during a re-render and why it matters.

<Image alt="Meme: 'Oh, so you like React? Tell me what triggers a re-render' with a skeptical cartoon character" src="react-meme.png" />

## The problem

Imagine you're an intern at a FAANG company. Your first task is to create a new React component. You're asked to add a
simple `button` that opens a `settings panel` at the top of the dashboard.

```jsx
const Dashboard = () => {
  // Some code here
  return <div className="container">
    {/* The trigger should go somewhere here */}
    <ExpensiveDataGrid />
    <AnalyticsWidget />
    <ActivityFeed />
  </div>;
};
```

Then you implement it. The task seems straightforward. We've all done it countless times:

```jsx
const Dashboard = () => {
  // Add state
  const [isExpanded, setIsExpanded] = useState(false);

  // Everything that is returned here will be re-rendered when the state is updated
  return <div>
    {/* Add the trigger */}
    <IconButton onClick={() => setIsExpanded(true)}>
      Show settings
    </IconButton>

    {/* Add the panel */}
    {isExpanded && <SettingsPanel onDismiss={() => setIsExpanded(false)} />}

    <ExpensiveDataGrid />
    <AnalyticsWidget />
    <ActivityFeed />
  </div>;
};
```

You add [state](https://react.dev/learn/state-a-components-memory) to track if the panel is expanded or collapsed. You include
a button to change the state and render the panel
based on this state.

When you run the app, there's a noticeable delay ⏰, **almost a second** — before the panel appears.

Experienced React developers might quickly suggest.

> "You’re re-rendering the whole app. Just wrap everything in [React.memo](https://react.dev/reference/react/memo) and
> use [useCallback](https://react.dev/reference/react/useCallback) to avoid unnecessary renders."

This advice has its place, but it’s wise to pause before jumping in. In this case, memoization isn’t needed and could
hurt performance.

First, let’s take a closer look at what exactly is happening and why this delay occurs.

<Image alt="Flowchart showing a state update at the root triggering re-renders in all child components down the tree" src="rerender.png" />

When we click the button, we trigger the `setIsExpanded` setter function, which updates the `isExpanded` state from `false` to
`true`. As a result, the `Dashboard` component that holds this state re-renders itself.

After the state updates and the `App` component re-renders, React must pass the new data to other dependent components.
It automatically re-renders all components that the first component shows. It keeps going down the tree until it reaches
the end.

If you visualize a typical React app as a tree structure, you will find that everything beneath the point where the
state update was initiated will be re-rendered.

> Re-rendering is crucial to understand in React.

The key point to remember is that React never re-renders components "up" the render tree. If a state update occurs in
the middle of the component tree, only the components "down" the tree will be re-rendered.

<Image alt="Component tree diagram where only the subtree below the state update node re-renders, leaving sibling branches unchanged" src="rerender-state.png" />

When a component is wrapped in `React.memo`, `React` will interrupt its default re-rendering process and first evaluate
whether the `props` have changed. If there are no changes to the `props`, re-renders will be halted. However, if even a
single `prop` is modified, the re-rendering will proceed as usual.

It's important to note that effectively preventing re-renders through memoization is a nuanced topic with various
considerations. For a deeper understanding, it is advisable to explore these concepts further in new articles. (Coming soon... or read about [Elements, Children as Props, and Re-Renders](/blog/react-elements-children))

<Image alt="Component tree diagram showing React.memo blocking re-renders on one branch while the other branch re-renders normally" src="react-memo.png" />


Wrapping components with `React.memo` can indeed help prevent unnecessary re-renders in certain scenarios. However, it's
important to note that using `React.memo` comes with its own set of complexities and caveats, which will be discussed in
future articles. A more effective approach is to isolate the components that rely on specific state and encapsulate both
the state and those components into a smaller, dedicated component. This can lead to improved performance and a clearer
component structure.

## Moving state down

Let's move our logic into a separate component.

```jsx
const SettingsToggle = () => {
  const [isExpanded, setIsExpanded] = useState(false);

  return <>
    <IconButton onClick={() => setIsExpanded(true)}>
      Show settings
    </IconButton>

    {isExpanded && <SettingsPanel onDismiss={() => setIsExpanded(false)} />}
  </>;
};
```

And then render this new component in the `Dashboard`:

```jsx
const Dashboard = () => {
  return <div>
    {/* Our new component */}
    <SettingsToggle />

    <ExpensiveDataGrid />
    <AnalyticsWidget />
    <ActivityFeed />
  </div>;
};
```

<Image alt="Before-and-after component tree: moving state into a child component isolates re-renders from the slow sibling component" src="rerender-performance-fix.png" />

Consequently, the settings panel appears immediately. We resolved a significant performance issue using a straightforward
composition technique!


Dive into the mechanics of React re-renders — learn what causes them, how they impact performance, and how to manage them effectively.

React Re-Renders: What Triggers Them and Why


Let's talk about version numbers in your `package.json`. You've probably seen versions like `1.2.3` or `^4.5.0`—but what
do they *actually* mean?

<Image src="semver.jpg" alt="Pulp Fiction meme: 'Semantic Versioning — do you speak it?' with Samuel L. Jackson pointing a gun" />

---

## **SemVer: The Three-Number System That Keeps Everyone Sane**

Semantic Versioning (SemVer) is just a fancy way of saying:  
**"Hey, let's use version numbers to tell people what *kind* of changes we made."**

Versions look like `x.y.z`:

- **Major (x)**: Big changes that might break your code. *Example:* Removing a feature your app relies on.
- **Minor (y)**: New stuff that won't wreck existing code. *Example:* Adding a cool new function.
- **Patch (z)**: Quiet fixes for bugs or security holes. *Example:* Fixing a crash when you type `null`.

Think of it like home renovations:

- **Major** = Tearing down a wall (big impact).
- **Minor** = Adding a new room (no harm done).
- **Patch** = Fixing a leaky faucet (everyone's happy).

---

## **Why Should You Care?**

Because npm uses these numbers to decide which updates are safe to install automatically. If everyone follows SemVer,
your app won't suddenly break when you run `npm update`.

---

## **The Secret Symbols in Your package.json**

Those weird characters like `^` and `~` in your dependencies? They're just rules for npm. Here's what they *really*
mean:

- **`^1.2.3`** = "New features and fixes are okay, but don't change anything big!"  
  *(Updates to 1.3.0 or 1.2.4 are fine. Won't jump to 2.0.0.)*

- **`~1.2.3`** = "Only tiny fixes, please."  
  *(Updates to 1.2.4 are okay. Won't go to 1.3.0.)*

- **`>` or `>=`** = "Give me anything newer than this."
- **`<` or `<=`** = "Nothing newer than this, thanks."
- **`1.2.3` - `1.5.0`** = "I'll take any version between these two."
- **`||`** = "Either version A *or* version B works."

**No symbol?** Example: `"lodash": "4.17.21"` means *"Only this exact version. Don't change a thing!"*

### **Watch Out for 0.x.x Versions**

The caret `^` behaves differently for versions below `1.0.0`:

- **`^0.2.3`** → allows only `0.2.x` (treats minor as major)
- **`^0.0.3`** → allows only `0.0.3` (most restrictive)

This is because pre-1.0 packages are considered unstable, so npm plays it safe.

---

## **But Wait... What About the Lock File?**

Great question! If you've ever wondered *"Why do I need `^` or `~` when `package-lock.json` already pins exact
versions?"*—you're not alone.

Here's the deal: **they serve different purposes**.

|                     | Lock File                      | Symbols (`^`, `~`)          |
|---------------------|--------------------------------|-----------------------------|
| **When it matters** | `npm install`                  | `npm update`                |
| **What it does**    | Freezes "what's installed now" | Defines "update boundaries" |
| **Purpose**         | Reproducibility                | Flexibility                 |

### **When Symbols Actually Matter**

**1. First install (no lock file yet)**

When you run `npm add react` on a fresh project, npm checks the registry for the latest version and writes:

- `package.json`: `"react": "^19.2.1"` (with caret by default)
- `package-lock.json`: `react: 19.2.1` (exact version)

**2. Running `npm update`**

This is where symbols shine:

| In package.json      | What happens on `npm update` |
|----------------------|------------------------------|
| `"react": "19.2.1"`  | ❌ Nothing changes            |
| `"react": "~19.2.1"` | Updates to latest `19.2.x`   |
| `"react": "^19.2.1"` | Updates to latest `19.x.x`   |

**3. Publishing a library**

If you're building an npm package, your lock file is **ignored** by consumers. They only see your `package.json` ranges.
This is why choosing the right symbols matters for library authors.

### **Think of It This Way**

- **Symbols** = the rules for *future* updates
- **Lock file** = a snapshot of *current* state

They work together: symbols say "what's allowed," the lock file says "what's installed." 🤝

---

## **Real-World Tips for Humans**

1. **Start with `^`** for most dependencies. It's the safest way to get bug fixes and new features without surprises.
2. **Use exact versions** for critical packages (like React or Vue) where unexpected changes could ruin your day.
3. **Check `npm outdated` weekly** to see which packages have updates. It's like a to-do list for your app's health.
4. **Commit `package-lock.json`** to avoid "but it works on *my* machine" moments. This file locks down every tiny
   detail.

<Image src="ops.jpg" alt="DevOps comic by Daniel Stori: Before DevOps 'It works on my machine!' vs After DevOps 'It works on my container!'" />

## **When Things Go Sideways**

- **Broke after an update?** Check if a major version sneaked in. Temporarily pin the version <br/>`"package": "1.2.3"`
  until you fix things.
- **Confused by symbols?** Use [semver.org](https://semver.org/) to understand semantic versioning rules.

---

## **Quick Cheat Sheet**

| Symbol   | What It Means                             |  
|----------|-------------------------------------------|  
| `^1.2.3` | "Keep me up to date, but no big changes!" |  
| `~1.2.3` | "Only bug fixes, please."                 |  
| `1.2.x`  | "Any patch version for 1.2."              |  
| `1.2.3`  | "Only this exact version."                |

---

## **Wrapping Up**

SemVer isn't about memorizing rules—it's about communicating changes clearly. Use `^` for flexibility, `~` for caution,
and exact versions when stability matters. <br/>And always, *always* check your `package-lock.json` into Git.

**Try this now:**

```bash  
npm outdated  
```  

See what updates are waiting? Update one with `npm update package-name` and see if your app still works. You've got
this! 🛠️

---  

*P.S. Sharing is caring. Forward this to a teammate who still edits `package.json` versions by hand. 😉*

## Related Articles

- [Migrate to pnpm](/blog/pnpm) - faster package management with better disk efficiency
- [Conventional Commits](/blog/conventional-commits) - structured commit messages for automated versioning


A friendly, practical guide to SemVer in npm. Learn versioning rules, avoid dependency chaos, and manage updates with confidence.

Mastering npm and Semantic Versioning for Smarter Development


Writing clean, maintainable JavaScript isn't just about making your code work - it's about making it understandable. In
this comprehensive guide, we'll explore the essential naming conventions that can transform your JavaScript code from
merely functional to professionally polished.

## Why Naming Matters in JavaScript

Every time you write code, you're not just writing it for the computer - you're writing it for other developers (
**including your future self** ). Good naming conventions serve as a form of documentation, making your code
self-explanatory
and reducing the cognitive load required to understand it.

## Core Principles of JavaScript Naming

### 1. Consistency Is Key

The most fundamental rule of naming in JavaScript is maintaining consistency throughout your project. Whether you choose
camelCase or snake_case, stick to it. Here's why:

- Reduces cognitive overhead for developers
- Makes code more predictable
- Simplifies maintenance and refactoring
- Improves team collaboration

### 2. Language Matters

While JavaScript is flexible enough to allow variable names in any language, stick to English. This ensures:

- Universal code readability
- Easier collaboration with international teams
- Better integration with existing codebases

### 3. The Case for Different Cases

JavaScript uses multiple naming conventions depending on the context:

- `camelCase` for variables, functions, and methods (e.g., when you need to [capitalize the first letter of a string](/snippets/how-to-capitalize-first-letter-of-string-in-javascript), the function name follows camelCase)
- `PascalCase` for classes and constructor functions
- `UPPER_SNAKE_CASE` for constants
- `kebab-case` typically for CSS classes and HTML attributes

JavaScript’s built-in APIs use camelCase (e.g., getElementById), PascalCase for classes (e.g., Date), and
UPPER_SNAKE_CASE for constants (e.g., Math.PI). Align your code with these patterns.

## Practical Naming Guidelines

### Variables and Functions

#### Boolean Variables

Boolean variables should start with an affirmative prefix, typically 'is' or 'has':

```javascript
// Bad ❌
const active = true;
const notAllowed = !user.checkAccess();

// Good ✅
const isActive = true;
const hasPermission = user.checkAccess();
```

> Another thing to remember at the conference is that the affirmative prefix shouldn't include a negation. This is
> because the negation operator (!) is most commonly used with Boolean values. So, a value named something like '
> isNotAllowed' with the negation applied to it, '!isNotAllowed', can be quite misleading.

Naming recommendations for Boolean from [W3C](https://w3ctag.github.io/design-principles/#naming-booleans).

#### Functions and Methods

Function names should be verbs that clearly describe their action:

```javascript
// Bad ❌
function userData() {}

function total() {}

// Good ✅
function getUserData() {}

function calculateTotal() {}
```

### Collections and Arrays

Use plural nouns for arrays and collections:

```javascript
// Bad ❌
const userRoleList = ['admin', 'editor', 'viewer'];
const activeUserArr = new Set();

// Good ✅
const userRoles = ['admin', 'editor', 'viewer'];
const activeUsers = new Set();
```

### Classes and Objects

#### Class Names

Classes should use PascalCase and be noun phrases:

```javascript
// Bad ❌
class userService {
  constructor() {}
}

// Good ✅
class UserService {
  constructor() {}
}
```

#### Class Members

Avoid repeating the class name in member names:

```javascript
// Bad ❌
class UserProfile {
  updateUserProfile() {}

  deleteUserProfile() {}
}

// Good ✅
class UserProfile {
  update() {}

  delete() {}
}
```

### Constants and Enums

#### Constants

Use UPPER_SNAKE_CASE for true constants:

```javascript
// Bad ❌
const maxRetryAttempts = 3;
const apiBaseUrl = 'https://api.example.com';

// Good ✅
const MAX_RETRY_ATTEMPTS = 3;
const API_BASE_URL = 'https://api.example.com';
```

#### Enums

Use PascalCase for enum names and UPPER_SNAKE_CASE for enum values:

```javascript
// Bad ❌
const userRoles = {
  admin: 'admin',
  editor: 'editor',
  viewer: 'viewer'
};

// Good ✅
const UserRole = {
  ADMIN: 'admin',
  EDITOR: 'editor',
  VIEWER: 'viewer'
};
```

#### Maps

Also known as a dictionary data structure. This data structure is used for mapping one value to another.

```javascript
// Bad ❌
const userRole = {
  [AccountType.SUPERVISOR]: 'Supervisor',
  [AccountType.VISITOR]: 'Visitor',
}

const REDIRECTING = {
  '/teams': '/supervisor-panel',
  '/account': '/authenticate',
}

const UserPermissions = {
  [AccountType.SUPERVISOR]: [AccessLevel.USER_ADMINISTRATION, AccessLevel.TEAM_ADMINISTRATION],
  [AccountType.VISITOR]: [AccessLevel.PROFILE_MANAGEMENT],
}

// Good ✅
const userRoleToReadable = {
  [AccountType.SUPERVISOR]: 'Supervisor',
  [AccountType.VISITOR]: 'Visitor',
}

const pagePathToRedirectPath = {
  '/teams': '/supervisor-panel',
  '/account': '/authenticate',
}

const userRoleToPermissions = {
  [AccountType.SUPERVISOR]: [AccessLevel.USER_ADMINISTRATION, AccessLevel.TEAM_ADMINISTRATION],
  [AccountType.VISITOR]: [AccessLevel.PROFILE_MANAGEMENT],
}
```

## Common Pitfalls to Avoid

### 1. Including Types in Names

```javascript
// Bad ❌
const userArray = ['John', 'Jane'];
const nameString = 'John';

// Good ✅
const users = ['John', 'Jane'];
const name = 'John';
```

### 2. Ambiguous Abbreviations

```javascript
// Bad ❌
const usr = getUser();
const pwd = 'secret';

// Good ✅
const user = getUser();
const password = 'secret';
```

### 3. Inconsistent Naming Patterns

```javascript
// Bad ❌
const get_user = () => {};
const fetchData = () => {};
const retrieve_info = () => {};

// Good ✅
const getUser = () => {};
const fetchData = () => {};
const retrieveInfo = () => {};
```

### 4. Different Languages

```javascript
// Bad ❌
const ユーザー名 = "John";

// Good ✅
const userName = "John";
```

## Types & Interfaces

Names of types and interfaces should be written in `PascalCase` notation.

```typescript
// Bad  ❌
type TUser = {
  firstName: string
  lastName: string
}

interface userServiceInterface {
  findByEmail: (email: string) => User
}

// Good ✅
type User = {
  firstName: string
  lastName: string
}

interface UserServiceContract {
  findByEmail: (email: string) => User
}

interface IUserService {
  findByEmail: (email: string) => User
}
```

> When engineering teams choose to leverage both class-based types and abstract definitions within the same project, best practices suggest adding a distinguishing marker to the abstract definitions. Common prefix choices include `T` and `Contract`.

## Tools for Maintaining Naming Conventions

To help maintain consistent naming conventions, consider using:

1. [ESLint](https://eslint.org/) with naming convention rules
2. [Prettier](https://prettier.io/) for consistent formatting
3. IDE extensions for code style enforcement
4. Team code review guidelines focused on naming

## Time-Tested Naming Conventions

- [Google TypeScript Style Guide](https://google.github.io/styleguide/tsguide.html#naming)
- [Airbnb JavaScript Style Guide](https://github.com/airbnb/javascript?tab=readme-ov-file#naming-conventions)

## Conclusion

Good naming conventions are more than just style preferences - they're a fundamental aspect of writing maintainable,
professional JavaScript code. By following these conventions consistently and thoughtfully, you'll create code that's
easier to understand, maintain, and debug.

Remember, the goal isn't to follow these rules blindly, but to use them as guidelines to write more readable and
maintainable code. The best naming convention is one that your entire team understands and follows consistently.

## Related

- [CSS Class Naming Conventions](/blog/class-naming-conventions) - BEM methodology for HTML/CSS
- [Common CSS Class Names](/snippets/common-css-classes) - practical BEM class name examples


Master JavaScript naming conventions with this guide. Learn best practices for naming variables, functions, and classes to write cleaner code.

JavaScript Naming Conventions: A Complete Guide for Clean Code


<Image src="conventional-commits.jpg" alt="Git commit history with colorful branch graph showing conventional commit messages in a dark IDE" />

I first came across Conventional Commits during my time at [MacPaw](/about), but initially, I didn't give much thought
to these unique commit messages.
It wasn't until recently that I took a closer look and realized how much more efficient and organized they make the
development process.

Here’s why you might want to give them a try too! 😃

## What Are Conventional Commits?

Conventional Commits is a specification that provides a simple, structured convention for commit messages.
It allows you to write messages that are easy to read and maintain, and which convey the specific intent behind each
change.

The conventional commit message format is straightforward. It starts with a **type**, optionally followed by a **scope
**, and a
short **description**. For example:

```bash
feat(login): add authentication with JWT
```

In this example:

- `feat` is the type of the commit, indicating a new feature.
- `login` is the scope, specifying the part of the project that is affected.
- `add authentication with JWT` is the short description of the change.

## Why Use Conventional Commits?

Using Conventional Commits offers several key benefits:

- `Consistency`: Standardized commit messages ensure that everyone on the team follows the same format, which enhances
  readability and reduces ambiguity.
- `Automation`: Tools can automatically generate change logs, version numbers, and releases based on the structured
  commit messages.
- `Collaboration`: Clear and descriptive commit messages help team members understand the history and context of
  changes, improving collaboration.
- `Compliance`: Adhering to a standardized format helps in meeting the guidelines and best practices of many open-source
  projects.

## Types of Conventional Commits

There are several predefined types of Conventional Commits that help categorize the nature of each change. Each type
indicates a specific kind of modification, making it easier to understand the impact of the commit. Here are the most
commonly used types:

- **feat**: A new feature for the user.
- **fix**: A bug fix for the user.
- **chore**: Changes that don't modify src or test files, such as updating build tasks.
- **docs**: Documentation-only changes.
- **style**: Changes that do not affect the meaning of the code (e.g., formatting, missing semicolons, etc.).
- **refactor**: A code change that neither fixes a bug nor adds a feature.
- **perf**: A code change that improves performance.
- **test**: Adding or updating tests.
- **build**: Changes that affect the build system or external dependencies (e.g., gulp, npm).
- **ci**: Changes to CI configuration files and scripts (e.g., CircleCI, Travis).
- **revert**: Reverts a previous commit.

## Cheat Sheet for Conventional Commits

<Image src="conventional-commits-cheatsheet.png" alt="Conventional Commits cheatsheet table listing commit types: feat, fix, chore, docs, style, refactor, perf, test, build, ci, and revert with descriptions and examples" />

| Type     | Description                | Example                          |
|:---------|:---------------------------|:---------------------------------|
| feat     | New feature                | feat(ui): add dark mode          |
| fix      | Bug fix                    | fix(api): resolve login issue    |
| docs     | Documentation only changes | docs(readme): update setup guide |
| style    | Code style changes only    | style(css): format CSS classes   |
| refactor | Code refactoring           | refactor(auth): optimize logic   |
| perf     | Performance improvement    | perf(database): optimize queries |
| test     | Adding tests               | test(routes): add unit tests     |
| chore    | Build tool/config changes  | chore(deps): bump dependencies   |
| ci       | Continuous Integration     | ci(travis): update config        |
| revert   | Revert previous commit     | revert: rollback last change     |

## Leveraging AI with Conventional Commits

AI-powered IDEs like **JetBrains'** suite of tools enhance your workflow by intelligently suggesting commit messages
that
adhere to Conventional Commits standards. These suggestions are contextually generated based on changes you've made,
significantly streamlining the process and reducing the cognitive load of writing detailed commit messages.

### AI-Powered IDEs and Conventional Commits

JetBrains IDEs, such as IntelliJ IDEA and WebStorm, integrate [AI tools](https://www.jetbrains.com/ai-assistant/) that:

- Automatically suggest precise commit messages.
- Detect commit types (feat, fix, docs, etc.) based on changes.
- Recommend appropriate scopes, improving accuracy and efficiency.

## Examples of Conventional Commits

Understanding the theory behind Conventional Commits is one thing, but seeing how they are applied in real-world
scenarios can be extremely helpful. Below are some examples illustrating how to write effective, clear, and standardized
commit messages.

> Here is an example of commits from [my GitHub](https://github.com/Shramkoweb/Portfolio/commits/develop/)

### Example 1: Adding a New Feature

**Commit Message**:

```bash
feat(auth): add OAuth 2.0 authentication
```

**Explanation**:

**Type**: `feat` (indicates a new feature). <br/>
**Scope**: `auth` (specifies that the change is related to authentication). <br/>
**Description**: `add OAuth 2.0 authentication` (brief summary of the change).

### Example 2: Fixing a Bug

**Commit Message**:

```bash
fix(profile): resolve issue with avatar upload
```

**Explanation**:

**Type**: `fix` (indicates a bug fix). <br/>
**Scope**: `profile` (specifies that the change affects the profile feature). <br/>
**Description**: `resolve issue with avatar upload` (briefly describes the problem and solution).

### Example 3: Updating Documentation

**Commit Message**:

```bash
docs(readme): update installation instructions
```

**Explanation**:

**Type**: `docs` (indicates a documentation change). <br/>
**Scope**: `readme` (specifies the README file). <br/>
**Description**: `update installation instructions` (details the specific update).

### Example 4: Refactoring Code

**Commit Message**:

```bash
refactor(utils): simplify the date parsing logic
```

**Explanation**:

**Type**: `refactor` (indicates a code change that neither fixes a bug nor adds a feature). <br/>
**Scope**: `utils` (specifies that the change pertains to utility functions). <br/>
**Description**: `simplify the date parsing logic` (briefly describes the refactoring).

### Example 5: Performance Improvement

**Commit Message**:

```bash
perf(db): optimize query execution time
```

**Explanation**:

**Type**: `perf` (indicates a performance improvement). <br/>
**Scope**: `db` (specifies that the change affects the database). <br/>
**Description**: `optimize query execution time` (summarizes the performance enhancement).

### Example 6: Adding or Updating Tests

**Commit Message**:

```bash
test(router): add unit tests for routing module
```

**Explanation**:

**Type**: `test` (indicates test-related changes). <br/>
**Scope**: `router` (specifies the routing module). <br/>
**Description**: `add unit tests for routing module` (briefly describes the tests added).

### Example 7: Maintenance or Chore

**Commit Message**:

```bash
chore(deps): upgrade lodash to version 4.17.21
```

**Explanation**:

**Type**: `chore` (indicates maintenance or chores). <br/>
**Scope**: `deps` (specifies that the change pertains to dependencies). <br/>
**Description**: `upgrade lodash to version 4.17.21` (details the specific update).

### Example 8: Continuous Integration Configuration

**Commit Message**:

```bash
ci(circleci): add build step for linting
```

**Explanation**:

**Type**: `ci` (indicates changes to CI configuration). <br/>
**Scope**: `circleci` (specifies the CI service being configured). <br/>
**Description**: `add build step for linting` (briefly describes the new CI step).

### Example 9: Reverting a Previous Commit

**Commit Message**:

```bash
revert: remove OAuth 2.0 authentication

This reverts commit abc123.
```

**Explanation**:

**Type**: `revert` (indicates the commit is a revert). <br/>
**Scope**: None (reverts don't usually need a scope). <br/>
**Description**: `remove OAuth 2.0 authentication` (describes what is being reverted).
Body: This reverts commit abc123. (provides context by specifying the commit being reverted).

## Using Conventional Commits in Projects

Incorporating Conventional Commits into your projects can significantly improve code quality and team collaboration.
Here’s a step-by-step guide on how to start using Conventional Commits in your projects.

### Step 1: Educate Your Team

Before adopting Conventional Commits, ensure that everyone on your team understands its benefits and guidelines. Share
resources, conduct workshops, or organize short training sessions to help everyone get up to speed.

### Step 2: Set Up Commit Message Linting

To enforce the Conventional Commits standard, you can use tools
like [commitlint](https://github.com/conventional-changelog/commitlint) and [husky](https://typicode.github.io/husky/).
These tools help ensure that
all commit messages adhere to the predefined format.

Example Configuration:

#### Install Dependencies:

```bash
npm install --save-dev @commitlint/config-conventional @commitlint/cli husky
```

#### Configure Commitlint:

Create a new file named `commitlint.config.js` in the root of your project and add the following content:

```js
module.exports = {
  extends: ['@commitlint/config-conventional'],
};
```

#### Set Up Husky Hooks:

The `init` command simplifies setting up husky in a project. It creates a `pre-commit` script in `.husky/` and updates
the prepare script in `package.json`. Modifications can be made later to suit your workflow.

```bash
npx husky init
```

### Step 3: Use Tools and Libraries

Conventional commits can be parsed by tools, and a very nice use-case is that of generating release changelogs.

<Image src="changelog.png" alt="Auto-generated CHANGELOG v4.1.0 on GitHub showing categorized features and bug fixes from conventional commits" />

#### Semantic Release:

- Automates the whole package release workflow including determining the next version number, generating the release
  notes, and publishing the package.
- [Semantic Release Documentation](https://semantic-release.gitbook.io/semantic-release)

#### Commitizen:

- A tool that prompts you to fill out the commit message with a CLI, ensuring you follow the Conventional Commits
  standard.
- [Commitizen Documentation](https://github.com/commitizen/cz-cli)

### Step 4: Continuous Integration and Continuous Deployment (CI/CD)

Integrate Conventional Commits with your `CI/CD` pipeline to automate tasks such as generating changelogs and
versioning.

Here’s how you can do it:

#### Changelog Generation:

- Use tools like standard-version to generate changelogs automatically.
- [Standard Version Documentation](https://github.com/conventional-changelog/standard-version)

#### Versioning and Releasing:

- Automate versioning and releasing using tools like Semantic Release.
- Define release steps in your CI configuration (e.g., GitHub Actions, Travis CI).

Example GitHub Actions Configuration for Semantic Release:

```yaml
name: Release
on:
  push:
    branches:
      - main
jobs:
  release:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Code
        uses: actions/checkout@v2
      - name: Install Node.js
        uses: actions/setup-node@v2
        with:
          node-version: 14
      - name: Install Dependencies
        run: npm install
      - name: Run Semantic Release
        run: npx semantic-release
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
```

## Conclusion

I hope this blog post has inspired you to delve into conventional commits.

Initially, conventional commits might seem a bit odd, and you might find yourself questioning the format as you make
commits. However, they soon become second nature, and you'll appreciate their impact on your software engineering
practices.

> Conventional commits pair well with [Semantic Versioning](/blog/npm-semantic-versioning) for automated package
> releases.

Looking for more productivity wins? I also wrote about why you should [unsubscribe from email newsletters immediately](/blog/unsubscribe-immediately) to stay focused.


Master Conventional Commits to write clear, structured commit messages. Learn the format, types like feat and fix, and how to automate changelog generation.

Conventional Commits enhance your coding practices


## Introduction

<Image src="pnpm-logo.png" alt="pnpm logo on gray background" />

I found an article from Vercel
about [Projects using pnpm can now be deployed with zero configuration](https://vercel.com/changelog/projects-using-pnpm-can-now-be-deployed-with-zero-configuration)
and I wanted to try it.

## Why Migrate to pnpm?

Before diving into the migration process, it’s important to understand why pnpm is beneficial:

1. **Speed** 🚀: pnpm installs dependencies faster than npm by using a unique package linking mechanism.
2. **Disk Space** 🔎: It saves disk space by using a global store and hard links.
3. **Consistency** 💡: pnpm ensures that dependencies are installed in a way that is more consistent with the version
   specified in your `package.json`.

## Installation of pnpm

First, you need to install pnpm globally. Make sure you have the right Node.js version installed — if you manage multiple versions, [NVM](/blog/nvm) makes switching between them effortless. Then run:

```bash
brew install pnpm
```

## Migration Steps

### 1. Clean the Project

Remove the `node_modules` directory and the `package-lock.json` file. This step is crucial to ensure that there are no
leftover artifacts from npm that might interfere with pnpm.

```bash
rm -rf node_modules package-lock.json
```

### 2. Initialize pnpm

Run the following command to initialize pnpm in your project directory:

```bash
pnpm install
```

This command will create a `pnpm-lock.yaml` file and install all the dependencies listed in your `package.json`.
Understanding [how semantic versioning works in npm](/blog/npm-semantic-versioning) will help you predict exactly what gets installed.

### 3. Verify Dependency Installation

Check that all dependencies have been installed correctly by running:

```bash
pnpm list
```

This command lists all the installed dependencies and their versions. Make sure that there are no missing or outdated
packages.

<Image src="pnpm-list.png" alt="pnpm list command result in terminal" />

## Updating Scripts

### 1. Update npm Scripts

In your `package.json`, update any npm scripts to use pnpm where necessary. For example, if you have a script for
installing dependencies, change it from:

```json
"scripts": {
"install": "npm install"
}
```

to:

```json
"scripts": {
"install": "pnpm install"
}
```

### 2. Update CI/CD Pipelines

If your project uses CI/CD pipelines, ensure that the build scripts and installation commands are updated to use pnpm.
For example, in a [GitHub Actions  with pnpm](https://pnpm.io/continuous-integration) workflow, you might update the
step as follows:

```yaml
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: pnpm/action-setup@v4
        with:
          version: 9
      - uses: actions/setup-node@v4
        with:
          node-version: ${{ matrix.node-version }}
          cache: 'pnpm'
      - name: Install
        run: pnpm i
      - name: Run Tests // All your CI commands
        run: pnpm run test
```

## Handling Issues and Troubleshooting

During the migration, you might encounter some issues.

> Error: Unable to locate executable file: pnpm. Please verify either the file path exists or the file can be found
> within a directory specified by the PATH environment variable. Also check the file mode to verify the file is
> executable.

I stuck with this error when I tried to run the `pnpm` command in GitHub Actions.

The solution was to use the `pnpm/action-setup@v4` before `actions/setup-node@v4`.
So simply just copy the [above code](#2-update-cicd-pipelines) and paste it in your `.yml` file.

## Conclusion

This migration helped me to reduce the time of deployment by **44%** and the size of `node_modules` by **5%**.

<Image src="vercel-deployment.png" alt="Vercel deployment dashboard showing build time of approximately one second after migrating to pnpm" />

More info how my blog works you can find there [How my site works under the hood](/blog/introducing-the-new-shramko.dev)


Migrate from npm to pnpm and cut your deployment time by 44%. Step-by-step guide covering installation, lockfile conversion, and CI/CD configuration.

Migrate from npm to pnpm – Save Time with This Guide

<Image src="astro.jpg" alt="Astro framework logo on a dark starry background" />

**Astro is a web framework that ships zero JavaScript by default, delivering lightning-fast websites through its Islands Architecture.** This Astro framework guide covers everything you need to build content-driven sites — blogs, marketing pages, docs, and e-commerce storefronts. Astro renders HTML at build time and hydrates only the interactive components you choose.

As of 2026, Astro 6.x powers over 1.3 million weekly npm downloads and holds 57K+ GitHub stars. It ranked **#1 in satisfaction** among meta-frameworks in the [State of JS 2025](https://2025.stateofjs.com/en-US/libraries/meta-frameworks/) survey — with a 39% gap over Next.js. In January 2026, [Cloudflare acquired Astro](https://blog.cloudflare.com/astro-joins-cloudflare/), signaling long-term investment in the framework's future.

> **Why Astro over Next.js?** If your site is primarily content (blogs, docs, landing pages), Astro delivers smaller bundles and faster page loads — no React runtime ships unless you need it. Next.js excels for highly interactive apps. Choose the right tool for the job.

## TL;DR

- **Zero JS by default** — Astro renders static HTML; no JavaScript ships unless you opt in
- **Islands Architecture** — hydrate only interactive components, not the entire page
- **UI-agnostic** — use React, Vue, Svelte, Solid, or plain HTML in the same project
- **Content Collections** — type-safe content management with schema validation
- **View Transitions** — native page transitions without a SPA framework
- **Server Islands** — defer server-rendered components with `server:defer`

## Islands Architecture

Astro pioneered the [Islands Architecture](https://docs.astro.build/en/concepts/islands/) for the web. Think of your page as an ocean of static HTML with small "islands" of interactivity.

```md:src/pages/index.astro
---
// Static content — ships as HTML, zero JS
import Header from '../components/Header.astro';
import Newsletter from '../components/Newsletter.tsx';
import Footer from '../components/Footer.astro';
---

<Header />

<main>
  <h1>Welcome to my site</h1>
  <p>This paragraph is static HTML. No JavaScript needed.</p>

  
  <Newsletter client:visible />
</main>

<Footer />
```

The `Header`, `Footer`, and all HTML ship as plain markup. Only the `Newsletter` component loads JavaScript — and only when it scrolls into view. This is why Astro sites score 90+ on Lighthouse by default.

## Content Collections and the Content Layer API

[Content Collections](https://docs.astro.build/en/guides/content-collections/) give you type-safe access to Markdown, MDX, JSON, and YAML content. Define a schema, and Astro validates your frontmatter at build time.

```ts:src/content.config.ts
import { defineCollection, z } from 'astro:content';
import { glob } from 'astro/loaders';

const blog = defineCollection({
  loader: glob({ pattern: '**/*.md', base: './src/data/blog' }),
  schema: z.object({
    title: z.string(),
    description: z.string(),
    pubDate: z.coerce.date(),
    tags: z.array(z.string()).default([]),
    draft: z.boolean().default(false),
  }),
});

export const collections = { blog };
// Output: type-safe collection with validated frontmatter
```

Query your content with full [TypeScript](/blog/discriminated-unions) autocompletion:

```md:src/pages/blog/index.astro
---
import { getCollection } from 'astro:content';

const posts = await getCollection('blog', ({ data }) => !data.draft);
// Output: Array of type-safe blog post objects
---

<ul>
  {posts.map(post => (
    <li>
      <a href={`/blog/${post.id}`}>{post.data.title}</a>
    </li>
  ))}
</ul>
```

The Content Layer API (Astro 5+) extends this to external sources — CMS platforms, databases, or APIs — using the same type-safe interface. See the [Content Layer docs](https://docs.astro.build/en/guides/content-collections/#the-content-layer) for details.

## View Transitions

Astro provides native [View Transitions](https://docs.astro.build/en/guides/view-transitions/) that create smooth page navigation without client-side routing.

```md:src/layouts/Base.astro
---
import { ViewTransitions } from 'astro:transitions';
---

<html>
  <head>
    <ViewTransitions />
  </head>
  <body>
    <slot />
  </body>
</html>
```

Add per-element animations with the `transition:animate` directive:

```md
<h1 transition:animate="slide">Page Title</h1>
<article transition:animate="fade">Content here</article>
```

> **Gotcha:** Scripts run only on initial page load by default. If you need code to run on every navigation, listen for the `astro:page-load` event:

```html
<script>
  document.addEventListener('astro:page-load', () => {
    // Runs on every page navigation
    console.log('Page loaded');
  });
</script>
```

## Server Islands

[Server Islands](https://docs.astro.build/en/guides/server-islands/) (Astro 5+) let you defer specific components to render on the server at request time while the rest of the page is statically cached.

```md:src/pages/product.astro
---
import ProductInfo from '../components/ProductInfo.astro';
import UserCart from '../components/UserCart.astro';
---


<ProductInfo />


<UserCart server:defer>
  <p slot="fallback">Loading cart...</p>
</UserCart>
```

This is perfect for personalized content (user carts, dashboards) on otherwise static pages. The static parts serve instantly from the CDN while the dynamic island streams in.

## Creating Your First Project

```shell
# Create a new Astro 6.x project
npm create astro@latest

# Start the dev server
npm run dev
```

<Image src="astro-dev.jpeg" alt="Astro welcome screen on localhost" />

Astro scaffolds a project with file-based routing, TypeScript support, and zero configuration. Add integrations like React, Tailwind, or MDX with one command:

```shell
npx astro add react mdx
```

## File-Based Routing

Astro uses [file-based routing](https://docs.astro.build/en/guides/routing/). Files in `src/pages/` become pages on your site:

```shell
# Static routes
src/pages/index.astro        → site.com/
src/pages/about.astro         → site.com/about
src/pages/blog/first-post.md  → site.com/blog/first-post
```

Dynamic routes use bracket syntax with `getStaticPaths()`:

```md:src/pages/blog/[slug].astro
---
import { getCollection } from 'astro:content';

export async function getStaticPaths() {
  const posts = await getCollection('blog');
  return posts.map(post => ({
    params: { slug: post.id },
    props: { post },
  }));
}

const { post } = Astro.props;
// Output: renders a page for each blog post
---

<h1>{post.data.title}</h1>
```

## Astro Component Structure

Every `.astro` component has two parts: the Component Script (frontmatter) and the Component Template.

```md:src/components/Greeting.astro
---
// Component Script — runs at build time
const { name } = Astro.props;
const greeting = `Hello, ${name}!`;
---


<h1>{greeting}</h1>

<style>
  h1 { color: navy; }
</style>
```

Use [slots](https://docs.astro.build/en/basics/astro-components/#slots) to pass child content into components:

```md:src/components/Wrapper.astro
---
const { title } = Astro.props;
---

<div class="wrapper">
  <h1>{title}</h1>
  <slot />  
</div>
```

## Client Directives (Hydration)

By default, UI framework components render as static HTML with **no JavaScript**. Use `client:*` directives to hydrate interactive [islands](https://docs.astro.build/en/concepts/islands/).

| Directive | Priority | When It Loads | Use Case |
|-----------|----------|---------------|----------|
| `client:load` | High | Immediately on page load | Buttons, modals, forms |
| `client:idle` | Medium | After page finishes loading | Analytics, non-critical widgets |
| `client:visible` | Low | When scrolled into viewport | Below-fold carousels, comments |
| `client:media` | Low | When CSS media query matches | Mobile-only sidebars |
| `client:only` | — | Client-only, no SSR HTML | Components needing `window` |

### The #1 Beginner Mistake

"Why isn't my `onClick` working?" — Because you forgot the client directive.

```jsx
// ❌ Wrong — renders as static HTML, no JavaScript runs
<Counter />
```

```jsx
// ✅ Correct — hydrates the component on page load
<Counter client:load />
```

Without a `client:*` directive, your React/Vue/Svelte component renders HTML only. Event handlers, state, and effects won't work. See the [client directives reference](https://docs.astro.build/en/reference/directives-reference/#client-directives).

Use `client:only="react"` when a component has no meaningful server-rendered HTML or depends on browser-only APIs like `window` or `localStorage`.

## Data Fetching

Astro supports two primary data fetching patterns.

**Content Collections** (recommended for local content):

```md
---
import { getCollection } from 'astro:content';

const posts = await getCollection('blog');
// Output: type-safe array of blog posts
---
```

**Global `fetch()`** for external APIs:

```md:src/pages/users.astro
---
const response = await fetch('https://api.github.com/users/octocat');
const user = await response.json();
// Output: { login: "octocat", name: "The Octocat", ... }
---

<h1>{user.name}</h1>
<p>{user.bio}</p>
```

> Before using React components for fetched data, add the [React integration](https://docs.astro.build/en/guides/integrations-guide/react/).

<Image src="astro-dev.gif" alt="Data fetching in Astro" />

**Build-time vs runtime:** In static mode (default), `fetch()` runs at build time. With [SSR enabled](https://docs.astro.build/en/guides/on-demand-rendering/), it runs on each request. Read more in the [data fetching docs](https://docs.astro.build/en/guides/data-fetching/).

## Styles & CSS

Astro scopes `<style>` blocks to their component by default — no CSS leaks:

```md:src/components/Card.astro
<style>
  /* Only applies to <h2> inside this component */
  h2 { color: navy; }
</style>

<h2>Scoped heading</h2>
```

**Tailwind CSS v4** setup uses the Vite plugin (the `@astrojs/tailwind` integration is deprecated in Astro 5+):

```shell
npm install tailwindcss @tailwindcss/vite
```

```ts:astro.config.mjs
import { defineConfig } from 'astro/config';
import tailwindcss from '@tailwindcss/vite';

export default defineConfig({
  vite: {
    plugins: [tailwindcss()],
  },
});
```

```css:src/styles/global.css
@import 'tailwindcss';
```

Astro also supports [Sass, Less, and CSS Modules](https://docs.astro.build/en/guides/styling/) out of the box.

> **Gotcha:** Styles inside `<style>` blocks cannot target elements inside `<astro-island>` wrappers. Use `:global()` or Tailwind utility classes for hydrated framework components.

## Astro vs Next.js: When to Use Each

Both are excellent frameworks, but they solve different problems.

| | Astro | Next.js |
|---|---|---|
| **Best for** | Content sites, blogs, docs, marketing | Interactive apps, dashboards, SaaS |
| **Default JS** | Zero | Full React runtime |
| **Rendering** | Static-first, opt-in SSR | SSR-first, opt-in static |
| **UI framework** | Any (or none) | React only |
| **Learning curve** | Low (HTML-first) | Medium (React required) |

**Choose Astro** when your site is mostly content with pockets of interactivity. **Choose Next.js** when every page needs heavy client-side state and routing. You can always use React components in Astro for the interactive parts — get the best of both worlds.

## Common Mistakes

### Forgetting `client:*` directives

```jsx
// ❌ No interactivity — renders as static HTML
<ReactForm />
```

```jsx
// ✅ Hydrated — event handlers and state work
<ReactForm client:load />
```

### Using the deprecated Tailwind integration

```shell
# ❌ Deprecated in Astro 5+
npx astro add tailwind
```

```shell
# ✅ Use the Vite plugin instead
npm install tailwindcss @tailwindcss/vite
```

### Ignoring `astro:page-load` with View Transitions

```html

<script>
  document.querySelector('.menu').addEventListener('click', toggle);
</script>
```

```html

<script>
  document.addEventListener('astro:page-load', () => {
    document.querySelector('.menu').addEventListener('click', toggle);
  });
</script>
```

### Fetching content without Content Collections

```md
---
// ❌ Manual glob — no type safety, no validation
const posts = await Astro.glob('../content/blog/*.md');
---
```

```md
---
// ✅ Type-safe with schema validation (Astro 5+)
import { getCollection } from 'astro:content';
const posts = await getCollection('blog');
---
```

## Why Learn Astro in 2026?

Astro ranked **#1 in satisfaction** among meta-frameworks in the [State of JS 2025](https://2025.stateofjs.com/en-US/libraries/meta-frameworks/) survey — a 39% gap over Next.js. With ~1.3M weekly npm downloads and 57K+ GitHub stars, it's one of the fastest-growing web frameworks.

In January 2026, [Cloudflare acquired Astro](https://blog.cloudflare.com/astro-joins-cloudflare/), bringing enterprise backing and deeper edge computing integration. The ecosystem continues to grow with [Starlight](https://starlight.astro.build/) (documentation framework) powering docs for Cloudflare, Sentry, and Stripe.

Whether you're building a personal blog, a [link tree](/blog/linktree), or deploying [images on Vercel](/blog/astro-image-on-vercel), Astro keeps your sites fast by default.

## Useful Links

- [Astro home page](https://astro.build/)
- [Astro documentation](https://docs.astro.build/en/getting-started/)
- [Astro GitHub repository](https://github.com/withastro/astro)
- [Astro integrations directory](https://astro.build/integrations/)
- [Starlight — documentation framework built on Astro](https://starlight.astro.build/)
- [State of JS 2025 — meta-frameworks](https://2025.stateofjs.com/en-US/libraries/meta-frameworks/)
- [Are SPAs better than MPAs? | HTTP 203](https://www.youtube.com/watch?v=ivLhf3hq7eM)

## My Astro Projects

- [Building a Link Tree](/blog/linktree) — my personal linktree with Astro and Vercel
- [Astro Image Component on Vercel](/blog/astro-image-on-vercel) — fixing image optimization for Vercel deployments

Master the Astro framework with this hands-on guide. Islands Architecture, Content Collections, View Transitions, and client directives with code examples.

Astro Framework Guide: Build Faster Sites in 2026


<Image src="node-post.jpg" alt="Laptop displaying code in a dark IDE on a dimly lit industrial surface" />

[NVM](https://github.com/nvm-sh/nvm), or Node Version Manager, is essential for managing multiple versions of Node.js on
our development environment.
[Node.js](https://nodejs.org/en) is a JavaScript-based web technology, that allows developers to write server-side code
using JavaScript.

By using NVM to manage different versions with ease, developers can keep their environment up-to-date with the best
tools and achieve their desired results with ease.

In this article, we’ll be looking at how to install NVM with Brew and verify it worked properly. Additionally, we’ll
take a look at why we need NVM, a useful NVM cheatsheet, and how to install NVM on Windows, Linux, and MacOS.

## What is NVM?

Simply put, it is a software that allows you to install and manage different versions of Node.js on your system. You can
also switch easily between them, making it ideal for keeping your development environment updated.

## Why Do We Need NVM?

NVM is essential for managing multiple versions of Node.js on our systems. By using NVM to manage and switch between
different versions, we can make sure our environment is always up-to-date with the latest version. This allows us to
take advantage of the newest tools available in the Node.js ecosystem.

Additionally, NVM helps us become more efficient as developers. With NVM, we can quickly switch between different
versions of Node.js without having to reconfigure our environment and restart our terminal.

## How to Install NVM with Brew

Installing NVM with [Brew](https://brew.sh/) is a fairly straightforward process.

First, you’ll need to install Brew, which you can do simply by entering this on your terminal:

```shell
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
```

Once Brew is installed, you can install NVM by entering `brew install nvm` on your terminal.
This command will download the latest version of NVM for your system, including the necessary libraries and packages.

```shell
brew install nvm
```

### Verify It Worked

Once you’ve installed NVM with Brew, you can verify that it worked by entering `nvm —-v` on your terminal. This command
will show you the version of NVM you’re currently running.

```shell
nvm —-v

#Node Version Manager (v0.39.3) // It's my version of NVM
```

## NVM Cheatsheet

Using NVM can be intimidating at first. To help, here’s a helpful NVM cheatsheet:

```shell
- nvm install 8.0.0                     #Install a specific version number
- nvm use 8.0                           #Use the latest available 8.0.x release
- nvm run 6.10.3 app.js                 #Run app.js using node 6.10.3
- nvm exec 4.8.3 node app.js            #Run `node app.js` with the PATH pointing to node 4.8.3
- nvm alias default 8.1.0               #Set default node version on a shell
- nvm alias default node                #Always default to the latest available node version on a shell
- nvm uninstall [<version>]             #This command will uninstall a specific version of Node.js

- nvm install node                      #Install the latest available version
- nvm use node                          #Use the latest version
- nvm install --lts                     #Install the latest LTS version
- nvm use --lts                         #Use the latest LTS version
```

## How to Install NVM on Windows

Installing NVM on Windows is slightly more involved than with Linux or macOS. To do so, you’ll need to have the [Windows
Subsystem for Linux](https://learn.microsoft.com/en-us/windows/wsl/install) (WSL) installed. Once you have WSL
installed, you can use Brew to install NVM just as you would with Linux or macOS.

## How to Install NVM on Linux

The easiest way to install NVM on Linux is to use Brew. Simply open your terminal and then enter `brew install nvm`.

Before that, install Brew 🍻

## Recap

Hopefully this article has helped you get a better understanding of NVM and how to install it on a variety of systems.
Installing and managing multiple versions of Node.js is essential for staying up-to-date with the best tools and
achieving better results.

With NVM, you’ll be able to easily switch between different versions and keep your development
environment updated.

## Further reading

- [pnpm — Fast, Disk Space Efficient Package Manager](/blog/pnpm) — a modern package manager that pairs well with NVM for Node.js projects
- [How to Create SSH Keys](/blog/how-to-create-ssh-keys) — another essential developer environment setup step


Learn how to install and use Node Version Manager (NVM) to switch between Node.js versions effortlessly. Manage multiple Node versions for different projects.

Node Version Manager (NVM): Install and Switch Versions


Very often, cloud database services such as [neon.tech](https://neon.com/) allow you to connect via URL.
That is, without credentials such as `user`, `password`, etc.

## Connection details

### Connection URL

It's [official PostgreSQL format for connection URLs](https://www.postgresql.org/docs/current/libpq-connect.html#LIBPQ-CONNSTRING)

<Image src="postgresql-connection-string.png" priority={true} alt="PostgreSQL connection URL string format showing protocol, user, password, host, port, and database" />

### Base URL and path

Here's an example of a base URL and path structure using uppercase placeholder values:

```text
postgresql://USER:PASSWORD@HOST:PORT/DATABASE
```

<Image src="db-table.png" priority={true} alt="PostgreSQL base URL and path structure with placeholder values for user, password, host, port, and database" />

## How this site connects to the database

### Store your credentials in .env

Store your credentials in your `.env` file.

```shell
PGHOST='<endpoint_hostname>:<port>'
PGDATABASE='<dbname>'
PGUSER='<username>'
PGPASSWORD='<password>'
ENDPOINT_ID='<endpoint_id>'
```

where:

- `endpoint_hostname` the hostname of the branch endpoint. The endpoint hostname has an ep- prefix and appears similar
  to
  this: **ep-tight-salad-272396.us-east-2.aws.neon.tech**
- `dbname` is the name of the database. The default Neon database is neondb
- `user` is the database user
- `password` is the database user's password, which is provided to you when you create a project
- `endpoint_id` is the ID of the branch endpoint that you are connecting to. The endpoint_id has an ep- prefix and
  appears
  similar to this: **ep-tight-salad-272396**

### Use prisma.io to connect Postgres

```js
// You can create DATABASE_URL in your code
const DATABASE_URL = `postgres://${PGUSER}:${PGPASSWORD}@${PGHOST}/${PGDATABASE}`;
```

```shell
# Or better to use .env file
datasource db {
  provider = "postgresql"
  url      = env("DATABASE_URL")
  referentialIntegrity = "prisma"
}
```

### Use Datagrip to connect Postgres

You can use the same credentials like `HOST`, `PORT`, `USER`, `PASSWORD`, `DATABASE` for connection to Database with
DataGrip.

<Image src="db-datagrip.png" priority={true} alt="DataGrip connection dialog configured with PostgreSQL credentials" />

## Related

- [Installing PostgreSQL on macOS](/snippets/postgres-install-macos) - step-by-step setup guide
- [SQL Countries Table](/snippets/countries-sql) - ready-to-use seed data for your database


Learn how to connect to PostgreSQL using a connection URL string. Simple guide for Node.js, DataGrip, or any client supporting URL-based database connections.

Use Postgres Connect URLs for DB Connections


<Image src="fruits.png" alt="JavaScript array illustration showing const fruits with six fruit emoji elements and their zero-based index positions" priority={true} />

## Syntax

Arrays are zero-indexed ordered lists of values. They are a convenient way to store a set of related elements of the
same type (such as numbers or strings), although an array can contain multiple types of elements, including other
arrays.

```js
// An array containing numbers
const numberArray = [0, 1, 2, 3, 4, 5];

// An array containing different data types
const mixedArray = [1, 'chicken', false];
```

## Creating an Array

The easiest way to create an array is to use array literals - `[]`, as in the example above.

```js
const fruits = ['🍎', '🍐', '🍊', '🍋', '🍉', '🍓'];
```

With the Array class by using the new keyword and passing in the elements as arguments:

```js
const fruits = new Array('🍎', '🍐', '🍊', '🍋', '🍉', '🍓');
```

Though, because the effect is exactly the same, it
is [preferable to use the literal method](https://google.github.io/styleguide/jsguide.html#features-arrays-ctor) for
simplicity

## Accessing the Elements of an Array

Array elements are ordered by index values, starting at 0:

- Index 0 has the first element
- Index 1 has the second element
- Index n-1 has the nth element
- Index array.length-1 has the last element

```js
//              [0]   [1]   [2]  [3]   [4]   [5]
const fruits = ['🍎', '🍐', '🍊', '🍋', '🍉', '🍓'];

// Get first element of array
console.log(fruits[0]); // 🍎

// Get third element of array n-1
console.log(fruits[2]); // 🍊

// Get last element of array
console.log(fruits[fruits.length - 1]); // 🍓
```

## Array methods and properties

Arrays provide a lot of methods and properties.

### Array properties

The Array does not have a lot of properties 😂.

#### Array length

The `length` property is used to know the amount of items in your array.

```js
const apples = ['🍎', '🍎', '🍎'];

// Length of an array
console.log(apples.length); // logs 3
```

### Array methods

For these examples I use this sample data:

```js:DATA_SAMPLE
const employees = [
  {
    name: 'Serhii',
    age: 29
  },
  {
    name: 'Anna',
    age: 20
  },
  {
    name: 'Roman',
    age: 27
  },
  {
    name: 'Julia',
    age: 25
  },
  {
    name: 'Mykola',
    age: 35
  }
];
```

#### Add & remove items from array

Methods that add and remove items from the beginning or the end:

- employees.push(...items) – adds items to the end
- employees.pop() – extracts an item from the end
- employees.shift() – extracts an item from the beginning
- employees.unshift(...items) – adds items to the beginning

#### Find element in array

The `.find()` method will return the **_first element_** in the array that matches a test you provide.

```js
const employees = [/* See DATA_SAMPLE */]

// Find employee with name 'Serhii'
const serhii = employees.find((employee) => employee.name === 'Serhii');

// or with object destructuring
const serhii = employees.find(({ name }) => name === 'Serhii');
```

#### Transform elements in array

The `.map()` method will apply a given function to every item in your array and give you a **_new array with those
values_**.

```js
// Transform employees array to new array of names.
// I use object destructuring in this and future examples
const names = employees.map(({ name }) => name);
```

#### Filter elements in array

The `.filter()` method takes your array and removes items that don't pass a test you give it, and return new array.

```js
// Keep employees who are younger than 25
const youngEmployees = employees.filter(({ age }) => age < 25);
```

#### Merge two arrays to one

The `.concat()` method is used to merge two or more arrays, or concat new array to old. This method does not change the
existing arrays, but instead returns a new array.

```js
const evenNumbers = [2, 4, 6];
const oddNumbers = [1, 3, 5];

const allNumbers = evenNumbers.concat(oddNumbers); // [ 2, 4, 6, 1, 3, 5 ]
```

#### Join each element in array

The `.join()` method creates and returns a new string by concatenating all elements in an array.

```js
// Before .join() we must transform each object in array to string
const formattedOutput = employees
  .map(({ name }) => name) // Transform employee object to name string
  .join("\n"); // "\n" – add newline after each element
```

```shell:Output
Serhii
Anna
Roman
Julia
Mykola
```

#### Check if every element in array matches some criteria

The `.every()` method checks that every single item in your array matches some criteria.

```js

const isAdult = (employee) => employee.age > 18;

// Check is every our employee older than 18 age
const isEveryEmployeeYoung = employees.every(isAdult); // true
```

#### Check if at least one item in array matches some criteria.

The `.some()` method checks that at least one item in your array matches some criteria by compare function.

```js

const isAdult = (employee) => employee.age > 18;

// Check if at least one employee is older than 18
const isSomeEmployeeAdult = employees.some(isAdult); // true
```

#### Check if at least one item includes in your array

The `.includes()` method checks that at least one item in your array matches some value.

```js
// Check is name "Serhii" includes in employees array
const isSerhiiNameExist = employees
  .map(({ name }) => name) // Transform employee object to name string
  .includes('Serhii'); // true
```

#### Loop through an array

The `.forEach()` method executes a provided function once for each array element.

It doesn't return a value though. It's useful for side effects.

```js
// Print to console name of each employee
employees.forEach((employee) => console.log(employee.name))
```

## Conclusion

The array has many methods, in this article I have shown the most used in my opinion.

Further, you can learn more methods on the pages of MDN Web Docs, so I wish you inspiration and hope this article will
be useful to you.

## Related

- [for...in vs for...of Loops](/blog/for-in-vs-for-of) - learn different ways to iterate over arrays
- [Remove Duplicates from an Array](/snippets/remove-duplicates-array) - common array operation
- [Sort an Array of Objects](/snippets/sort-an-array-of-objects-in-javascript) - sorting by multiple properties
- [Generate a Range of Numbers](/snippets/generate-range) - quickly create sequential arrays


Master JavaScript array methods with this beginner-friendly guide. Learn map, filter, reduce, find, and other essential methods with practical examples.

JavaScript Arrays: Essential Methods for Beginners


I am a Frontend mentor in a [MacPaw internship](https://macpaw.com/bootcamp) and sometimes my interns get confused 🫠
about how links work in HTML.

So I decided to write a small article about this topic.

## Anatomy of a URL

<abbr title="Uniform Resource Locator">URL</abbr> - is a string that indicates the address of a document or file on the
Internet.

<Image src="anatomy.png" alt="URL anatomy diagram breaking down https://shramko.dev/blog into scheme, domain name, and path to file" inverted />

### Scheme

The first part of the URL is the scheme, which indicates the protocol that the browser must use to request the resource.
The protocol is usually HTTPS or HTTP, but can also be:

- ftp
- gopher
- file
- mailto
- and others

### Authority

Authority is the domain and optional port like `:80`.

Now you are in `shramko.dev` domain.

### Path to resource or file

```text
/blog/difference-between-absolute-and-relative-url
```

This is the path to the HTML file of this article. You can check it in the console if you write:

```javascript
window.location.pathname
```

For more ways to work with the current page address, see my snippet on [how to get the current URL with JavaScript](/snippets/how-to-get-the-current-url-with-javascript).

## Relative links

These links will always be anchored to the place where they are located.
The browser will use the same protocol and the same domain.

### Relative to the root of the site

An important point, we add `/` to the address at the beginning.

```html
<a href="/about">About page</a>
```

<Image src="root-example.png" alt="Diagram showing how a root-relative link /about resolves from shramko.dev/blog to shramko.dev/about" inverted />

### Relative path from the current document

Similar to the previous example, but
the [path to the file](#path-to-resource-or-file) is saved.

An important point, we do not add `/` to the address at the beginning.

```html
<a href="category/js">JS category of Blog</a>
```

<Image src="location.png" alt="Diagram showing how a relative path category/js appends to the current URL shramko.dev/blog resulting in shramko.dev/blog/category/js" inverted />

## Absolute links

An absolute link is an address to a file or page as a whole, with all the above-described parts of
the <abbr title="Uniform Resource Locator">URL</abbr>. With such a link, regardless of where this link is located, you
will be able to get to the right resource.

You will be taken to any page or site exactly as indicated by a link of this type:

```html
<a href="https://shramko.dev/dashboard">My Dashboard</a>
```

You can not specify the protocol `http/https`, then the browser will automatically use the protocol on which the site
was loaded.

```html
<a href="//shramko.dev/dashboard">My Dashboard</a>
```

## Anchors (links by #id)

Anchor links are usually used to navigate the current page. For example, a link to a paragraph or heading.

The link below moves you to the section about [Anatomy of URL on this page](#anatomy-of-a-url).

Add `#anatomy-of-a-url` to the current URL in your browser.

## Cheat Sheet

Examples that we discussed today.

<Image src="cheat-sheet.png" alt="Cheat sheet comparing absolute URLs, root-relative paths, relative paths, and fragment links with examples" inverted />

## Useful links

- [Article about how my site works under the hood](https://shramko.dev/blog/introducing-the-new-shramko.dev)
- [Site where I drew pictures](https://okso.app/)
- [Nice tutorial about how DNS works](https://howdns.works/)
- [What is a URL](https://developer.mozilla.org/en-US/docs/Learn_web_development/Howto/Web_mechanics/What_is_a_URL)
- [Check if URL is Absolute](/snippets/is-absolute-url) - utility function to validate absolute URLs


Understand when to use absolute vs relative URLs in HTML. Clear examples showing how each type works, their pros and cons.

Absolute vs Relative URL: Which One Should You Use


## ❌ Problem

In my opinion, one of the most important tasks when writing code is to make it as simple and understandable as possible.
There are even principles in programming aimed at this - [KISS](https://en.wikipedia.org/wiki/KISS_principle).

You can often see such code with a lot of `if`, and `switch` statements in tutorials or answers on StackOverflow:

```js
function handleUserMove(direction) {
  if (direction === 'north') {
    movePlayerTo("north");
  } else if (direction === 'east') {
    movePlayerTo("east");
  } else if (direction === 'south') {
    movePlayerTo("south");
  } else if (direction === 'west') {
    movePlayerTo("west");
  } else {
    console.error("Unknown direction");
  }
}
```

If we had more conditionals who know how long this `if/else` statement could get 🤯, and it's not very dynamic.

We can use a `switch` statement:

```js
function handleUserMove(direction) {
  switch (direction) {
    case "north":
      movePlayerTo("north");
      break;
    case "east":
      movePlayerTo("east");
      break;
    case "south":
      movePlayerTo("south");
      break;
    case "west":
      movePlayerTo("west");
      break;
    default:
      console.error("Unknown direction");
  }
}
```

Although there is a little more code, `switch` itself describes the dispatching process more explicitly, but we write a
lot of static (control) code, and we must not forget about `break`. Too complicated for such a simple task.

## ✅ Solution

So what can we do to simplify it?

```js
const userInputToDirection = {
  north: movePlayer("north"),
  east: movePlayer("east"),
  south: movePlayer("south"),
  west: movePlayer("west")
}

function handleUserMove(direction) {
  userInputToDirection[direction]();
}
```

This option is better than the previous two for several reasons:

- It is shorter
- It is more flexible. Conditional constructs are static code that cannot be changed without rewriting the program
  itself.
- With
  the [Single Responsibility Principle (SRP)](https://www.freecodecamp.org/news/solid-principles-single-responsibility-principle-explained)
  , we have separated the execution function of our `handleUserMove` business logic from the direction determination
  logic.

Conditional constructs are static code that cannot be changed without rewriting the program itself.
But data is a completely different matter.
With this approach, it is easy to add new behavior without changing the application code `handleUserMove` itself.

## Real example

For example, in Next.js applications, you can
configure [next.config.js](https://nextjs.org/docs/pages/api-reference/config/next-config-js) and the code there looks
like this:

```js
const nextConfig = {
  /* Next.js config options here */
}

let resultConfig;

if (process.env.NODE_ENV === 'development') {
  resultConfig = withBundleAnalyzer(nextConfig);
} else if (process.env.NODE_ENV === 'production') {
  resultConfig = withSentryConfig(nextConfig);
} else if (process.env.NODE_ENV === 'test') {
  resultConfig = nextConfig;
}

module.exports = resultConfig;
```

With new knowledge, we can rewrite it like this:

```js
const nextConfigByEnv = {
  development: withBundleAnalyzer(nextConfig),
  production: withSentryConfig(nextConfig),
  test: nextConfig,
};

module.exports = nextConfigByEnv[process.env.NODE_ENV];
```

Will it look and read much better? I use [dispatch tables](/blog/introducing-the-new-shramko.dev#monitoring-with-sentry)
in my projects, and I can say that it is very convenient.

## Production example: CSP headers per environment

Here's a more advanced real-world example. Imagine you need to
configure [Content Security Policy](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP) headers differently for each
environment — local development needs relaxed rules, while production should be locked down.

Without a dispatch table, you might end up with a chain of `if/else` blocks checking the environment for every
directive. Instead, we can define per-environment config as a lookup object:

```ts
type TEnv = 'development' | 'stage' | 'production' | 'local';

const ENV = process.env.NEXT_PUBLIC_NODE_ENV as TEnv;

interface EnvConfig {
  imageSrc: string[];
  connectSrc: string[];
  scriptSrc?: string[];
}

const envConfig: Record<TEnv, EnvConfig> = {
  local: {
    imageSrc: [
      'https://dev.cdn.example.com',
      'https://stage.cdn.example.com',
      'https://cdn.example.com',
      'https://images.example.com',
    ],
    connectSrc: [
      'http://localhost:3001',
      'https://api.dev.example.com',
      'https://api-1.dev.example.com',
      'https://api.stage.example.com',
      'https://api.example.com',
    ],
    scriptSrc: ["'unsafe-eval'"],
  },
  development: {
    imageSrc: ['https://dev.cdn.example.com', 'https://images.example.com'],
    connectSrc: [
      'https://api.dev.example.com',
      'https://api-1.dev.example.com',
    ],
  },
  stage: {
    imageSrc: ['https://stage.cdn.example.com', 'https://images.example.com'],
    connectSrc: ['https://api.stage.example.com'],
  },
  production: {
    imageSrc: ['https://cdn.example.com', 'https://images.example.com'],
    connectSrc: ['https://api.example.com'],
  },
};

const { imageSrc, connectSrc, scriptSrc = [] } = envConfig[ENV];
```

The key line is `envConfig[ENV]` — a single lookup replaces what could be four separate `if` branches with duplicated
destructuring logic.

Then we compose the full CSP header by spreading the environment-specific values into the shared directives:

```ts
const CSP_DIRECTIVES: Record<string, string[]> = {
  'default-src': ["'self'"],
  'script-src': [
    "'self'",
    "'unsafe-inline'",
    'https://www.googletagmanager.com',
    'https://cdn.analytics.example.com',
    ...scriptSrc,
  ],
  'style-src': ["'self'", "'unsafe-inline'"],
  'img-src': ["'self'", ...imageSrc],
  'font-src': ["'self'"],
  'frame-src': ["'self'", 'https://embed.example.com'],
  'object-src': ["'none'"],
  'base-uri': ["'self'"],
  'form-action': ["'self'"],
  'connect-src': [
    "'self'",
    'https://sentry.example.com',
    'https://analytics.example.com',
    ...connectSrc,
  ],
  'frame-ancestors': ["'none'"],
};
```

Notice how the dispatch table cleanly separates **what varies** (per-environment URLs) from **what's shared** (the CSP
structure). Adding a new environment is just adding a new key to `envConfig` — no control flow to touch.

## Useful links

- [Example in CLI parser app](https://github.com/Shramkoweb/CLI-diff-generator/blob/develop/src/parsers.js#L31)
- [Naming Conventions for Key-Value Maps](https://softwareas.com/naming-conventions-for-key-value-maps/)
- [Dispatch table](https://en.wikipedia.org/wiki/Dispatch_table)
- [The Early Return Pattern](/blog/the-early-return-pattern-in-javascript) - another clean code pattern for simplifying
  conditionals


Replace messy switch statements with dispatch tables in JavaScript. Learn this clean code pattern for handling multiple conditions with maintainable code.

Dispatch Tables in JavaScript: A Clean Code Approach


## The For Loop

There are many ways to iterate in JavaScript, and probably one of the most common is a for loop.

The for statement is a type of loop that will use up to three optional expressions to implement the repeated execution
of a code block.
Let’s take a look at an example of what that means:

```js
for (initialization; condition; final expression) {
  // code to be executed
}
```

```js
// Initialize a for statement with 5 iterations
for (let i = 0; i < 5; i++) {
  // Print each iteration to the console
  console.log(`The number is ${i}`);
}
```

```shell:Output
The number is 0
The number is 1
The number is 2
The number is 3
The number is 4
```

But in addition to this `for` loop, there are two other types of for iteration methods we can use: `for...in`
and `for...of`.

## The for...in Statement

The `for...in` statement iterates over
all [enumerable properties](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Enumerability_and_ownership_of_properties)
of an object that is keyed by strings (ignoring one keyed by Symbols), including inherited enumerable properties.

The syntax `for...in` looks like this:

```js
for (const variable in enumerable) {
  // Do something
}
```

For example, to loop through and `console.log` all the values in this `user` Object:

```js
const user = {
  name: 'Serhii',
  age: 29,
  email: 'shramko.dev@gmail.com',
  country: 'Ukraine',
  city: 'Kyiv'
}

for (const key in user) {
  console.log(`user.${key} = ${user[key]}`)
}
```

```shell:Output
user.name = Serhii
user.age = 29
user.email = shramko.dev@gmail.com
user.country = Ukraine
user.city = Kyiv
```

We iterate through each `key` of the `user` Object, and then through this key we get the value
with [Bracket notation](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_accessors#bracket_notation)
.

### for...in and Objects

`for...in` is probably the easiest way to go through the object and use the key to get the value from it.

### for...in and Arrays

The keys in the array are indexes (numbers).

```js
const creatures = [
  "octopus",
  "squid",
  "shark",
  "seahorse",
  "starfish",
];

for (const index in creatures) {
  // We need access to creatures value by index
  console.log(creatures[index])
}
```

```shell:Output
octopus
squid
shark
seahorse
starfish
```

### for...in and Strings

```js
const oceanCreature = 'Shark';

for (const index in oceanCreature) {
  console.log(oceanCreature[index])
}
```

```shell:Output
S
h
a
r
k
```

## The for...of Statement

The `for...in` statement is useful for iterating over object properties, but to iterate over iterable objects like
arrays and strings, we can use the for...of statement. The `for...of` statement is a newer feature as of ECMAScript 6.

In this example of a `for...of` loop, we will create an array and print each item in the array to the console.

```js
const sharks = ["tiger", "great white", "hammerhead"];

// Print out each type of shark
for (const shark of sharks) {
  // Unlike for...in, we don't need an index now
  // we have immediate access to the element of the array
  console.log(shark);
}
```

```shell:Output
tiger
great white
hammerhead
```

### for...of and Objects

The `for...of` loop doesn't work with Objects because they don't have a [Symbol.iterator] property.
You can try but you will get an error:

```js
"Uncaught TypeError: Object is not iterable"
```

### Iterating over a DOM collection

Iterating over DOM collections like [NodeList](https://developer.mozilla.org/en-US/docs/Web/API/NodeList):

```js
const paragraphElements = document.querySelectorAll('p');

for (const paragraph of paragraphElements) {
  // Make all paragraphs red
  paragraph.style.color = 'red';
}
```

## Conclusion

In this post, we understood how for loops work and the difference between `for...of` and `for...in` statements.

Loops are an integral part of any programming language, as they are constantly used in places where you need to perform
the same type of tasks several times.

> Want to learn more about arrays? Check out my [JavaScript Arrays guide](/blog/js-arrays) covering essential methods like map, filter, and reduce.

## Related

- [Remove Duplicates from Array](/snippets/remove-duplicates-array) - a handy snippet for array deduplication


Understand the key differences between for...in and for...of loops in JavaScript. Learn when to use each for iterating over arrays, objects, and iterables.

JavaScript Loops: for...in vs for...of


JavaScript distinguishes _expressions_ and _statements_. A statement is an instruction, an action.

Remember conditions with `if`, `loops` with `while` and `for` — all those are _statements_, because they just perform
actions and control actions, but don't become values.

`Expression` returns (expresses) a value. Each of the following lines contains an expression:

```js
100 // this is a literal that expresses number 100

getUserName() // expresses Serhii

5 + 2 // expresses 7
```

`Statements` produce or control actions, but do not turn into values:

```js
let x; // declare a variable 'x'

function foo() {} // declare a function 'foo'

function bar() {
  return null // return is also a statement
}
```

You can't put statements where expressions are expected. For example, passing a const statement as a function
argument will produce an error. Or trying to assign the if statement to a variable:

```js
let b = if (x > 10) { return 100; };  // error!

console.log(const y);  // error!
```

## Related posts

- [Expressions versus statements in JavaScript](https://2ality.com/2012/09/expressions-vs-statements.html)
- [Expressions - MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_operators)

## Further reading

- [The Early Return Pattern in JavaScript](/blog/the-early-return-pattern-in-javascript) — a clean code pattern that simplifies control flow with expressions
- [Dispatch Tables](/blog/dispatch-tables) — replace verbose switch statements with a cleaner, expression-based approach


Learn the difference between expressions and statements in JavaScript. Understanding this distinction helps you write better code and avoid syntax errors.

JavaScript Expressions vs Statements: What's the Difference?


<Image src="es-module.png" alt="ES module dependency graph with main.js as entry point importing from counter.js and display.js" priority={true} />

## Problem

I ran into this error when using ```__dirname``` in an ES module.

```__dirname``` is an environment variable that tells you the absolute path of the directory containing the currently
executing file, and many Node.js projects use this.

But if you use it inside an ES module, you can't use it because of the infamous "__dirname is not defined in ES module
scope" an error appears.

## Solution

What can you do in this case?

To get the current file directory, we'll want to use a combination of a global variable and a few built-in methods:

- `import.meta.url` to get the current file as a URL
- `url.fileURLToPath` to change the URL to a path
- `path.dirname` to get the directory name

Using these methods, we can reconstruct the global `__dirname` and `__filename` variables:

```js
import path from 'path';
import { fileURLToPath } from 'url';

const __filename = fileURLToPath(import.meta.url);

const __dirname = path.dirname(__filename);
```

Now you can use `__dirname` as usual:

```js
console.log(__dirname)
```

## Conclusion

Due to the different approaches to modularity in Node.js and EcmaScript, you may encounter such problems.

If you are working with file paths, you may also find it useful to know [how to check if a file exists in Node.js](/snippets/how-to-check-if-file-exists-node).

For further reading, check out
the [Node.js documentation for __dirname](https://nodejs.org/docs/latest/api/modules.html#modules_dirname).


Fix the "__dirname is not defined in ES module scope" error in Node.js. Recreate __dirname and __filename using import.meta.url.

Fix “__dirname Not Defined” in ES Modules – Quick Guide

Master JavaScript with practical tutorials and best practices. Learn ES6+ features, async patterns, and modern techniques for web development.

JS16 articles

Articles

The early return pattern in JavaScript

Custom Hooks Pitfalls

React Re-Renders

Semantic Versioning in npm

Why Are JavaScript Naming Conventions Important?

Conventional Commits

How to decrease deployment time by 44% with pnpm

What Is Astro? The Complete Framework Guide for 2026

Node Version Manager

Postgres connect to database with URL

JavaScript 101: Arrays

Difference between absolute and relative URL in HTML

Dispatch table in javascript

for...in vs for...of Loops

Expressions vs Statements

How to fix "__dirname is not defined in ES module scope"