URL

[稳定版: 2 - 稳定版]

源代码: lib/url.js

node:url 模块提供 URL 解析和处理的实用工具。可以使用以下方式访问：

ESMCJS

import url from 'node:url'

const url = require('node:url')

URL 字符串和 URL 对象

URL 字符串是一个包含多个有意义组件的结构化字符串。解析后，将返回一个 URL 对象，其中包含这些组件的属性。

node:url 模块提供两种用于处理 URL 的 API：一种是特定于 Node.js 的旧版 API，另一种是实现与 Web 浏览器使用的相同 WHATWG URL 标准的较新 API。

以下是 WHATWG 和旧版 API 之间的比较。在 URL 'https://user:[email protected]:8080/p/a/t/h?query=string#hash' 上方，显示了旧版 url.parse() 返回的对象的属性。在其下方是 WHATWG URL 对象的属性。

WHATWG URL 的 origin 属性包含 protocol 和 host，但不包含 username 或 password。

text

┌────────────────────────────────────────────────────────────────────────────────────────────────┐
│                                              href                                              │
├──────────┬──┬─────────────────────┬────────────────────────┬───────────────────────────┬───────┤
│ protocol │  │        auth         │          host          │           path            │ hash  │
│          │  │                     ├─────────────────┬──────┼──────────┬────────────────┤       │
│          │  │                     │    hostname     │ port │ pathname │     search     │       │
│          │  │                     │                 │      │          ├─┬──────────────┤       │
│          │  │                     │                 │      │          │ │    query     │       │
"  https:   //    user   :   pass   @ sub.example.com : 8080   /p/a/t/h  ?  query=string   #hash "
│          │  │          │          │    hostname     │ port │          │                │       │
│          │  │          │          ├─────────────────┴──────┤          │                │       │
│ protocol │  │ username │ password │          host          │          │                │       │
├──────────┴──┼──────────┴──────────┼────────────────────────┤          │                │       │
│   origin    │                     │         origin         │ pathname │     search     │ hash  │
├─────────────┴─────────────────────┴────────────────────────┴──────────┴────────────────┴───────┤
│                                              href                                              │
└────────────────────────────────────────────────────────────────────────────────────────────────┘
(""行中的所有空格应忽略。它们纯粹用于格式化。)

使用 WHATWG API 解析 URL 字符串：

const myURL = new URL('https://user::8080/p/a/t/h?query=string#hash')

使用旧版 API 解析 URL 字符串：

ESMCJS

import url from 'node:url'
const myURL = url.parse('https://user::8080/p/a/t/h?query=string#hash')

const url = require('node:url')
const myURL = url.parse('https://user::8080/p/a/t/h?query=string#hash')

通过组件构建 URL 并获取构建后的字符串

可以使用属性设置器或模板字面量字符串来从组件构建 WHATWG URL：

const myURL = new URL('https://example.org')
myURL.pathname = '/a/b/c'
myURL.search = '?d=e'
myURL.hash = '#fgh'

const pathname = '/a/b/c'
const search = '?d=e'
const hash = '#fgh'
const myURL = new URL(`https://example.org${pathname}${search}${hash}`)

要获取构建后的 URL 字符串，请使用 href 属性访问器：

console.log(myURL.href)

WHATWG URL API

类: `URL`

[历史]

版本	变更
v10.0.0	此类现在可在全局对象上使用。
v7.0.0, v6.13.0	新增于：v7.0.0, v6.13.0

浏览器兼容的 URL 类，通过遵循 WHATWG URL 标准实现。已解析 URL 的示例可在标准本身中找到。URL 类也可在全局对象上使用。

根据浏览器约定，URL 对象的所有属性都作为类原型上的 getter 和 setter 实现，而不是作为对象本身上的数据属性。因此，与旧版 urlObject 不同，在 URL 对象的任何属性上使用 delete 关键字（例如 delete myURL.protocol、delete myURL.pathname 等）都不会产生任何效果，但仍会返回 true。

`new URL(input[, base])`

[历史]

版本	变更
v20.0.0, v18.17.0	已移除 ICU 要求。

input <字符串> 要解析的绝对或相对输入 URL。如果 input 是相对 URL，则需要 base。如果 input 是绝对 URL，则忽略 base。如果 input 不是字符串，则首先将其转换为字符串。
base <字符串> 如果 input 不是绝对 URL，则相对于其解析的基准 URL。如果 base 不是字符串，则首先将其转换为字符串。

通过相对于 base 解析 input 来创建一个新的 URL 对象。如果 base 以字符串形式传递，则其解析方式等同于 new URL(base)。

const myURL = new URL('/foo', 'https://example.org/')
// https://example.org/foo

URL 构造函数可在全局对象上作为属性访问。它也可以从内置的 url 模块导入：

ESMCJS

import { URL } from 'node:url'
console.log(URL === globalThis.URL) // 打印 'true'。

console.log(URL === require('node:url').URL) // 打印 'true'。

如果 input 或 base 不是有效的 URL，则会抛出 TypeError。请注意，将尝试强制将给定值转换为字符串。例如：

const myURL = new URL({ toString: () => 'https://example.org/' })
// https://example.org/

input 主机名中出现的 Unicode 字符将使用Punycode 算法自动转换为 ASCII。

const myURL = new URL('https://測試')
// https://xn--g6w251d/

如果事先不知道 input 是否为绝对 URL 并提供了 base，建议验证 URL 对象的 origin 是否符合预期。

let myURL = new URL('http://Example.com/', 'https://example.org/')
// http://example.com/

myURL = new URL('https://Example.com/', 'https://example.org/')
// https://example.com/

myURL = new URL('foo://Example.com/', 'https://example.org/')
// foo://Example.com/

myURL = new URL('http:Example.com/', 'https://example.org/')
// http://example.com/

myURL = new URL('https:Example.com/', 'https://example.org/')
// https://example.org/Example.com/

myURL = new URL('foo:Example.com/', 'https://example.org/')
// foo:Example.com/

`url.hash`

<字符串>

获取和设置 URL 的片段部分。

const myURL = new URL('https://example.org/foo#bar')
console.log(myURL.hash)
// 输出 #bar

myURL.hash = 'baz'
console.log(myURL.href)
// 输出 https://example.org/foo#baz

分配给 hash 属性的值中包含的无效 URL 字符将进行百分比编码。进行百分比编码的字符选择可能与 url.parse() 和 url.format() 方法生成的字符略有不同。

`url.host`

<字符串>

获取和设置 URL 的主机部分。

const myURL = new URL('https://example.org:81/foo')
console.log(myURL.host)
// 输出 example.org:81

myURL.host = 'example.com:82'
console.log(myURL.href)
// 输出 https://example.com:82/foo

