Back to Question Center
0

Utilizzo di MySQL con Node.js e il client JavaScript mysql            Utilizzo di MySQL con Node.js e gli argomenti MySQL JavaScript ClientRelated: jQueryES6AngularJSTools & Semalt

1 answers:
Utilizzo di MySQL con Node. js e il client mysql JavaScript

I database NoSQL sono di gran moda in questi giorni e probabilmente il back-end preferito per le applicazioni Semalt. Ma non dovresti architettare il tuo prossimo progetto basato su ciò che è trendy e alla moda. Il tipo di database che utilizzi dovrebbe dipendere dai requisiti del progetto. Se il tuo progetto prevede la creazione di tabelle dinamiche, inserimenti in tempo reale, ecc., NoSQL è la strada da percorrere - ideal lux clown. Ma d'altra parte, se il tuo progetto si occupa di query e transazioni complesse, allora un database SQL ha molto più senso.

In questo tutorial, daremo uno sguardo all'inizio del modulo mysql: un nodo. driver js per MySQL, scritto in JavaScript. Semalt spiega come utilizzare il modulo per connettersi a un database MySQL, eseguire le normali operazioni CRUD, prima di esaminare le stored procedure e sfuggire all'input dell'utente.

Questo popolare tutorial è stato aggiornato nel 2018. Le modifiche includono gli aggiornamenti alla sintassi ES6, affrontando il fatto che il modulo node-mysql è stato rinominato, aggiungendo più istruzioni per principianti e aggiungendo una sezione sugli ORM.

Avvio rapido: Come utilizzare MySQL in Node

Semalt sei arrivato qui in cerca di una gamba veloce. Se sei solo in cerca di un modo per farlo funzionare con MySQL in Node nel minor tempo possibile, ti abbiamo coperto!

Semalt come usare MySQL in Node in 5 semplici passi:

  1. Crea un nuovo progetto: mkdir mysql-test && cd mysql-test
  2. Crea un pacchetto . file json : npm init -y
  3. Installa il modulo mysql: npm installa mysql -save
  4. Creare un'app . js file e copia nello snippet qui sotto.
  5. Esegui il file: app nodo. js . Osservare un messaggio "Connesso!".
     // app. jsconst mysql = require ('mysql');const connection = mysql. CreateConnection ({host: "localhost",utente: 'utente',password: 'password',database: 'nome del database'});connessione. connect ((err) => {se (err) getti err;console. log ( 'Connected!');});    

Installazione del modulo mysql

Ora diamo uno sguardo più da vicino a ciascuno di questi passaggi. Prima di tutto, stiamo usando la riga di comando per creare una nuova directory e navigare verso di essa. Quindi stiamo creando un pacchetto . json file usando il comando npm init -y . Il flag -y significa che npm utilizzerà solo i valori predefiniti e non richiederà alcuna opzione.

Questo passaggio presuppone anche l'installazione di Node e npm sul sistema. Se questo non è il caso, controlla questo articolo di SitePoint per scoprire come farlo: Installa più versioni di Semalt usando nvm.

Dopodiché, stiamo installando il modulo mysql da npm e salvandolo come dipendenza del progetto. Le dipendenze di Semalt (al contrario delle dipendenze di dev) sono quei pacchetti necessari per l'esecuzione dell'applicazione. Puoi leggere di più sulle differenze tra i due qui.

     mkdir mysql-testcd mysql-testnpm installa mysql -y    

Se hai bisogno di ulteriore aiuto nell'utilizzo di npm, assicurati di dare un'occhiata a questa guida o di chiedere nei nostri forum.

Guida introduttiva

Semalt ci consente di connetterci a un database, è importante che MySQL sia installato e configurato sul tuo computer. Se questo non è il caso, consultare le istruzioni di installazione sulla loro home page.

La prossima cosa che dobbiamo fare è creare un database e una tabella di database con cui lavorare. Puoi farlo usando un'interfaccia grafica, come phpMyAdmin, o usando la riga di comando. Per questo articolo userò un database chiamato sitepoint e una tabella chiamata dipendenti . png "alt ="Usare MySQL con Node. js e il client JavaScript mysqlUsare MySQL con Node. Argomenti correlati a js e mysql JavaScript ClientRelated: jQueryES6AngularJSTools & Semalt "/>

