Node.js v8.16.2 Documentation


URL#

url模块提供用于URL解析和解析的实用程序. 可以使用以下命令访问它:

const url = require('url');

URL Strings and URL Objects#

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

url模块提供了两个用于处理URL的API:一个是特定于Node.js的旧API,另一个是实现与Web浏览器使用的WHATWG URL标准相同的API.

注意 :虽然旧版API尚未弃用,但仅出于与现有应用程序向后兼容的目的对其进行维护. 新的应用程序代码应使用WHATWG API.

下面提供了WHATWG和Legacy API之间的比较. URL'http 'http://user: [email protected] :8080/p/a/t/h?query=string#hash' url.parse()显示了旧版url.parse()返回的对象的属性. 它的下面是WHATWG URL对象的属性.

注意 :WHATWG URL的origin属性包括protocolhost ,但不包括usernamepassword .

┌─────────────────────────────────────────────────────────────────────────────────────────────┐
│                                            href                                             │
├──────────┬──┬─────────────────────┬─────────────────────┬───────────────────────────┬───────┤
│ protocol │  │        auth         │        host         │           path            │ hash  │
│          │  │                     ├──────────────┬──────┼──────────┬────────────────┤       │
│          │  │                     │   hostname   │ port │ pathname │     search     │       │
│          │  │                     │              │      │          ├─┬──────────────┤       │
│          │  │                     │              │      │          │ │    query     │       │
"  https:   //    user   :   pass   @ sub.host.com : 8080   /p/a/t/h  ?  query=string   #hash "
│          │  │          │          │   hostname   │ port │          │                │       │
│          │  │          │          ├──────────────┴──────┤          │                │       │
│ protocol │  │ username │ password │        host         │          │                │       │
├──────────┴──┼──────────┴──────────┼─────────────────────┤          │                │       │
│   origin    │                     │       origin        │ pathname │     search     │ hash  │
├─────────────┴─────────────────────┴─────────────────────┴──────────┴────────────────┴───────┤
│                                            href                                             │
└─────────────────────────────────────────────────────────────────────────────────────────────┘
(all spaces in the "" line should be ignored — they are purely for formatting)

使用WHATWG API解析URL字符串:

const { URL } = require('url');
const myURL =
  new URL('https://user:[email protected]:8080/p/a/t/h?query=string#hash');

注意 :在Web浏览器中,WHATWG URL类是始终可用的全局变量. 但是,在Node.js中,必须通过require('url').URL访问URL类.

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

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

The WHATWG URL API#

Class: URL#

浏览器兼容的URL类,通过遵循WHATWG URL标准实现. 在标准本身中可以找到解析的URL的示例 .

注意 :根据浏览器约定, URL对象的所有属性都在类原型上实现为getter和setter,而不是对象本身的数据属性. 因此,与旧版urlObject不同,在URL对象的任何属性(例如delete myURL.protocoldelete myURL.pathname等)上使用delete关键字delete myURL.pathname ,但仍会返回true .

Constructor: new URL(input[, base])#

  • input <string>要解析的输入URL
  • base <string> | <URL> input不是绝对值时要解析的基本URL.

通过相对于base解析input来创建新的URL对象. 如果base作为字符串传递,它将被解析为与new URL(base)等效.

const { URL } = require('url');
const myURL = new URL('/foo', 'https://example.org/');
// https://example.org/foo

如果inputbase网址无效,则将引发TypeError . 注意,将努力将给定值强制转换为字符串. 例如:

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

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

const { URL } = require('url');
const myURL = new URL('https://你好你好');
// https://xn--6qqa088eba/

注意 :仅当node可执行文件在启用ICU的情况下编译时,此功能才可用. 如果不是,域名将原样传递.

url.hash#

获取并设置URL的片段部分.

const { URL } = require('url');
const myURL = new URL('https://example.org/foo#bar');
console.log(myURL.hash);
// Prints #bar

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

分配给hash属性的值中包含的无效URL字符采用百分比编码 . 请注意,对要百分比编码的字符的选择可能与url.parse()url.format()方法产生的结果有所不同.

url.host#

获取并设置URL的主机部分.

const { URL } = require('url');
const myURL = new URL('https://example.org:81/foo');
console.log(myURL.host);
// Prints example.org:81

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

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

url.hostname#

获取并设置URL的主机名部分. 之间的主要区别url.hosturl.hostnameurl.hostname 包括端口.

const { URL } = require('url');
const myURL = new URL('https://example.org:81/foo');
console.log(myURL.hostname);
// Prints example.org

myURL.hostname = 'example.com:82';
console.log(myURL.href);
// Prints https://example.com:81/foo