分配给 host 属性的无效主机值将被忽略。

`url.hostname`

<字符串>

获取和设置 URL 的主机名部分。url.host 和 url.hostname 的主要区别在于 url.hostname 不包含端口。

const myURL = new URL('https://example.org:81/foo')
console.log(myURL.hostname)
// 打印 example.org

// 设置 hostname 不会改变端口
myURL.hostname = 'example.com'
console.log(myURL.href)
// 打印 https://example.com:81/foo

// 使用 myURL.host 来改变 hostname 和端口
myURL.host = 'example.org:82'
console.log(myURL.href)
// 打印 https://example.org:82/foo

为 hostname 属性赋值无效的主机名值将被忽略。

`url.href`

<字符串>

获取和设置序列化后的 URL。

const myURL = new URL('https://example.org/foo')
console.log(myURL.href)
// 打印 https://example.org/foo

myURL.href = 'https://example.com/bar'
console.log(myURL.href)
// 打印 https://example.com/bar

获取 href 属性的值等同于调用 url.toString()。

将此属性的值设置为新值等同于使用 new URL(value) 创建一个新的 URL 对象。URL 对象的每个属性都将被修改。

如果赋给 href 属性的值不是有效的 URL，则会抛出 TypeError。

`url.origin`

[历史]

版本	变更
v15.0.0	"gopher" 方案不再特殊，`url.origin` 现在为其返回 `'null'`。

<字符串>

获取 URL 原点的只读序列化结果。

const myURL = new URL('https://example.org/foo/bar?baz')
console.log(myURL.origin)
// 输出 https://example.org

const idnURL = new URL('https://測試')
console.log(idnURL.origin)
// 输出 https://xn--g6w251d

console.log(idnURL.hostname)
// 输出 xn--g6w251d

`url.password`

<字符串>

获取和设置 URL 的密码部分。

const myURL = new URL('https://abc:')
console.log(myURL.password)
// Prints xyz

myURL.password = '123'
console.log(myURL.href)
// Prints https://abc:/

赋值给 password 属性的值中包含的无效 URL 字符将进行百分比编码。进行百分比编码的字符的选择可能与 url.parse() 和 url.format() 方法生成的字符略有不同。

`url.pathname`

<字符串>

获取和设置 URL 的路径部分。

const myURL = new URL('https://example.org/abc/xyz?123')
console.log(myURL.pathname)
// 打印 /abc/xyz

myURL.pathname = '/abcdef'
console.log(myURL.href)
// 打印 https://example.org/abcdef?123

分配给 pathname 属性的值中包含的无效 URL 字符将进行百分比编码。哪些字符需要百分比编码的选择可能与 url.parse() 和 url.format() 方法生成的有所不同。

`url.port`

[历史]

版本	变更
v15.0.0	"gopher" 方案不再特殊。

<字符串>

获取和设置 URL 的端口部分。

端口值可以是数字，也可以是包含 0 到 65535（含）范围内数字的字符串。将值设置为给定 protocol 的 URL 对象的默认端口将导致 port 值变为空字符串 ('')。

端口值可以为空字符串，在这种情况下，端口取决于协议/方案：

协议	端口
"ftp"	21
"file"
"http"	80
"https"	443
"ws"	80
"wss"	443

分配值给端口后，该值将首先使用 .toString() 转换为字符串。

如果该字符串无效，但以数字开头，则将前导数字分配给 port。如果该数字超出上面表示的范围，则忽略它。

const myURL = new URL('https://example.org:8888')
console.log(myURL.port)
// 打印 8888

// 默认端口会自动转换为空字符串
// (HTTPS 协议的默认端口是 443)
myURL.port = '443'
console.log(myURL.port)
// 打印空字符串
console.log(myURL.href)
// 打印 https://example.org/

myURL.port = 1234
console.log(myURL.port)
// 打印 1234
console.log(myURL.href)
// 打印 https://example.org:1234/

// 完全无效的端口字符串将被忽略
myURL.port = 'abcd'
console.log(myURL.port)
// 打印 1234

// 前导数字被视为端口号
myURL.port = '5678abcd'
console.log(myURL.port)
// 打印 5678

// 非整数将被截断
myURL.port = 1234.5678
console.log(myURL.port)
// 打印 1234

// 超出范围的数字（未用科学计数法表示）
// 将被忽略。
myURL.port = 1e10 // 10000000000，将按如下所述进行范围检查
console.log(myURL.port)
// 打印 1234

包含小数点的数字，例如浮点数或科学计数法中的数字，并非此规则的例外。前导数字（直到小数点）将设置为 URL 的端口，假设它们有效：

myURL.port = 4.567e21
console.log(myURL.port)
// 打印 4（因为它是字符串 '4.567e21' 中的前导数字）

`url.protocol`

<字符串>

获取和设置 URL 的协议部分。

const myURL = new URL('https://example.org')
console.log(myURL.protocol)
// 打印 https:

myURL.protocol = 'ftp'
console.log(myURL.href)
// 打印 ftp://example.org/

为 protocol 属性分配无效的 URL 协议值将被忽略。

特殊方案

[历史]

版本	变更
v15.0.0	"gopher" 方案不再是特殊的。

WHATWG URL 标准认为少数 URL 协议方案在解析和序列化方面是特殊的。当使用这些特殊协议之一解析 URL 时，url.protocol 属性可能会更改为另一个特殊协议，但不能更改为非特殊协议，反之亦然。

例如，从 http 更改为 https 可以正常工作：

const u = new URL('http://example.org')
u.protocol = 'https'
console.log(u.href)
// https://example.org/

但是，从 http 更改为假设的 fish 协议则不行，因为新协议不是特殊的。

const u = new URL('http://example.org')
u.protocol = 'fish'
console.log(u.href)
// http://example.org/

同样，从非特殊协议更改为特殊协议也不允许：

const u = new URL('fish://example.org')
u.protocol = 'http'
console.log(u.href)
// fish://example.org

根据 WHATWG URL 标准，特殊协议方案为 ftp、file、http、https、ws 和 wss。

`url.search`

<字符串>

获取和设置 URL 的序列化查询部分。

const myURL = new URL('https://example.org/abc?123')
console.log(myURL.search)
// 打印 ?123

myURL.search = 'abc=xyz'
console.log(myURL.href)
// 打印 https://example.org/abc?abc=xyz

赋值给 search 属性的任何无效 URL 字符都将进行百分比编码。进行百分比编码的字符选择可能与 url.parse() 和 url.format() 方法生成的字符略有不同。

`url.searchParams`

<URLSearchParams>

