Path and PathBuf: Cross-Platform Path Handling

18 min read

Quick Overview

Every command-line tool eventually has to build, split, and inspect file paths. In Node you reach for the node:path module and pass strings around; Rust has dedicated Path and PathBuf types in the standard library that make path manipulation explicit, cross-platform, and hard to get wrong. This page maps the node:path API you already know onto Rust’s std::path, and flags the places where the two genuinely disagree — most notably how joining an absolute segment behaves and why paths are not just strings.

The current stable toolchain is Rust 1.96.0 on the latest stable edition (2024); cargo new selects it automatically. Everything here is in the standard library, so no crates are required.

Note: This page is about manipulating paths (building them, pulling them apart, comparing them). Actually reading and writing files lives in File I/O, and the broader portability story — line endings, cfg!(windows), exit codes — is in Cross-Platform Considerations.

TypeScript/JavaScript Example

Here is a small helper module in Node that mirrors a source file under an output directory and swaps its extension — the kind of logic a static-site generator or asset pipeline runs constantly. It uses the node:path module throughout.

1
// paths.ts — run with: npx tsx paths.ts
2
import path from "node:path";
3

4
// Build a path from segments.
5
console.log(path.join("/var/log", "app", "today.log")); // /var/log/app/today.log
6

7
// Pull a path apart.
8
const file = "/home/ada/notes/todo.txt";
9
console.log(path.basename(file));          // todo.txt
10
console.log(path.basename(file, ".txt"));  // todo
11
console.log(path.extname(file));           // .txt
12
console.log(path.dirname(file));           // /home/ada/notes
13

14
// path.parse gives you everything at once.
15
console.log(path.parse(file));
16
// { root: '/', dir: '/home/ada/notes', base: 'todo.txt', ext: '.txt', name: 'todo' }
17

18
// Mirror a source file under an output dir, swapping the extension.
19
function outputPath(srcRoot: string, outRoot: string, srcFile: string): string {
20
  const rel = path.relative(srcRoot, srcFile);   // strip the source root
21
  const mirrored = path.join(outRoot, rel);       // re-root under output
22
  const { dir, name } = path.parse(mirrored);
23
  return path.join(dir, `${name}.html`);          // swap extension
24
}
25

26
console.log(outputPath("content", "public", "content/blog/hello.md"));
27
// public/blog/hello.html

1
$ npx tsx paths.ts
2
/var/log/app/today.log
3
todo.txt
4
todo
5
.txt
6
/home/ada/notes
7
{
8
  root: '/',
9
  dir: '/home/ada/notes',
10
  base: 'todo.txt',
11
  ext: '.txt',
12
  name: 'todo'
13
}
14
public/blog/hello.html

Everything here is a string. path.join is just clever string concatenation that normalizes separators, and there is nothing stopping you from accidentally treating a path as a generic string, slicing it by hand, or comparing it with === and getting tripped up by a trailing slash.

Rust Equivalent

Rust models a path as its own type. A borrowed, unsized view is Path (the &str of the path world); an owned, growable buffer is PathBuf (the String of the path world). The pairing is exactly the str/String relationship from the basics.

1
use std::path::{Path, PathBuf};
2

3
fn main() {
4
    // Build a path from segments — push mutates a PathBuf in place.
5
    let mut path = PathBuf::from("/var/log");
6
    path.push("app");
7
    path.push("today.log");
8
    println!("{}", path.display()); // /var/log/app/today.log
9

10
    // Or chain `join`, which returns a fresh PathBuf each time.
11
    let p = Path::new("/var/log").join("app").join("today.log");
12
    println!("{}", p.display()); // /var/log/app/today.log
13

14
    // Pull a path apart — every accessor returns an Option.
15
    let file = Path::new("/home/ada/notes/todo.txt");
16
    println!("{:?}", file.file_name()); // Some("todo.txt")
17
    println!("{:?}", file.file_stem()); // Some("todo")
18
    println!("{:?}", file.extension()); // Some("txt")  — note: no leading dot
19
    println!("{:?}", file.parent());    // Some("/home/ada/notes")
20
}

1
$ cargo run --quiet
2
/var/log/app/today.log
3
/var/log/app/today.log
4
Some("todo.txt")
5
Some("todo")
6
Some("txt")
7
Some("/home/ada/notes")

And here is the output-path helper, the direct equivalent of the TypeScript outputPath function:

1
use std::path::{Path, PathBuf};
2