分配给hostname属性的无效主机名值将被忽略.

url.href#

获取并设置序列化的URL.

const { URL } = require('url');
const myURL = new URL('https://example.org/foo');
console.log(myURL.href);
// Prints https://example.org/foo

myURL.href = 'https://example.com/bar';
console.log(myURL.href);
// Prints https://example.com/bar

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

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

如果分配给href属性的值不是有效的URL,则将引发TypeError .

url.origin#

获取URL来源的只读序列化.

const { URL } = require('url');
const myURL = new URL('https://example.org/foo/bar?baz');
console.log(myURL.origin);
// Prints https://example.org
const { URL } = require('url');
const idnURL = new URL('https://你好你好');
console.log(idnURL.origin);
// Prints https://xn--6qqa088eba

console.log(idnURL.hostname);
// Prints xn--6qqa088eba

url.password#

获取并设置URL的密码部分.

const { URL } = require('url');
const myURL = new URL('https://abc:[email protected]');
console.log(myURL.password);
// Prints xyz

myURL.password = '123';
console.log(myURL.href);
// Prints https://abc:[email protected]

分配给password属性的值中包含的无效URL字符是百分比编码的 . 请注意,对要百分比编码的字符的选择可能与url.parse()url.format()方法产生的结果有所不同.

url.pathname#

获取并设置URL的路径部分.

const { URL } = require('url');
const myURL = new URL('https://example.org/abc/xyz?123');
console.log(myURL.pathname);
// Prints /abc/xyz

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

分配给pathname属性的值中包含的无效URL字符是百分比编码的 . 请注意,对要百分比编码的字符的选择可能与url.parse()url.format()方法产生的结果有所不同.

url.port#

获取并设置URL的端口部分.

const { URL } = require('url');
const myURL = new URL('https://example.org:8888');
console.log(myURL.port);
// Prints 8888

// Default ports are automatically transformed to the empty string
// (HTTPS protocol's default port is 443)
myURL.port = '443';
console.log(myURL.port);
// Prints the empty string
console.log(myURL.href);
// Prints https://example.org/

myURL.port = 1234;
console.log(myURL.port);
// Prints 1234
console.log(myURL.href);
// Prints https://example.org:1234/

// Completely invalid port strings are ignored
myURL.port = 'abcd';
console.log(myURL.port);
// Prints 1234

// Leading numbers are treated as a port number
myURL.port = '5678abcd';
console.log(myURL.port);
// Prints 5678

// Non-integers are truncated
myURL.port = 1234.5678;
console.log(myURL.port);
// Prints 1234

// Out-of-range numbers are ignored
myURL.port = 1e10;
console.log(myURL.port);
// Prints 1234

端口值可以设置为数字,也可以设置为包含065535 (含)之间数字的字符串. 该值设置为默认的端口URL给对象protocol将导致port值成为空字符串( '' ).

如果将无效的字符串分配给port属性,但是它以数字开头,则将前导数字分配给port . 否则,或者如果数字超出上述范围,则将其忽略.

url.protocol#

获取并设置URL的协议部分.

const { URL } = require('url');
const myURL = new URL('https://example.org');
console.log(myURL.protocol);
// Prints https:

myURL.protocol = 'ftp';
console.log(myURL.href);
// Prints ftp://example.org/

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

url.search#

获取并设置URL的序列化查询部分.

const { URL } = require('url');
const myURL = new URL('https://example.org/abc?123');
console.log(myURL.search);
// Prints ?123

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

在分配给search属性的值中出现的所有无效URL字符将被百分比编码 . 请注意,对要百分比编码的字符的选择可能与url.parse()url.format()方法产生的结果有所不同.

url.searchParams#

获取表示URL查询参数的URLSearchParams对象. 该属性是只读的; 要替换URL的整个查询参数,请使用url.search setter. 有关详细信息,请参见URLSearchParams文档.

url.username#

获取并设置URL的用户名部分.

const { URL } = require('url');
const myURL = new URL('https://abc:[email protected]');
console.log(myURL.username);
// Prints abc

myURL.username = '123';
console.log(myURL.href);
// Prints https://123:[email protected]/

在分配给username属性的值中出现的所有无效URL字符都将进行百分比编码 . 请注意,对要百分比编码的字符的选择可能与url.parse()url.format()方法产生的结果有所不同.

url.toString()#

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

由于需要符合标准,因此该方法不允许用户自定义URL的序列化过程. 为了获得更大的灵活性,可能require('url').format()方法.

url.toJSON()#

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

使用JSON.stringify()序列化URL对象时,将自动调用此方法.

