Interface PlatformPath

Hierarchy

PlatformPath

Index

Properties

delimiter posix sep win32

Methods

basename dirname extname format isAbsolute join normalize parse relative resolve toNamespacedPath

Properties

`Readonly` delimiter

delimiter: string

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

`Readonly` posix

posix: PlatformPath

Posix specific pathing. Same as parent object on posix.

`Readonly` sep

sep: string

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

`Readonly` win32

win32: PlatformPath

Windows specific pathing. Same as parent object on windows

Methods

basename

basename(p: string, ext?: 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.
Parameters
- p: string
  
  the path to evaluate.
- Optional ext: string
  
  optionally, an extension to remove from the result.
Returns string

dirname

dirname(p: string): string

Return the directory name of a path. Similar to the Unix dirname command.
Parameters
- p: string
  
  the path to evaluate.
Returns string

extname

extname(p: 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
Parameters
- p: string
  
  the path to evaluate.
Returns string

format

format(pP: FormatInputPathObject): string

Returns a path string from an object - the opposite of parse().
Parameters
- pP: FormatInputPathObject
Returns string

isAbsolute

isAbsolute(p: string): boolean

Determines whether {path} is an absolute path. An absolute path will always resolve to the same location, regardless of the working directory.
Parameters
- p: string
Returns boolean

join

join(...paths: string[]): string

Join all arguments together and normalize the resulting path. Arguments must be strings. In v0.8, non-string arguments were silently ignored. In v0.10 and up, an exception is thrown.
Parameters
- Rest ...paths: string[]
  
  paths to join.
Returns string

normalize

normalize(p: 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.
Parameters
- p: string
  
  string path to normalize.
Returns string

parse

parse(p: string): ParsedPath

Returns an object from a path string - the opposite of format().
Parameters
- p: string
Returns ParsedPath

relative

relative(from: string, to: string): string

Solve the relative path from {from} to {to}. 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.
Parameters
- from: string
- to: string
Returns string

resolve

resolve(...pathSegments: 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.
Parameters
- Rest ...pathSegments: string[]
  
  string paths to join. Non-string arguments are ignored.
Returns string

toNamespacedPath

toNamespacedPath(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.
Parameters
- path: string
Returns string

Generated using TypeDoc