获取表示 URL 查询参数的 URLSearchParams 对象。此属性是只读的，但它提供的 URLSearchParams 对象可用于更改 URL 实例；要替换 URL 的全部查询参数，请使用 url.search 设置器。有关详细信息，请参阅 URLSearchParams 文档。

使用 .searchParams 修改 URL 时要小心，因为根据 WHATWG 规范，URLSearchParams 对象使用不同的规则来确定要对哪些字符进行百分比编码。例如，URL 对象不会对 ASCII 波浪号 (~) 字符进行百分比编码，而 URLSearchParams 始终会对其进行编码：

const myURL = new URL('https://example.org/abc?foo=~bar')

console.log(myURL.search) // 打印 ?foo=~bar

// 通过 searchParams 修改 URL...
myURL.searchParams.sort()

console.log(myURL.search) // 打印 ?foo=%7Ebar

`url.username`

<字符串>

获取和设置 URL 的用户名部分。

const myURL = new URL('https://abc:')
console.log(myURL.username)
// 输出 abc

myURL.username = '123'
console.log(myURL.href)
// 输出 https://123:/

分配给 username 属性的任何无效 URL 字符都将进行百分比编码。百分比编码的字符选择可能与 url.parse() 和 url.format() 方法产生的结果略有不同。

`url.toString()`

返回值: <字符串>

URL 对象上的 toString() 方法返回序列化的 URL。返回值等效于 url.href 和 url.toJSON() 的值。

`url.toJSON()`

新增于：v7.7.0, v6.13.0

返回值：<string>

URL 对象上的 toJSON() 方法返回序列化后的 URL。返回值等同于 url.href 和 url.toString()。

当使用 JSON.stringify() 序列化 URL 对象时，会自动调用此方法。

const myURLs = [new URL('https://www.example.com'), new URL('https://test.example.org')]
console.log(JSON.stringify(myURLs))
// 输出 ["https://www.example.com/","https://test.example.org/"]

`URL.createObjectURL(blob)`

新增于：v16.7.0

[稳定性：1 - 实验性]

稳定性：1 稳定性：1 - 实验性

blob <Blob>
返回值：<string>

创建一个 'blob:nodedata:...' URL 字符串，该字符串表示给定的 <Blob> 对象，并可用于稍后检索该 Blob。

const { Blob, resolveObjectURL } = require('node:buffer')

const blob = new Blob(['hello'])
const id = URL.createObjectURL(blob)

// 稍后...

const otherBlob = resolveObjectURL(id)
console.log(otherBlob.size)

已注册的 <Blob> 对象存储的数据将保留在内存中，直到调用 URL.revokeObjectURL()将其移除。

Blob 对象在当前线程中注册。如果使用 Worker 线程，则在一个 Worker 中注册的 Blob 对象将无法用于其他 Worker 或主线程。

`URL.revokeObjectURL(id)`

新增于：v16.7.0

[稳定性：1 - 实验性]

稳定性：1 稳定性：1 - 实验性

id <字符串> 由先前对 URL.createObjectURL() 的调用返回的 'blob:nodedata:... URL 字符串。

移除由给定 ID 标识的已存储 <Blob>。尝试撤销未注册的 ID 将会静默失败。

`URL.canParse(input[, base])`

新增于：v19.9.0, v18.17.0

input <字符串> 要解析的绝对或相对输入 URL。如果 input 是相对的，则需要 base。如果 input 是绝对的，则忽略 base。如果 input 不是字符串，则首先将其转换为字符串。
base <字符串> 如果 input 不是绝对的，则要解析的基准 URL。如果 base 不是字符串，则首先将其转换为字符串。
返回值： <布尔值>

检查相对于 base 的 input 是否可以解析为 URL。

const isValid = URL.canParse('/foo', 'https://example.org/') // true

const isNotValid = URL.canParse('/foo') // false

`URL.parse(input[, base])`

新增于: v22.1.0

input <字符串> 要解析的绝对或相对输入 URL。如果 input 是相对 URL，则需要 base。如果 input 是绝对 URL，则忽略 base。如果 input 不是字符串，则首先将其转换为字符串。
base <字符串> 如果 input 不是绝对 URL，则作为解析依据的基准 URL。如果 base 不是字符串，则首先将其转换为字符串。
返回值: <URL> | <null>

将字符串解析为 URL。如果提供了 base，它将用作解析非绝对 input URL 的基准 URL。如果 input 无效，则返回 null。

类: `URLSearchParams`

[历史]

版本	变更
v10.0.0	此类现在可在全局对象上使用。
v7.5.0, v6.13.0	添加于：v7.5.0, v6.13.0

URLSearchParams API 提供了对 URL 查询的读写访问。URLSearchParams 类也可以独立使用，并可以使用以下四种构造函数之一。URLSearchParams 类也存在于全局对象上。

WHATWG URLSearchParams 接口和 querystring 模块具有相似的用途，但querystring 模块的用途更通用，因为它允许自定义分隔符字符（& 和 =）。另一方面，此 API 纯粹用于 URL 查询字符串。

const myURL = new URL('https://example.org/?abc=123')
console.log(myURL.searchParams.get('abc'))
// 输出 123

myURL.searchParams.append('abc', 'xyz')
console.log(myURL.href)
// 输出 https://example.org/?abc=123&abc=xyz

myURL.searchParams.delete('abc')
myURL.searchParams.set('a', 'b')
console.log(myURL.href)
// 输出 https://example.org/?a=b

const newSearchParams = new URLSearchParams(myURL.searchParams)
// 以上等同于
// const newSearchParams = new URLSearchParams(myURL.search);

newSearchParams.append('a', 'c')
console.log(myURL.href)
// 输出 https://example.org/?a=b
console.log(newSearchParams.toString())
// 输出 a=b&a=c

// newSearchParams.toString() 被隐式调用
myURL.search = newSearchParams
console.log(myURL.href)
// 输出 https://example.org/?a=b&a=c
newSearchParams.delete('a')
console.log(myURL.href)
// 输出 https://example.org/?a=b&a=c

`new URLSearchParams()`

实例化一个新的空 URLSearchParams 对象。

`new URLSearchParams(string)`

string <字符串> 一个查询字符串

将 string 解析为查询字符串，并用它来实例化一个新的 URLSearchParams 对象。如果存在前导 '?'，则会被忽略。

let params

params = new URLSearchParams('user=abc&query=xyz')
console.log(params.get('user'))
// 打印 'abc'
console.log(params.toString())
// 打印 'user=abc&query=xyz'

params = new URLSearchParams('?user=abc&query=xyz')
console.log(params.toString())
// 打印 'user=abc&query=xyz'

`new URLSearchParams(obj)`

新增于：v7.10.0, v6.13.0

obj <对象> 一个表示键值对集合的对象

