Node.js-url-Modul
Node.js integrierte ModuleIn Node.js, dasurlDas Modul ist ein integriertes Modul, das zum Verarbeiten und Parsen von URLs (Uniform Resource Locators) verwendet wird. Es bietet eine Reihe von Hilfsmethoden, um URL-Zeichenfolgen einfach zu parsen, zu formatieren und zu verarbeiten.
URL (Uniform Resource Locator) ist eine Adresse im Internet, mit der Ressourcen identifiziert und lokalisiert werden, zum Beispiel:
https://www.example.com:8080/path/to/resource?query=string#hash
Kernmethoden
url.parse()-Methode
url.parse()Diese Methode wird verwendet, um eine URL-Zeichenfolge in ein URL-Objekt zu parsen.
Beispiel
const urlString = 'https://www.example.com:8080/path/to/resource?query=string#hash';
const parsedUrl = url.parse(urlString);
console.log(parsedUrl);
Die Ausgabe enthält die folgenden Eigenschaften:
protocol: Protokoll (z. B. 'https:')host: Hostname und Port (z. B. 'www.example.com:8080'）hostname: Hostname (z. B. 'www.example.com'）port: Portnummer (z. B. '8080')pathname: Pfadteil (z. B. '/path/to/resource')query: Abfragezeichenfolge (z. B. 'query=string')hash: Fragmentbezeichner (z. B. '#hash')
url.format()-Methode
url.format()Die Methode, im Gegensatz zuparse()Umgekehrt wandelt sie ein URL-Objekt in eine String-Form um.
Beispiel
const urlObject = {
protocol: 'https:',
host: 'www.example.com:8080',
pathname: '/path/to/resource',
query: { query: 'string' },
hash: '#hash'
};
const formattedUrl = url.format(urlObject);
console.log(formattedUrl);
// Ausgabe: https://www.example.com:8080/path/to/resource?query=string#hash
url.resolve()-Methode
url.resolve()Diese Methode wird verwendet, um eine Ziel-URL relativ zu einer Basis-URL aufzulösen.
Beispiel
const baseUrl = 'https://www.example.com/path/';
const relativeUrl = 'to/resource';
const resolvedUrl = url.resolve(baseUrl, relativeUrl);
console.log(resolvedUrl);
// Ausgabe: https://www.example.com/path/to/resource
Struktur des URL-Objekts
Ein vollständiges URL-Objekt enthält normalerweise die folgenden Eigenschaften:
- Protokoll (protocol)- wie 'http:' oder 'https:'
- Authentifizierungsinformationen (auth)- enthält Benutzername und Passwort
- Host (host)- Hostname und Portnummer
- Hostname (hostname)- nur Hostname
- Port (port)- Portnummer
- Pfad (pathname)- Ressourcenpfad
- Abfragezeichenfolge (search)- Abfragezeichenfolge beginnend mit '?'
- Abfrageparameter (query)- das geparste Ergebnis der Abfragezeichenfolge
- Fragmentbezeichner (hash)- Fragmentbezeichner beginnend mit '#'
Neue URL-API
Node.js stellt außerdem eine neue API bereit, die auf dem WHATWG-URL-Standard basiert:
URL-Klasse
Beispiel
const myUrl = new URL('https://www.example.com:8080/path/to/resource?query=string#hash');
console.log(myUrl.protocol); // 'https:'
console.log(myUrl.hostname); // 'www.example.com'
console.log(myUrl.port); // '8080'
console.log(myUrl.pathname); // '/path/to/resource'
console.log(myUrl.search); // '?query=string'
console.log(myUrl.hash); // '#hash'
URLSearchParams-Klasse
URLSearchParamsBietet praktische Methoden für den Umgang mit Query-Strings:
Beispiel
const myUrl = new URL('https://example.com/?name=John&age=30');
const params = new URLSearchParams(myUrl.search);
// Parameter abrufen
console.log(params.get('name')); // 'John'
console.log(params.get('age')); // '30'
// Parameter hinzufügen
params.append('city', 'New York');
// Parameter löschen
params.delete('age');
// In String umwandeln
console.log(params.toString()); // 'name=John&city=New+York'
Praktische Anwendungsszenarien
1. Parsen von Anfrage-URLs
Die URL einer Client-Anfrage in einem HTTP-Server parsen:
Beispiel
const url = require('url');
const server = http.createServer((req, res) => {
const parsedUrl = url.parse(req.url, wahr);
console.log('Pfad:', parsedUrl.pathname);
console.log('Abfrage:', parsedUrl.query);
res.end('URL erfolgreich geparst');
});
server.listen(3000);
2. API-Endpunkte erstellen
Verwenden Sie das URL-Modul, um RESTful-API-Endpunkte zu erstellen:
Beispiel
const url = require('url');
const server = http.createServer((req, res) => {
const parsedUrl = url.parse(req.url, wahr);
const path = parsedUrl.pathname;
if (path === '/api/users') {
// Benutzerbezogene Anfragen bearbeiten
res.end(JSON.stringify({ users: ['John', 'Jane'] }));
} else if (path === '/api/products') {
// Produktbezogene Anfragen bearbeiten
res.end(JSON.stringify({ products: ['Phone', 'Laptop'] }));
} else {
res.statusCode = 404;
res.end('Nicht gefunden');
}
});
server.listen(3000);
3. Umgang mit Query-Parametern
Beispiel
const url = require('url');
const server = http.createServer((req, res) => {
const parsedUrl = url.parse(req.url, wahr);
const query = parsedUrl.query;
if (parsedUrl.pathname === '/search') {
const keyword = query.q || '';
const page = parseInt(query.page) || 1;
res.end(`Suche nach "${keyword}" auf Seite ${page}`);
}
});
server.listen(3000);
Best Practices
- URLs immer validieren- Bei der Verarbeitung von benutzerbereitgestellten URLs immer deren Gültigkeit überprüfen
- Die neue API verwenden- Bevorzugen Sie die WHATWG URL API, da sie besser zu modernen Standards passt
- Ausnahmen behandeln- Verwenden Sie try-catch, um Fehler zu behandeln, die während des URL-Parsings auftreten können
- Sonderzeichen codieren- Verwenden Sie
encodeURIComponent()um Sonderzeichen in Abfrageparametern zu codieren - Sicherheitsüberlegungen- Validieren Sie beim Umgang mit Weiterleitungen die Ziel-URL, um Open-Redirect-Schwachstellen zu verhindern
Beispiel
function isValidRedirect(url) {
const allowedDomains = ['example.com', 'trusted-site.com'];
const parsedUrl = new URL(url);
return allowedDomains.includes(parsedUrl.hostname);
}
Wenn Sie das Node.js-urlModul, mit dem Sie problemlos verschiedene URL-bezogene Operationen ausführen und robustere und sicherere Webanwendungen erstellen können.