3
/// Mirror `file` (which lives under `src_root`) into `out_root`,
4
/// swapping its extension. Returns `None` if `file` is not under `src_root`.
5
fn output_path(src_root: &Path, out_root: &Path, file: &Path, new_ext: &str) -> Option<PathBuf> {
6
    let rel = file.strip_prefix(src_root).ok()?; // strip the source root
7
    let mut dest = out_root.join(rel);           // re-root under output
8
    dest.set_extension(new_ext);                 // swap extension in place
9
    Some(dest)
10
}
11

12
fn main() {
13
    let dest = output_path(
14
        Path::new("content"),
15
        Path::new("public"),
16
        Path::new("content/blog/hello.md"),
17
        "html",
18
    );
19
    println!("{:?}", dest.map(|p| p.display().to_string()));
20
    // Some("public/blog/hello.html")
21
}

1
$ cargo run --quiet
2
Some("public/blog/hello.html")

Detailed Explanation

`Path` vs `PathBuf` (and why there are two)

The split mirrors str vs String exactly:

Path is a borrowed, unsized slice type. You almost always handle it behind a reference, &Path. Path::new("…") is a zero-cost view over an existing string; it allocates nothing.
PathBuf is the owned, heap-allocated, growable version. push, set_extension, and set_file_name all mutate it in place; from, join, and with_extension create new ones.

A &PathBuf automatically coerces to &Path (via Deref), so you write functions that take &Path and call them with either type. That is the same pattern as accepting &str so you can pass both &String and string literals.

Joining is not always concatenation

PathBuf::push and Path::join add a component, inserting the platform separator for you. But there is one rule that surprises every newcomer: pushing an absolute path replaces the whole buffer.

1
use std::path::Path;
2

3
fn main() {
4
    let weird = Path::new("/etc").join("/usr/local");
5
    println!("{}", weird.display()); // /usr/local — NOT /etc/usr/local
6
}

1
$ cargo run --quiet
2
/usr/local

Node’s path.join("/etc", "/usr/local") instead produces /etc/usr/local (it strips the leading slash and concatenates), whereas path.resolve("/etc", "/usr/local") produces /usr/local. Rust’s join behaves like Node’s resolve on this point, not like join. This is a deliberate safety property: if a later segment is absolute, it is taken to mean “start over from here,” which matters when one of the segments comes from user input or an environment variable.

Accessors return `Option`, and extensions have no dot

file_name, file_stem, extension, and parent all return Option because not every path has them: / has no file name, and Makefile has no extension. This is Rust pushing the “what if it’s missing?” question into the type system instead of letting you discover it via undefined at runtime.

Two details to internalize:

extension() does not include the leading dot. Rust gives you "txt"; Node’s path.extname gives you ".txt". Adjust your comparisons accordingly.
These accessors return &OsStr, not &str — see the next section.

1
use std::path::Path;
2

3
fn main() {
4
    // Multi-dot files: only the LAST segment is the extension.
5
    let archive = Path::new("backup.tar.gz");
6
    println!("{:?}", archive.file_stem()); // Some("backup.tar")
7
    println!("{:?}", archive.extension()); // Some("gz")
8

9
    // A leading-dot file is treated as a name, not an extension.
10
    let dot = Path::new(".gitignore");
11
    println!("{:?}", dot.file_name());     // Some(".gitignore")
12
    println!("{:?}", dot.file_stem());     // Some(".gitignore")
13
    println!("{:?}", dot.extension());     // None
14
}

1
$ cargo run --quiet
2
Some("backup.tar")
3
Some("gz")
4
Some(".gitignore")
5
Some(".gitignore")
6
None

Node agrees on these: path.extname("backup.tar.gz") is ".gz" and path.extname(".gitignore") is "" (empty). Good news — the semantics line up here.

`OsStr`, `to_str`, and `display`

A path on disk is not guaranteed to be valid UTF-8. On Unix a filename is an arbitrary sequence of bytes; on Windows it is UTF-16 that may contain unpaired surrogates. To model this honestly, path components are OsStr/OsString (the OS-native string type), not str/String. JavaScript pretends this problem does not exist and hands you a (possibly lossy) UTF-16 string; Rust makes the lossiness explicit:

