URL

[Stabile: 2 - Stabile]

Codice Sorgente: lib/url.js

Il modulo node:url fornisce utility per la risoluzione e l'analisi degli URL. È accessibile tramite:

ESMCJS

import url from 'node:url'

const url = require('node:url')

Stringhe URL e oggetti URL

Una stringa URL è una stringa strutturata contenente più componenti significative. Quando viene analizzata, viene restituito un oggetto URL contenente le proprietà per ciascuna di queste componenti.

Il modulo node:url fornisce due API per lavorare con gli URL: un'API legacy specifica di Node.js e un'API più recente che implementa lo stesso Standard URL WHATWG utilizzato dai browser web.

Di seguito è riportato un confronto tra le API WHATWG e legacy. Sopra l'URL 'https://user:[email protected]:8080/p/a/t/h?query=string#hash', sono mostrate le proprietà di un oggetto restituito dall'API legacy url.parse(). Sotto di esso ci sono le proprietà di un oggetto URL WHATWG.

La proprietà origin di WHATWG URL include protocol e host, ma non username o 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 │          │                │       │
│          │  │          │          ├─────────────────┴──────┤          │                │       │
│          │  │          │          │          host          │          │                │       │
├──────────┴──┼──────────┴──────────┼────────────────────────┤          │                │       │
│   origin    │                     │         origin         │ pathname │     search     │ hash  │
├─────────────┴─────────────────────┴────────────────────────┴──────────┴────────────────┴───────┤
│                                              href                                              │
└────────────────────────────────────────────────────────────────────────────────────────────────┘
(Tutti gli spazi nella riga "" devono essere ignorati. Sono puramente per la formattazione.)

Analisi della stringa URL utilizzando l'API WHATWG:

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

Analisi della stringa URL utilizzando l'API legacy:

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

Costruzione di un URL da parti componenti e ottenimento della stringa costruita

È possibile costruire un URL WHATWG da parti componenti utilizzando i setter delle proprietà o una stringa letterale di modello:

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}`)

Per ottenere la stringa URL costruita, utilizzare l'accessore della proprietà href:

console.log(myURL.href)

L'API WHATWG URL

Classe: `URL`

[Cronologia]

Versione	Modifiche
v10.0.0	La classe è ora disponibile sull'oggetto globale.
v7.0.0, v6.13.0	Aggiunta in: v7.0.0, v6.13.0

Classe URL compatibile con il browser, implementata seguendo lo standard WHATWG URL. Esempi di URL analizzati si trovano nello standard stesso. La classe URL è anche disponibile sull'oggetto globale.

In conformità con le convenzioni del browser, tutte le proprietà degli oggetti URL sono implementate come getter e setter sul prototipo della classe, piuttosto che come proprietà dati sull'oggetto stesso. Quindi, a differenza delle vecchie urlObject, l'utilizzo della parola chiave delete su qualsiasi proprietà degli oggetti URL (ad esempio delete myURL.protocol, delete myURL.pathname, ecc.) non ha effetto ma restituirà comunque true.

`new URL(input[, base])`

[Cronologia]

Versione	Modifiche
v20.0.0, v18.17.0	Il requisito ICU è rimosso.

input <string> L'URL di input assoluto o relativo da analizzare. Se input è relativo, allora base è richiesto. Se input è assoluto, base viene ignorato. Se input non è una stringa, viene prima convertito in una stringa.
base <string> L'URL base rispetto al quale risolvere se l'input non è assoluto. Se base non è una stringa, viene prima convertito in una stringa.

Crea un nuovo oggetto URL analizzando l'input in relazione alla base. Se base viene passato come stringa, verrà analizzato in modo equivalente a new URL(base).

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

Il costruttore URL è accessibile come proprietà sull'oggetto globale. Può anche essere importato dal modulo url integrato:

ESMCJS

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

console.log(URL === require('node:url').URL) // Stampa 'true'.

Verà lanciato un TypeError se l'input o la base non sono URL validi. Si noti che verrà fatto uno sforzo per forzare i valori dati in stringhe. Ad esempio:

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

I caratteri Unicode che compaiono nel nome host di input verranno automaticamente convertiti in ASCII utilizzando l'algoritmo Punycode.

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

Nei casi in cui non si sa in anticipo se input è un URL assoluto e viene fornita una base, si consiglia di verificare che l'origin dell'oggetto URL sia quello previsto.

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`

<string>

Ottiene e imposta la parte fragment dell'URL.

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

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

I caratteri URL non validi inclusi nel valore assegnato alla proprietà hash sono percentualmente codificati. La selezione dei caratteri da codificare percentualmente può variare leggermente rispetto a quanto produrrebbero i metodi url.parse() e url.format().

`url.host`

<string>

Ottiene e imposta la parte host dell'URL.

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

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

I valori host non validi assegnati alla proprietà host vengono ignorati.

`url.hostname`

<string>

Ottiene e imposta la parte del nome host dell'URL. La differenza principale tra url.host e url.hostname è che url.hostname non include la porta.

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

// L'impostazione del nome host non modifica la porta
myURL.hostname = 'example.com'
console.log(myURL.href)
// Stampa https://example.com:81/foo

// Utilizzare myURL.host per modificare il nome host e la porta
myURL.host = 'example.org:82'
console.log(myURL.href)
// Stampa https://example.org:82/foo

I valori del nome host non validi assegnati alla proprietà hostname vengono ignorati.

`url.href`

<string>

Ottiene e imposta l'URL serializzato.

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

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

Ottenere il valore della proprietà href è equivalente a chiamare url.toString().

Impostare il valore di questa proprietà su un nuovo valore è equivalente alla creazione di un nuovo oggetto URL usando new URL(value). Ogni proprietà dell'oggetto URL verrà modificata.

