Node.js v25.0.0 文件

new URL(input[, base])#

• input <string> 要解析的絕對或相對輸入 URL。如果 input 是相對的，則 base 是必需的。如果 input 是絕對的，則 base 會被忽略。如果 input 不是字串，它會首先被轉換為字串。
• base <string> 如果 input 不是絕對 URL，則用作解析基準的 URL。如果 base 不是字串，它會首先被轉換為字串。

透過相對於 base 解析 input 來建立一個新的 URL 物件。如果 base 作為字串傳遞，它將被解析為等同於 new URL(base)。

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

URL 建構函式可作為全域性物件的屬性訪問。也可以從內建的 url 模組匯入

import { URL } from 'node:url';
console.log(URL === globalThis.URL); // Prints 'true'.console.log(URL === require('node:url').URL); // Prints 'true'.copy

如果 input 或 base 不是有效的 URL，則會丟擲 TypeError。請注意，系統會嘗試將給定值強制轉換為字串。例如：

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

出現在 input 主機名中的 Unicode 字元將使用 Punycode 演算法自動轉換為 ASCII。

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

如果事先不知道 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/ copy

url.hash#

• 型別：<string>

獲取並設定 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 copy

分配給 hash 屬性的值中包含的無效 URL 字元會被百分號編碼。選擇哪些字元進行百分號編碼可能與 url.parse() 和 url.format() 方法的產生結果略有不同。

url.host#

• 型別：<string>

獲取並設定 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 copy

分配給 host 屬性的無效主機值將被忽略。

url.hostname#

• 型別：<string>

獲取並設定 URL 的主機名部分。url.host 和 url.hostname 之間的主要區別在於 url.hostname 不包含埠。

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

// Setting the hostname does not change the port
myURL.hostname = 'example.com';
console.log(myURL.href);
// Prints https://example.com:81/foo

// Use myURL.host to change the hostname and port
myURL.host = 'example.org:82';
console.log(myURL.href);
// Prints https://example.org:82/foo copy

分配給 hostname 屬性的無效主機名值將被忽略。

url.href#

• 型別：<string>

獲取並設定序列化的 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 copy

獲取 href 屬性的值等同於呼叫 url.toString()。

將此屬性的值設定為一個新值，等同於使用 new URL(value) 建立一個新的 URL 物件。URL 物件的每個屬性都將被修改。

如果分配給 href 屬性的值不是一個有效的 URL，則會丟擲 TypeError。

url.origin#

• 型別：<string>

獲取 URL 源的只讀序列化表示。

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

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

console.log(idnURL.hostname);
// Prints xn--g6w251d copy

url.password#

• 型別：<string>

獲取並設定 URL 的密碼部分。

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

myURL.password = '123';
console.log(myURL.href);
// Prints https://abc:123@example.com/ copy

分配給 password 屬性的值中包含的無效 URL 字元會被百分號編碼。選擇哪些字元進行百分號編碼可能與 url.parse() 和 url.format() 方法的產生結果略有不同。

url.pathname#

• 型別：<string>

獲取並設定 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 copy

分配給 pathname 屬性的值中包含的無效 URL 字元會被百分號編碼。選擇哪些字元進行百分號編碼可能與 url.parse() 和 url.format() 方法的產生結果略有不同。

url.port#

• 型別：<string>

獲取並設定 URL 的埠部分。

埠值可以是一個數字或一個包含數字的字串，範圍在 0 到 65535（含）之間。將值設定為 URL 物件給定 protocol 的預設埠，將導致 port 值變為空字串（''）。

埠值可以是一個空字串，在這種情況下，埠取決於協議/方案

在給埠賦值時，該值將首先使用 .toString() 轉換為字串。

如果該字串無效但以數字開頭，則開頭的數字將被分配給 port。如果數字超出了上述範圍，它將被忽略。

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 which are not represented in scientific notation
// will be ignored.
myURL.port = 1e10; // 10000000000, will be range-checked as described below
console.log(myURL.port);
// Prints 1234 copy