path.to_str() -> Option<&str> — Some only if the path is valid UTF-8, None otherwise. Use this when you want to refuse non-UTF-8 paths.
path.to_string_lossy() -> Cow<str> — always succeeds, replacing invalid sequences with the U+FFFD replacement character. Use this for display when you would rather show something than fail.
path.display() — returns a helper whose Display impl is lossy in the same way; use it inside println!("{}", path.display()). A Path does not implement Display directly, precisely so you cannot accidentally print one without acknowledging the lossiness.

1
use std::path::Path;
2

3
fn main() {
4
    let p = Path::new("/srv/www/index.html");
5
    match p.to_str() {
6
        Some(s) => println!("utf-8: {s}"),
7
        None => println!("path is not valid UTF-8"),
8
    }
9
    println!("{}", p.to_string_lossy()); // /srv/www/index.html
10
}

1
$ cargo run --quiet
2
utf-8: /srv/www/index.html
3
/srv/www/index.html

Inspecting and comparing paths by component

Path offers structural queries that operate on whole components, not raw substrings:

1
use std::path::Path;
2

3
fn main() {
4
    let abs = Path::new("/srv/www/app/index.html");
5

6
    println!("{}", abs.is_absolute());            // true
7
    println!("{}", abs.starts_with("/srv/www"));  // true (component-wise)
8

9
    match abs.strip_prefix("/srv/www") {
10
        Ok(rel) => println!("{}", rel.display()), // app/index.html
11
        Err(_) => println!("not under that prefix"),
12
    }
13

14
    // ends_with matches trailing COMPONENTS, not a substring.
15
    println!("{}", abs.ends_with("index.html"));      // true
16
    println!("{}", abs.ends_with(".html"));           // false!
17
    println!("{}", abs.ends_with("app/index.html"));  // true
18

19
    // Walk the path one component at a time.
20
    print!("components:");
21
    for comp in Path::new("/usr/local/bin").components() {
22
        print!(" {comp:?}");
23
    }
24
    println!();
25
}

1
$ cargo run --quiet
2
true
3
true
4
app/index.html
5
false
6
true
7
components: RootDir Normal("usr") Normal("local") Normal("bin")

The ends_with(".html") == false result is the headline surprise for a JavaScript developer: this is not String.prototype.endsWith. Path::ends_with asks “does this path end with these whole components?”, so .html (which is not a complete final component) does not match. To test a file extension, use extension(), not ends_with.

Key Differences

Concern	Node `path` (strings)	Rust `std::path`
Core type	plain `string`	`&Path` (borrowed) / `PathBuf` (owned)
Join a segment	`path.join(a, b)`	`a.join(b)` / `buf.push(b)`
Join with absolute segment	`join` concatenates; `resolve` restarts	`join`/`push` restart (like `resolve`)
File name	`path.basename(p)` → `string`	`p.file_name()` → `Option<&OsStr>`
Name without extension	`path.basename(p, ext)` / `parse().name`	`p.file_stem()` → `Option<&OsStr>`
Extension	`path.extname(p)` → `".txt"` (with dot)	`p.extension()` → `Some("txt")` (no dot)
Directory	`path.dirname(p)`	`p.parent()` → `Option<&Path>`
Everything at once	`path.parse(p)`	combine `file_stem` + `extension` + `parent`
Make relative	`path.relative(from, to)`	`p.strip_prefix(base)` → `Result`
Separator	`path.sep`	`std::path::MAIN_SEPARATOR{,_STR}`
Force a platform	`path.win32` / `path.posix`	always native; no in-API override
Missing piece	`undefined` / `""` at runtime	`None` / `Err` in the type
Non-UTF-8 path	silently lossy	explicit `OsStr` + `to_str`/`to_string_lossy`

Cross-platform behavior

std::path always targets the platform you compile for. On Unix the separator is /; on Windows the API accepts both / and \ as separators and also understands drive prefixes like C: and UNC paths (\\server\share). The components() iterator normalizes all of this into typed Component values (RootDir, Prefix, Normal, ParentDir, CurDir), so your matching logic is portable without if (process.platform === "win32") branches.

1
use std::path::{MAIN_SEPARATOR, MAIN_SEPARATOR_STR};
2

3
fn main() {
4
    // On Unix this prints '/'; on Windows it would print '\\'.
5
    println!("{MAIN_SEPARATOR:?}");
6
    println!("{MAIN_SEPARATOR_STR:?}");
7
}

1
$ cargo run --quiet
2
'/'
3
"/"