Se il valore assegnato alla proprietà href non è un URL valido, verrà generato un TypeError.

`url.origin`

[Cronologia]

Versione	Modifiche
v15.0.0	Lo schema "gopher" non è più speciale e `url.origin` ora restituisce `'null'` per esso.

<string>

Ottiene la serializzazione di sola lettura dell'origine dell'URL.

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

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

console.log(idnURL.hostname)
// Stampa xn--g6w251d

`url.password`

<string>

Ottiene e imposta la parte password dell'URL.

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

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

I caratteri URL non validi inclusi nel valore assegnato alla proprietà password sono percentualmente codificati. La selezione dei caratteri da codificare percentualmente può variare leggermente rispetto a quanto produrrebbero i metodi url.parse() e url.format().

`url.pathname`

<string>

Ottiene e imposta la parte del percorso dell'URL.

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

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

I caratteri URL non validi inclusi nel valore assegnato alla proprietà pathname sono percentualmente codificati. La selezione dei caratteri da codificare percentualmente può variare leggermente rispetto a quanto produrrebbero i metodi url.parse() e url.format().

`url.port`

[Cronologia]

Versione	Modifiche
v15.0.0	Lo schema "gopher" non è più speciale.

<string>

Ottiene e imposta la parte di porta dell'URL.

Il valore della porta può essere un numero o una stringa contenente un numero nell'intervallo 0 a 65535 (inclusivo). Impostare il valore sulla porta predefinita degli oggetti URL dato il protocol farà sì che il valore port diventi una stringa vuota ('').

Il valore della porta può essere una stringa vuota, nel qual caso la porta dipende dal protocollo/schema:

protocollo	porta
"ftp"	21
"file"
"http"	80
"https"	443
"ws"	80
"wss"	443

Dopo aver assegnato un valore alla porta, il valore verrà prima convertito in una stringa usando .toString().

Se tale stringa è non valida ma inizia con un numero, il numero iniziale viene assegnato a port. Se il numero è al di fuori dell'intervallo indicato sopra, viene ignorato.

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

// Le porte predefinite vengono automaticamente trasformate nella stringa vuota
// (la porta predefinita del protocollo HTTPS è 443)
myURL.port = '443'
console.log(myURL.port)
// Stampa la stringa vuota
console.log(myURL.href)
// Stampa https://example.org/

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

// Le stringhe di porta completamente non valide vengono ignorate
myURL.port = 'abcd'
console.log(myURL.port)
// Stampa 1234

// I numeri iniziali vengono trattati come un numero di porta
myURL.port = '5678abcd'
console.log(myURL.port)
// Stampa 5678

// I non-interi vengono troncati
myURL.port = 1234.5678
console.log(myURL.port)
// Stampa 1234

// I numeri fuori intervallo che non sono rappresentati in notazione scientifica
// verranno ignorati.
myURL.port = 1e10 // 10000000000, verrà controllato come descritto di seguito
console.log(myURL.port)
// Stampa 1234

I numeri che contengono un punto decimale, come i numeri a virgola mobile o i numeri in notazione scientifica, non fanno eccezione a questa regola. I numeri iniziali fino al punto decimale verranno impostati come porta dell'URL, a condizione che siano validi:

myURL.port = 4.567e21
console.log(myURL.port)
// Stampa 4 (perché è il numero iniziale nella stringa '4.567e21')

`url.protocol`

<string>

Ottiene e imposta la parte del protocollo dell'URL.

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

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

I valori del protocollo URL non validi assegnati alla proprietà protocol vengono ignorati.

Schemi speciali

[Cronologia]

Versione	Modifiche
v15.0.0	Lo schema "gopher" non è più speciale.

Lo Standard WHATWG URL considera una manciata di schemi di protocollo URL come speciali in termini di come vengono analizzati e serializzati. Quando un URL viene analizzato utilizzando uno di questi protocolli speciali, la proprietà url.protocol può essere modificata in un altro protocollo speciale, ma non può essere modificata in un protocollo non speciale, e viceversa.

Ad esempio, la modifica da http a https funziona:

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

Tuttavia, la modifica da http a un ipotetico protocollo fish non funziona perché il nuovo protocollo non è speciale.

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

Allo stesso modo, la modifica da un protocollo non speciale a un protocollo speciale non è consentita:

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

Secondo lo Standard WHATWG URL, gli schemi di protocollo speciali sono ftp, file, http, https, ws e wss.

`url.search`

<string>

Ottiene e imposta la parte di query serializzata dell'URL.

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

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

Qualsiasi carattere URL non valido che appare nel valore assegnato alla proprietà search verrà codificato in percentuale. La selezione dei caratteri da codificare in percentuale può variare leggermente da ciò che i metodi url.parse() e url.format() produrrebbero.

`url.searchParams`

<URLSearchParams>

Ottiene l'oggetto URLSearchParams che rappresenta i parametri di query dell'URL. Questa proprietà è di sola lettura, ma l'oggetto URLSearchParams che fornisce può essere utilizzato per mutare l'istanza URL; per sostituire l'intera parte dei parametri di query dell'URL, utilizzare il setter url.search. Vedere la documentazione di URLSearchParams per i dettagli.

Prestare attenzione quando si utilizza .searchParams per modificare l'oggetto URL perché, secondo la specifica WHATWG, l'oggetto URLSearchParams utilizza regole diverse per determinare quali caratteri percentualmente codificare. Ad esempio, l'oggetto URL non codifica in percentuale il carattere tilde ASCII (~), mentre URLSearchParams lo codifica sempre:

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

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

// Modifica l'URL tramite searchParams...
myURL.searchParams.sort()

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

`url.username`

<string>

Ottiene e imposta la parte username dell'URL.

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

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