使用查询哈希映射实例化一个新的 URLSearchParams 对象。obj 的每个属性的键和值始终被强制转换为字符串。

与 querystring 模块不同，不允许以数组值形式出现重复键。数组使用 array.toString() 进行字符串化，它只是用逗号连接所有数组元素。

const params = new URLSearchParams({
  user: 'abc',
  query: ['first', 'second'],
})
console.log(params.getAll('query'))
// 打印 [ 'first,second' ]
console.log(params.toString())
// 打印 'user=abc&query=first%2Csecond'

`new URLSearchParams(iterable)`

新增于：v7.10.0, v6.13.0

iterable <Iterable> 一个其元素为键值对的可迭代对象

以类似于Map 构造函数的方式，使用可迭代映射实例化一个新的 URLSearchParams 对象。iterable 可以是 Array 或任何可迭代对象。这意味着 iterable 可以是另一个 URLSearchParams，在这种情况下，构造函数将简单地创建一个提供的 URLSearchParams 的克隆。iterable 的元素是键值对，本身也可以是任何可迭代对象。

允许重复键。

let params

// 使用数组
params = new URLSearchParams([
  ['user', 'abc'],
  ['query', 'first'],
  ['query', 'second'],
])
console.log(params.toString())
// 输出 'user=abc&query=first&query=second'

// 使用 Map 对象
const map = new Map()
map.set('user', 'abc')
map.set('query', 'xyz')
params = new URLSearchParams(map)
console.log(params.toString())
// 输出 'user=abc&query=xyz'

// 使用生成器函数
function* getQueryPairs() {
  yield ['user', 'abc']
  yield ['query', 'first']
  yield ['query', 'second']
}
params = new URLSearchParams(getQueryPairs())
console.log(params.toString())
// 输出 'user=abc&query=first&query=second'

// 每个键值对必须恰好包含两个元素
new URLSearchParams([['user', 'abc', 'error']])
// 抛出 TypeError [ERR_INVALID_TUPLE]:
//        每个查询对必须是一个可迭代的 [name, value] 元组

`urlSearchParams.append(name, value)`

name <字符串>
value <字符串>

向查询字符串追加新的名称-值对。

`urlSearchParams.delete(name[, value])`

[历史]

版本	变更
v20.2.0, v18.18.0	添加对可选 `value` 参数的支持。

name <字符串>
value <字符串>

如果提供了 value，则删除所有名称为 name 且值为 value 的名称-值对。

如果未提供 value，则删除所有名称为 name 的名称-值对。

`urlSearchParams.entries()`

返回值: <迭代器>

返回查询中每个名称-值对的 ES6 迭代器。迭代器的每一项都是一个 JavaScript 数组。数组 的第一项是 name，第二项是 value。

urlSearchParams[@@iterator]() 的别名。

`urlSearchParams.forEach(fn[, thisArg])`

[历史]

版本	变更
v18.0.0	向 `fn` 参数传递无效回调现在会抛出 `ERR_INVALID_ARG_TYPE` 而不是 `ERR_INVALID_CALLBACK`。

fn <函数> 为查询中的每个名称-值对调用
thisArg <对象> 用作调用 fn 时的 this 值

迭代查询中的每个名称-值对并调用给定的函数。

const myURL = new URL('https://example.org/?a=b&c=d')
myURL.searchParams.forEach((value, name, searchParams) => {
  console.log(name, value, myURL.searchParams === searchParams)
})
// 输出：
//   a b true
//   c d true

`urlSearchParams.get(name)`

name <字符串>
返回值: <字符串> | <null> 如果没有名称为 name 的名称-值对，则返回字符串或 null。

返回名称为 name 的第一个名称-值对的值。如果没有这样的对，则返回 null。

`urlSearchParams.getAll(name)`

name <string>
返回值: <string[]>

返回所有名称为 name 的键值对的值。如果没有这样的键值对，则返回一个空数组。

`urlSearchParams.has(name[, value])`

[历史]

版本	变更
v20.2.0, v18.18.0	添加对可选 `value` 参数的支持。

name <string>
value <string>
返回值: <boolean>

根据 name 和可选的 value 参数检查 URLSearchParams 对象是否包含键值对。

如果提供了 value，则当存在名称和值相同的键值对时返回 true。

如果没有提供 value，则如果至少存在一个名称为 name 的键值对，则返回 true。

`urlSearchParams.keys()`

返回值: <迭代器>

返回一个包含每个键值对名称的 ES6 迭代器。

const params = new URLSearchParams('foo=bar&foo=baz')
for (const name of params.keys()) {
  console.log(name)
}
// 打印：
//   foo
//   foo

`urlSearchParams.set(name, value)`

name <字符串>
value <字符串>

将 URLSearchParams 对象中与 name 关联的值设置为 value。如果存在任何名称为 name 的现有键值对，则将第一个此类键值对的值设置为 value 并删除所有其他键值对。如果没有，则将键值对添加到查询字符串。

const params = new URLSearchParams()
params.append('foo', 'bar')
params.append('foo', 'baz')
params.append('abc', 'def')
console.log(params.toString())
// 打印 foo=bar&foo=baz&abc=def

params.set('foo', 'def')
params.set('xyz', 'opq')
console.log(params.toString())
// 打印 foo=def&abc=def&xyz=opq

`urlSearchParams.size`

新增于：v19.8.0, v18.16.0

参数条目的总数。

`urlSearchParams.sort()`

新增于：v7.7.0, v6.13.0

按名称对所有现有的键值对进行就地排序。排序使用稳定排序算法，因此具有相同名称的键值对之间的相对顺序将保留。

此方法尤其可以用来增加缓存命中率。

const params = new URLSearchParams('query[]=abc&type=search&query[]=123')
params.sort()
console.log(params.toString())
// 输出 query%5B%5D=abc&query%5B%5D=123&type=search

`urlSearchParams.toString()`

返回值：<string>

返回序列化为字符串的搜索参数，必要时对字符进行百分比编码。

`urlSearchParams.values()`

返回值：<Iterator>

返回每个键值对的值的 ES6 Iterator。

`urlSearchParams[Symbol.iterator]()`

返回值: <迭代器>

返回查询字符串中每个名称-值对的 ES6 迭代器。迭代器的每一项都是一个 JavaScript 数组。数组 的第一项是 名称，第二项是 值。

urlSearchParams.entries() 的别名。

const params = new URLSearchParams('foo=bar&xyz=baz')
for (const [name, value] of params) {
  console.log(name, value)
}
// 输出：
//   foo bar
//   xyz baz

`url.domainToASCII(domain)`

[历史]

版本	变更
v20.0.0, v18.17.0	已移除 ICU 要求。
v7.4.0, v6.13.0	新增于：v7.4.0, v6.13.0