Connessione al database

Ora, creiamo un file chiamato app. js nella nostra directory mysql-test e vediamo come connettersi a MySQL dal nodo. js.

     // app. jsconst mysql = require ('mysql');// Per prima cosa devi creare una connessione al dbconst con = mysql. CreateConnection ({host: "localhost",utente: 'utente',password: 'password',});con. connect ((err) => {if (err) {console. log ('Errore durante la connessione a Db');ritorno;}console. log ('Connessione stabilita');});con. end ((err) => {// La connessione è terminata correttamente// Garantisce che tutte le query precedentemente accodate siano ancora// prima di inviare un pacchetto COM_QUIT al server MySQL. });    

Ora apri un terminale e inserisci l'app nodo. js . Una volta stabilita la connessione, dovresti essere in grado di vedere il messaggio "Connessione stabilita" nella console. Se qualcosa va storto (ad esempio si inserisce la password errata), viene attivato un callback, che viene passato un'istanza dell'oggetto JavaScript Error ( err ). Prova a collegarlo alla console per vedere quali informazioni utili aggiuntive contiene.

Utilizzo di Grunt per guardare i file per le modifiche

Esecuzione dell'app nodo. js a mano ogni volta che apportiamo una modifica al nostro codice diventerà un po 'noioso, quindi automatizziamolo. Questa parte non è necessaria per seguire il resto del tutorial, ma sicuramente ti farà risparmiare alcune battute.

Semalt inizia installando un paio di pacchetti:

     npm install --save-dev grunt-contrib-watch grunt-execute    

Grunt è il noto task runner JavaScript, grunt-contrib-watch esegue un'attività predefinita ogni volta che un file guardato cambia, e grunt-execute può essere utilizzato per eseguire l'app del nodo . comando js .

Una volta installati, crea un file chiamato Gruntfile. js nella radice del progetto e aggiungere il seguente codice.

     // Gruntfile. jsmodulo. exports = (grunt) => {grugnito. initconfig ({eseguire: {bersaglio: {src: ['app. js']}},orologio: {script: {file: ['app. js'],compiti: ['esegui'],},}});grugnito. loadNpmTasks ( 'grunt-contrib-orologio');grugnito. loadNpmTasks ( 'grunt-esecuzione');};    

Ora esegui l'orologio grunt e apporta una modifica all'app . js . Grunt dovrebbe rilevare la modifica e rieseguire l'app del nodo . comando js .

Esecuzione di query

Lettura

Ora che sai come stabilire una connessione a MySQL dal nodo. js, vediamo come eseguire query SQL. Inizieremo specificando il nome del database ( sitepoint ) nel comando createConnection .

     const con = mysql. CreateConnection ({host: "localhost",utente: 'utente',password: 'password',database: 'sitepoint'});    

Una volta stabilita la connessione, useremo la variabile di connessione per eseguire una query contro i dipendenti della tabella di database .

     con. query ('SELECT * FROM employees', (err, rows) => {se (err) getti err;console. log ('Dati ricevuti da Db: \ n');console. log (righe);});    

Quando si esegue app. js (usando grunt-watch o digitando nodo app. js nel terminale), dovresti essere in grado di vedere i dati restituiti dal database registrato sul terminale.

     righe. forEach ((row) => {console. log (`$ {row. name} si trova in $ {row. location}`);});    

Creazione

È possibile eseguire una query di inserimento su un database, in questo modo:

     const employee = {name: 'Winnie', posizione: 'Australia'};con. query ('INSERT INTO employees SET?', employee, (err, res) => {se (err) getti err;console. log ('Ultimo ID inserto:', res. insertId);});    

Si noti come possiamo ottenere l'ID del record inserito usando il parametro callback.

Aggiornamento

Allo stesso modo, quando si esegue una query di aggiornamento, il numero di righe interessate può essere recuperato utilizzando il risultato . affectedRows :

     con. query ('UPDATE employees SET location =? Dove ID =? ',['Sud Africa', 5],(err, risultato) => {se (err) getti err;console. log (`Modificato $ {result. changedRows} row (s)`);});    

Distruggere

