📃 📻 👨🏿‍💼 Guide Node.js, partie 10: modules standard, flux, bases de données, NODE

Ce document conclut la série de traductions du manuel Node.js. Aujourd'hui, nous allons parler des systèmes d'exploitation, des événements et des modules http, discuter de l'utilisation des flux et des bases de données et discuter de l'utilisation de Node.js dans le développement et la production d'applications.

[Nous vous conseillons de lire] Autres parties du cycle

Partie 1: Informations générales et mise en route
Partie 2: JavaScript, V8, quelques astuces de développement
Partie 3: Hébergement, REPL, travailler avec la console, les modules
Partie 4: fichiers npm, package.json et package-lock.json
Partie 5: npm et npx
Partie 6: boucle d'événements, pile d'appels, temporisateurs
Partie 7: Programmation asynchrone
Partie 8: Protocoles HTTP et WebSocket
Partie 9: travailler avec le système de fichiers
Partie 10: modules standard, threads, bases de données, NODE_ENV
PDF complet du guide Node.js

Module OS Node.js

Le module os donne accès à de nombreuses fonctions qui peuvent être utilisées pour obtenir des informations sur le système d'exploitation et le matériel de l'ordinateur exécutant Node.js. Il s'agit d'un module standard, vous n'avez pas besoin de l'installer, pour travailler avec lui à partir du code, il suffit de le connecter:

 const os = require('os')

Il existe plusieurs propriétés utiles ici, qui, en particulier, peuvent être utiles lorsque vous travaillez avec des fichiers.

Ainsi, la propriété os.EOL permet de connaître le séparateur de ligne utilisé dans le système (un os.EOL ligne). Sous Linux et macOS, c'est \n , sous Windows, \r\n .

Il convient de noter que lorsque nous mentionnons «Linux et macOS» ici, nous parlons de plates-formes compatibles POSIX. Par souci de concision, nous ne mentionnons pas ici les plateformes moins populaires.

La propriété os.constants.signals fournit des informations sur les constantes utilisées pour traiter les signaux de processus tels que SIGHUP , SIGKILL , etc. Ici vous pouvez trouver des détails à leur sujet.

La propriété os.constants.errno contient les constantes utilisées pour les messages d'erreur - comme EADDRINUSE , EOVERFLOW .

Considérons maintenant les principales méthodes du module os .

▍os.arch ()

Cette méthode renvoie une chaîne identifiant l'architecture du système, par exemple, arm , x64 , arm64 .

▍os.cpus ()

Renvoie des informations sur les processeurs disponibles dans le système. Par exemple, ces informations peuvent ressembler à ceci:

 [ { model: 'Intel(R) Core(TM)2 Duo CPU     P8600 @ 2.40GHz',   speed: 2400,   times:    { user: 281685380,      nice: 0,      sys: 187986530,      idle: 685833750,      irq: 0 } }, { model: 'Intel(R) Core(TM)2 Duo CPU     P8600 @ 2.40GHz',   speed: 2400,   times:    { user: 282348700,      nice: 0,      sys: 161800480,      idle: 703509470,      irq: 0 } } ]

▍os.endianness ()

Renvoie BE ou LE fonction de l' ordre des octets (Big Engian ou Little Endian) utilisé pour compiler le fichier binaire Node.js.

▍os.freemem ()

Renvoie la quantité de mémoire système libre en octets.

▍os.homedir ()

Renvoie le chemin d'accès au répertoire personnel de l'utilisateur actuel. Par exemple, '/Users/flavio' .

▍os.hostname ()

Renvoie le nom d'hôte.

▍os.loadavg ()

Renvoie, dans un tableau, les données de charge moyenne calculées par le système d'exploitation. Ces informations n'ont de sens que sous Linux et macOS. Cela peut ressembler à ceci:

 [ 3.68798828125, 4.00244140625, 11.1181640625 ]

▍os.networkInterfaces ()

