les modules de base les plus utilisés de Node.js

Ein Node.js-Modul ist im Wesentlichen eine Reihe von JavaScript-Funktionen oder -Objekten, die in eine Anwendung eingebunden werden können. Mit Knotenmodulen können Sie Ihren Code in kleinere, wiederverwendbare Teile aufteilen.

Kernmodule:

Diese sind in Node.js integriert und bieten wesentliche Funktionen wie fs (Dateisystem), http (HTTP-Server/Client), Pfad, URL und mehr. Sie können auf diese Module zugreifen, ohne sie zu installieren, indem Sie require()

verwenden

Hier sind die am häufigsten verwendeten Kernmodule, die Entwickler in ihrem Projekt verwendet haben.

1. Pfad

Das Pfadmodul in Node.js bietet Dienstprogramme für die Arbeit mit Datei- und Verzeichnispfaden. Hier sind einige der am häufigsten verwendeten Methoden im Pfadmodul.

path.join()

Kombiniert mehrere Pfadsegmente zu einem einzigen Pfad. Es normalisiert den resultierenden Pfad und verarbeitet redundante Schrägstriche oder relative Pfade

const path = require('path');
const filePath = path.join('/users', 'john', 'documents', 'file.txt');
console.log(filePath); 
// Output: /users/john/documents/file.txt

path.resolve()

Löst eine Folge von Pfaden oder Pfadsegmenten in einen absoluten Pfad auf, beginnend mit dem aktuellen Arbeitsverzeichnis.

const absolutePath = path.resolve('documents', 'file.txt');
console.log(absolutePath); 
// Output: /your/current/working/directory/documents/file.txt

path.basename()

Gibt den letzten Teil eines Pfads zurück, normalerweise den Dateinamen. Sie können auch eine Erweiterung angeben, die aus dem Ergebnis entfernt werden soll.

const fullPath = '/users/john/file.txt';
console.log(path.basename(fullPath));       
 // Output: file.txt
console.log(path.basename(fullPath, '.txt')); 
// Output: file

path.dirname()

Gibt den Verzeichnisteil eines Pfades zurück.

const filePath = '/users/john/documents/file.txt';
console.log(path.dirname(filePath)); 
// Output: /users/john/documents

path.extname()

Gibt die Erweiterung der Datei im Pfad zurück, einschließlich des Punkts (.).

const filePath = '/users/john/documents/file.txt';
console.log(path.dirname(filePath));
 // Output: /users/john/documents

path.parse()

Gibt ein Objekt mit Eigenschaften zurück, die verschiedene Teile des Pfads darstellen

const parsedPath = path.parse('/users/john/file.txt');
console.log(parsedPath);
/* Output:
{
  root: '/',
  dir: '/users/john',
  base: 'file.txt',
  ext: '.txt',
  name: 'file'
}
*/

path.isAbsolute()

Überprüft, ob ein Pfad absolut ist, d. h. er beginnt im Stammverzeichnis (/ unter UNIX oder C: unter Windows).

console.log(path.isAbsolute('/users/john'));  
// Output: true
console.log(path.isAbsolute('file.txt'));    
 // Output: false

Es gibt weitere Methoden, mit denen Sie das offizielle Dokument des Pfadmoduls überprüfen können

2. fs (Dateisystem)

Das fs-Modul (File System) in Node.js ermöglicht Ihnen die Interaktion mit dem Dateisystem, um Dateien und Verzeichnisse zu lesen, zu schreiben und zu bearbeiten. Hier sind einige der am häufigsten verwendeten Methoden im fs-Modul

fs.readFile() & fs.readFileSync()

Liest den Inhalt einer Datei asynchron und synchron.

const fs = require('fs');
fs.readFile('example.txt', 'utf8', (err, data) => {
  if (err) throw err;
  console.log(data);
});

const data = fs.readFileSync('example.txt', 'utf8');
console.log(data);

fs.writeFile() & fs.writeFileSync()

Schreibt Daten asynchron und synchron in eine Datei.

fs.writeFile('example.txt', 'Hello, World!', (err) => {
  if (err) throw err;
  console.log('File written successfully');
});

fs.writeFileSync('example.txt', 'Hello, World!');
console.log('File written successfully');

fs.appendFile() & fs.appendFile()

Hängt Daten asynchron und synchron an eine Datei an.

fs.appendFile('example.txt', 'Hello, World!', (err) => {
  if (err) throw err;
  console.log('File written successfully');
});

fs.appendFileSync('example.txt', 'Hello, World!');
console.log('File written successfully');