const { URL } = require('url');
const myURLs = [
  new URL('https://www.example.com'),
  new URL('https://test.example.org')
];
console.log(JSON.stringify(myURLs));
// Prints ["https://www.example.com/","https://test.example.org/"]

Class: URLSearchParams#

URLSearchParams API提供对URL查询的读写访问. URLSearchParams类也可以与以下四个构造函数之一一起单独使用.

WHATWG URLSearchParams接口和querystring模块具有相似的用途,但是querystring模块的用途更为通用,因为它允许自定义分隔符( &= ). 另一方面,此API纯粹是为URL查询字符串设计的.

const { URL, URLSearchParams } = require('url');

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

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

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

const newSearchParams = new URLSearchParams(myURL.searchParams);
// The above is equivalent to
// const newSearchParams = new URLSearchParams(myURL.search);

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

// newSearchParams.toString() is implicitly called
myURL.search = newSearchParams;
console.log(myURL.href);
// Prints https://example.org/?a=b&a=c
newSearchParams.delete('a');
console.log(myURL.href);
// Prints https://example.org/?a=b&a=c

Constructor: new URLSearchParams()#

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

Constructor: new URLSearchParams(string)#

string解析为查询字符串,然后使用它实例化新的URLSearchParams对象. 领先的'?' (如果存在)被忽略.

const { URLSearchParams } = require('url');
let params;

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

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

Constructor: new URLSearchParams(obj)#

  • obj <Object> An object representing a collection of key-value pairs

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

注意 :与querystring模块不同,不允许使用数组值形式的重复键. 数组使用array.toString()进行字符串化,该数组仅将所有数组元素都用逗号连接.

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

Constructor: new URLSearchParams(iterable)#

  • iterable <Iterable>一个可迭代对象,其元素是键值对

使用类似于Map的构造函数的方式,使用可迭代的地图实例化新的URLSearchParams对象. iterable可以是Array或任何可迭代对象. 这意味着iterable可以是另一个URLSearchParams ,在这种情况下,构造函数将只创建所提供的URLSearchParams的副本. iterable元素是键值对,并且本身可以是任何可迭代的对象.

允许重复的密钥.

const { URLSearchParams } = require('url');
let params;

// Using an array
params = new URLSearchParams([
  ['user', 'abc'],
  ['query', 'first'],
  ['query', 'second']
]);
console.log(params.toString());
// Prints 'user=abc&query=first&query=second'

// Using a Map object
const map = new Map();
map.set('user', 'abc');
map.set('query', 'xyz');
params = new URLSearchParams(map);
console.log(params.toString());
// Prints 'user=abc&query=xyz'

// Using a generator function
function* getQueryPairs() {
  yield ['user', 'abc'];
  yield ['query', 'first'];
  yield ['query', 'second'];
}
params = new URLSearchParams(getQueryPairs());
console.log(params.toString());
// Prints 'user=abc&query=first&query=second'

// Each key-value pair must have exactly two elements
new URLSearchParams([
  ['user', 'abc', 'error']
]);
// Throws TypeError [ERR_INVALID_TUPLE]:
//        Each query pair must be an iterable [name, value] tuple

urlSearchParams.append(name, value)#

将新的名称/值对附加到查询字符串.

urlSearchParams.delete(name)#

删除所有名称-值对他的名字是name .

urlSearchParams.entries()#

在查询中的每个名称/值对上返回一个ES6迭代器. 迭代器的每一项都是一个JavaScript数组. 数组的第一项是name ,数组的第二项是value .

urlSearchParams[@@iterator]()别名.

urlSearchParams.forEach(fn[, thisArg])#

  • fn <Function>为查询中的每个名称/值对调用的函数.
  • thisArg <Object>在调用fn时用作this值的对象

遍历查询中的每个名称/值对,并调用给定的函数.

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

urlSearchParams.get(name)#

  • name <string>
  • 返回: <string>;如果不存在具有给定name名称/值对,则返回null .

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

urlSearchParams.getAll(name)#

返回名称为name的所有名称-值对的值. 如果没有这样的对,则返回一个空数组.

urlSearchParams.has(name)#

返回true ,如果至少有一个名称-值对他的名字是name .

urlSearchParams.keys()#

返回每个名称/值对的名称上的ES6迭代器.

const { URLSearchParams } = require('url');
const params = new URLSearchParams('foo=bar&foo=baz');
for (const name of params.keys()) {
  console.log(name);
}
// Prints:
//   foo
//   foo

urlSearchParams.set(name, value)#