domain <字符串>
返回值: <字符串>

返回 domain 的 Punycode ASCII 序列化。如果 domain 是无效域名，则返回空字符串。

它执行与 url.domainToUnicode() 相反的操作。

ESMCJS

import url from 'node:url'

console.log(url.domainToASCII('español.com'))
// 输出 xn--espaol-zwa.com
console.log(url.domainToASCII('中文.com'))
// 输出 xn--fiq228c.com
console.log(url.domainToASCII('xn--iñvalid.com'))
// 输出空字符串

const url = require('node:url')

console.log(url.domainToASCII('español.com'))
// 输出 xn--espaol-zwa.com
console.log(url.domainToASCII('中文.com'))
// 输出 xn--fiq228c.com
console.log(url.domainToASCII('xn--iñvalid.com'))
// 输出空字符串

`url.domainToUnicode(domain)`

[历史记录]

版本	变更
v20.0.0, v18.17.0	移除了 ICU 依赖。
v7.4.0, v6.13.0	v7.4.0, v6.13.0 版本中添加

domain <字符串>
返回值: <字符串>

返回 domain 的 Unicode 序列化结果。如果 domain 是无效域名，则返回空字符串。

它是 url.domainToASCII() 的逆运算。

ESMCJS

import url from 'node:url'

console.log(url.domainToUnicode('xn--espaol-zwa.com'))
// 打印 español.com
console.log(url.domainToUnicode('xn--fiq228c.com'))
// 打印 中文.com
console.log(url.domainToUnicode('xn--iñvalid.com'))
// 打印空字符串

const url = require('node:url')

console.log(url.domainToUnicode('xn--espaol-zwa.com'))
// 打印 español.com
console.log(url.domainToUnicode('xn--fiq228c.com'))
// 打印 中文.com
console.log(url.domainToUnicode('xn--iñvalid.com'))
// 打印空字符串

`url.fileURLToPath(url[, options])`

[历史]

版本	变更
v22.1.0, v20.13.0	`options` 参数现在可用于确定如何解析 `path` 参数。
v10.12.0	新增于：v10.12.0

url <URL> | <字符串> 要转换为路径的文件 URL 字符串或 URL 对象。
options <对象>
- windows <布尔值> | <未定义> 如果 path 应作为 Windows 文件路径返回，则为 true，如果是 POSIX 路径则为 false，系统默认值为 undefined。默认值：undefined。
返回值: <字符串> 完全解析的特定于平台的 Node.js 文件路径。

此函数确保正确解码百分比编码的字符，并确保跨平台有效的绝对路径字符串。

ESMCJS

import { fileURLToPath } from 'node:url'

const __filename = fileURLToPath(import.meta.url)

new URL('file:///C:/path/').pathname // 错误：/C:/path/
fileURLToPath('file:///C:/path/') // 正确：  C:\path\ (Windows)

new URL('file://nas/foo.txt').pathname // 错误：/foo.txt
fileURLToPath('file://nas/foo.txt') // 正确：  \\nas\foo.txt (Windows)

new URL('file:///你好.txt').pathname // 错误：/%E4%BD%A0%E5%A5%BD.txt
fileURLToPath('file:///你好.txt') // 正确：  /你好.txt (POSIX)

new URL('file:///hello world').pathname // 错误：/hello%20world
fileURLToPath('file:///hello world') // 正确：  /hello world (POSIX)

const { fileURLToPath } = require('node:url')
new URL('file:///C:/path/').pathname // 错误：/C:/path/
fileURLToPath('file:///C:/path/') // 正确：  C:\path\ (Windows)

new URL('file://nas/foo.txt').pathname // 错误：/foo.txt
fileURLToPath('file://nas/foo.txt') // 正确：  \\nas\foo.txt (Windows)

new URL('file:///你好.txt').pathname // 错误：/%E4%BD%A0%E5%A5%BD.txt
fileURLToPath('file:///你好.txt') // 正确：  /你好.txt (POSIX)

new URL('file:///hello world').pathname // 错误：/hello%20world
fileURLToPath('file:///hello world') // 正确：  /hello world (POSIX)

`url.format(URL[, options])`

新增于: v7.6.0

URL <URL> 一个 WHATWG URL 对象
options <Object>
- auth <boolean> 如果序列化后的 URL 字符串应该包含用户名和密码，则为 true，否则为 false。默认值: true。
- fragment <boolean> 如果序列化后的 URL 字符串应该包含片段，则为 true，否则为 false。默认值: true。
- search <boolean> 如果序列化后的 URL 字符串应该包含搜索查询，则为 true，否则为 false。默认值: true。
- unicode <boolean> 如果 URL 字符串的主机组件中出现的 Unicode 字符应该直接编码而不是进行 Punycode 编码，则为 true。默认值: false。
返回值: <string>

返回 WHATWG URL 对象的可定制的序列化 URL 字符串表示形式。

URL 对象同时具有 toString() 方法和 href 属性，它们返回 URL 的字符串序列化。但是，这些方法都不能进行任何自定义。url.format(URL[, options]) 方法允许对输出进行基本的自定义。

ESMCJS

import url from 'node:url'
const myURL = new URL('https://a:b@測試?abc#foo')

console.log(myURL.href)
// 输出 https://a:b@xn--g6w251d/?abc#foo

console.log(myURL.toString())
// 输出 https://a:b@xn--g6w251d/?abc#foo

console.log(url.format(myURL, { fragment: false, unicode: true, auth: false }))
// 输出 'https://測試/?abc'

const url = require('node:url')
const myURL = new URL('https://a:b@測試?abc#foo')

console.log(myURL.href)
// 输出 https://a:b@xn--g6w251d/?abc#foo

console.log(myURL.toString())
// 输出 https://a:b@xn--g6w251d/?abc#foo

console.log(url.format(myURL, { fragment: false, unicode: true, auth: false }))
// 输出 'https://測試/?abc'

`url.pathToFileURL(path[, options])`

[历史]

版本	变更
v22.1.0, v20.13.0	`options` 参数现在可以用来确定如何返回 `path` 值。
v10.12.0	新增于：v10.12.0

path <字符串> 要转换为文件 URL 的路径。
options <对象>
- windows <布尔值> | <未定义> 如果 path 应被视为 Windows 文件路径，则为 true，对于 POSIX 系统则为 false，对于系统默认值则为 undefined。默认值： undefined。
返回值： <URL> 文件 URL 对象。

此函数确保 path 被绝对解析，并且在转换为文件 URL 时 URL 控制字符被正确编码。

ESMCJS

import { pathToFileURL } from 'node:url'

new URL('/foo#1', 'file:') // 错误：file:///foo#1
pathToFileURL('/foo#1') // 正确：  file:///foo%231 (POSIX)

