What is the role of the path module and why is it preferred over manual string concatenation?

Q: What is the role of the path module and why is it preferred over manual string concatenation?

**Target Audience:** Engineers preparing for Node.js phone screens — no prior file-system path handling experience assumed. **Difficulty:** Easy > **How to read this doc:** Concepts are explained in plain language first, then tagged with 📌 Interview term: . Every path shown below was **actually produced** by running the code on Node v24.19.0 (on Windows, for this run), not written by hand as an illustration. ## 1. Why This Even Matters — A Story First Writing an address by hand, gluing fragments together with a fixed rule like "always add a comma after the street," works fine until one fragment already ends with a comma and the result reads "Main St,, Springfield" — a small, silly-looking mistake that is nonetheless a real, wrong address. A properly designed form field, by contrast, normalizes punctuation regardless of what was typed into each box. `path.join` is that properly designed form for file paths; manual string concatenation is gluing fragments together and ho

The problem

Question presented to candidate: "You see code building a file path with string concatenation, like folder + '/' + filename. What can actually go wrong with that, and what does Node's path module do differently?"

What a strong answer should cover:

Node's built-in path module builds and manipulates file-system paths correctly for the current operating system — path.join, path.resolve, path.basename, path.extname, path.dirname, and others.
📌 The concrete bug manual concatenation introduces: joining path segments with a hardcoded "/" (or worse, no separator handling at all) produces double separators, missing separators, or wrong separators entirely depending on whether the input already ended in a slash and which OS is running — path.join normalizes all of that automatically.
path.join also correctly resolves relative segments like ".." and "." within the joined result, which naive concatenation does not do at all — it just concatenates literal strings.
Windows uses \ as its separator; POSIX systems (Linux, macOS) use /. Code that hardcodes either separator breaks on the other platform; path.join/path.resolve use path.sep, the correct separator for the platform actually running, automatically.
path.win32 and path.posix are explicitly available for code that needs to build a path for a specific platform regardless of which OS it currently runs on (e.g. generating a path string to embed in a config file meant for a different target platform) — distinct from the default path export, which always reflects the current platform.
A precise answer distinguishes path.join (concatenates segments, normalizes the result, does not resolve to an absolute path unless an input already was) from path.resolve (always produces an absolute path, resolving against process.cwd() if needed) — a commonly confused pair.

Clarifying questions expected:

"Does this code need to run correctly on both Windows and POSIX, or only one target platform?" — decides how much of the separator discussion actually matters.
"Is an absolute path needed, or just a correctly joined relative one?" — decides between path.join and path.resolve.

Code / implementation expected: Yes — showing path.join correctly normalizing a case where manual concatenation visibly breaks is the concrete, convincing part of the answer.

path
file-system
cross-platform

Try it yourself

Sketch your approach before you read the solution. That is what the interview tests.

Stuck? Get a hint.

A short nudge toward the approach. It will not give the answer away.

Solution

Target Audience: Engineers preparing for Node.js phone screens — no prior file-system path handling experience assumed. Difficulty: Easy

How to read this doc: Concepts are explained in plain language first, then tagged with 📌 Interview term:. Every path shown below was actually produced by running the code on Node v24.19.0 (on Windows, for this run), not written by hand as an illustration.

1. Why This Even Matters — A Story First

Writing an address by hand, gluing fragments together with a fixed rule like "always add a comma after the street," works fine until one fragment already ends with a comma and the result reads "Main St,, Springfield" — a small, silly-looking mistake that is nonetheless a real, wrong address. A properly designed form field, by contrast, normalizes punctuation regardless of what was typed into each box.

path.join is that properly design

The solution is hidden so you can try first

5 min read · 9 sections

Read the code

JavaScriptpath.join correctly normalizing separators and resolving .. where manual concatenation breaks, plus win32 vs posix

const path = require("path");

console.log(path.join("a/", "/b", "c"));   // a\b\c  (normalized, no double separator)
console.log("a/" + "/b" + "c");             // a//bc  (broken, literal double separator)

console.log(path.join("/foo/bar", "../baz")); // \foo\baz  (.. actually resolved)

console.log(path.win32.join("a", "b", "c")); // a\b\c
console.log(path.posix.join("a", "b", "c")); // a/b/c

console.log(path.resolve("a", "b"));          // an ABSOLUTE path, resolved against process.cwd()
console.log(path.join("a", "b"));             // stays relative: "a\b"

Discussion

Other approaches, follow-ups and how it went in real interviews.

Sign in to join the discussion.

No comments yet. Share how you would answer it.

The solution is hidden so you can try first

Keep your momentum going.