module URL
L'utilisation du module URL est extrêmement élevée lors de la gestion des demandes HTTP car le module permet d'analyser les URL, la génération d'URL et les URL d'épissage. Tout d'abord, jetons un coup d'œil aux composants d'une URL complète.
La copie de code est la suivante:
href
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
chemin de l'hôte
--------------------------------------------------------------------------------------------------------------------------------
http: // utilisateur: pass @ host.com: 8080 / p / a / t / h? query = string #hash
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Protocole Auth Hostname Port PathName Search Hash
------------
requête
Nous pouvons utiliser la méthode .Parse pour convertir une chaîne d'URL en un objet URL, comme indiqué ci-dessous.
La copie de code est la suivante:
url.parse ('http: // utilisateur: [email protected]: 8080 / p / a / t / h? query = string # hash');
/ * =>
{protocole: 'http:',
Auth: 'User: Pass',
Hôte: 'host.com:8080',
Port: '8080',
nom d'hôte: 'host.com',
Hash: '#hash',
Recherche: '? Query = String',
requête: 'query = string',
pathname: '/ p / a / t / h',
chemin: '/ p / a / t / h? query = string',
href: 'http: // utilisateur: [email protected]: 8080 / p / a / t / h? Query = string # hash'}
* /
La méthode .parse n'est pas nécessairement une URL complète. Par exemple, dans la fonction de rappel du serveur HTTP, request.url ne contient pas de têtes de protocole et de noms de domaine, mais peut également être analysé à l'aide de la méthode .Parse.
La copie de code est la suivante:
http.createServer (fonction (demande, réponse) {
var tmp = request.url; // => "/ foo / bar? a = b"
url.parse (TMP);
/ * =>
{protocole: nul,
Slashes: NULL,
Auth: NULL,
Hôte: NULL,
Port: NULL,
nom d'hôte: null,
Hash: Null,
Recherche: '? a = b',
requête: 'a = b',
pathname: '/ foo / bar',
chemin: '/ foo / bar? a = b',
href: '/ foo / bar? a = b'}
* /
}). écouter (80);
La méthode .Parse prend également en charge les deuxième et troisième paramètres optionnels de type booléen. Lorsque le deuxième paramètre est égal à TRUE, le champ de requête dans l'objet URL renvoyé par la méthode n'est plus une chaîne, mais un objet de paramètre converti par le module QuerryString. Lorsque le troisième paramètre est égal à TRUE, cette méthode peut analyser correctement les URL sans en-têtes de protocole, tels que //www.example.com/foo/bar.
La méthode de format, à son tour, permet de convertir un objet URL en une chaîne d'URL, comme indiqué ci-dessous.
La copie de code est la suivante:
url.format ({
protocole: 'http:',
Hôte: «www.example.com»,
pathname: '/ p / a / t / h',
Recherche: 'query = string'
});
/ * =>
'http://www.example.com/p/a/t/h?query=string'
* /
De plus, la méthode. Resolve peut être utilisée pour épisser les URL, comme indiqué ci-dessous.
La copie de code est la suivante:
url.resolve ('http://www.example.com/foo/bar', '../baz');
/ * =>
http://www.example.com/baz
* /
Chaîne de requête
Le module de requête est utilisé pour convertir les chaînes de paramètres d'URL et les objets de paramètre, comme indiqué ci-dessous.
La copie de code est la suivante:
queystring.parse ('foo = bar & baz = qux & baz = quux & Corge');
/ * =>
{foo: 'bar', baz: ['qux', 'quux'], Corge: ''}
* /
queystring.stringify ({foo: 'bar', baz: ['qux', 'quux'], corge: ''});
/ * =>
'foo = bar & baz = qux & baz = quux & corge ='
* /