Qualsiasi carattere URL non valido che appare nel valore assegnato alla proprietà username verrà codificato in percentuale. La selezione dei caratteri da codificare in percentuale può variare leggermente da quella che i metodi url.parse() e url.format() produrrebbero.

`url.toString()`

Restituisce: <string>

Il metodo toString() sull'oggetto URL restituisce l'URL serializzato. Il valore restituito è equivalente a quello di url.href e url.toJSON().

`url.toJSON()`

Aggiunto in: v7.7.0, v6.13.0

Restituisce: <string>

Il metodo toJSON() sull'oggetto URL restituisce l'URL serializzato. Il valore restituito è equivalente a quello di url.href e url.toString().

Questo metodo viene chiamato automaticamente quando un oggetto URL viene serializzato con JSON.stringify().

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

`URL.createObjectURL(blob)`

Aggiunto in: v16.7.0

[Stabile: 1 - Sperimentale]

Stabile: 1 Stabilità: 1 - Sperimentale

blob <Blob>
Restituisce: <string>

Crea una stringa URL 'blob:nodedata:...' che rappresenta il dato oggetto <Blob> e può essere utilizzata per recuperare il Blob in seguito.

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

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

// successivamente...

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

I dati memorizzati dal <Blob> registrato saranno mantenuti in memoria fino a quando non verrà chiamato URL.revokeObjectURL() per rimuoverli.

Gli oggetti Blob sono registrati all'interno del thread corrente. Se si utilizzano i Worker Thread, gli oggetti Blob registrati all'interno di un Worker non saranno disponibili ad altri worker o al thread principale.

`URL.revokeObjectURL(id)`

Aggiunto in: v16.7.0

[Stabile: 1 - Sperimentale]

Stabile: 1 Stabilità: 1 - Sperimentale

id <string> Una stringa URL 'blob:nodedata:... restituita da una chiamata precedente a URL.createObjectURL().

Rimuove il <Blob> memorizzato identificato dall'ID specificato. Tentare di revocare un ID non registrato non avrà alcun effetto.

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

Aggiunto in: v19.9.0, v18.17.0

input <string> L'URL di input assoluta o relativa da analizzare. Se input è relativo, allora base è richiesto. Se input è assoluto, base viene ignorato. Se input non è una stringa, viene prima convertito in una stringa.
base <string> L'URL di base da risolvere se input non è assoluto. Se base non è una stringa, viene prima convertito in una stringa.
Restituisce: <boolean>

Controlla se un input relativo a base può essere analizzato come un URL.

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

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

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

Aggiunto in: v22.1.0

input <string> L'URL di input assoluta o relativa da analizzare. Se input è relativo, allora base è richiesto. Se input è assoluto, base viene ignorato. Se input non è una stringa, viene prima convertito in una stringa.
base <string> L'URL di base da risolvere se input non è assoluto. Se base non è una stringa, viene prima convertito in una stringa.
Restituisce: <URL> | <null>

Analizza una stringa come URL. Se base è fornito, verrà utilizzato come URL di base per risolvere gli URL input non assoluti. Restituisce null se input non è valido.

Classe: `URLSearchParams`

[Cronologia]

Versione	Modifiche
v10.0.0	La classe è ora disponibile sull'oggetto globale.
v7.5.0, v6.13.0	Aggiunta in: v7.5.0, v6.13.0

L'API URLSearchParams fornisce accesso in lettura e scrittura alla query di un URL. La classe URLSearchParams può anche essere utilizzata in modo indipendente con uno dei quattro costruttori seguenti. La classe URLSearchParams è disponibile anche sull'oggetto globale.

L'interfaccia WHATWG URLSearchParams e il modulo querystring hanno uno scopo simile, ma lo scopo del modulo querystring è più generale, in quanto consente la personalizzazione dei caratteri delimitatori (& e =). D'altra parte, questa API è progettata puramente per le stringhe di query URL.

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

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

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

const newSearchParams = new URLSearchParams(myURL.searchParams)
// Il codice sopra è equivalente a
// const newSearchParams = new URLSearchParams(myURL.search);

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

// newSearchParams.toString() viene chiamato implicitamente
myURL.search = newSearchParams
console.log(myURL.href)
// Stampa https://example.org/?a=b&a=c
newSearchParams.delete('a')
console.log(myURL.href)
// Stampa https://example.org/?a=b&a=c

`new URLSearchParams()`

Crea un nuovo oggetto URLSearchParams vuoto.

`new URLSearchParams(string)`

string <string> Una stringa di query

Analizza la stringa come stringa di query e la usa per creare un nuovo oggetto URLSearchParams. Un '?' iniziale, se presente, viene ignorato.

let params

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

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

`new URLSearchParams(obj)`

Aggiunto in: v7.10.0, v6.13.0

obj <Object> Un oggetto che rappresenta una collezione di coppie chiave-valore

Crea un nuovo oggetto URLSearchParams con una mappa hash di query. La chiave e il valore di ogni proprietà di obj sono sempre convertiti in stringhe.

A differenza del modulo querystring, non sono consentite chiavi duplicate sotto forma di valori di array. Gli array vengono convertiti in stringhe usando array.toString(), che semplicemente unisce tutti gli elementi dell'array con delle virgole.

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

`new URLSearchParams(iterable)`

Aggiunto in: v7.10.0, v6.13.0

iterable <Iterable> Un oggetto iterabile i cui elementi sono coppie chiave-valore

Crea un nuovo oggetto URLSearchParams con una mappa iterabile in modo simile al costruttore di Map. iterable può essere un Array o qualsiasi oggetto iterabile. Ciò significa che iterable può essere un altro URLSearchParams, nel qual caso il costruttore creerà semplicemente un clone del URLSearchParams fornito. Gli elementi di iterable sono coppie chiave-valore e possono essere essi stessi qualsiasi oggetto iterabile.

Sono consentite chiavi duplicate.

let params