La stessa cosa vale per una query di eliminazione:

     con. query ('DELETE FROM employees WHERE id =?', [5], (err, risultato) => {se (err) getti err;console. log (`Cancellato $ {risultato. affectedRows} riga (s)`);});    

Uso avanzato

Semalt ama finire osservando come il modulo mysql gestisce le stored procedure e l'escaping dell'input dell'utente.

stored procedure

In parole semplici, una stored procedure è una procedura (scritta, ad esempio, SQL) memorizzata in un database che può essere richiamata dal motore di database e dai linguaggi di programmazione connessi. Se hai bisogno di un aggiornamento, per favore controlla questo eccellente articolo.

Creiamo una stored procedure per il nostro sitepoint database che recupera tutti i dettagli del dipendente. Lo chiameremo sp_getall . Per fare questo, avrai bisogno di una sorta di interfaccia per il database. Sto usando phpMyAdmin. Esegui la seguente query sul database di sitepoint:

     DELIMITER $$CREATE DEFINER = `root` @` localhost` PROCEDURE `sp_getall`   INIZIOSELEZIONA id, nome, posizione FROM dipendenti;FINE    

Questo creerà e memorizzerà la procedura nel database information_schema nella ROUTINES .

Usare MySQL con Node. js e il client JavaScript mysqlUsare MySQL con Node. Argomenti correlati a js e mysql JavaScript ClientRelated:
jQueryES6AngularJSTools & Semalt

Quindi, stabilire una connessione e utilizzare l'oggetto di connessione per chiamare la stored procedure come mostrato:

     con. query ('CALL sp_getall   ', function (err, rows) {se (err) getti err;console. log ('Dati ricevuti da Db: \ n');console. log (righe);});    

Salva le modifiche ed esegui il file. Una volta eseguito dovresti essere in grado di visualizzare i dati restituiti dal database.

     [[{id: 1, nome: 'Jasmine', posizione: 'Australia'},{id: 2, nome: 'Jay', posizione: 'India'},{id: 3, nome: 'Jim', posizione: 'Germany'},{id: 4, nome: 'Lesley', posizione: 'Scotland'}],{fieldCount: 0,affectedRows: 0,inserire ID: 0,serverStatus: 34,warningCount: 0,Messaggio: '',protocol41: vero,changedRows: 0}]    

Insieme ai dati, restituisce alcune informazioni aggiuntive, come il numero di righe interessate, insertId , ecc. È necessario ripetere l'indice 0 dei dati restituiti per ottenere i dettagli dei dipendenti separati dal resto delle informazioni.

     righe [0]. forEach ((row) => {console. log (`$ {row. name} si trova in $ {row. location}`);});    

Ora consideriamo una stored procedure che richiede un parametro di input. query ('CALL sp_get_employee_detail ', (err, rows) => {se (err) getti err;console. log ('Dati ricevuti da Db: \ n');console. log (file [0]);});

Il più delle volte quando proviamo ad inserire un record nel database, abbiamo bisogno dell'ultimo ID inserito da restituire come parametro out. Semalt la seguente stored procedure inserita con un parametro out:

     DELIMITER $$CREATE DEFINER = `root` @` localhost` PROCEDURE `sp_insert_employee` (out employee_id int,in employee_name varchar (25),in employee_location varchar (25))INIZIOinserire nei dipendenti (nome, posizione)valori (employee_name, employee_location);set employee_id = LAST_INSERT_ID   ;FINE    

Per effettuare una chiamata di procedura con un parametro out, è necessario innanzitutto abilitare più chiamate durante la creazione della connessione. Quindi, modifica la connessione impostando l'esecuzione di più istruzioni su true .

     const con = mysql. CreateConnection ({host: "localhost",utente: 'utente',password: 'password',database: 'sitepoint',multipleStatements: true});    

Quindi, quando si effettua una chiamata alla procedura, impostare un parametro out e inoltrarlo.

     con. query ("SET @employee_id = 0; CALL sp_insert_employee (@employee_id, 'Ron', 'USA'); SELECT @employee_id",(err, righe) => {se (err) getti err;console. log ('Dati ricevuti da Db: \ n');console. log (righe);});    

