URL -Modul
Die Verwendung von URL -Modul ist bei der Behandlung von HTTP -Anforderungen extrem hoch, da das Modul an das Parsen von URLs, das Erzeugen von URLs und das Spleißen von URLs ermöglicht wird. Schauen wir uns zunächst die Komponenten einer vollständigen URL an.
Die Codekopie lautet wie folgt:
href
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Hostpfad
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
http: // user: Pass @ host.com: 8080/p/a/t/h? query = String #Hash
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Protokollauth Hostname Port Pathname Search Hash
------------
Abfrage
Wir können die .Parse -Methode verwenden, um eine URL -Zeichenfolge in ein URL -Objekt umzuwandeln, wie unten gezeigt.
Die Codekopie lautet wie folgt:
url.parse ('http: // user: [email protected]: 8080/p/a/t/h? query = String#Hash');
/* =>
{Protocol: 'Http:',,
Auth: 'Benutzer: Pass',
Host: 'Host.com:8080',
Port: '8080',
Hostname: 'host.com',
Hash: '#Hash',
Suche: '? Query = String',
Abfrage: 'Query = String',
Pfadname: '/p/a/t/h',
Pfad: '/p/a/t/h? query = string',
href: 'http: // user: [email protected]: 8080/p/a/t/h? query = string#Hash'}
*/
Die .Parse -Methode ist nicht unbedingt eine vollständige URL. Beispielsweise enthält in der HTTP -Server -Rückruffunktion Request.URL keine Protokollheader und Domainnamen, sondern auch mit der Methode .Parse analysiert werden.
Die Codekopie lautet wie folgt:
http.createServer (Funktion (Anfrage, Antwort) {
var tmp = request.url; // => "/foo/bar? a = b"
url.Parse (TMP);
/* =>
{Protokoll: NULL,
Schrägstriche: null,
AUTH: NULL,
Host: NULL,
Port: null,
Hostname: Null,
Hash: Null,
Suche: '? A = B',
Abfrage: 'A = B',
Pfadname: '/foo/bar',
Pfad: '/foo/bar? a = b',
href: '/foo/bar? a = b'}
*/
}). Hören (80);
Die .Parse -Methode unterstützt auch die optionalen Parameter des zweiten und dritten Booleschen Typs. Wenn der zweite Parameter gleich ist, ist das von der Methode zurückgegebene Abfragefeld im URL -Objekt kein String mehr, sondern ein vom QueryString -Modul konvertierter Parameterobjekt. Wenn der dritte Parameter entspricht, kann diese Methode URLs ohne Protokollheader wie //www.example.com/foo/bar korrekt analysieren.
Die Formatmethode ermöglicht das Umwandeln eines URL -Objekts in eine URL -Zeichenfolge, wie unten gezeigt.
Die Codekopie lautet wie folgt:
url.format ({{
Protokoll: 'http:',
Host: 'www.example.com',
Pfadname: '/p/a/t/h',
Suche: 'query = string' '
});
/* =>
'http://www.example.com/p/a/t/h?query=string'
*/
Zusätzlich kann die .resolve -Methode verwendet werden, um URLs zu spleißen, wie unten gezeigt.
Die Codekopie lautet wie folgt:
url.resolve ('http://www.example.com/foo/bar', '../baz');
/* =>
http://www.example.com/baz
*/
Abfragezeichenfolge
Das QueryString -Modul wird verwendet, um URL -Parameterzeichenfolgen und Parameterobjekte zu konvertieren, wie unten gezeigt.
Die Codekopie lautet wie folgt:
queryString.parse ('foo = bar & baz = qux & baz = quux & corge');
/* =>
{foo: 'bar', baz: ['qux', 'quux'], korge: ''}
*/
queryString.stringify ({foo: 'bar', baz: ['qux', 'quux'], Corge: ''});
/* =>
'foo = bar & baz = qux & baz = quux & corge ='
*/