// Usando un array
params = new URLSearchParams([
  ['user', 'abc'],
  ['query', 'first'],
  ['query', 'second'],
])
console.log(params.toString())
// Stampa 'user=abc&query=first&query=second'

// Usando un oggetto Map
const map = new Map()
map.set('user', 'abc')
map.set('query', 'xyz')
params = new URLSearchParams(map)
console.log(params.toString())
// Stampa 'user=abc&query=xyz'

// Usando una funzione generatore
function* getQueryPairs() {
  yield ['user', 'abc']
  yield ['query', 'first']
  yield ['query', 'second']
}
params = new URLSearchParams(getQueryPairs())
console.log(params.toString())
// Stampa 'user=abc&query=first&query=second'

// Ogni coppia chiave-valore deve avere esattamente due elementi
new URLSearchParams([['user', 'abc', 'error']])
// Genera TypeError [ERR_INVALID_TUPLE]:
//        Ogni coppia di query deve essere una tupla iterabile [nome, valore]

`urlSearchParams.append(name, value)`

name <string>
value <string>

Aggiunge una nuova coppia nome-valore alla stringa di query.

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

[Cronologia]

Versione	Modifiche
v20.2.0, v18.18.0	Aggiunto supporto per l'argomento `value` opzionale.

name <string>
value <string>

Se value è fornito, rimuove tutte le coppie nome-valore in cui il nome è name e il valore è value.

Se value non è fornito, rimuove tutte le coppie nome-valore il cui nome è name.

`urlSearchParams.entries()`

Restituisce: <Iterator>

Restituisce un iteratore ES6 per ciascuna delle coppie nome-valore nella query. Ogni elemento dell'iteratore è un array JavaScript. Il primo elemento dell'array è il name, il secondo elemento dell'array è il value.

Alias per urlSearchParams[@@iterator]().

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

[Cronologia]

Versione	Modifiche
v18.0.0	Passare una callback non valida all'argomento `fn` ora genera `ERR_INVALID_ARG_TYPE` invece di `ERR_INVALID_CALLBACK`.

fn <Function> Invocato per ogni coppia nome-valore nella query
thisArg <Object> Da utilizzare come valore this quando viene chiamato fn

Iterare su ogni coppia nome-valore nella query e invoca la funzione data.

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

`urlSearchParams.get(name)`

name <string>
Restituisce: <string> | <null> Una stringa o null se non esiste una coppia nome-valore con il nome specificato name.

Restituisce il valore della prima coppia nome-valore il cui nome è name. Se non esistono tali coppie, viene restituito null.

`urlSearchParams.getAll(name)`

name <string>
Restituisce: <string[]>

Restituisce i valori di tutte le coppie nome-valore il cui nome è name. Se non esistono tali coppie, viene restituita una matrice vuota.

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

[Cronologia]

Versione	Modifiche
v20.2.0, v18.18.0	Aggiunto supporto per l'argomento `value` opzionale.

name <string>
value <string>
Restituisce: <boolean>

Controlla se l'oggetto URLSearchParams contiene coppie chiave-valore in base a name e a un argomento value opzionale.

Se value è fornito, restituisce true quando esiste una coppia nome-valore con lo stesso name e value.

Se value non è fornito, restituisce true se esiste almeno una coppia nome-valore il cui nome è name.

`urlSearchParams.keys()`

Restituisce: <Iterator>

Restituisce un iteratore ES6 sui nomi di ogni coppia nome-valore.

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

`urlSearchParams.set(name, value)`

name <string>
value <string>

Imposta il valore nell'oggetto URLSearchParams associato a name su value. Se esistono coppie nome-valore preesistenti i cui nomi sono name, imposta il valore della prima di tali coppie su value e rimuove tutte le altre. In caso contrario, aggiungi la coppia nome-valore alla stringa di query.

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

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

`urlSearchParams.size`

Aggiunto in: v19.8.0, v18.16.0

Il numero totale di voci dei parametri.

`urlSearchParams.sort()`

Aggiunto in: v7.7.0, v6.13.0

Ordina in loco tutte le coppie nome-valore esistenti in base ai loro nomi. L'ordinamento viene eseguito con un algoritmo di ordinamento stabile, quindi l'ordine relativo tra le coppie nome-valore con lo stesso nome viene mantenuto.

Questo metodo può essere utilizzato, in particolare, per aumentare le hit della cache.

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

`urlSearchParams.toString()`

Restituisce: <string>

Restituisce i parametri di ricerca serializzati come stringa, con i caratteri codificati in percentuale dove necessario.

`urlSearchParams.values()`

Restituisce: <Iterator>

Restituisce un iteratore ES6 su i valori di ogni coppia nome-valore.

`urlSearchParams[Symbol.iterator]()`

Restituisce: <Iterator>

Restituisce un iteratore ES6 per ciascuna delle coppie nome-valore nella stringa di query. Ogni elemento dell'iteratore è un array JavaScript. Il primo elemento dell'array è il nome, il secondo elemento dell'array è il valore.

Alias per urlSearchParams.entries().

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

`url.domainToASCII(domain)`

[Cronologia]

Versione	Modifiche
v20.0.0, v18.17.0	Rimosso il requisito ICU.
v7.4.0, v6.13.0	Aggiunto in: v7.4.0, v6.13.0

domain <string>
Restituisce: <string>

Restituisce la serializzazione ASCII Punycode del dominio. Se domain è un dominio non valido, viene restituita una stringa vuota.

Esegue l'operazione inversa a url.domainToUnicode().

ESMCJS

import url from 'node:url'

console.log(url.domainToASCII('español.com'))
// Stampa xn--espaol-zwa.com
console.log(url.domainToASCII('中文.com'))
// Stampa xn--fiq228c.com
console.log(url.domainToASCII('xn--iñvalid.com'))
// Stampa una stringa vuota

