Class Uri

Readonlyauthority

Readonlyfragment

ReadonlyfsPath

const u = URI.parse('file://server/c$/folder/file.txt')
u.authority === 'server'
u.path === '/c$/folder/file.txt'
u.fsPath === '\\server\c$\folder\file.txt'
Copy

Readonlypath

Readonlyquery

Readonlyscheme

toJSON

• toJSON(): any

  Returns a JSON representation of this Uri.

  Returns any

  An object.

toString

• toString(skipEncoding?: boolean): string

  Returns a string representation of this Uri. The representation and normalization of a URI depends on the scheme.

  • The resulting string can be safely used with Uri.parse.
  • The resulting string shall not be used for display purposes.

  Note that the implementation will encode aggressive which often leads to unexpected, but not incorrect, results. For instance, colons are encoded to %3A which might be unexpected in file-uri. Also & and = will be encoded which might be unexpected for http-uris. For stability reasons this cannot be changed anymore. If you suffer from too aggressive encoding you should use the skipEncoding-argument: uri.toString(true).

  Parameters

  • OptionalskipEncoding: boolean

    Do not percentage-encode the result, defaults to false. Note that the # and ? characters occurring in the path will always be encoded.

  Returns string

  A string representation of this Uri.

with

• with(
      change: {
          authority?: string;
          fragment?: string;
          path?: string;
          query?: string;
          scheme?: string;
      },
  ): Uri

  Derive a new Uri from this Uri.

  let file = Uri.parse('before:some/file/path');
  let other = file.with({ scheme: 'after' });
  assert.ok(other.toString() === 'after:some/file/path');
  Copy

  Parameters

  • change: {
        authority?: string;
        fragment?: string;
        path?: string;
        query?: string;
        scheme?: string;
    }

    An object that describes a change to this Uri. To unset components use null or the empty string.

    • Optionalauthority?: string

      The new authority, defaults to this Uri's authority.

    • Optionalfragment?: string

      The new fragment, defaults to this Uri's fragment.

    • Optionalpath?: string

      The new path, defaults to this Uri's path.

    • Optionalquery?: string

      The new query, defaults to this Uri's query.

    • Optionalscheme?: string

      The new scheme, defaults to this Uri's scheme.

  Returns Uri

  A new Uri that reflects the given change. Will return this Uri if the change is not changing anything.

Staticfile

• file(path: string): Uri

  Create an URI from a file system path. The scheme will be file.

  The difference between Uri.parse and Uri.file is that the latter treats the argument as path, not as stringified-uri. E.g. Uri.file(path) is not the same as Uri.parse('file://' + path) because the path might contain characters that are interpreted (# and ?). See the following sample:

  const good = URI.file('/coding/c#/project1');
  good.scheme === 'file';
  good.path === '/coding/c#/project1';
  good.fragment === '';
  
  const bad = URI.parse('file://' + '/coding/c#/project1');
  bad.scheme === 'file';
  bad.path === '/coding/c'; // path is now broken
  bad.fragment === '/project1';
  Copy

  Parameters

  • path: string

    A file system or UNC path.

  Returns Uri

  A new Uri instance.

Staticfrom

• from(
      components: {
          authority?: string;
          fragment?: string;
          path?: string;
          query?: string;
          scheme: string;
      },
  ): Uri

  Create an URI from its component parts

  Parameters

  • components: {
        authority?: string;
        fragment?: string;
        path?: string;
        query?: string;
        scheme: string;
    }

    The component parts of an Uri.

    • Optional Readonlyauthority?: string

      The authority of the uri

    • Optional Readonlyfragment?: string

      The fragment identifier of the uri

    • Optional Readonlypath?: string

      The path of the uri

    • Optional Readonlyquery?: string

      The query string of the uri

    • Readonlyscheme: string

      The scheme of the uri

  Returns Uri

  A new Uri instance.

  See

  Function.toString

StaticjoinPath

• joinPath(base: Uri, ...pathSegments: string[]): Uri

  Create a new uri which path is the result of joining the path of the base uri with the provided path segments.

  • Note 1: joinPath only affects the path component and all other components (scheme, authority, query, and fragment) are left as they are.
  • Note 2: The base uri must have a path; an error is thrown otherwise.

  The path segments are normalized in the following ways:

  • sequences of path separators (/ or \) are replaced with a single separator
  • for file-uris on windows, the backslash-character (``) is considered a path-separator
  • the ..-segment denotes the parent segment, the . denotes the current segment
  • paths have a root which always remains, for instance on windows drive-letters are roots so that is true: joinPath(Uri.file('file:///c:/root'), '../../other').fsPath === 'c:/other'

  Parameters

  • base: Uri

    An uri. Must have a path.

  • ...pathSegments: string[]

    One more more path fragments

  Returns Uri

  A new uri which path is joined with the given fragments

Staticparse

• parse(value: string, strict?: boolean): Uri

  Create an URI from a string, e.g. http://www.example.com/some/path, file:///usr/home, or scheme:with/path.

  Note that for a while uris without a scheme were accepted. That is not correct as all uris should have a scheme. To avoid breakage of existing code the optional strict-argument has been added. We strongly advise to use it, e.g. Uri.parse('my:uri', true)

  Parameters

  • value: string

    The string value of an Uri.

  • Optionalstrict: boolean

    Throw an error when value is empty or when no scheme can be parsed.

  Returns Uri

  A new Uri instance.

  See

  Function.toString