fs.rename() & fs.renameSync()

Benennt oder verschiebt eine Datei asynchron und synchron.

fs.rename('example.txt', 'renamed.txt', (err) => {
  if (err) throw err;
  console.log('File renamed successfully');
});

fs.renameSync('example.txt', 'renamed.txt');
console.log('File renamed successfully');

fs.unlink() & fs.unlinkSync()

Löscht eine Datei asynchron und synchron.

fs.unlink('example.txt', (err) => {
  if (err) throw err;
  console.log('File deleted');
});

fs.unlinkSync('example.txt');
console.log('File deleted');

fs.mkdir() & fs.mkdirSync()

Creates a new directory asynchronously and synchronously.

fs.mkdir('newDirectory', (err) => {
  if (err) throw err;
  console.log('Directory created');
});

fs.mkdirSync('newDirectory');
console.log('Directory created');

fs.existsSync()

Checks if a file or directory exists synchronously.

const exists = fs.existsSync('example.txt');
console.log(exists ? 'File exists' : 'File does not exist');

fs.copyFile()

Copies a file asynchronously from one location to another.

fs.copyFile('source.txt', 'destination.txt', (err) => {
  if (err) throw err;
  console.log('File copied successfully');
});

There are more methods you can use for that check official document of fs module

3. events

The events module in Node.js is essential for implementing event-driven programming. It allows you to create, listen to, and manage custom events. The most commonly used class in this module is EventEmitter, which provides various methods for handling events. Here are some of the most used methods:

emitter.on()

Registers a listener (callback function) for a specific event. Multiple listeners can be registered for a single event.

emitter.emit()

Emits a specific event, triggering all listeners registered for that event. You can pass arguments to the listeners.

const EventEmitter = require('events');
const emitter = new EventEmitter();

emitter.on('greet', (name) => {
  console.log(`Hello, ${name}!`);
});

emitter.emit('greet', 'Alice'); // Output: Hello, Alice!

emitter.once()

Registers a listener for an event that will be called only once. After the event is emitted, the listener is automatically removed.

emitter.once('welcome', (name) => {
  console.log(`Welcome, ${name}!`);
});

emitter.emit('welcome', 'Alice'); // Output: Welcome, Alice!
emitter.emit('welcome', 'Bob');   // No output (listener is removed after first call)

emitter.removeAllListeners()

Removes all listeners for a specific event or for all events if no event is specified.

emitter.on('goodbye', () => console.log('Goodbye!'));
emitter.removeAllListeners('goodbye');

There are more methods you can use for that check official document of events module

4. URL()

The url module in Node.js provides utilities for URL parsing, formatting, and resolving. This module is useful for handling and manipulating URL strings in web applications.

new URL()

Creates a new URL object, which parses a given URL and provides access to its components.

URL.searchParams

Creates a new URL object, which parses a given URL and provides access to its components.

const { URL } = require('url');
const myUrl = new URL('https://example.com/path?name=John&age=30');

console.log(myUrl.searchParams.get('name'));  // Output: John

URL.toString() & URL.toJSON()

Converts a URL object into a string representation. Serializes the URL as a JSON string

const { URL } = require('url');
const myUrl = new URL('https://example.com/path?name=John');
console.log(myUrl.toString()); 
// Output: https://example.com/path?name=John

console.log(myUrl.toJSON()); 
// Output: "https://example.com/path?name=John"

URL.hostname & URL.port

Gets or sets the hostname portion of the URL (without port). Gets or sets the port portion of the URL.

const { URL } = require('url');
const myUrl = new URL('https://example.com:8000/path?name=John');
console.log(myUrl.hostname); 
// Output: example.com

console.log(myUrl.port); 
// Output: 8000

There are more methods you can use for that check official document of url module

5. http

The http module in Node.js provides functionality to create and handle HTTP requests and responses. Here are some of the most commonly used methods in the http module:

http.createServer()

Creates an HTTP server that listens for incoming requests. This method returns an instance of http.Server.

server.listen()

Starts the HTTP server and listens for requests on the specified port and host.

server.close()

Stops the server from accepting new connections and closes existing connections.

const http = require('http');

const server = http.createServer((req, res) => {
  res.statusCode = 200;
  res.setHeader('Content-Type', 'text/plain');
  res.end('Hello, World!\n');
});

server.listen(3000, () => {
  console.log('Server is running on http://localhost:3000');
});

server.close(() => {
  console.log('Server has been closed');
});

There are more methods you can use for that check official document of http module

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!