const url = require('node:url')

console.log(url.domainToASCII('español.com'))
// Stampa xn--espaol-zwa.com
console.log(url.domainToASCII('中文.com'))
// Stampa xn--fiq228c.com
console.log(url.domainToASCII('xn--iñvalid.com'))
// Stampa una stringa vuota

`url.domainToUnicode(domain)`

[Cronologia]

Versione	Modifiche
v20.0.0, v18.17.0	Rimosso il requisito ICU.
v7.4.0, v6.13.0	Aggiunto in: v7.4.0, v6.13.0

domain <string>
Restituisce: <string>

Restituisce la serializzazione Unicode del dominio. Se domain è un dominio non valido, viene restituita una stringa vuota.

Esegue l'operazione inversa a url.domainToASCII().

ESMCJS

import url from 'node:url'

console.log(url.domainToUnicode('xn--espaol-zwa.com'))
// Stampa español.com
console.log(url.domainToUnicode('xn--fiq228c.com'))
// Stampa 中文.com
console.log(url.domainToUnicode('xn--iñvalid.com'))
// Stampa una stringa vuota

const url = require('node:url')

console.log(url.domainToUnicode('xn--espaol-zwa.com'))
// Stampa español.com
console.log(url.domainToUnicode('xn--fiq228c.com'))
// Stampa 中文.com
console.log(url.domainToUnicode('xn--iñvalid.com'))
// Stampa una stringa vuota

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

[Cronologia]

Versione	Modifiche
v22.1.0, v20.13.0	L'argomento `options` può ora essere utilizzato per determinare come analizzare l'argomento `path`.
v10.12.0	Aggiunto in: v10.12.0

url <URL> | <stringa> La stringa URL del file o l'oggetto URL da convertire in un percorso.
options <Oggetto>
- windows <booleano> | <non definito> true se il path deve essere restituito come percorso file Windows, false per posix e undefined per l'impostazione predefinita del sistema. Predefinito: undefined.
Restituisce: <stringa> Il percorso file Node.js specifico della piattaforma completamente risolto.

Questa funzione garantisce la corretta decodifica dei caratteri percentualmente codificati e garantisce una stringa di percorso assoluto valida per più piattaforme.

ESMCJS

import { fileURLToPath } from 'node:url'

const __filename = fileURLToPath(import.meta.url)

new URL('file:///C:/path/').pathname // Errato: /C:/path/
fileURLToPath('file:///C:/path/') // Corretto:   C:\path\ (Windows)

new URL('file://nas/foo.txt').pathname // Errato: /foo.txt
fileURLToPath('file://nas/foo.txt') // Corretto:   \\nas\foo.txt (Windows)

new URL('file:///你好.txt').pathname // Errato: /%E4%BD%A0%E5%A5%BD.txt
fileURLToPath('file:///你好.txt') // Corretto:   /你好.txt (POSIX)

new URL('file:///hello world').pathname // Errato: /hello%20world
fileURLToPath('file:///hello world') // Corretto:   /hello world (POSIX)

const { fileURLToPath } = require('node:url')
new URL('file:///C:/path/').pathname // Errato: /C:/path/
fileURLToPath('file:///C:/path/') // Corretto:   C:\path\ (Windows)

new URL('file://nas/foo.txt').pathname // Errato: /foo.txt
fileURLToPath('file://nas/foo.txt') // Corretto:   \\nas\foo.txt (Windows)

new URL('file:///你好.txt').pathname // Errato: /%E4%BD%A0%E5%A5%BD.txt
fileURLToPath('file:///你好.txt') // Corretto:   /你好.txt (POSIX)

new URL('file:///hello world').pathname // Errato: /hello%20world
fileURLToPath('file:///hello world') // Corretto:   /hello world (POSIX)

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

Aggiunto in: v7.6.0

URL <URL> Un oggetto WHATWG URL
options <Object>
- auth <boolean> true se la stringa URL serializzata deve includere nome utente e password, false altrimenti. Default: true.
- fragment <boolean> true se la stringa URL serializzata deve includere il fragment, false altrimenti. Default: true.
- search <boolean> true se la stringa URL serializzata deve includere la query di ricerca, false altrimenti. Default: true.
- unicode <boolean> true se i caratteri Unicode che compaiono nel componente host della stringa URL devono essere codificati direttamente invece di essere codificati in Punycode. Default: false.
Restituisce: <string>

Restituisce una serializzazione personalizzabile di una rappresentazione String di URL di un oggetto WHATWG URL.

L'oggetto URL ha sia un metodo toString() che una proprietà href che restituiscono serializzazioni stringa dell'URL. Queste, tuttavia, non sono personalizzabili in alcun modo. Il metodo url.format(URL[, options]) consente una personalizzazione di base dell'output.

ESMCJS

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

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

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

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

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

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

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

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

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

[Cronologia]

Versione	Modifiche
v22.1.0, v20.13.0	L'argomento `options` può ora essere utilizzato per determinare come restituire il valore `path`.
v10.12.0	Aggiunto in: v10.12.0

path <string> Il percorso da convertire in un URL di file.
options <Object>
- windows <boolean> | <undefined> true se il path deve essere trattato come un percorso file di Windows, false per posix e undefined per il valore predefinito del sistema. Predefinito: undefined.
Restituisce: <URL> L'oggetto URL del file.

Questa funzione garantisce che path sia risolto in modo assoluto e che i caratteri di controllo dell'URL siano codificati correttamente durante la conversione in un URL di file.

ESMCJS

import { pathToFileURL } from 'node:url'

new URL('/foo#1', 'file:') // Non corretto: file:///foo#1
pathToFileURL('/foo#1') // Corretto:   file:///foo%231 (POSIX)