包含小數點的數字，如浮點數或科學記數法中的數字，不屬於此規則的例外。小數點前的開頭數字將被設定為 URL 的埠，前提是它們是有效的

myURL.port = 4.567e21;
console.log(myURL.port);
// Prints 4 (because it is the leading number in the string '4.567e21') copy

url.protocol#

• 型別：<string>

獲取並設定 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/ copy

分配給 protocol 屬性的無效 URL 協議值將被忽略。

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

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

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

url.search#

• 型別：<string>

獲取並設定 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 copy

出現在賦給 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);  // prints ?foo=~bar

// Modify the URL via searchParams...
myURL.searchParams.sort();

console.log(myURL.search);  // prints ?foo=%7Ebar copy

url.username#

• 型別：<string>

獲取並設定 URL 的使用者名稱部分。

const myURL = new URL('https://abc:xyz@example.com');
console.log(myURL.username);
// Prints abc

myURL.username = '123';
console.log(myURL.href);
// Prints https://123:xyz@example.com/ copy

出現在賦給 username 屬性的值中的任何無效 URL 字元都將被百分號編碼。選擇哪些字元進行百分號編碼可能與 url.parse() 和 url.format() 方法的產生結果略有不同。

url.toString()#

• 返回: <string>

URL 物件上的 toString() 方法返回序列化的 URL。返回的值等同於 url.href 和 url.toJSON() 的值。

url.toJSON()#

• 返回: <string>

URL 物件上的 toJSON() 方法返回序列化的 URL。返回的值等同於 url.href 和 url.toString() 的值。

當 URL 物件使用 JSON.stringify() 進行序列化時，會自動呼叫此方法。

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/"] copy

URL.createObjectURL(blob)#

• blob <Blob>
• 返回: <string>

建立一個表示給定 <Blob> 物件的 'blob:nodedata:...' URL 字串，該字串可用於稍後檢索 Blob。

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

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

// later...

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

已註冊的 <Blob> 所儲存的資料將保留在記憶體中，直到呼叫 URL.revokeObjectURL() 將其移除。

Blob 物件在當前執行緒內註冊。如果使用工作執行緒，在一個工作執行緒中註冊的 Blob 物件將對其他工作執行緒或主執行緒不可用。

URL.revokeObjectURL(id)#

• id <string> 一個由先前呼叫 URL.createObjectURL() 返回的 'blob:nodedata:... URL 字串。

移除由給定 ID 標識的已儲存 <Blob>。嘗試撤銷一個未註冊的 ID 將會靜默失敗。

URL.canParse(input[, base])#

• input <string> 要解析的絕對或相對輸入 URL。如果 input 是相對的，則 base 是必需的。如果 input 是絕對的，則 base 會被忽略。如果 input 不是字串，它會首先被轉換為字串。
• base <string> 如果 input 不是絕對 URL，則用作解析基準的 URL。如果 base 不是字串，它會首先被轉換為字串。
• 返回：<boolean>

檢查相對於 base 的 input 是否可以解析為 URL。

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

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

URL.parse(input[, base])#

• input <string> 要解析的絕對或相對輸入 URL。如果 input 是相對的，則 base 是必需的。如果 input 是絕對的，則 base 會被忽略。如果 input 不是字串，它會首先被轉換為字串。
• base <string> 如果 input 不是絕對 URL，則用作解析基準的 URL。如果 base 不是字串，它會首先被轉換為字串。
• 返回：<URL> | <null>

將字串解析為 URL。如果提供了 base，它將被用作解析非絕對 input URL 的基準 URL。如果引數無法解析為有效的 URL，則返回 null。

new URLPattern()#

例項化一個新的空 URLPattern 物件。

new URLPattern(string[, baseURL][, options])#

• string <string> 一個 URL 字串
• baseURL <string> | <undefined> 一個基礎 URL 字串
• options <Object> 選項

將 string 解析為 URL，並用它來例項化一個新的 URLPattern 物件。

如果未指定 baseURL，則預設為 undefined。

選項可以有一個 ignoreCase 布林屬性，如果設定為 true，則啟用不區分大小寫的匹配。

