BuildDocsReferenceGuidesBlog
Discord logo
Discord
GitHub logo
Bun

Node.js module

path

The 'node:path' module provides utilities for working with file and directory paths, including join, resolve, basename, and dirname.

It normalizes path separators, handles relative paths, and provides platform-specific adjustments for POSIX and Windows paths.

Works in Bun

Fully implemented. 100% of Node.js's test suite passes.

    • interface FormatInputPathObject

      • base?: string

        The file name including extension (if any) such as 'index.html'

      • dir?: string

        The full directory path such as '/home/user/dir' or 'c:\path\dir'

      • ext?: string

        The file extension (if any) such as '.html'

      • name?: string

        The file name without extension (if any) such as 'index'

      • root?: string

        The root of the path such as '/' or 'c:'

    • interface ParsedPath

      A parsed path object generated by path.parse() or consumed by path.format().

      • base: string

        The file name including extension (if any) such as 'index.html'

      • dir: string

        The full directory path such as '/home/user/dir' or 'c:\path\dir'

      • ext: string

        The file extension (if any) such as '.html'

      • name: string

        The file name without extension (if any) such as 'index'

      • root: string

        The root of the path such as '/' or 'c:'

    • const delimiter: ';' | ':'

      The platform-specific file delimiter. ';' or ':'.

    • const sep: '\' | '/'

      The platform-specific file separator. '\' or '/'.

    • function basename(
      path: string,
      suffix?: string
      ): string;

      Return the last portion of a path. Similar to the Unix basename command. Often used to extract the file name from a fully qualified path.

      @param path

      the path to evaluate.

      @param suffix

      optionally, an extension to remove from the result.

    • function dirname(
      path: string
      ): string;

      Return the directory name of a path. Similar to the Unix dirname command.

      @param path

      the path to evaluate.

    • function extname(
      path: string
      ): string;

      Return the extension of the path, from the last '.' to end of string in the last portion of the path. If there is no '.' in the last portion of the path or the first character of it is '.', then it returns an empty string.

      @param path

      the path to evaluate.

    • function format(
      pathObject: FormatInputPathObject
      ): string;

      Returns a path string from an object - the opposite of parse().

      @param pathObject

      path to evaluate.

    • function isAbsolute(
      path: string
      ): boolean;

      Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.

      If the given {path} is a zero-length string, false will be returned.

      @param path

      path to test.

    • function join(
      ...paths: string[]
      ): string;

      Join all arguments together and normalize the resulting path.

      @param paths

      paths to join.

    • function matchesGlob(
      path: string,
      pattern: string
      ): boolean;

      The path.matchesGlob() method determines if path matches the pattern.

      @param path

      The path to glob-match against.

      @param pattern

      The glob to check the path against.

      @returns

      Whether or not the path matched the pattern.

    • function normalize(
      path: string
      ): string;

      Normalize a string path, reducing '..' and '.' parts. When multiple slashes are found, they're replaced by a single one; when the path contains a trailing slash, it is preserved. On Windows backslashes are used. If the path is a zero-length string, '.' is returned, representing the current working directory.

      @param path

      string path to normalize.

    • function parse(
      path: string

      Returns an object from a path string - the opposite of format().

      @param path

      path to evaluate.

    • function relative(
      from: string,
      to: string
      ): string;

      Solve the relative path from {from} to {to} based on the current working directory. At times we have two absolute paths, and we need to derive the relative path from one to the other. This is actually the reverse transform of path.resolve.

    • function resolve(
      ...paths: string[]
      ): string;

      The right-most parameter is considered {to}. Other parameters are considered an array of {from}.

      Starting from leftmost {from} parameter, resolves {to} to an absolute path.

      If {to} isn't already absolute, {from} arguments are prepended in right to left order, until an absolute path is found. If after using all {from} paths still no absolute path is found, the current working directory is used as well. The resulting path is normalized, and trailing slashes are removed unless the path gets resolved to the root directory.

      @param paths

      A sequence of paths or path segments.

    • path: string
      ): string;

      On Windows systems only, returns an equivalent namespace-prefixed path for the given path. If path is not a string, path will be returned without modifications. This method is meaningful only on Windows system. On POSIX systems, the method is non-operational and always returns path without modifications.