Renvoie des informations sur les interfaces réseau disponibles sur le système. Par exemple:

 { lo0:  [ { address: '127.0.0.1',      netmask: '255.0.0.0',      family: 'IPv4',      mac: 'fe:82:00:00:00:00',      internal: true },    { address: '::1',      netmask: 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff',      family: 'IPv6',      mac: 'fe:82:00:00:00:00',      scopeid: 0,      internal: true },    { address: 'fe80::1',      netmask: 'ffff:ffff:ffff:ffff::',      family: 'IPv6',      mac: 'fe:82:00:00:00:00',      scopeid: 1,      internal: true } ], en1:  [ { address: 'fe82::9b:8282:d7e6:496e',      netmask: 'ffff:ffff:ffff:ffff::',      family: 'IPv6',      mac: '06:00:00:02:0e:00',      scopeid: 5,      internal: false },    { address: '192.168.1.38',      netmask: '255.255.255.0',      family: 'IPv4',      mac: '06:00:00:02:0e:00',      internal: false } ], utun0:  [ { address: 'fe80::2513:72bc:f405:61d0',      netmask: 'ffff:ffff:ffff:ffff::',      family: 'IPv6',      mac: 'fe:80:00:20:00:00',      scopeid: 8,      internal: false } ] }

▍os.platform ()

Renvoie des informations sur la plate-forme pour laquelle Node.js. a été compilé. Voici quelques-unes des valeurs de retour possibles:

Darwin
freebsd
linux
openbsd
win32

▍os.release ()

Renvoie une chaîne identifiant le numéro de version du système d'exploitation.

▍os.tmpdir ()

Renvoie le chemin d'accès au répertoire spécifié dans le système pour le stockage des fichiers temporaires.

▍os.totalmem ()

Renvoie la quantité totale de mémoire système en octets.

▍os.type ()

Renvoie des informations qui identifient le système d'exploitation. Par exemple:

Linux - Linux.
Darwin - macOS.
Windows_NT - Windows.

▍os.uptime ()

Renvoie la disponibilité du système en secondes depuis le dernier redémarrage.

Module d'événements Node.js

Le module d' events nous fournit la classe EventEmitter , qui est conçue pour fonctionner avec des événements sur la plate-forme Node.js. Nous avons déjà parlé un peu de ce module dans le septième de cette série de documents. Voici la documentation pour cela. Ici, nous regardons l'API de ce module. Rappelez-vous que pour l'utiliser dans le code, vous devez le connecter, comme c'est généralement le cas avec les modules standard. Après cela, vous devez créer un nouvel objet EventEmitter . Cela ressemble à ceci:

 const EventEmitter = require('events') const door = new EventEmitter()

L'objet de la classe EventEmitter utilise des mécanismes standard, en particulier les événements suivants:

newListener - cet événement est newListener lorsqu'un gestionnaire d'événements est ajouté.
removeListener - appelé lorsque le gestionnaire est supprimé.

Considérez les méthodes d'objets les plus utiles de la classe EventEmitter (un objet similaire dans les noms des méthodes est indiqué comme emitter ).

▍emitter.addListener ()

Un alias pour la méthode emitter.on() .

▍emitter.emit ()

Génère un événement. Appelle tous les gestionnaires d'événements de manière synchrone dans l'ordre dans lequel ils ont été enregistrés.

▍emitter.eventNames ()

Renvoie un tableau contenant les événements enregistrés.

▍emitter.getMaxListeners ()

Renvoie le nombre maximal de gestionnaires pouvant être ajoutés à un objet de la classe EventEmitter . La valeur par défaut est 10. Si nécessaire, ce paramètre peut être augmenté ou diminué à l'aide de la méthode setMaxListeners() .

▍emitter.listenerCount ()

Renvoie le nombre de gestionnaires d'événements dont le nom est transmis à cette méthode en tant que paramètre:

 door.listenerCount('open')

▍emitter.listeners ()

Renvoie un tableau de gestionnaires d'événements pour l'événement correspondant, dont le nom est transmis à cette méthode:

 door.listeners('open')

▍emitter.off ()

Un alias pour la méthode emitter.removeListener() , introduite dans le nœud 10.

▍emitter.on ()

Enregistrez un rappel qui est appelé lorsqu'un événement est généré. Voici comment l'utiliser:

 door.on('open', () => { console.log('Door was opened') })

▍emitter.once ()

Il enregistre un rappel qui n'est appelé qu'une seule fois - lors de la première occurrence d'un événement pour lequel ce rappel est enregistré. Par exemple:

 const EventEmitter = require('events') const ee = new EventEmitter() ee.once('my-event', () => { //         })

▍emitter.prependListener ()

Lors de l'inscription d'un gestionnaire à l'aide des méthodes on() ou addListener() , ce gestionnaire est ajouté à la fin de la file d'attente du gestionnaire et est appelé en dernier pour gérer l'événement correspondant. Lorsque vous utilisez la méthode prependListener() , le gestionnaire est ajouté à l'avant de la file d'attente, ce qui le fait être appelé en premier pour traiter l'événement.

▍emitter.prependOnceListener ()

Cette méthode est similaire à la précédente. À savoir, lorsqu'un gestionnaire destiné à un seul appel est enregistré à l'aide de la méthode once() , il s'avère qu'il est le dernier dans la file d'attente des gestionnaires et le dernier à être appelé. La méthode prependOnceListener() vous permet d'ajouter un tel gestionnaire à l'avant de la file d'attente.

▍emitter.removeAllListeners ()

Cette méthode supprime tous les gestionnaires d'un événement donné enregistrés dans l'objet correspondant. Ils l'utilisent comme ceci:

 door.removeAllListeners('open')

▍emitter.removeListener ()

Supprime le gestionnaire spécifié à transmettre à cette méthode. Afin de sauvegarder le gestionnaire pour une suppression ultérieure, le rappel correspondant peut être affecté à une variable. Cela ressemble à ceci:

 const doSomething = () => {} door.on('open', doSomething) door.removeListener('open', doSomething)

▍emitter.setMaxListeners ()

Cette méthode vous permet de spécifier le nombre maximal de gestionnaires pouvant être ajoutés à un seul événement dans une instance de la classe EventEmitter . Par défaut, comme déjà mentionné, vous pouvez ajouter jusqu'à 10 gestionnaires pour un événement particulier. Cette valeur peut être modifiée. Utilisez cette méthode comme suit:

 door.setMaxListeners(50)

Module http Node.js

Dans la huitième partie de cette série de documents, nous avons déjà parlé du module http Node.js standard. Il met à disposition des mécanismes de développement destinés à créer des serveurs HTTP. C'est le module principal utilisé pour résoudre les problèmes d'échange de données sur le réseau dans Node.js. Vous pouvez le connecter dans le code comme ceci:

 const http = require('http')

Il se compose de propriétés, de méthodes et de classes. Parlons-en.

▍Propriétés

http.METHODS

Cette propriété répertorie toutes les méthodes HTTP prises en charge:

 > require('http').METHODS [ 'ACL', 'BIND', 'CHECKOUT', 'CONNECT', 'COPY', 'DELETE', 'GET', 'HEAD', 'LINK', 'LOCK', 'M-SEARCH', 'MERGE', 'MKACTIVITY', 'MKCALENDAR', 'MKCOL', 'MOVE', 'NOTIFY', 'OPTIONS', 'PATCH', 'POST', 'PROPFIND', 'PROPPATCH', 'PURGE', 'PUT', 'REBIND', 'REPORT', 'SEARCH', 'SUBSCRIBE', 'TRACE', 'UNBIND', 'UNLINK', 'UNLOCK', 'UNSUBSCRIBE' ]

http.STATUS_CODES

Il contient les codes d'état HTTP et leurs descriptions:

 > require('http').STATUS_CODES { '100': 'Continue', '101': 'Switching Protocols', '102': 'Processing', '200': 'OK', '201': 'Created', '202': 'Accepted', '203': 'Non-Authoritative Information', '204': 'No Content', '205': 'Reset Content', '206': 'Partial Content', '207': 'Multi-Status', '208': 'Already Reported', '226': 'IM Used', '300': 'Multiple Choices', '301': 'Moved Permanently', '302': 'Found', '303': 'See Other', '304': 'Not Modified', '305': 'Use Proxy', '307': 'Temporary Redirect', '308': 'Permanent Redirect', '400': 'Bad Request', '401': 'Unauthorized', '402': 'Payment Required', '403': 'Forbidden', '404': 'Not Found', '405': 'Method Not Allowed', '406': 'Not Acceptable', '407': 'Proxy Authentication Required', '408': 'Request Timeout', '409': 'Conflict', '410': 'Gone', '411': 'Length Required', '412': 'Precondition Failed', '413': 'Payload Too Large', '414': 'URI Too Long', '415': 'Unsupported Media Type', '416': 'Range Not Satisfiable', '417': 'Expectation Failed', '418': 'I\'ma teapot', '421': 'Misdirected Request', '422': 'Unprocessable Entity', '423': 'Locked', '424': 'Failed Dependency', '425': 'Unordered Collection', '426': 'Upgrade Required', '428': 'Precondition Required', '429': 'Too Many Requests', '431': 'Request Header Fields Too Large', '451': 'Unavailable For Legal Reasons', '500': 'Internal Server Error', '501': 'Not Implemented', '502': 'Bad Gateway', '503': 'Service Unavailable', '504': 'Gateway Timeout', '505': 'HTTP Version Not Supported', '506': 'Variant Also Negotiates', '507': 'Insufficient Storage', '508': 'Loop Detected', '509': 'Bandwidth Limit Exceeded', '510': 'Not Extended', '511': 'Network Authentication Required' }

http.globalAgent

Cette propriété pointe vers l'instance globale de la classe http.Agent . Il est utilisé pour gérer les connexions. Il peut être considéré comme un composant clé du sous-système HTTP Node.js. Nous parlerons plus en détail de la classe http.Agent ci-dessous.

▍Méthodes

http.createServer ()

Renvoie une nouvelle instance de la classe http.Server . Voici comment utiliser cette méthode pour créer un serveur HTTP:

 const server = http.createServer((req, res) => { //      })

http.request ()

Vous permet de faire une requête HTTP au serveur en créant une instance de la classe http.ClientRequest .

http.get ()

Cette méthode est similaire à http.request() , mais elle définit automatiquement la méthode HTTP sur GET et appelle automatiquement une commande de la forme req.end() .

▍ Classes

Le module HTTP fournit 5 classes - Agent , ClientRequest , Server , ServerResponse et IncomingMessage . Considérez-les.

http.Agent

L'instance globale de la classe http.Agent créée par Node.js est utilisée pour gérer les connexions. Il est utilisé comme valeur par défaut pour toutes les requêtes HTTP et fournit la mise en file d'attente et la réutilisation des sockets. De plus, il prend en charge un pool de sockets, qui permet des performances élevées du sous-système réseau Node.js. Si nécessaire, vous pouvez créer votre propre objet http.Agent .

http.ClientRequest

Un objet de la classe http.ClientRequest , qui est une demande en cours d'exécution, est créé lorsque les http.request() ou http.get() sont appelées. Lorsqu'une réponse à une demande est reçue, l'événement de réponse est déclenché, dans lequel la réponse est transmise - une instance de http.IncomingMessage . Les données obtenues une fois la requête terminée peuvent être traitées de deux manières:

Vous pouvez appeler la méthode response.read() .
Dans le gestionnaire d'événements de response , vous pouvez configurer un écouteur pour l'événement de data , ce qui vous permet de travailler avec des données en streaming.

http.Server

Les instances de cette classe sont utilisées pour créer des serveurs à l'aide de la commande http.createServer() . Après avoir un objet serveur, nous pouvons utiliser ses méthodes:

La méthode listen() est utilisée pour démarrer le serveur et organiser l'attente et le traitement des requêtes entrantes.
La méthode close() arrête le serveur.

http.ServerResponse

Cet objet est créé par la classe http.Server et transmis en tant que deuxième paramètre à l'événement de request lorsqu'il se produit. En règle générale, ces objets dans le code reçoivent le nom res :

 const server = http.createServer((req, res) => { //res -   http.ServerResponse })

Dans ces gestionnaires, une fois que la réponse du serveur est prête à être envoyée au client, la méthode end() est appelée, ce qui termine la réponse. Cette méthode doit être appelée après la fin de chaque réponse.

Voici les méthodes utilisées pour travailler avec les en-têtes HTTP:

getHeaderNames() - retourne une liste de noms d'en-têtes installés.
getHeaders() - renvoie une copie des en-têtes HTTP définis.
setHeader('headername', value) - définit la valeur de l'en-tête spécifié.
getHeader('headername') - renvoie l'en-tête défini.
removeHeader('headername') - supprime l'en-tête installé.
hasHeader('headername') - renvoie true si la réponse a déjà un en-tête dont le nom est passé à cette méthode.
headersSent() - renvoie true si les en-têtes sont déjà envoyés au client.

Après avoir traité les en-têtes, ils peuvent être envoyés au client en appelant la méthode response.writeHead() , qui, en tant que premier paramètre, prend un code d'état. En tant que deuxième et troisième paramètres, un message correspondant au code d'état et aux en-têtes peut lui être transmis.

Pour envoyer des données au client, la méthode write() est utilisée dans le corps de la réponse. Il envoie des données en mémoire tampon au flux de réponse HTTP.

Si les en-têtes n'ont pas encore été définis avec la commande response.writeHead() , les en-têtes avec le code d'état et le message spécifiés dans la demande seront envoyés en premier. Vous pouvez définir leurs valeurs en définissant des valeurs pour les statusMessage statusCode et statusMessage :

 response.statusCode = 500 response.statusMessage = 'Internal Server Error'

http.IncomingMessage

Un objet de la classe http.IncomingMessage est créé au cours des mécanismes suivants:

http.Server - lors du traitement de l'événement de request .
http.ClientRequest - lors de la gestion de l'événement de response .

Il peut être utilisé pour travailler avec des données de réponse. À savoir:

Afin de connaître le code d'état de réponse et le message correspondant, les propriétés statusCode et statusMessage sont utilisées.
Vous pouvez voir les en- headers réponse headers rawHearders headers ou rawHearders (pour une liste des en-têtes raw).
Vous pouvez découvrir la méthode de demande à l'aide de la propriété method .
Pour savoir quelle version de HTTP est utilisée, utilisez la propriété httpVersion .
Pour obtenir l'URL, la propriété url est destinée.
La propriété socket vous permet d'obtenir l'objet net.Socket associé à la connexion.

Les données de réponse sont présentées sous forme de flux, car l'objet http.IncomingMessage implémente l'interface Readable Stream .

Travailler avec des flux dans Node.js

Les threads sont l'un des concepts fondamentaux utilisés dans les applications Node.js. Les flux sont des outils qui vous permettent de lire et d'écrire des fichiers, d'organiser la mise en réseau entre les systèmes et, en général, de mettre en œuvre efficacement des opérations d'échange de données.

Le concept de threads n'est pas unique à Node.js. Ils sont apparus sur la famille d'OS Unix il y a des décennies. En particulier, les programmes peuvent interagir les uns avec les autres, en transmettant des flux de données à l'aide de pipelines (en utilisant le caractère pipe - | ).

Si vous imaginez, disons, lire un fichier sans utiliser de flux, alors, pendant l'exécution de la commande correspondante, le contenu du fichier sera entièrement lu en mémoire, après quoi vous pourrez travailler avec ce contenu.

Grâce à l'utilisation du mécanisme de flux, les fichiers peuvent être lus et traités en plusieurs parties, ce qui élimine le besoin de stocker de grandes quantités de données en mémoire.

Le module de flux Node.js est la base sur laquelle toutes les API prenant en charge le streaming sont construites.

▍À propos des points forts de l'utilisation des flux

Les flux, par rapport à d'autres méthodes de traitement des données, présentent les avantages suivants:

Utilisation efficace de la mémoire. Travailler avec un flux n'implique pas de stocker en mémoire de grandes quantités de données chargées à l'avance, avant qu'il ne devienne possible de les traiter.
Gain de temps. Les données reçues du flux peuvent être traitées beaucoup plus rapidement que lorsque vous devez attendre qu'elles soient entièrement chargées pour commencer à les traiter.

▍ Exemple de travail avec des flux

Un exemple traditionnel de travail avec des flux montre la lecture d'un fichier à partir du disque.

Tout d'abord, considérez le code dans lequel les threads ne sont pas utilisés. Le module standard Node.js fs vous permet de lire un fichier, après quoi il peut être transféré via HTTP en réponse à une requête reçue par un serveur HTTP:

 const http = require('http') const fs = require('fs') const server = http.createServer(function (req, res) { fs.readFile(__dirname + '/data.txt', (err, data) => {   res.end(data) }) }) server.listen(3000)

La méthode readFile() utilisée ici vous permet de lire l'intégralité du fichier. Une fois la lecture terminée, il appelle le rappel correspondant.

La res.end(data) , appelée dans le rappel, envoie le contenu du fichier au client.

Si la taille du fichier est importante, cette opération prendra beaucoup de temps. Voici le même exemple réécrit à l'aide de flux:

 const http = require('http') const fs = require('fs') const server = http.createServer((req, res) => { const stream = fs.createReadStream(__dirname + '/data.txt') stream.pipe(res) }) server.listen(3000)

Au lieu d'attendre le moment où le fichier est entièrement lu, nous commençons à transférer ses données au client immédiatement après que la première partie de ces données est prête pour l'envoi.

Méthode MethodPipe ()

Dans l'exemple précédent, nous avons utilisé une construction de la forme stream.pipe(res) , dans laquelle la méthode de flux de fichiers pipe() est appelée. Cette méthode prend les données de sa source et les envoie à la destination.

Il s'agit d'un flux représentant une source de données. Dans ce cas, il s'agit du flux de fichiers envoyé à la réponse HTTP.

La valeur de retour de la méthode pipe() est le flux cible. C'est très pratique, car cela vous permet de chaîner plusieurs appels à la méthode pipe() :

 src.pipe(dest1).pipe(dest2)

Cela équivaut à une telle conception:

 src.pipe(dest1) dest1.pipe(dest2)

▍API Node.js qui utilise des flux

Les threads sont un mécanisme utile; par conséquent, de nombreux modules du noyau Node.js offrent des capacités de threading standard. Nous en énumérons quelques-uns:

process.stdin - retourne un thread connecté à stdin .
process.stdout - Retourne le thread connecté à stdout .
process.stderr - retourne un thread connecté à stderr .
fs.createReadStream() - crée un flux lisible pour travailler avec un fichier.
fs.createWriteStream() - crée un flux inscriptible pour travailler avec un fichier.
net.connect() - initie une connexion basée sur le flux.
http.request() - renvoie une instance de la classe http.ClientRequest qui donne accès au flux en cours d'écriture.
zlib.createGzip() - compresse les données à l'aide de l'algorithme gzip et les envoie au flux.
zlib.createGunzip() - décompresse un flux gzip .
zlib.createDeflate() - compresse les données en utilisant l'algorithme de deflate et les envoie au flux.
zlib.createInflate() - décompresse un flux de zlib.createInflate() .

▍Divers types de flux

Il existe quatre types de flux:

Un flux lisible est un flux à partir duquel des données peuvent être lues. Vous ne pouvez pas écrire de données dans un tel flux. Lorsque des données arrivent dans un tel flux, elles sont mises en mémoire tampon jusqu'à ce que le consommateur de données commence à les lire.
Un flux d'écriture ( Writable ) est un flux dans lequel vous pouvez envoyer des données. Vous ne pouvez pas en lire les données.
Flux duplex ( Duplex ) - dans ce flux, vous pouvez envoyer des données et les lire. Il s'agit essentiellement d'une combinaison d'un flux de lecture et d'un flux d'écriture.
Transformer le flux ( Transform ) - ces flux sont similaires aux flux duplex, la différence est que ce qui vient à l'entrée de ces flux transformera ce qui peut être lu à partir d'eux.

▍Créer un flux de lecture

, stream :

 const Stream = require('stream') const readableStream = new Stream.Readable()

, :

 readableStream.push('hi!') readableStream.push('ho!')

▍

Writable _write() . :

 const Stream = require('stream') const writableStream = new Stream.Writable()

_write() :

 writableStream._write = (chunk, encoding, next) => {   console.log(chunk.toString())   next() }

, :

 process.stdin.pipe(writableStream)

▍

, , :

 const Stream = require('stream') const readableStream = new Stream.Readable() const writableStream = new Stream.Writable() writableStream._write = (chunk, encoding, next) => {   console.log(chunk.toString())   next() } readableStream.pipe(writableStream) readableStream.push('hi!') readableStream.push('ho!') readableStream.push(null)

readableStream.push(null) .

, readable :

 readableStream.on('readable', () => { console.log(readableStream.read()) })

▍

write() :

 writableStream.write('hey!\n')

▍ ,

, , end() :

 writableStream.end()

. , , .

MySQL Node.js

MySQL . Node.js , MySQL-, — , .

mysqljs/mysql . , , 12000 GitHub. , MySQL-.

▍

 npm install mysql

▍

 const mysql = require('mysql')

 const options = { user: 'the_mysql_user_name', password: 'the_mysql_user_password', database: 'the_mysql_database_name' } const connection = mysql.createConnection(options)

 connection.connect(err => { if (err) {   console.error('An error occurred while connecting to the DB')   throw err } }

▍

options :

 const options = { user: 'the_mysql_user_name', password: 'the_mysql_user_password', database: 'the_mysql_database_name' }

. — :

host — , MySQL-, — localhost .
port — , — 3306 .
socketPath — Unix .
debug — , .
trace — , .
ssl — SSL- .

▍ SELECT

SQL- . query , . — , . . :

 connection.query('SELECT * FROM todos', (error, todos, fields) => { if (error) {   console.error('An error occurred while executing the query')   throw error } console.log(todos) })

, :

 const id = 223 connection.query('SELECT * FROM todos WHERE id = ?', [id], (error, todos, fields) => { if (error) {   console.error('An error occurred while executing the query')   throw error } console.log(todos) })