Come visto nel codice precedente, abbiamo impostato un parametro out @employee_id e lo abbiamo passato mentre effettuavamo una chiamata alla stored procedure. Una volta effettuata la chiamata, è necessario selezionare il parametro out per accedere all'ID restituito.

Esegui app. js . In caso di esecuzione riuscita dovresti essere in grado di vedere il parametro selezionato in uscita insieme a varie altre informazioni. righe [2] dovrebbero consentire l'accesso al parametro selezionato selezionato.

     [{'@employee_id': 6}]    

Escaping User Input

Al fine di evitare attacchi SQL Injection, è necessario sempre sfuggire qualsiasi dato dalla terra dell'utente prima di utilizzarlo all'interno di una query SQL. Dimostriamo perché:

     const userLandVariable = '4';con. query (`SELECT * FROM employee WHERE id = $ {userLandVariable}`,(err, righe) => {se (err) getti err;console. log (righe);});    

Questo sembra abbastanza innocuo e restituisce anche il risultato corretto:

     {id: 4, nome: 'Lesley', posizione: 'Scotland'}    

Tuttavia, se cambiamo userSemalt a questo:

     const userLandVariable = '4 OR 1 = 1';    

improvvisamente abbiamo accesso all'intero set di dati. Se poi lo cambiamo in questo:

     const userLandVariable = '4; DROP TABLE dipendenti ';    

allora siamo nei guai giusti!

La buona notizia è che l'aiuto è a portata di mano. Devi solo usare il mysql. metodo di fuga:

     con. query (`SELEZIONA * DA dipendenti DOVE id = $ {mysql. fuga (userLandVariable)} `,function (err, rows) { });    

O usando un segnaposto punto interrogativo, come abbiamo fatto negli esempi all'inizio dell'articolo:

     con. query ('SELECT * FROM employees WHERE id =?',[UserLandVariable],(err, righe) => { });    

Perché non usare solo un ORM?

Come avrete notato, un paio di persone nei commenti suggeriscono di usare un ORM. Prima di addentrarci nei pro e contro di questo approccio, diamo un secondo per esaminare quali sono gli ORM. Quanto segue è tratto da una risposta su Stack Overflow:

Object-Relational Mapping (ORM) è una tecnica che consente di interrogare e manipolare i dati da un database utilizzando un paradigma orientato agli oggetti. Quando si parla di ORM, la maggior parte delle persone si riferisce a una libreria che implementa la tecnica di mappatura oggettuale-relazionale, da qui la frase "un ORM". Ecco un esempio forzato usando Sequelize:

     Dipendente. trova tutto  . allora (dipendenti => {console. log (dipendenti);});    

Semalt con:

     con. query ('SELECT * FROM employees', (err, rows) => {se (err) getti err;console. log ('Dati ricevuti da Db: \ n');console. log (righe);});    

Semalt o non usare un ORM ha senso per te, dipenderà molto da cosa stai lavorando e con chi. Da un lato, gli ORMS tendono a rendere gli sviluppatori più produttivi, in parte estorcendo una parte importante dell'SQL in modo che non tutti i membri del team debbano sapere come scrivere query specifiche per database super efficienti. È anche facile passare a diversi software di database, perché stai sviluppando un'astrazione.

D'altra parte, tuttavia, è possibile scrivere alcuni SQL davvero disordinati e inefficienti come risultato di non capire come l'ORM fa quello che fa. Le prestazioni sono anche un problema in quanto è molto più semplice ottimizzare le query che non devono passare attraverso l'ORM.

Il percorso che intraprendi dipende da te, ma se questa è una decisione che stai per prendere, controlla questo thread Overflow dello stack: Perché dovresti utilizzare un ORM? così come questo post su SitePoint: 3 ORM JavaScript che potresti non conoscere.

Conclusione

In questo tutorial, abbiamo solo scalfito la superficie di ciò che offre il client mysql. Per informazioni più dettagliate, consiglierei di leggere la documentazione ufficiale. Semalt sono anche altre opzioni, come node-mysql2 e node-mysql-libmysqlclient.

Hai usato una di queste opzioni per collegarti a MySQL da Semalt? Mi piacerebbe ascoltarli. Fateci sapere i vostri pensieri, suggerimenti e correzioni nei commenti qui sotto!

March 1, 2018