Parlons de certains modules intégrés de nœud couramment utilisés et de leurs fonctions

Node.js est un environnement d'exécution open source basé sur le moteur JavaScript Chrome V8, qui permet à JavaScript de s'exécuter côté serveur. Node.js est léger, efficace et multiplateforme, il est donc très populaire dans le développement Web, le développement d'applications, le traitement de données et d'autres domaines.

Dans le développement réel, nous avons souvent besoin d'interagir avec des interfaces externes, comme l'obtention de données, l'envoi de requêtes, etc. Alors, Node.js lui-même a-t-il sa propre interface ?

La réponse est oui. Node.js fournit de nombreux modules intégrés qui peuvent être utilisés pour interagir avec des interfaces externes. Présentons un par un quelques modules intégrés couramment utilisés et leurs fonctions.

http

Dans Node.js, http est un module intégré permettant de créer des serveurs et des clients HTTP. Grâce au module http, nous pouvons facilement créer un serveur HTTP capable de gérer les requêtes et les réponses HTTP et de fournir des fonctions d'interface avec le monde extérieur. Par exemple, nous pouvons renvoyer différentes données en fonction de différents chemins d'URL.

Voici un exemple simple :

const http = require('http');

const server = http.createServer((req, res) => {
  if (req.url === '/') {
    res.end('Hello, world!');
  } else if (req.url === '/about') {
    res.end('About us');
  } else {
    res.end('Not found');
  }
});

server.listen(3000, () => {
  console.log('Server started on port 3000');
});

https

En plus du module http, Node.js fournit également un module https pour créer des serveurs et des clients HTTPS. Semblable à http, nous pouvons également renvoyer différentes données en fonction de différents chemins d'URL. Cependant, il est important de noter que HTTPS est un protocole HTTP crypté et qu'il nécessite un certificat pour fonctionner correctement.

Voici un exemple simple :

const https = require('https');
const fs = require('fs');

const options = {
  key: fs.readFileSync('server.key'),
  cert: fs.readFileSync('server.cert')
};

const server = https.createServer(options, (req, res) => {
  if (req.url === '/') {
    res.end('Hello, world (HTTPS)!');
  } else if (req.url === '/about') {
    res.end('About us (HTTPS)');
  } else {
    res.end('Not found (HTTPS)');
  }
});

server.listen(3000, () => {
  console.log('Server started on port 3000 (HTTPS)');
});

net

En plus des modules http et https, Node.js fournit également le module net pour créer des serveurs et clients TCP. Grâce au module net, nous pouvons réaliser la transmission réseau, la communication Socket et d'autres fonctions. Par exemple, nous pouvons mettre en œuvre des fonctions telles que des salons de discussion multi-personnes et des jeux en ligne via la communication Socket.

Voici un exemple simple :

const net = require('net');

const server = net.createServer((socket) => {
  socket.write('Echo server\r\n');
  socket.pipe(socket);
});

server.listen(1337, '127.0.0.1', () => {
  console.log('Server started on port 1337');
});

dns

Dans Node.js, dns est un module intégré utilisé pour la résolution de noms de domaine. Grâce au module DNS, nous pouvons facilement implémenter la fonction de résolution des noms de domaine en adresses IP et fournir des interfaces externes.

Voici un exemple simple :

const dns = require('dns');

dns.lookup('www.google.com', (err, address) => {
  console.log('address: %j', address);
});

url

Dans Node.js, url est un module intégré pour l'analyse d'URL. Grâce au module url, nous pouvons facilement obtenir diverses parties de l'URL, telles que le protocole, le nom d'hôte, le numéro de port, le chemin, les paramètres de requête, etc.

Voici un exemple simple :

const url = require('url');

const myUrl = url.parse('https://www.baidu.com/search?q=node.js');

console.log('protocol:', myUrl.protocol); // https:
console.log('hostname:', myUrl.hostname); // www.baidu.com
console.log('port:', myUrl.port); // null
console.log('pathname:', myUrl.pathname); // /search
console.log('query:', myUrl.query); // q=node.js

querystring

Dans Node.js, querystring est un module intégré pour analyser et formater les chaînes de requête. Grâce au module querystring, nous pouvons facilement obtenir chaque paramètre de la chaîne de requête et fournir une interface avec le monde extérieur.

Voici un exemple simple :

const querystring = require('querystring');

const myQuery = querystring.parse('q=node.js&from=google');

console.log(myQuery); // { q: 'node.js', from: 'google' }

const myString = querystring.stringify(myQuery);

console.log(myString); // q=node.js&from=google

Résumé

Grâce à l'introduction ci-dessus, nous pouvons voir que dans Node.js, il existe de nombreux modules intégrés qui peuvent être utilisés pour interagir avec des interfaces externes. Ces modules peuvent répondre à la plupart de nos besoins et éviter d'introduire trop de dépendances. Bien entendu, Node.js prend également en charge les modules tiers, et nous pouvons également choisir des modules tiers appropriés en fonction de circonstances spécifiques.

Fournir des interfaces externes est une partie importante du développement Web La puissante fonction d'interface de Node.js fournit une aide précieuse pour notre développement.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!