new URL('/some/path%.c', 'file:') // Non corretto: file:///some/path%.c
pathToFileURL('/some/path%.c') // Corretto:   file:///some/path%25.c (POSIX)

const { pathToFileURL } = require('node:url')
new URL(__filename) // Non corretto: genera un errore (POSIX)
new URL(__filename) // Non corretto: C:\... (Windows)
pathToFileURL(__filename) // Corretto:   file:///... (POSIX)
pathToFileURL(__filename) // Corretto:   file:///C:/... (Windows)

new URL('/foo#1', 'file:') // Non corretto: file:///foo#1
pathToFileURL('/foo#1') // Corretto:   file:///foo%231 (POSIX)

new URL('/some/path%.c', 'file:') // Non corretto: file:///some/path%.c
pathToFileURL('/some/path%.c') // Corretto:   file:///some/path%25.c (POSIX)

`url.urlToHttpOptions(url)`

[Cronologia]

Versione	Modifiche
v19.9.0, v18.17.0	L'oggetto restituito conterrà anche tutte le proprietà enumerabili proprie dell'argomento `url`.
v15.7.0, v14.18.0	Aggiunto in: v15.7.0, v14.18.0

url <URL> L'oggetto WHATWG URL da convertire in un oggetto options.
Restituisce: <Oggetto> Oggetto options
- protocol <stringa> Protocollo da utilizzare.
- hostname <stringa> Un nome di dominio o un indirizzo IP del server a cui inviare la richiesta.
- hash <stringa> La parte fragment dell'URL.
- search <stringa> La parte query serializzata dell'URL.
- pathname <stringa> La parte path dell'URL.
- path <stringa> Percorso della richiesta. Dovrebbe includere la query string, se presente. Esempio: '/index.html?page=12'. Viene sollevata un'eccezione quando il percorso della richiesta contiene caratteri illegali. Attualmente, solo gli spazi vengono rifiutati, ma ciò potrebbe cambiare in futuro.
- href <stringa> L'URL serializzato.
- port <numero> Porta del server remoto.
- auth <stringa> Autenticazione di base, ad esempio 'user:password' per calcolare un'intestazione di autorizzazione.

Questa funzione di utilità converte un oggetto URL in un normale oggetto options come previsto dalle API http.request() e https.request().

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'
}
*/

API URL legacy

[Cronologia]

Versione	Modifiche
v15.13.0, v14.17.0	Revoche della deprecazione. Stato modificato in "Legacy".
v11.0.0	Questa API è deprecata.

[Stabile: 3 - Legacy]

Stabile: 3 Stabilità: 3 - Legacy: Utilizzare invece l'API URL WHATWG.

`urlObject` legacy

[Cronologia]

Versione	Modifiche
v15.13.0, v14.17.0	Revoche della deprecazione. Stato modificato in "Legacy".
v11.0.0	L'API URL legacy è deprecata. Utilizzare l'API URL WHATWG.

[Stabile: 3 - Legacy]

Stabile: 3 Stabilità: 3 - Legacy: Utilizzare invece l'API URL WHATWG.

L'oggetto urlObject legacy (require('node:url').Url o import { Url } from 'node:url') è creato e restituito dalla funzione url.parse().

`urlObject.auth`

La proprietà auth è la parte nome utente e password dell'URL, anche detta userinfo. Questo sottoinsieme di stringa segue il protocol e le barre doppie (se presenti) e precede il componente host, delimitato da @. La stringa è il nome utente, oppure il nome utente e la password separati da :.

Ad esempio: 'user:pass'.

`urlObject.hash`

La proprietà hash è la parte identificatore frammento dell'URL, incluso il carattere # iniziale.

Ad esempio: '#hash'.

`urlObject.host`

La proprietà host è la parte host completa in minuscolo dell'URL, incluso la port se specificata.

Ad esempio: 'sub.example.com:8080'.

`urlObject.hostname`

La proprietà hostname è la parte nome host in minuscolo del componente host senza la port inclusa.

Ad esempio: 'sub.example.com'.

`urlObject.href`

La proprietà href è la stringa URL completa che è stata analizzata con sia il protocol che i componenti host convertiti in minuscolo.

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

`urlObject.path`

La proprietà path è una concatenazione dei componenti pathname e search.

Ad esempio: '/p/a/t/h?query=string'.

Nessuna decodifica di path viene eseguita.

`urlObject.pathname`

