Module url de Node.js

Java FileModules intégrés de Node.js

Dans Node.js, leurlmodule est un module intégré utilisé pour gérer et analyser les URL (Uniform Resource Locators). Il fournit une série de méthodes utilitaires pour analyser, formater et traiter facilement des chaînes URL.

Une URL (Uniform Resource Locator) est une adresse sur Internet utilisée pour identifier et localiser des ressources, par exemple :

https://www.example.com:8080/path/to/resource?query=string#hash

Méthodes de base

méthode url.parse()

url.parse()Cette méthode est utilisée pour analyser une chaîne URL en un objet URL.

Exemple

const url = require('url');

const urlString = 'https://www.example.com:8080/path/to/resource?query=string#hash';
const parsedUrl = url.parse(urlString);

console.log(parsedUrl);

La sortie contiendra les propriétés suivantes :

  • protocol: protocole (par ex., 'https:')
  • host: nom d'hôte et port (par ex., 'www.example.com:8080'）
  • hostname: nom d'hôte (par ex., 'www.example.com'）
  • port: numéro de port (par ex., '8080')
  • pathname: partie de chemin (par ex., '/path/to/resource')
  • query: chaîne de requête (par ex., 'query=string')
  • hash: identificateur de fragment (par ex., '#hash')

méthode url.format()

url.format()La méthode, par opposition àparse()Inversement, elle convertit un objet URL en une chaîne de caractères.

Exemple

const url = require('url');

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);
// Sortie : https://www.example.com:8080/path/to/resource?query=string#hash

méthode url.resolve()

url.resolve()Cette méthode est utilisée pour résoudre une URL cible relative à une URL de base.

Exemple

const url = require('url');

const baseUrl = 'https://www.example.com/path/';
const relativeUrl = 'to/resource';

const resolvedUrl = url.resolve(baseUrl, relativeUrl);
console.log(resolvedUrl);
// Sortie : https://www.example.com/path/to/resource

Structure de l'objet URL

Un objet URL complet contient généralement les propriétés suivantes :

  1. Protocole (protocol)- tel que 'http:' ou 'https:'
  2. Informations d'authentification (auth)- contient le nom d'utilisateur et le mot de passe
  3. Hôte (host)- nom d'hôte et numéro de port
  4. Nom d'hôte (hostname)- nom d'hôte uniquement
  5. Port (port)- numéro de port
  6. Chemin (pathname)- chemin de la ressource
  7. Chaîne de requête (search)- chaîne de requête commençant par '?'
  8. Paramètres de requête (query)- résultat analysé de la chaîne de requête
  9. Identifiant de fragment (hash)- identifiant de fragment commençant par '#'

Nouvelle API URL

Node.js fournit également une nouvelle API basée sur le standard URL WHATWG :

Classe URL

Exemple

const { URL } = require('url');

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'

Classe URLSearchParams

URLSearchParamsFournit des méthodes pratiques pour gérer les chaînes de requête :

Exemple

const { URL, URLSearchParams } = require('url');

const myUrl = new URL('https://example.com/?name=John&age=30');
const params = new URLSearchParams(myUrl.search);

// Obtenir le paramètre
console.log(params.get('name')); // 'John'
console.log(params.get('age'));  // '30'

// Ajouter un paramètre
params.append('city', 'New York');

// Supprimer le paramètre
params.delete('age');

// Convertir en chaîne de caractères
console.log(params.toString()); // 'name=John&city=New+York'

Scénarios d'application pratiques

1. Analyse des URL de requête

Analyser l'URL d'une requête client dans un serveur HTTP :

Exemple

const http = require('http');
const url = require('url');

const server = http.createServer((req, res) => {
  const parsedUrl = url.parse(req.url, vrai);
 
  console.log('Chemin :', parsedUrl.pathname);
  console.log('Requête :', parsedUrl.query);
 
  res.end('URL analysée avec succès');
});

server.listen(3000);

2. Construction des points de terminaison d'API

Utilisez le module URL pour créer des points de terminaison d'API RESTful :

Exemple

const http = require('http');
const url = require('url');

const server = http.createServer((req, res) => {
  const parsedUrl = url.parse(req.url, vrai);
  const path = parsedUrl.pathname;
 
  if (path === '/api/users') {
    // Gérer les requêtes liées aux utilisateurs
    res.end(JSON.stringify({ users: ['John', 'Jane'] }));
  } else if (path === '/api/products') {
    // Gérer les requêtes liées aux produits
    res.end(JSON.stringify({ products: ['Phone', 'Laptop'] }));
  } else {
    res.statusCode = 404;
    res.end('Not Found');
  }
});

server.listen(3000);

3. Gestion des paramètres de requête

Exemple

const http = require('http');
const url = require('url');

const server = http.createServer((req, res) => {
  const parsedUrl = url.parse(req.url, vrai);
  const query = parsedUrl.query;
 
  if (parsedUrl.pathname === '/') {
    const keyword = query.q || '';
    const page = parseInt(query.page) || 1;
   
    res.end(`Searching for "${keyword}"⟦⟧on page $ on page ${page}`);
  }
});

server.listen(3000);

Bonnes pratiques

  1. Toujours valider les URL- Lors du traitement d'URL fournies par l'utilisateur, validez toujours leur validité
  2. Utilisez la nouvelle- Préférez l'API URL WHATWG, car elle est plus conforme aux normes modernes
  3. Gérer les exceptions- Utiliser try-catch pour gérer les erreurs pouvant survenir lors de l'analyse d'URL
  4. Encoder les caractères spéciaux- UtiliserencodeURIComponent()pour encoder les caractères spéciaux dans les paramètres de requête
  5. Considérations de sécurité- Lors de la gestion des redirections, validez l'URL cible pour prévenir les vulnérabilités de redirection ouverte

Exemple

// Exemple de sécurité : valider l'URL de redirection
function isValidRedirect(url) {
  const allowedDomains = ['example.com', 'trusted-site.com'];
  const parsedUrl = new URL(url);
  return allowedDomains.includes(parsedUrl.hostname);
}

En maîtrisant leurlmodule, vous pouvez facilement gérer diverses opérations liées aux URL et créer des applications web plus robustes et sécurisées.

Java FileModules intégrés de Node.js

Autres extensions