Unlike Node, the Rust standard library does not expose win32/posix sub-modules to manipulate foreign-platform paths from the current platform. If you genuinely need to parse Windows paths on Unix (rare — usually a sign you should store data differently), reach for a crate such as typed-path. For normal CLI tools, just use std::path and let it pick the right behavior per target.

Common Pitfalls

Trying to build paths with string concatenation

A JavaScript habit is to glue paths together with +. Path/PathBuf do not implement Add, so this fails at compile time:

1
use std::path::Path;
2

3
fn main() {
4
    let dir = Path::new("/var/log");
5
    let logfile = dir + "/app.log"; // does not compile (error[E0369])
6
    println!("{}", logfile.display());
7
}

1
$ cargo build
2
error[E0369]: cannot add `&str` to `&Path`
3
 --> src/main.rs:6:23
4
  |
5
6 |     let logfile = dir + "/app.log";
6
  |                   --- ^ ---------- &str
7
  |                   |
8
  |                   &Path

The fix is dir.join("app.log"). Note you pass "app.log", not "/app.log" — a leading slash would make the segment absolute and (per the rule above) discard /var/log entirely.

Comparing an extension against a `&str` with the leading dot

extension() yields Option<&OsStr>, so comparing it directly with Some("png") (a &str) is a type error, and even when you fix the type you must remember there is no leading dot:

1
use std::path::Path;
2

3
fn main() {
4
    let p = Path::new("photo.png");
5
    if p.extension() == Some("png") {   // does not compile (error[E0308])
6
        println!("it's a png");
7
    }
8
}

1
$ cargo build
2
error[E0308]: mismatched types
3
 --> src/main.rs:6:30
4
  |