La proprietà pathname consiste nell'intera sezione del percorso dell'URL. È tutto ciò che segue l' host (inclusa la port) e prima dell'inizio dei componenti query o hash, delimitato dai caratteri punto interrogativo ASCII (?) o cancelletto (#).

Ad esempio: '/p/a/t/h'.

Nessuna decodifica della stringa del percorso viene eseguita.

`urlObject.port`

La proprietà port è la parte numerica della porta del componente host.

Ad esempio: '8080'.

`urlObject.protocol`

La proprietà protocol identifica lo schema del protocollo URL in minuscolo.

Ad esempio: 'http:'.

`urlObject.query`

La proprietà query è o la stringa di query senza il punto interrogativo ASCII iniziale (?), o un oggetto restituito dal metodo parse() del modulo querystring. Se la proprietà query è una stringa o un oggetto è determinato dall'argomento parseQueryString passato a url.parse().

Ad esempio: 'query=string' o {'query': 'string'}.

Se restituita come stringa, non viene eseguita alcuna decodifica della stringa di query. Se restituita come oggetto, sia le chiavi che i valori vengono decodificati.

`urlObject.search`

La proprietà search consiste nell'intera parte "stringa di query" dell'URL, incluso il carattere punto interrogativo ASCII iniziale (?).

Ad esempio: '?query=string'.

Nessuna decodifica della stringa di query viene eseguita.

`urlObject.slashes`

La proprietà slashes è un valore booleano con valore true se sono necessari due caratteri di barra rovesciata ASCII (/) dopo i due punti nel protocol.

`url.format(urlObject)`

[Cronologia]

Versione	Modifiche
v17.0.0	Ora genera un'eccezione `ERR_INVALID_URL` quando la conversione Punycode di un nome host introduce modifiche che potrebbero causare una rianalisi diversa dell'URL.
v15.13.0, v14.17.0	Revocato il deprecato. Stato cambiato in "Legacy".
v11.0.0	L'API URL Legacy è deprecata. Utilizzare l'API URL WHATWG.
v7.0.0	Gli URL con uno schema `file:` ora utilizzeranno sempre il numero corretto di barre oblique indipendentemente dall'opzione `slashes`. Un'opzione `slashes` falsa senza protocollo è ora rispettata in ogni momento.
v0.1.25	Aggiunto in: v0.1.25

[Stabile: 3 - Legacy]

Stabile: 3 Stabilità: 3 - Legacy: Utilizzare invece l'API URL WHATWG.

urlObject <Oggetto> | <stringa> Un oggetto URL (come restituito da url.parse() o costruito altrimenti). Se una stringa, viene convertita in un oggetto passandola a url.parse().

Il metodo url.format() restituisce una stringa URL formattata derivata da urlObject.

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'

Se urlObject non è un oggetto o una stringa, url.format() genererà un TypeError.

Il processo di formattazione funziona come segue:

Viene creata una nuova stringa vuota result.
Se urlObject.protocol è una stringa, viene aggiunta così com'è a result.
Altrimenti, se urlObject.protocol non è undefined e non è una stringa, viene generato un Error.
Per tutti i valori stringa di urlObject.protocol che non terminano con un carattere due punti ASCII (: ), la stringa letterale : verrà aggiunta a result.
Se una delle seguenti condizioni è vera, la stringa letterale // verrà aggiunta a result:
- la proprietà urlObject.slashes è vera;
- urlObject.protocol inizia con http, https, ftp, gopher o file;
Se il valore della proprietà urlObject.auth è veritiero, e sia urlObject.host che urlObject.hostname non sono undefined, il valore di urlObject.auth verrà convertito in una stringa e aggiunto a result seguito dalla stringa letterale @.
Se la proprietà urlObject.host è undefined allora:
- Se urlObject.hostname è una stringa, viene aggiunta a result.
- Altrimenti, se urlObject.hostname non è undefined e non è una stringa, viene generato un Error.
- Se il valore della proprietà urlObject.port è veritiero, e urlObject.hostname non è undefined:
- La stringa letterale : viene aggiunta a result, e
- Il valore di urlObject.port viene convertito in una stringa e aggiunto a result.
Altrimenti, se il valore della proprietà urlObject.host è veritiero, il valore di urlObject.host viene convertito in una stringa e aggiunto a result.
Se la proprietà urlObject.pathname è una stringa che non è una stringa vuota:
- Se urlObject.pathname non inizia con una barra rovesciata ASCII (/), la stringa letterale '/' viene aggiunta a result.
- Il valore di urlObject.pathname viene aggiunto a result.
Altrimenti, se urlObject.pathname non è undefined e non è una stringa, viene generato un Error.
Se la proprietà urlObject.search è undefined e se la proprietà urlObject.query è un Oggetto, la stringa letterale ? viene aggiunta a result seguita dall'output della chiamata al metodo stringify() del modulo querystring passando il valore di urlObject.query.
Altrimenti, se urlObject.search è una stringa:
- Se il valore di urlObject.search non inizia con il carattere punto interrogativo ASCII (?), la stringa letterale ? viene aggiunta a result.
- Il valore di urlObject.search viene aggiunto a result.
Altrimenti, se urlObject.search non è undefined e non è una stringa, viene generato un Error.
Se la proprietà urlObject.hash è una stringa:
- Se il valore di urlObject.hash non inizia con il carattere cancelletto ASCII (#), la stringa letterale # viene aggiunta a result.
- Il valore di urlObject.hash viene aggiunto a result.
Altrimenti, se la proprietà urlObject.hash non è undefined e non è una stringa, viene generato un Error.
Viene restituito result.

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

[Cronologia]

Versione	Modifiche
v19.0.0, v18.13.0	Deprecazione solo a livello di documentazione.
v15.13.0, v14.17.0	Deprecazione revocata. Stato cambiato in "Legacy".
v11.14.0	La proprietà `pathname` sull'oggetto URL restituito è ora `/` quando non c'è percorso e lo schema del protocollo è `ws:` o `wss:`.
v11.0.0	L'API URL Legacy è deprecata. Utilizzare l'API URL WHATWG.
v9.0.0	La proprietà `search` sull'oggetto URL restituito è ora `null` quando non è presente alcuna stringa di query.
v0.1.25	Aggiunto in: v0.1.25

[Stabile: 0 - Obsoleto]

Stabile: 0 Stabilità: 0 - Obsoleto: Utilizzare invece l'API URL WHATWG.

urlString <string> La stringa URL da analizzare.
parseQueryString <boolean> Se true, la proprietà query sarà sempre impostata su un oggetto restituito dal metodo parse() del modulo querystring. Se false, la proprietà query sull'oggetto URL restituito sarà una stringa non analizzata e non decodificata. Default: false.
slashesDenoteHost <boolean> Se true, il primo token dopo la stringa letterale // e che precede il successivo / sarà interpretato come host. Ad esempio, dato //foo/bar, il risultato sarebbe {host: 'foo', pathname: '/bar'} anziché {pathname: '//foo/bar'}. Default: false.

Il metodo url.parse() accetta una stringa URL, la analizza e restituisce un oggetto URL.

Viene generato un TypeError se urlString non è una stringa.

Viene generato un URIError se la proprietà auth è presente ma non può essere decodificata.

url.parse() utilizza un algoritmo permissivo e non standard per l'analisi delle stringhe URL. È soggetto a problemi di sicurezza come lo spoofing del nome host e la gestione errata di nomi utente e password. Non utilizzare con input non attendibili. Non vengono emessi CVE per le vulnerabilità di url.parse(). Utilizzare invece l'API WHATWG URL.

`url.resolve(from, to)`

[Cronologia]

Versione	Modifiche
v15.13.0, v14.17.0	Revoche della deprecazione. Stato modificato in "Legacy".
v11.0.0	L'API URL Legacy è deprecata. Utilizzare l'API URL WHATWG.
v6.6.0	I campi `auth` vengono ora mantenuti intatti quando `from` e `to` si riferiscono allo stesso host.
v6.0.0	Il campo `auth` viene ora cancellato se il parametro `to` contiene un nome host.
v6.5.0, v4.6.2	Il campo `port` viene ora copiato correttamente.
v0.1.25	Aggiunto in: v0.1.25

[Stabile: 3 - Legacy]

Stabile: 3 Stabilità: 3 - Legacy: Utilizzare invece l'API URL WHATWG.

from <string> L'URL base da utilizzare se to è un URL relativo.
to <string> L'URL di destinazione da risolvere.

Il metodo url.resolve() risolve un URL di destinazione in relazione a un URL base in modo simile a quello di un browser web che risolve un tag di ancoraggio.

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'

Per ottenere lo stesso risultato utilizzando l'API URL WHATWG:

function resolve(from, to) {
  const resolvedUrl = new URL(to, new URL(from, 'resolve://'))
  if (resolvedUrl.protocol === 'resolve:') {
    // `from` è un URL relativo.
    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'

Percent-encoding negli URL

Gli URL sono consentiti solo per una certa gamma di caratteri. Qualsiasi carattere che rientri al di fuori di tale intervallo deve essere codificato. Il modo in cui tali caratteri vengono codificati e quali caratteri codificare dipende interamente da dove si trova il carattere nella struttura dell'URL.

API legacy

Nell'API legacy, gli spazi (' ') e i seguenti caratteri verranno automaticamente escapeati nelle proprietà degli oggetti URL:

text

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

Ad esempio, il carattere spazio ASCII (' ') è codificato come %20. Il carattere barra (/) ASCII è codificato come %3C.

API WHATWG

Lo standard WHATWG URL utilizza un approccio più selettivo e granulare per la selezione dei caratteri codificati rispetto a quello utilizzato dall'API legacy.

L'algoritmo WHATWG definisce quattro "set di percentuale-codifica" che descrivono gli intervalli di caratteri che devono essere percentualmente codificati:

Il set di percentuale-codifica di controllo C0 include i punti codice nell'intervallo U+0000 a U+001F (inclusi) e tutti i punti codice maggiori di U+007E (~).
Il set di percentuale-codifica del frammento include il set di percentuale-codifica di controllo C0 e i punti codice U+0020 SPAZIO, U+0022 ("), U+003C (<), U+003E (>), e U+0060 (`).
Il set di percentuale-codifica del percorso include il set di percentuale-codifica di controllo C0 e i punti codice U+0020 SPAZIO, U+0022 ("), U+0023 (#), U+003C (<), U+003E (>), U+003F (?), U+0060 (`), U+007B ({), e U+007D (}).
Il set di codifica userinfo include il set di percentuale-codifica del percorso e i punti codice U+002F (/), U+003A (😃, U+003B (😉, U+003D (=), U+0040 (@), U+005B ([) a U+005E(^), e U+007C (|).

Il set di percentuale-codifica userinfo è utilizzato esclusivamente per nomi utente e password codificati all'interno dell'URL. Il set di percentuale-codifica del percorso è utilizzato per il percorso della maggior parte degli URL. Il set di percentuale-codifica del frammento è utilizzato per i frammenti di URL. Il set di percentuale-codifica di controllo C0 è utilizzato per l'host e il percorso in determinate condizioni specifiche, oltre a tutti gli altri casi.

Quando i caratteri non ASCII compaiono all'interno di un nome host, il nome host viene codificato utilizzando l'algoritmo Punycode. Si noti, tuttavia, che un nome host può contenere sia caratteri codificati Punycode che caratteri percentualmente codificati:

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

URL ​

Stringhe URL e oggetti URL ​

Costruzione di un URL da parti componenti e ottenimento della stringa costruita ​

L'API WHATWG URL ​

Classe: URL ​

new URL(input[, base]) ​

url.hash ​

url.host ​

url.hostname ​

url.href ​

url.origin ​

url.password ​

url.pathname ​

url.port ​

url.protocol ​

Schemi speciali ​

url.search ​

url.searchParams ​

url.username ​

url.toString() ​

url.toJSON() ​

URL.createObjectURL(blob) ​

URL.revokeObjectURL(id) ​

URL.canParse(input[, base]) ​

URL.parse(input[, base]) ​

Classe: 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) ​

API URL legacy ​

urlObject legacy ​

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) ​

Percent-encoding negli URL ​

API legacy ​

API WHATWG ​

URL

Stringhe URL e oggetti URL

Costruzione di un URL da parti componenti e ottenimento della stringa costruita

L'API WHATWG URL

Classe: `URL`

`new URL(input[, base])`

`url.hash`

`url.host`

`url.hostname`

`url.href`

`url.origin`

`url.password`

`url.pathname`

`url.port`

`url.protocol`

Schemi speciali

`url.search`

`url.searchParams`

`url.username`

`url.toString()`

`url.toJSON()`

`URL.createObjectURL(blob)`

`URL.revokeObjectURL(id)`

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

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

Classe: `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)`

API URL legacy

`urlObject` legacy

`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)`

Percent-encoding negli URL

API legacy

API WHATWG