将与name关联的URLSearchParams对象中的值设置为value . 如果存在名称为name任何先前的名称/值对,请将第一个此类的值对设置为value然后删除所有其他值对. 如果不是,请将名称/值对附加到查询字符串.

const { URLSearchParams } = require('url');

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

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

urlSearchParams.sort()#

按名称对所有现有的名称/值对进行排序. 排序是通过稳定的排序算法完成的 ,因此保留了具有相同名称的名称-值对之间的相对顺序.

该方法尤其可以用于增加缓存命中率.

const { URLSearchParams } = require('url');
const params = new URLSearchParams('query[]=abc&type=search&query[]=123');
params.sort();
console.log(params.toString());
// Prints query%5B%5D=abc&query%5B%5D=123&type=search

urlSearchParams.toString()#

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

urlSearchParams.values()#

返回每个名称/值对的值的ES6迭代器.

urlSearchParams[@@iterator]()#

在查询字符串中的每个名称/值对上返回一个ES6迭代器. 迭代器的每一项都是一个JavaScript数组. 数组的第一项是name ,数组的第二项是value .

urlSearchParams.entries()别名.

const { URLSearchParams } = require('url');
const params = new URLSearchParams('foo=bar&xyz=baz');
for (const [name, value] of params) {
  console.log(name, value);
}
// Prints:
//   foo bar
//   xyz baz

url.domainToASCII(domain)#

返回domainPunycode ASCII序列化. 如果domain是无效的域,则返回空字符串.

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

const url = require('url');
console.log(url.domainToASCII('español.com'));
// Prints xn--espaol-zwa.com
console.log(url.domainToASCII('中文.com'));
// Prints xn--fiq228c.com
console.log(url.domainToASCII('xn--iñvalid.com'));
// Prints an empty string

url.domainToUnicode(domain)#

返回domain的Unicode序列化. 如果domain是无效的域,则返回空字符串.

它对url.domainToASCII()执行相反的操作.

const url = require('url');
console.log(url.domainToUnicode('xn--espaol-zwa.com'));
// Prints español.com
console.log(url.domainToUnicode('xn--fiq228c.com'));
// Prints 中文.com
console.log(url.domainToUnicode('xn--iñvalid.com'));
// Prints an empty string

url.format(URL[, options])#

  • URL <URL> A WHATWG URL object
  • options <Object>
    • auth <boolean>如果序列化的URL字符串应包含用户名和密码,则为true ,否则为false . 默认值: true .
    • fragment <boolean> true if the serialized URL string should include the fragment, false otherwise. Default: true.
    • search <boolean>如果序列化的URL字符串应包含搜索查询,则为true ,否则为false . 默认值: true .
    • unicode <boolean>如果在URL字符串的主机组件中出现的Unicode字符应直接编码而不是Punycode编码,则为true . 默认值: false .

返回WHATWG URL对象的URL字符串表示形式的可自定义序列化.

The URL object has both a toString() method and href property that return string serializations of the URL. These are not, however, customizable in any way. The url.format(URL[, options]) method allows for basic customization of the output.

例如:

const { URL } = require('url');
const myURL = new URL('https://a:[email protected]你好你好?abc#foo');

console.log(myURL.href);
// Prints https://a:[email protected]/?abc#foo

console.log(myURL.toString());
// Prints https://a:[email protected]/?abc#foo

console.log(url.format(myURL, { fragment: false, unicode: true, auth: false }));
// Prints 'https://你好你好/?abc'

Legacy URL API#

Legacy urlObject#

旧版urlObject( require('url').Url )由url.parse()函数创建并返回.

urlObject.auth#

auth属性是URL的用户名和密码部分,也称为" userinfo". 此字符串子集遵循protocol和双斜杠(如果存在),并位于host组件之前,并以ASCII"符号"( @ )分隔. 字符串的格式为{username}[:{password}] ,其中[:{password}]部分为可选.

例如: 'user:pass'

urlObject.hash#

hash属性由URL的"片段"部分组成,包括前导ASCII哈希( # )字符.

例如: '#hash'

urlObject.host#

host属性是URL的完整的小写主机部分,包括port如果已指定).

例如: 'sub.host.com:8080'

urlObject.hostname#

hostname属性是host组件的小写主机名部分, 包括port .

例如: 'sub.host.com'

urlObject.href#

href属性是完整的URL字符串,已将protocolhost组件转换为小写形式进行了解析.

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

urlObject.path#

path属性是pathnamesearch组件的串联.

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

不执行path解码.

urlObject.pathname#

pathname属性由URL的整个路径部分组成. 这就是host (包括port )之后, queryhash组件开始之前的所有内容,它们由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#