new URL('/some/path%.c', 'file:') // 错误：file:///some/path%.c
pathToFileURL('/some/path%.c') // 正确：  file:///some/path%25.c (POSIX)

const { pathToFileURL } = require('node:url')
new URL(__filename) // 错误：抛出异常 (POSIX)
new URL(__filename) // 错误：C:\... (Windows)
pathToFileURL(__filename) // 正确：  file:///... (POSIX)
pathToFileURL(__filename) // 正确：  file:///C:/... (Windows)

new URL('/foo#1', 'file:') // 错误：file:///foo#1
pathToFileURL('/foo#1') // 正确：  file:///foo%231 (POSIX)

new URL('/some/path%.c', 'file:') // 错误：file:///some/path%.c
pathToFileURL('/some/path%.c') // 正确：  file:///some/path%25.c (POSIX)

`url.urlToHttpOptions(url)`

[历史]

版本	变更
v19.9.0, v18.17.0	返回的对象也将包含 `url` 参数的所有自身可枚举属性。
v15.7.0, v14.18.0	新增于：v15.7.0, v14.18.0

url <URL> 要转换为选项对象的 WHATWG URL 对象。
返回值: <Object> 选项对象
- protocol <string> 要使用的协议。
- hostname <string> 要向其发出请求的服务器的域名或 IP 地址。
- hash <string> URL 的片段部分。
- search <string> URL 的序列化查询部分。
- pathname <string> URL 的路径部分。
- path <string> 请求路径。如果存在，应包含查询字符串。例如：'/index.html?page=12'。当请求路径包含非法字符时，会抛出异常。目前，只拒绝空格，但这在未来可能会改变。
- href <string> 序列化的 URL。
- port <number> 远程服务器的端口。
- auth <string> 基本身份验证，例如 'user:password'，用于计算授权标头。

ESMCJS

import { urlToHttpOptions } from 'node:url'
const myURL = new URL('https://a:b@測試?abc#foo')

console.log(urlToHttpOptions(myURL))
/*
{
  protocol: 'https:',
  hostname: 'xn--g6w251d',
  hash: '#foo',
  search: '?abc',
  pathname: '/',
  path: '/?abc',
  href: 'https://a:b@xn--g6w251d/?abc#foo',
  auth: 'a:b'
}
*/

const { urlToHttpOptions } = require('node:url')
const myURL = new URL('https://a:b@測試?abc#foo')

console.log(urlToHttpOptions(myURL))
/*
{
  protocol: 'https:',
  hostname: 'xn--g6w251d',
  hash: '#foo',
  search: '?abc',
  pathname: '/',
  path: '/?abc',
  href: 'https://a:b@xn--g6w251d/?abc#foo',
  auth: 'a:b'
}
*/

旧版 URL API

[历史]

版本	变更
v15.13.0, v14.17.0	取消弃用。状态更改为“旧版”。
v11.0.0	此 API 已弃用。

[稳定性: 3 - 旧版]

稳定性: 3 稳定性: 3 - 旧版：请改用 WHATWG URL API。

旧版 `urlObject`

[历史]

版本	变更
v15.13.0, v14.17.0	取消弃用。状态更改为“旧版”。
v11.0.0	旧版 URL API 已弃用。请使用 WHATWG URL API。

[稳定性: 3 - 旧版]

稳定性: 3 稳定性: 3 - 旧版：请改用 WHATWG URL API。

旧版 urlObject (require('node:url').Url 或 import { Url } from 'node:url') 由 url.parse() 函数创建并返回。

`urlObject.auth`

auth 属性是 URL 的用户名和密码部分，也称为 用户信息。此字符串子集位于 protocol 和双斜杠（如果存在）之后，host 组件之前，由 @ 分隔。该字符串要么是用户名，要么是用户名和密码，用 : 分隔。

例如：'user:pass'。

`urlObject.hash`

hash 属性是 URL 的片段标识符部分，包括前导的 # 字符。

例如：'#hash'。

`urlObject.host`

host 属性是 URL 的完整小写主机部分，如果指定了 port，则包括 port。

例如：'sub.example.com:8080'。

`urlObject.hostname`

hostname 属性是 host 组件的小写主机名部分，不包含 port。

例如：'sub.example.com'。

`urlObject.href`

href 属性是已解析的完整 URL 字符串，其 protocol 和 host 组件都已转换为小写。

例如：'http://user:[email protected]:8080/p/a/t/h?query=string#hash'。

`urlObject.path`

path 属性是 pathname 和 search 组件的串联。

例如：'/p/a/t/h?query=string'。

不会对 path 进行解码。

`urlObject.pathname`

pathname 属性包含 URL 的整个路径部分。这是 host（包括 port）之后以及 query 或 hash 组件开始之前的所有内容，由 ASCII 问号（?）或井号（#）字符分隔。

例如：'/p/a/t/h'。

不会对路径字符串进行解码。

`urlObject.port`

port 属性是 host 组件的数字端口部分。

例如：'8080'。

`urlObject.protocol`

protocol 属性标识 URL 的小写协议方案。

例如：'http:'。

`urlObject.query`

query 属性或者是没有前导 ASCII 问号 (?) 的查询字符串，或者是由 querystring 模块的 parse() 方法返回的对象。query 属性是字符串还是对象取决于传递给 url.parse() 的 parseQueryString 参数。

例如：'query=string' 或 {'query': 'string'}。

如果返回的是字符串，则不执行查询字符串的解码。如果返回的是对象，则键和值都会被解码。

`urlObject.search`

search 属性包含 URL 的整个“查询字符串”部分，包括前导 ASCII 问号 (?) 字符。

例如：'?query=string'。

不执行查询字符串的解码。

`urlObject.slashes`

slashes 属性是一个布尔值，如果在 protocol 后的冒号后需要两个 ASCII 正斜杠字符 (/)，则其值为 true。

`url.format(urlObject)`

[历史]

版本	变更
v17.0.0	现在在主机名的 Punycode 转换引入可能导致 URL 以不同方式重新解析的更改时，会抛出 `ERR_INVALID_URL` 异常。
v15.13.0, v14.17.0	弃用撤销。状态更改为“旧版”。
v11.0.0	旧版 URL API 已弃用。请使用 WHATWG URL API。
v7.0.0	使用 `file:` 方案的 URL 现在将始终使用正确的斜杠数量，而不管 `slashes` 选项如何。现在，在任何时候都将尊重没有协议的虚假 `slashes` 选项。
v0.1.25	新增于：v0.1.25

[稳定性：3 - 旧版]

稳定性：3 稳定性：3 - 旧版：请改用 WHATWG URL API。