5
6 |     if p.extension() == Some("png") {   // does not compile (error[E0308])
6
  |                         ---- ^^^^^ expected `&OsStr`, found `&str`
7
  |                         |
8
  |                         arguments to this enum variant are incorrect
9
  |
10
  = note: expected reference `&OsStr`
11
             found reference `&'static str`

The idiomatic fix — which also handles case-insensitivity, something === ".png" in JavaScript silently gets wrong — looks like this:

1
use std::path::Path;
2

3
fn is_png(path: &Path) -> bool {
4
    path.extension()
5
        .map(|e| e.eq_ignore_ascii_case("png"))
6
        .unwrap_or(false)
7
}
8

9
fn main() {
10
    println!("{}", is_png(Path::new("photo.PNG"))); // true
11
    println!("{}", is_png(Path::new("notes.md")));  // false
12
    println!("{}", is_png(Path::new("Makefile")));  // false
13
}

1
$ cargo run --quiet
2
true
3
false
4
false

If you only need an exact, case-sensitive match, path.extension() == Some(std::ffi::OsStr::new("png")) also works.

Assuming `set_extension` appends like a string

set_extension("html") replaces the existing extension; it does not append. report.md becomes report.html, not report.md.html. To add a second extension on purpose (e.g. app.log → app.log.gz), build the new file name explicitly rather than calling set_extension. Likewise, with_extension returns a new PathBuf and leaves the original untouched — handy when the source path is borrowed and you cannot mutate it.

Reaching for `canonicalize` when you just want to normalize

std::fs::canonicalize resolves ., .., and symlinks into a real absolute path — but it touches the filesystem and errors if the path does not exist. It is not a pure string operation like Node’s path.normalize. For purely lexical normalization without hitting disk, iterate components() yourself or use the path-clean crate. (On Windows, canonicalize also returns a verbatim \\?\ prefix that surprises many programs; the dunce crate exists specifically to strip it.)

Best Practices

Accept impl AsRef<Path> in your function signatures. This lets callers pass a &str, String, &Path, or PathBuf interchangeably — the path analogue of taking &str. Convert once at the top with .as_ref().

1
use std::path::{Path, PathBuf};
2

3
fn log_path(base: impl AsRef<Path>, name: &str) -> PathBuf {
4
    base.as_ref().join(name).with_extension("log")
5
}
6

7
fn main() {
8
    println!("{}", log_path("/var/log", "app").display());        // &str
9
    println!("{}", log_path(String::from("/tmp"), "session").display()); // String
10
    println!("{}", log_path(Path::new("logs"), "errors").display());     // &Path
11
}

1
$ cargo run --quiet
2
/var/log/app.log
3
/tmp/session.log
4
logs/errors.log

Store PathBuf, pass &Path. Keep owned paths in your structs and config; take &Path (or impl AsRef<Path>) in functions. Cloning a PathBuf allocates, so borrow when you can — see Ownership.
Never hardcode / or \. Use join/push so the right separator is chosen per platform. If you must show a literal separator in a message, use MAIN_SEPARATOR_STR.
Decide your non-UTF-8 policy explicitly. Use to_str() (returns Option) when a non-UTF-8 path is an error you want to surface, and to_string_lossy() only for human-facing display.
Use display() for printing, never to_str().unwrap(). The latter panics on the (admittedly rare) non-UTF-8 path; display() degrades gracefully.
Validate untrusted path input before joining. Reject .. components and absolute paths so a user-supplied “filename” cannot escape your working directory (see the directory-traversal exercise below).

Real-World Example

A common CLI chore: given a source tree and an output directory, compute where each file should land after a conversion step, mirroring the directory structure and swapping the extension. This is the core of a static-site generator, an asset transpiler, or a backup tool. It exercises strip_prefix, join, set_extension, and Option/Result handling together.

1
use std::path::{Path, PathBuf};
2

3
/// Compute the output path for `file` by mirroring its location below
4
/// `src_root` into `out_root` and swapping the extension to `new_ext`.
5
/// Returns `None` when `file` does not actually live under `src_root`,
6
/// so callers can skip or report stray inputs instead of producing nonsense.
7
fn output_path(
8
    src_root: &Path,
9
    out_root: &Path,
10
    file: &Path,
11
    new_ext: &str,
12
) -> Option<PathBuf> {
13
    let rel = file.strip_prefix(src_root).ok()?;
14
    let mut dest = out_root.join(rel);
15
    dest.set_extension(new_ext);
16
    Some(dest)
17
}
18

19
fn main() {
20
    let src_root = Path::new("content");
21
    let out_root = Path::new("public");
22

23
    let inputs = [
24
        "content/index.md",
25
        "content/blog/hello-world.md",
26
        "content/blog/nested/deep.md",
27
        "elsewhere/strange.md", // not under src_root
28
    ];
29

30
    for input in inputs {
31
        let file = Path::new(input);
32
        match output_path(src_root, out_root, file, "html") {
33
            Some(dest) => println!("{input:<35} -> {}", dest.display()),
34
            None => println!("{input:<35} -> (skipped: outside source root)"),
35
        }
36
    }
37
}

1
$ cargo run --quiet
2
content/index.md                    -> public/index.html
3
content/blog/hello-world.md         -> public/blog/hello-world.html
4
content/blog/nested/deep.md         -> public/blog/nested/deep.html
5
elsewhere/strange.md                -> (skipped: outside source root)

Notice how the “this file isn’t under the root I expected” case is a None you must handle, not a silently wrong string. In the TypeScript version, path.relative("content", "elsewhere/strange.md") returns "../elsewhere/strange.md", which would then be re-rooted into public/../elsewhere/strange.html — a bug that escapes your output directory and that nothing forces you to notice.

Exercises

Exercise 1: Classify files by extension

Difficulty: Easy

Objective: Write a function classify(path: &Path) -> &'static str that returns "image", "video", "text", "other", or "no extension" based on a file’s extension, matching case-insensitively.

Instructions:

Pull the extension with extension() and convert it to a &str.
Lowercase it and match on the known groups.
Handle the no-extension case (e.g. Makefile) by returning "no extension".

Solution

1
use std::path::Path;
2

3
fn classify(path: &Path) -> &'static str {
4
    match path.extension().and_then(|e| e.to_str()) {
5
        Some(ext) => match ext.to_ascii_lowercase().as_str() {
6
            "png" | "jpg" | "jpeg" | "gif" | "webp" => "image",
7
            "mp4" | "mov" | "mkv" => "video",
8
            "md" | "txt" | "rst" => "text",
9
            _ => "other",
10
        },
11
        None => "no extension",
12
    }
13
}
14

15
fn main() {
16
    for f in ["a.PNG", "clip.mp4", "README.md", "Makefile", "archive.tar.gz"] {
17
        println!("{f:<16} -> {}", classify(Path::new(f)));
18
    }
19
}

1
$ cargo run --quiet
2
a.PNG            -> image
3
clip.mp4         -> video
4
README.md        -> text
5
Makefile         -> no extension
6
archive.tar.gz   -> other

extension() for archive.tar.gz is "gz", which isn’t in any group, so it lands in "other" — a reminder that Rust only treats the final segment as the extension.