建構函式可能會丟擲一個 TypeError 來表示解析失敗。

new URLPattern(obj[, baseURL][, options])#

• obj <Object> 一個輸入模式
• baseURL <string> | <undefined> 一個基礎 URL 字串
• options <Object> 選項

將 Object 解析為輸入模式，並用它來例項化一個新的 URLPattern 物件。該物件的成員可以是 protocol、username、password、hostname、port、pathname、search、hash 或 baseURL 中的任意一個。

如果未指定 baseURL，則預設為 undefined。

選項可以有一個 ignoreCase 布林屬性，如果設定為 true，則啟用不區分大小寫的匹配。

建構函式可能會丟擲一個 TypeError 來表示解析失敗。

urlPattern.exec(input[, baseURL])#

• input <string> | <Object> 一個 URL 或 URL 的部分
• baseURL <string> | <undefined> 一個基礎 URL 字串

輸入可以是一個字串或一個提供各個 URL 部分的物件。物件成員可以是 protocol、username、password、hostname、port、pathname、search、hash 或 baseURL 中的任意一個。

如果未指定 baseURL，則預設為 undefined。

返回一個物件，其中包含一個 inputs 鍵，其值為傳入函式的引數陣列，以及 URL 元件的鍵，其中包含匹配的輸入和匹配的組。

const myPattern = new URLPattern('https://nodejs.com.tw/docs/latest/api/*.html');
console.log(myPattern.exec('https://nodejs.com.tw/docs/latest/api/dns.html'));
// Prints:
// {
//  "hash": { "groups": {  "0": "" },  "input": "" },
//  "hostname": { "groups": {}, "input": "nodejs.org" },
//  "inputs": [
//    "https://nodejs.com.tw/docs/latest/api/dns.html"
//  ],
//  "password": { "groups": { "0": "" }, "input": "" },
//  "pathname": { "groups": { "0": "dns" }, "input": "/docs/latest/api/dns.html" },
//  "port": { "groups": {}, "input": "" },
//  "protocol": { "groups": {}, "input": "https" },
//  "search": { "groups": { "0": "" }, "input": "" },
//  "username": { "groups": { "0": "" }, "input": "" }
// } copy

urlPattern.test(input[, baseURL])#

• input <string> | <Object> 一個 URL 或 URL 的部分
• baseURL <string> | <undefined> 一個基礎 URL 字串

輸入可以是一個字串或一個提供各個 URL 部分的物件。物件成員可以是 protocol、username、password、hostname、port、pathname、search、hash 或 baseURL 中的任意一個。

如果未指定 baseURL，則預設為 undefined。

返回一個布林值，表示輸入是否與當前模式匹配。

const myPattern = new URLPattern('https://nodejs.com.tw/docs/latest/api/*.html');
console.log(myPattern.test('https://nodejs.com.tw/docs/latest/api/dns.html'));
// Prints: true copy

new URLSearchParams()#

例項化一個新的空 URLSearchParams 物件。

new URLSearchParams(string)#

• string <string> 一個查詢字串

將 string 解析為查詢字串，並用它來例項化一個新的 URLSearchParams 物件。如果存在前導 '?'，則會被忽略。

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' copy

new URLSearchParams(obj)#

• obj <Object> 一個表示鍵值對集合的物件

使用查詢雜湊對映例項化一個新的 URLSearchParams 物件。obj 的每個屬性的鍵和值總是被強制轉換為字串。

與 querystring 模組不同，不允許以陣列值的形式出現重複的鍵。陣列使用 array.toString() 進行字串化，它只是用逗號連線所有陣列元素。

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' copy

new URLSearchParams(iterable)#

• iterable <Iterable> 一個可迭代物件，其元素是鍵值對

使用可迭代對映例項化一個新的 URLSearchParams 物件，方式類似於 <Map> 的建構函式。iterable 可以是 Array 或任何可迭代物件。這意味著 iterable 可以是另一個 URLSearchParams，在這種情況下，建構函式將簡單地建立所提供的 URLSearchParams 的克隆。iterable 的元素是鍵值對，並且它們本身也可以是任何可迭代物件。