urlObject <对象> | <字符串> 一个 URL 对象（由 url.parse() 返回或以其他方式构造）。如果是一个字符串，则通过将其传递给 url.parse() 来将其转换为对象。

url.format() 方法返回从 urlObject 派生的格式化 URL 字符串。

const url = require('node:url')
url.format({
  protocol: 'https',
  hostname: 'example.com',
  pathname: '/some/path',
  query: {
    page: 1,
    format: 'json',
  },
})

// => 'https://example.com/some/path?page=1&format=json'

如果 urlObject 不是对象或字符串，url.format() 将抛出 TypeError。

格式化过程如下：

创建一个新的空字符串 result。
如果 urlObject.protocol 是一个字符串，则按原样将其附加到 result。
否则，如果 urlObject.protocol 不是 undefined 且不是字符串，则会抛出 Error。
对于所有不以 ASCII 冒号 (:) 字符结尾的 urlObject.protocol 字符串值，字面字符串 : 将附加到 result。
如果以下任一条件为真，则字面字符串 // 将附加到 result：
- urlObject.slashes 属性为 true；
- urlObject.protocol 以 http、https、ftp、gopher 或 file 开头；
如果 urlObject.auth 属性的值为真值，并且 urlObject.host 或 urlObject.hostname 不是 undefined，则 urlObject.auth 的值将被强制转换为字符串并附加到 result，后跟字面字符串 @。
如果 urlObject.host 属性为 undefined，则：
- 如果 urlObject.hostname 是一个字符串，则将其附加到 result。
- 否则，如果 urlObject.hostname 不是 undefined 且不是字符串，则会抛出 Error。
- 如果 urlObject.port 属性值为真值，并且 urlObject.hostname 不为 undefined：
- 字面字符串 : 附加到 result，并且
- urlObject.port 的值被强制转换为字符串并附加到 result。
否则，如果 urlObject.host 属性的值为真值，则 urlObject.host 的值将被强制转换为字符串并附加到 result。
如果 urlObject.pathname 属性是一个非空字符串：
- 如果 urlObject.pathname 不以 ASCII 正斜杠 (/) 开头，则字面字符串 '/' 将附加到 result。
- urlObject.pathname 的值将附加到 result。
否则，如果 urlObject.pathname 不是 undefined 且不是字符串，则会抛出 Error。
如果 urlObject.search 属性为 undefined 并且 urlObject.query 属性为 Object，则字面字符串 ? 将附加到 result，后跟调用 querystring 模块的 stringify() 方法并将 urlObject.query 的值作为参数传递的结果。
否则，如果 urlObject.search 是一个字符串：
- 如果 urlObject.search 的值不以 ASCII 问号 (?) 字符开头，则字面字符串 ? 将附加到 result。
- urlObject.search 的值将附加到 result。
否则，如果 urlObject.search 不是 undefined 且不是字符串，则会抛出 Error。
如果 urlObject.hash 属性是一个字符串：
- 如果 urlObject.hash 的值不以 ASCII 井号 (#) 字符开头，则字面字符串 # 将附加到 result。
- urlObject.hash 的值将附加到 result。
否则，如果 urlObject.hash 属性不是 undefined 且不是字符串，则会抛出 Error。
返回 result。

`url.parse(urlString[, parseQueryString[, slashesDenoteHost]])`

[历史]

版本	变更
v19.0.0, v18.13.0	仅文档弃用。
v15.13.0, v14.17.0	撤销弃用。状态更改为“旧版”。
v11.14.0	返回的 URL 对象上的 `pathname` 属性现在在没有路径且协议方案为 `ws:` 或 `wss:` 时为 `/`。
v11.0.0	旧版 URL API 已弃用。请使用 WHATWG URL API。
v9.0.0	当没有查询字符串时，返回的 URL 对象上的 `search` 属性现在为 `null`。
v0.1.25	新增于：v0.1.25

[稳定性：0 - 已弃用]

稳定性：0 稳定性：0 - 已弃用：请改用 WHATWG URL API。

urlString <字符串> 要解析的 URL 字符串。
parseQueryString <布尔值> 如果为 true，则 query 属性将始终设置为 querystring 模块的 parse() 方法返回的对象。如果为 false，则返回的 URL 对象上的 query 属性将是一个未解析的、未解码的字符串。默认值： false。
slashesDenoteHost <布尔值> 如果为 true，则字面量字符串 // 之后并紧接下一个 / 之前的第一个标记将被解释为 host。例如，给定 //foo/bar，结果将为 {host: 'foo', pathname: '/bar'} 而不是 {pathname: '//foo/bar'}。默认值： false。

url.parse() 方法接收一个 URL 字符串，对其进行解析，并返回一个 URL 对象。

如果 urlString 不是字符串，则会抛出 TypeError。

如果 auth 属性存在但无法解码，则会抛出 URIError。

url.parse() 使用宽松的、非标准的算法来解析 URL 字符串。它容易出现安全问题，例如主机名欺骗和用户名和密码的错误处理。不要与不受信任的输入一起使用。不会为 url.parse() 漏洞发布 CVE。请改用 WHATWG URL API。

`url.resolve(from, to)`

[历史]

版本	变更
v15.13.0, v14.17.0	弃用撤销。状态更改为“旧版”。
v11.0.0	旧版 URL API 已弃用。请使用 WHATWG URL API。
v6.6.0	当 `from` 和 `to` 指向同一主机时，`auth` 字段现在保持不变。
v6.0.0	当 `to` 参数包含主机名时，`auth` 字段现在被清除。
v6.5.0, v4.6.2	`port` 字段现在被正确复制。
v0.1.25	新增于：v0.1.25

[稳定性：3 - 旧版]

稳定性：3 稳定性：3 - 旧版：请改用 WHATWG URL API。

from <字符串> 如果 to 是相对 URL，则使用其作为基准 URL。
to <字符串> 要解析的目标 URL。

url.resolve() 方法以类似于 Web 浏览器解析锚点标签的方式解析相对于基准 URL 的目标 URL。

const url = require('node:url')
url.resolve('/one/two/three', 'four') // '/one/two/four'
url.resolve('http://example.com/', '/one') // 'http://example.com/one'
url.resolve('http://example.com/one', '/two') // 'http://example.com/two'

要使用 WHATWG URL API 达到相同的结果：

function resolve(from, to) {
  const resolvedUrl = new URL(to, new URL(from, 'resolve://'))
  if (resolvedUrl.protocol === 'resolve:') {
    // `from` 是一个相对 URL。
    const { pathname, search, hash } = resolvedUrl
    return pathname + search + hash
  }
  return resolvedUrl.toString()
}

resolve('/one/two/three', 'four') // '/one/two/four'
resolve('http://example.com/', '/one') // 'http://example.com/one'
resolve('http://example.com/one', '/two') // 'http://example.com/two'

URL 中的百分号编码

URL 仅允许包含特定范围的字符。任何超出此范围的字符都必须进行编码。如何对这些字符进行编码，以及对哪些字符进行编码，完全取决于字符在 URL 结构中的位置。

传统 API

在传统 API 中，URL 对象属性中的空格（' '）和以下字符将自动转义：

text

< > " ` \r \n \t { } | \ ^ '

例如，ASCII 空格字符（' '）编码为 %20。ASCII 正斜杠（/）字符编码为 %3C。（译者注：原文此处有误，ASCII 正斜杠应编码为 %2F）

WHATWG API

WHATWG URL 标准使用比传统 API 更具选择性和细粒度的字符编码选择方法。

WHATWG 算法定义了四个“百分号编码集”，这些集合描述了必须进行百分号编码的字符范围：

C0 控制字符百分号编码集 包括 U+0000 到 U+001F（含）范围内的代码点以及所有大于 U+007E (~) 的代码点。
片段百分号编码集 包括 C0 控制字符百分号编码集 和代码点 U+0020 SPACE，U+0022 (")，U+003C (<)，U+003E (>) 和 U+0060 (`)。
路径百分号编码集 包括 C0 控制字符百分号编码集 和代码点 U+0020 SPACE，U+0022 (")，U+0023 (#)，U+003C (<)，U+003E (>)，U+003F (?)，U+0060 (`)，U+007B ({) 和 U+007D (})。
用户信息编码集 包括 路径百分号编码集 和代码点 U+002F (/)，U+003A (😃，U+003B (😉，U+003D (=)，U+0040 (@)，U+005B ([) 到 U+005E(^) 和 U+007C (|)。

用户信息百分号编码集 专门用于 URL 中编码的用户名和密码。路径百分号编码集 用于大多数 URL 的路径。片段百分号编码集 用于 URL 片段。C0 控制字符百分号编码集 用于主机和路径（在某些特定条件下），以及所有其他情况。

当非 ASCII 字符出现在主机名中时，主机名使用 Punycode 算法进行编码。但是，请注意，主机名可能同时包含 Punycode 编码和百分号编码的字符：

const myURL = new URL('https://%CF%80.example.com/foo')
console.log(myURL.href)
// 打印 https://xn--1xa.example.com/foo
console.log(myURL.origin)
// 打印 https://xn--1xa.example.com

URL ​

URL 字符串和 URL 对象 ​

通过组件构建 URL 并获取构建后的字符串 ​

WHATWG URL API ​

类: URL ​

new URL(input[, base]) ​

url.hash ​

url.host ​

url.hostname ​

url.href ​

url.origin ​

url.password ​

url.pathname ​

url.port ​

url.protocol ​

特殊方案 ​

url.search ​

url.searchParams ​

url.username ​

url.toString() ​

url.toJSON() ​

URL.createObjectURL(blob) ​

URL.revokeObjectURL(id) ​

URL.canParse(input[, base]) ​

URL.parse(input[, base]) ​

类: URLSearchParams ​

new URLSearchParams() ​

new URLSearchParams(string) ​

new URLSearchParams(obj) ​

new URLSearchParams(iterable) ​

urlSearchParams.append(name, value) ​

urlSearchParams.delete(name[, value]) ​

urlSearchParams.entries() ​

urlSearchParams.forEach(fn[, thisArg]) ​

urlSearchParams.get(name) ​

urlSearchParams.getAll(name) ​

urlSearchParams.has(name[, value]) ​

urlSearchParams.keys() ​

urlSearchParams.set(name, value) ​

urlSearchParams.size ​

urlSearchParams.sort() ​

urlSearchParams.toString() ​

urlSearchParams.values() ​

urlSearchParams[Symbol.iterator]() ​

url.domainToASCII(domain) ​

url.domainToUnicode(domain) ​

url.fileURLToPath(url[, options]) ​

url.format(URL[, options]) ​

url.pathToFileURL(path[, options]) ​

url.urlToHttpOptions(url) ​

旧版 URL API ​

旧版 urlObject ​

urlObject.auth ​

urlObject.hash ​

urlObject.host ​

urlObject.hostname ​

urlObject.href ​

urlObject.path ​

urlObject.pathname ​

urlObject.port ​

urlObject.protocol ​

urlObject.query ​

urlObject.search ​

urlObject.slashes ​

url.format(urlObject) ​

url.parse(urlString[, parseQueryString[, slashesDenoteHost]]) ​

url.resolve(from, to) ​

URL 中的百分号编码 ​

传统 API ​

WHATWG API ​

URL

URL 字符串和 URL 对象

通过组件构建 URL 并获取构建后的字符串

WHATWG URL API

类: `URL`

`new URL(input[, base])`

`url.hash`

`url.host`

`url.hostname`

`url.href`

`url.origin`

`url.password`

`url.pathname`

`url.port`

`url.protocol`

特殊方案

`url.search`

`url.searchParams`

`url.username`

`url.toString()`

`url.toJSON()`

`URL.createObjectURL(blob)`

`URL.revokeObjectURL(id)`

`URL.canParse(input[, base])`

`URL.parse(input[, base])`

类: `URLSearchParams`

`new URLSearchParams()`

`new URLSearchParams(string)`

`new URLSearchParams(obj)`

`new URLSearchParams(iterable)`

`urlSearchParams.append(name, value)`

`urlSearchParams.delete(name[, value])`

`urlSearchParams.entries()`

`urlSearchParams.forEach(fn[, thisArg])`

`urlSearchParams.get(name)`

`urlSearchParams.getAll(name)`

`urlSearchParams.has(name[, value])`

`urlSearchParams.keys()`

`urlSearchParams.set(name, value)`

`urlSearchParams.size`

`urlSearchParams.sort()`

`urlSearchParams.toString()`

`urlSearchParams.values()`

`urlSearchParams[Symbol.iterator]()`

`url.domainToASCII(domain)`

`url.domainToUnicode(domain)`

`url.fileURLToPath(url[, options])`

`url.format(URL[, options])`

`url.pathToFileURL(path[, options])`

`url.urlToHttpOptions(url)`

旧版 URL API

旧版 `urlObject`

`urlObject.auth`

`urlObject.hash`

`urlObject.host`

`urlObject.hostname`

`urlObject.href`

`urlObject.path`

`urlObject.pathname`

`urlObject.port`

`urlObject.protocol`

`urlObject.query`

`urlObject.search`

`urlObject.slashes`

`url.format(urlObject)`

`url.parse(urlString[, parseQueryString[, slashesDenoteHost]])`

`url.resolve(from, to)`

URL 中的百分号编码

传统 API

WHATWG API