Exercise 2: A traversal-safe join

Difficulty: Medium

Objective: Write safe_join(base: &Path, user_input: &str) -> Option<PathBuf> that joins user-supplied input under base but refuses anything that could escape base (absolute paths, .., drive prefixes, or a root segment).

Instructions:

Reject the input outright if Path::new(user_input).is_absolute().
Iterate components() and reject if you see a Component::ParentDir, Component::RootDir, or Component::Prefix.
Otherwise return Some(base.join(user_input)).

Solution

1
use std::path::{Component, Path, PathBuf};
2

3
fn safe_join(base: &Path, user_input: &str) -> Option<PathBuf> {
4
    let candidate = Path::new(user_input);
5
    if candidate.is_absolute() {
6
        return None;
7
    }
8
    for comp in candidate.components() {
9
        if matches!(
10
            comp,
11
            Component::ParentDir | Component::RootDir | Component::Prefix(_)
12
        ) {
13
            return None;
14
        }
15
    }
16
    Some(base.join(candidate))
17
}
18

19
fn main() {
20
    let base = Path::new("/srv/uploads");
21
    for input in ["avatar.png", "img/cat.jpg", "../../etc/passwd", "/etc/passwd"] {
22
        match safe_join(base, input) {
23
            Some(p) => println!("{input:<20} -> {}", p.display()),
24
            None => println!("{input:<20} -> rejected"),
25
        }
26
    }
27
}

1
$ cargo run --quiet
2
avatar.png           -> /srv/uploads/avatar.png
3
img/cat.jpg          -> /srv/uploads/img/cat.jpg
4
../../etc/passwd     -> rejected
5
/etc/passwd          -> rejected

This is the kind of check a file-serving CLI or upload handler needs. Matching on typed Component values is portable: the same code rejects a Windows drive prefix (Component::Prefix) without any cfg!(windows) branching.

Exercise 3: Count files by extension

Difficulty: Medium

Objective: Given a slice of path strings, build a sorted report of how many files share each (lowercased) extension, with a (none) bucket for extensionless files.

Instructions:

Use a BTreeMap<String, usize> so the output comes out sorted by extension.
For each path, derive the key from extension() (lowercased) or (none) when there is no extension.
Increment the count with the entry API and print each ext count pair.

Solution

1
use std::collections::BTreeMap;
2
use std::path::Path;
3

4
fn main() {
5
    let files = [
6
        "src/main.rs",
7
        "src/lib.rs",
8
        "README.md",
9
        "docs/guide.md",
10
        "assets/logo.png",
11
        "Makefile",
12
    ];
13

14
    let mut counts: BTreeMap<String, usize> = BTreeMap::new();
15
    for f in files {
16
        let key = Path::new(f)
17
            .extension()
18
            .and_then(|e| e.to_str())
19
            .map(|e| e.to_ascii_lowercase())
20
            .unwrap_or_else(|| "(none)".to_string());
21
        *counts.entry(key).or_insert(0) += 1;
22
    }
23

24
    for (ext, n) in &counts {
25
        println!("{ext:<8} {n}");
26
    }
27
}

1
$ cargo run --quiet
2
(none)   1
3
md       2
4
png      1
5
rs       2

The BTreeMap keeps the keys ordered, so (none) sorts first and the extensions follow alphabetically. Swap in a HashMap if you do not care about ordering — see Collections for the trade-offs.

Path and PathBuf: Cross-Platform Path Handling

Quick Overview

TypeScript/JavaScript Example

Rust Equivalent

Detailed Explanation

Path vs PathBuf (and why there are two)

Joining is not always concatenation

Accessors return Option, and extensions have no dot

OsStr, to_str, and display

Inspecting and comparing paths by component

Key Differences

Cross-platform behavior

Common Pitfalls

Trying to build paths with string concatenation

Comparing an extension against a &str with the leading dot

Assuming set_extension appends like a string

Reaching for canonicalize when you just want to normalize

Best Practices

Real-World Example

Further Reading

Exercises

Exercise 1: Classify files by extension

Exercise 2: A traversal-safe join

Exercise 3: Count files by extension

`Path` vs `PathBuf` (and why there are two)

Accessors return `Option`, and extensions have no dot

`OsStr`, `to_str`, and `display`

Comparing an extension against a `&str` with the leading dot

Assuming `set_extension` appends like a string

Reaching for `canonicalize` when you just want to normalize