允許重複的鍵。

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 copy

urlSearchParams.append(name, value)#

• name <string>
• value <string>

向查詢字串中追加一個新的名稱-值對。

urlSearchParams.delete(name[, value])#

• name <string>
• value <string>

如果提供了 value，則刪除所有名稱為 name 且值為 value 的名稱-值對。

如果未提供 value，則刪除所有名稱為 name 的名稱-值對。

urlSearchParams.entries()#

• 返回：<Iterator>

返回一個 ES6 Iterator，用於遍歷查詢中的每個名稱-值對。迭代器的每個專案都是一個 JavaScript Array。Array 的第一項是 name，第二項是 value。

urlSearchParams[Symbol.iterator]() 的別名。

urlSearchParams.forEach(fn[, thisArg])#

• fn <Function> 為查詢中的每個名稱-值對呼叫
• thisArg <Object> 當呼叫 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);
});
// Prints:
//   a b true
//   c d true copy

urlSearchParams.get(name)#

• name <string>
• 返回：<string> | <null> 一個字串，如果沒有給定 name 的名稱-值對，則為 null。

返回第一個名稱為 name 的名稱-值對的值。如果沒有這樣的對，則返回 null。

urlSearchParams.getAll(name)#

• name <string>
• 返回：<string[]>

返回所有名稱為 name 的名稱-值對的值。如果沒有這樣的對，則返回一個空陣列。

urlSearchParams.has(name[, value])#

• name <string>
• value <string>
• 返回：<boolean>

根據 name 和可選的 value 引數，檢查 URLSearchParams 物件是否包含鍵值對。

如果提供了 value，當存在具有相同 name 和 value 的名稱-值對時返回 true。

如果未提供 value，只要存在至少一個名稱為 name 的名稱-值對，就返回 true。

urlSearchParams.keys()#

• 返回：<Iterator>

返回一個 ES6 Iterator，用於遍歷每個名稱-值對的名稱。

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

urlSearchParams.set(name, value)#

• name <string>
• value <string>

將 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());
// 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 copy

urlSearchParams.size#

引數條目的總數。

urlSearchParams.sort()#

按名稱對所有現有的名稱-值對進行原地排序。排序使用穩定排序演算法完成，因此保留了具有相同名稱的名稱-值對之間的相對順序。

此方法尤其可用於增加快取命中率。

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 copy

urlSearchParams.toString()#

• 返回: <string>

返回序列化為字串的搜尋引數，必要時對字元進行百分號編碼。

urlSearchParams.values()#

• 返回：<Iterator>

返回一個 ES6 Iterator，用於遍歷每個名稱-值對的值。

urlSearchParams[Symbol.iterator]()#

• 返回：<Iterator>

返回一個 ES6 Iterator，用於遍歷查詢字串中的每個名稱-值對。迭代器的每個專案都是一個 JavaScript Array。Array 的第一項是 name，第二項是 value。

urlSearchParams.entries() 的別名。

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

urlObject.auth#

auth 屬性是 URL 的使用者名稱和密碼部分，也稱為使用者資訊。此字串子集跟在 protocol 和雙斜槓（如果存在）之後，並位於 host 元件之前，由 @ 分隔。該字串要麼是使用者名稱，要麼是由 : 分隔的使用者名稱和密碼。

例如：'user:pass'。

urlObject.hash#

hash 屬性是 URL 的片段識別符號部分，包括前導的 # 字元。

例如：'#hash'。

urlObject.host#

host 屬性是 URL 的完整小寫主機部分，包括指定的 port。

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

urlObject.hostname#

hostname 屬性是 host 元件的小寫主機名部分，不包括 port。

例如：'sub.example.com'。

urlObject.href#

href 屬性是解析後的完整 URL 字串，其中 protocol 和 host 元件都已轉換為小寫。

例如：'http://user:pass@sub.example.com: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#

如果 protocol 中的冒號後需要兩個 ASCII 正斜槓字元 (/)，則 slashes 屬性是一個值為 true 的 boolean。