如果在protocol的冒号后面需要两个ASCII正斜杠字符( / ),则slashes属性是一个boolean ,其值为true .

url.format(urlObject)#

  • urlObject <Object> | <string> A URL object (as returned by url.parse() or constructed otherwise). If a string, it is converted to an object by passing it to url.parse().

url.format()方法返回从urlObject派生的格式化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 .
  • If urlObject.protocol is a string, it is appended as-is to result.
  • 否则,如果urlObject.protocol不是undefined的也不是字符串,则抛出Error .
  • 有关所有字符串值urlObject.protocol 与ASCII冒号结束: )字符,文字串:将被附加到result .
  • 如果满足以下任一条件,则将文字字符串//添加到result
    • urlObject.slashes属性为true;
    • urlObject.protocolhttphttpsftpgopherfile
  • 如果urlObject.auth属性的值是true,并且urlObject.hosturlObject.hostnameundefined ,则urlObject.auth的值将被强制转换为字符串,并附加到result后面,然后是文字字符串@ .
  • If the urlObject.host property is undefined then:
    • 如果urlObject.hostname是字符串,则将其附加到result .
    • 否则,如果urlObject.hostname不是undefined的也不是字符串,则抛出Error .
    • 如果urlObject.port属性值是true,并且urlObject.hostname不是undefined
      • 文字字符串:附加到result ,和
      • urlObject.port的值被强制为字符串,并附加到result .
  • 否则,如果urlObject.host属性值是truthy,的值urlObject.host被强制转换为字符串,并追加到result .
  • 如果urlObject.pathname属性是不是空字符串的字符串:
    • 如果urlObject.pathname 以ASCII正斜杠( /开头 ,则将文字字符串'/'附加到result .
    • urlObject.pathname的值附加到result .
  • 否则,如果urlObject.pathname不是undefined的也不是字符串,则抛出Error .
  • 如果urlObject.search属性undefined并且urlObject.query属性是Object ,则文字字符串? 被附加到result然后是通过传递urlObject.query的值调用querystring模块的stringify()方法的urlObject.query .
  • 否则,如果urlObject.search是一个字符串:
    • 如果urlObject.search的值不是以ASCII问号( ? )字符开头urlObject.search文字字符串? 附加到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]])#

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

url.parse()方法获取URL字符串,对其进行解析,然后返回URL对象.

如果urlString不是字符串,则抛出TypeError .

如果auth属性存在但无法解码,则抛出URIError .

url.resolve(from, to)#

url.resolve()方法以类似于Web浏览器解析锚标记HREF的方式,相对于基本URL解析目标URL.

例如:

const url = require('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'

Percent-Encoding in URLs#

URL只能包含一定范围的字符. 超出该范围的任何字符都必须进行编码. 这些字符的编码方式以及要编码的字符完全取决于字符在URL结构中的位置.

Legacy API#

在旧版API中,URL对象的属性中的空格( ' ' )和以下字符将自动转义:

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

例如,ASCII空格字符( ' ' )编码为 . ASCII正斜杠( / )字符编码为< .

WHATWG API#

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

WHATWG算法定义了四个"百分比编码集",它们描述了必须进行百分比编码的字符范围:

  • C0控制百分比编码集包括范围在U + 0000到U + 001F(含)之间的代码点,以及所有大于U + 007E的代码点.

  • 片段百分比编码集包括C0控制百分比编码集和代码点U + 0020,U + 0022,U + 003C,U + 003E和U + 0060.

  • 路径百分比编码集包括C0控制百分比编码集和代码点U + 0020,U + 0022,U + 0023,U + 003C,U + 003E,U + 003F,U + 0060,U + 007B和U + 007D.

  • userinfo编码集包括路径百分比编码集和代码点U + 002F,U + 003A,U + 003B,U + 003D,U + 0040,U + 005B,U + 005C,U + 005D,U + 005E,和U + 007C.

userinfo percent-encode设置专门用于URL中编码的用户名和密码. 路径百分比编码集用于大多数URL的路径. 片段百分比编码集用于URL片段. 除所有其他情况外,在某些特定条件下, C0控制百分比编码集还用于主机和路径.

当主机名中出现非ASCII字符时,将使用Punycode算法对主机名进行编码. 但是请注意,一个主机可能 同时包含的Punycode编码,百分比编码的字符. 例如:

const { URL } = require('url');
const myURL = new URL('https://%CF%80.com/foo');
console.log(myURL.href);
// Prints https://xn--1xa.com/foo
console.log(myURL.origin);
// Prints https://π.com

by  ICOPY.SITE