node-js-it
Caricato da
fantomas76node-js-it
Caricato da
fantomas76Node.
js
#node.js
Sommario
Di 1
Capitolo 1: Iniziare con Node.js 2
Osservazioni 2
Versioni 2
Examples 6
Ciao server World HTTP 6
Ciao linea di comando mondiale 7
Installazione ed esecuzione di Node.js 8
Esecuzione di un programma di nodo 8
Distribuzione dell'applicazione online 9
Debug della tua applicazione NodeJS 9
Debugging nativamente 9
Ciao mondo con Express 10
Hello World routing di base 10
Socket TLS: server e client 12
Come creare una chiave e un certificato 12
Importante! 12
TLS Socket Server 12
TLS Socket Client 13
Ciao mondo nella REPL 14
Moduli core 15
Tutti i moduli di base a colpo d'occhio 15
Come ottenere un server Web HTTPS di base attivo e funzionante! 20
Passaggio 1: creare un'autorità di certificazione 20
Passaggio 2: installa il certificato come certificato di origine 20
Passaggio 3: avvio del server nodo 21
Capitolo 2: Ambiente 23
Examples 23
Accesso alle variabili d'ambiente 23
argomenti della riga di comando process.argv 23
Utilizzo di diverse proprietà / configurazione per ambienti diversi come dev, qa, staging, 24
Caricamento delle proprietà dell'ambiente da un "file di proprietà" 25
Capitolo 3: Analizzare gli argomenti della riga di comando 27
Examples 27
Passando azione (verbo) e valori 27
Passare gli switch booleani 27
Capitolo 4: API CRUD basata su REST semplice 28
Examples 28
API REST per CRUD in Express 3+ 28
Capitolo 5: App Web con Express 29
introduzione 29
Sintassi 29
Parametri 29
Examples 29
Iniziare 30
Routing di base 30
Ottenere informazioni dalla richiesta 32
Applicazione espressa modulare 33
Esempio più complicato 33
Utilizzo di un motore di modelli 34
Utilizzo di un motore di modelli 34
Esempio di modello EJS 35
API JSON con ExpressJS 36
Servire file statici 36
Più cartelle 37
Percorsi con nomi in stile Django 37
Gestione degli errori 38
Utilizzo del middleware e della prossima richiamata 39
Gestione degli errori 40
Hook: come eseguire il codice prima di qualsiasi req e dopo qualsiasi res 42
Gestire richieste POST 42
Impostazione dei cookie con cookie-parser 43
Middleware personalizzato in Express 43
Gestione degli errori in Express 44
Aggiunta di middleware 44
Ciao mondo 45
Capitolo 6: Arresto grazioso 46
Examples 46
Graceful Shutdown - SIGTERM 46
Capitolo 7: Async / Await 47
introduzione 47
Examples 47
Funzioni asincrone con gestione degli errori Try-Catch 47
Confronto tra Promises e Async / Await 48
Progressione da Callbacks 48
Interrompe l'esecuzione in attesa 49
Capitolo 8: async.js 51
Sintassi 51
Examples 51
Parallelo: multi-tasking 51
Chiama async.parallel() con un oggetto 52
Risoluzione di più valori 52
Serie: mono-tasking indipendente 53
Chiama async.series() con un oggetto 54
Cascata: mono-tasking dipendente 54
async.times (Per gestire il ciclo in modo migliore) 55
async.each (Per gestire in modo efficiente l'array di dati) 55
async.series (per gestire gli eventi uno per uno) 56
Capitolo 9: Autenticazione di Windows sotto node.js 57
Osservazioni 57
Examples 57
Utilizzando activedirectory 57
Installazione 57
uso 57
Capitolo 10: Autoreload su modifiche 58
Examples 58
Il caricamento automatico sul codice sorgente cambia usando nodemon 58
Installazione di nodemon a livello globale 58
Installare nodemon localmente 58
Utilizzando nodemon 58
Browsersync 58
Panoramica 58
Installazione 58
Utenti Windows 59
Uso di base 59
Uso avanzato 59
Grunt.js 59
Gulp.js 60
API 60
Capitolo 11: Biblioteca Mongoose 61
Examples 61
Connetti a MongoDB usando Mongoose 61
Salva i dati su MongoDB usando Mongoose e Express.js Routes 61
Impostare 61
Codice 62
uso 63
Trova i dati in MongoDB usando i percorsi Mongoose e Express.js 63
Impostare 63
Codice 63
uso 65
Trova i dati in MongoDB usando Mongoose, Express.js Routes e $ text Operator 65
Impostare 65
Codice 66
uso 67
Indici nei modelli. 68
Funzioni utili di Mongoose 70
trova i dati in mongodb usando le promesse 70
Impostare 70
Codice 70
uso 72
Capitolo 12: Buon stile di codifica 73
Osservazioni 73
Examples 73
Programma base per la registrazione 73
Capitolo 13: CLI 77
Sintassi 77
Examples 77
Opzioni della riga di comando 77
Capitolo 14: Codice Node.js per STDIN e STDOUT senza utilizzare alcuna libreria 81
introduzione 81
Examples 81
Programma 81
Capitolo 15: Come vengono caricati i moduli 82
Examples 82
Modalità globale 82
Caricamento dei moduli 82
Caricamento di un modulo di cartelle 82
Capitolo 16: Comunicazione Arduino con nodeJs 84
introduzione 84
Examples 84
Comunicazione Node Js con Arduino via serialport 84
Codice js del nodo 84
Codice Arduino 85
Cominciando 85
Capitolo 17: Comunicazione client-server 87
Examples 87
/ w Express, jQuery e Jade 87
Capitolo 18: Comunicazione Socket.io 89
Examples 89
"Ciao mondo!" con i messaggi socket 89
Capitolo 19: Connetti a Mongodb 90
introduzione 90
Sintassi 90
Examples 90
Semplice esempio per collegare mongoDB da Node.JS 90
Un modo semplice per collegare mongoDB con il core Node.JS 90
Capitolo 20: Consegna HTML o qualsiasi altro tipo di file 91
Sintassi 91
Examples 91
Consegna HTML al percorso specificato 91
Struttura delle cartelle 91
server.js 91
Capitolo 21: Creazione di API con Node.js 93
Examples 93
Ottieni API usando Express 93
API POST utilizzando Express 93
Capitolo 22: Creazione di una libreria Node.js che supporti entrambe le promesse e le call 95
introduzione 95
Examples 95
Modulo di esempio e programma corrispondente che utilizza Bluebird 95
Capitolo 23: Database (MongoDB con Mongoose) 98
Examples 98
Connessione Mongoose 98
Modello 98
Inserisci dati 99
Leggi i dati 99
Capitolo 24: Debug dell'applicazione Node.js 101
Examples 101
Core node.js debugger e node inspector 101
Utilizzo del debugger principale 101
Riferimento del comando 101
Utilizzando l'ispettore del nodo incorporato 102
Utilizzando l'ispettore Node 102
Capitolo 25: Debug remoto in Node.JS 105
Examples 105
NodeJS esegue la configurazione 105
Configurazione IntelliJ / Webstorm 105
Usa il proxy per il debug tramite la porta su Linux 106
Capitolo 26: Design API restful: best practice 107
Examples 107
Gestione degli errori: OTTENERE tutte le risorse 107
Capitolo 27: Disinstallazione di Node.js 109
Examples 109
Disinstallare completamente Node.js su Mac OSX 109
Disinstallare Node.js su Windows 109
Capitolo 28: Distribuzione dell'applicazione Node.js senza tempi di inattività. 110
Examples 110
Distribuzione utilizzando PM2 senza tempi di fermo. 110
Capitolo 29: Distribuzione di applicazioni Node.js in produzione 112
Examples 112
Impostazione NODE_ENV = "produzione" 112
Bandiere di runtime 112
dipendenze 112
Gestisci l'app con il gestore dei processi 113
PM2 Process Manager 113
Distribuzione utilizzando PM2 114
Distribuzione utilizzando il gestore dei processi 115
Forvever 115
Utilizzo di diverse proprietà / configurazione per ambienti diversi come dev, qa, staging, 116
Approfittando dei cluster 117
Capitolo 30: ECMAScript 2015 (ES6) con Node.js 118
Examples 118
const / let dichiarazioni 118
Funzioni della freccia 118
Esempio di funzione freccia 118
destrutturazione 119
flusso 119
Classe ES6 120
Capitolo 31: Emettitori di eventi 121
Osservazioni 121
Examples 121
Analisi HTTP tramite un emettitore di eventi 121
Nozioni di base 122
Ottieni i nomi degli eventi a cui sei iscritto 123
Ottieni il numero di ascoltatori registrati per ascoltare un evento specifico 123
Capitolo 32: Esecuzione di file o comandi con Child Processes 125
Sintassi 125
Osservazioni 125
Examples 125
Creazione di un nuovo processo per eseguire un comando 125
Creazione di una shell per eseguire un comando 126
Generare un processo per eseguire un eseguibile 127
Capitolo 33: Esecuzione di node.js come servizio 128
introduzione 128
Examples 128
Node.js come un demone di sistema 128
Capitolo 34: Esportazione e consumo di moduli 130
Osservazioni 130
Examples 130
Caricamento e utilizzo di un modulo 130
Creazione di un modulo hello-world.js 131
Invalida della cache del modulo 132
Costruire i tuoi moduli 133
Ogni modulo iniettato una sola volta 134
Caricamento del modulo da node_modules 134
Cartella come modulo 135
Capitolo 35: Esportazione e importazione del modulo in node.js 137
Examples 137
Utilizzando un modulo semplice in node.js 137
Uso delle importazioni in ES6 138
Esportazione con sintassi ES6 139
Capitolo 36: Eventloop 140
introduzione 140
Examples 140
Come si è evoluto il concetto di event loop. 140
Eventloop in pseudo codice 140
Esempio di un server HTTP a thread singolo senza loop di eventi 140
Esempio di un server HTTP multi-thread con nessun ciclo di eventi 140
Esempio di un server HTTP con ciclo di eventi 141
Capitolo 37: Evita l'inferno del callback 143
Examples 143
Modulo asincrono 143
Modulo asincrono 143
Capitolo 38: File system I / O 145
Osservazioni 145
Examples 145
Scrivere su un file usando writeFile o writeFileSync 145
Leggi in modo asincrono dai file 146
Con codifica 146
Senza codifica 146
Percorsi relativi 146
Elenco dei contenuti della directory con readdir o readdirSync 147
Utilizzando un generatore 147
Lettura da un file in modo sincrono 148
Leggere una stringa 148
Eliminazione di un file utilizzando lo scollegamento o lo scollegamento sincronizzato 148
Lettura di un file in un buffer utilizzando i flussi 149
Verifica le autorizzazioni di un file o di una directory 149
in modo asincrono 150
sincrono 150
Evitare le condizioni di gara durante la creazione o l'utilizzo di una directory esistente 150
Verifica se esiste un file o una directory 151
in modo asincrono 151
sincrono 152
Clonazione di un file utilizzando i flussi 152
Copia di file tramite streaming di piping 152
Modifica del contenuto di un file di testo 153
Determinazione del numero di righe di un file di testo 153
app.js 153
Leggere un file riga per riga 153
app.js 153
Capitolo 39: Gestione degli errori di Node.js 155
introduzione 155
Examples 155
Creazione dell'oggetto Error 155
Errore di lancio 155
prova ... cattura blocco 156
Capitolo 40: Gestire la richiesta POST in Node.js 158
Osservazioni 158
Examples 158
Esempio di server node.js che gestisce solo le richieste POST 158
Capitolo 41: Gestore pacchetti filati 160
introduzione 160
Examples 160
Installazione del filato 160
Mac OS 160
homebrew 160
MacPorts 160
Aggiunta di filati al PERCORSO 160
finestre 160
Installer 160
cioccolatoso 160
Linux 161
Debian / Ubuntu 161
CentOS / Fedora / RHEL 161
Arco 161
Solus 161
Tutte le distribuzioni 162
Metodo alternativo di installazione 162
Script di shell 162
tarball 162
npm 162
Post installazione 162
Creare un pacchetto base 162
Installa il pacchetto con Yarn 163
Capitolo 42: grugnito 164
Osservazioni 164
Examples 164
Introduzione a GruntJs 164
Installazione di gruntplugins 165
Capitolo 43: Guida per principianti NodeJS 167
Examples 167
Ciao mondo ! 167
Capitolo 44: Hack 168
Examples 168
Aggiungi nuove estensioni da richiedere () 168
Capitolo 45: http 169
Examples 169
server http 169
client http 170
Capitolo 46: Iniezione di dipendenza 172
Examples 172
Perché utilizzare l'iniezione delle dipendenze 172
Capitolo 47: Iniziare con la profilatura dei nodi 173
introduzione 173
Osservazioni 173
Examples 173
Creazione di profili di una semplice applicazione di nodo 173
Capitolo 48: Installare Node.js 176
Examples 176
Installa Node.js su Ubuntu 176
Utilizzando il gestore di pacchetti apt 176
Utilizzando l'ultima versione specifica (ad es. LTS 6.x) direttamente da nodesource 176
Installazione di Node.js su Windows 176
Utilizzo di Node Version Manager (nvm) 177
Installa Node.js da Source con il gestore pacchetti APT 178
Installare Node.js su Mac usando il gestore pacchetti 178
homebrew 178
macports 179
Installazione tramite MacOS X Installer 179
Controlla se il Nodo è installato 180
Installazione di Node.js su Raspberry PI 180
Installazione con Node Version Manager in Fish Shell con Oh My Fish! 180
Installa Node.js dal sorgente su Centos, RHEL e Fedora 181
Installare Node.js con n 182
Capitolo 49: Instradare richieste ajax con Express.JS 183
Examples 183
Una semplice implementazione di AJAX 183
Capitolo 50: Integrazione con Mongodb 185
Sintassi 185
Parametri 185
Examples 186
Connetti a MongoDB 186
Metodo MongoClient Connect() 186
Inserisci un documento 186
Metodo di raccolta insertOne() 187
Leggi una collezione 187
Metodo di raccolta find() 188
Aggiorna un documento 188
Metodo di raccolta updateOne() 188
Elimina un documento 189
Metodo di raccolta deleteOne() 189
Elimina più documenti 189
Metodo di raccolta deleteMany() 190
Semplice connessione 190
Connessione semplice, usando le promesse 190
Capitolo 51: Integrazione con MySQL 191
introduzione 191
Examples 191
Interrogare un oggetto di connessione con parametri 191
Utilizzo di un pool di connessioni 191
un. Esecuzione di più query contemporaneamente 191
b. Raggiungimento della multi-tenancy sul server di database con diversi database ospitati 192
Connetti a MySQL 193
Interrogare un oggetto di connessione senza parametri 193
Esegui un numero di query con una singola connessione da un pool 193
Restituisce la query quando si verifica un errore 194
Esporta pool di connessioni 194
Capitolo 52: Integrazione del passaporto 196
Osservazioni 196
Examples 196
Iniziare 196
Autenticazione locale 196
Autenticazione Facebook 198
Semplice nome utente-password di autenticazione 199
Autenticazione Google Passport 200
Capitolo 53: Integrazione di Cassandra 202
Examples 202
Ciao mondo 202
Capitolo 54: Integrazione di PostgreSQL 203
Examples 203
Connetti a PostgreSQL 203
Query con oggetto Connection 203
Capitolo 55: Integrazione MongoDB per Node.js / Express.js 204
introduzione 204
Osservazioni 204
Examples 204
Installare MongoDB 204
Creazione di un modello Mongoose 204
Interrogare il tuo database Mongo 205
Capitolo 56: Interagire con la console 207
Sintassi 207
Examples 207
Registrazione 207
Modulo console 207
console.log 207
Console.Error 207
console.time, console.timeEnd 207
Modulo di processo 208
formattazione 208
Generale 208
Colori dei caratteri 208
Colori di sfondo 209
Capitolo 57: Invia notifica Web 210
Examples 210
Invia notifica Web utilizzando GCM (Google Cloud Messaging System) 210
Capitolo 58: Invio di un flusso di file al client 212
Examples 212
Utilizzo di fs And pipe per il flusso di file statici dal server 212
Streaming Utilizzando fluent-ffmpeg 213
Capitolo 59: Koa Framework v2 214
Examples 214
Ciao esempio del mondo 214
Gestione degli errori utilizzando il middleware 214
Capitolo 60: La gestione delle eccezioni 215
Examples 215
Gestione dell'eccezione in Node.Js 215
Gestione delle eccezioni non gestita 216
Eccezioni di gestione silenziosa 217
Ritorno allo stato iniziale 217
Errori e promesse 218
Capitolo 61: Le notifiche push 219
introduzione 219
Parametri 219
Examples 219
Notifica Web 219
Mela 220
Capitolo 62: Linea di lettura 222
Sintassi 222
Examples 222
Lettura file riga per riga 222
Richiesta di input da parte dell'utente tramite CLI 222
Capitolo 63: Localizzazione del nodo JS 224
introduzione 224
Examples 224
utilizzando il modulo i18n per mantenere la localizzazione nell'app nodo js 224
Capitolo 64: Lodash 226
introduzione 226
Examples 226
Filtra una raccolta 226
Capitolo 65: Loopback - Connettore basato REST 227
introduzione 227
Examples 227
Aggiungere un connettore basato sul web 227
Capitolo 66: Mantenere costantemente attiva un'applicazione di nodo 229
Examples 229
Utilizzare PM2 come gestore processi 229
Comandi utili per il monitoraggio del processo 229
Esecuzione e arresto di un daemon Forever 230
Funzionamento continuo con nohup 231
Process Mangement with Forever 231
Capitolo 67: metalsmith 232
Examples 232
Costruisci un semplice blog 232
Capitolo 68: Modulo Cluster 233
Sintassi 233
Osservazioni 233
Examples 233
Ciao mondo 233
Esempio di cluster 234
Capitolo 69: MSSQL Intergration 236
introduzione 236
Osservazioni 236
Examples 236
Connessione con SQL tramite. modulo mssql npm 236
Capitolo 70: multithreading 238
introduzione 238
Osservazioni 238
Examples 238
Grappolo 238
Processo figlio 239
Capitolo 71: N-API 240
introduzione 240
Examples 240
Ciao a N-API 240
Capitolo 72: Node server senza framework 242
Osservazioni 242
Examples 242
Node server senza Framework 242
Superare i problemi CORS 243
Capitolo 73: Node.js (express.js) con il codice di esempio angular.js 244
introduzione 244
Examples 244
Creare il nostro progetto. 244
Ok, ma come creiamo il progetto express skeleton? 244
Come funziona espresso, brevemente? 245
Installazione di Pug e aggiornamento del motore di template Express. 245
In che modo AngularJS si inserisce in tutto questo? 246
Capitolo 74: Node.js Architecture & Inner Workings 248
Examples 248
Node.js - sotto il cofano 248
Node.js - in movimento 248
Capitolo 75: Node.js con CORS 250
Examples 250
Abilita CORS in express.js 250
Capitolo 76: Node.JS con ES6 251
introduzione 251
Examples 251
Nodo ES6 Supporto e creazione di un progetto con Babel 251
Usa JS es6 sulla tua app NodeJS 252
Prerequisiti: 252
Capitolo 77: Node.js con Oracle 255
Examples 255
Connetti a Oracle DB 255
Interrogare un oggetto di connessione senza parametri 255
Utilizzo di un modulo locale per interrogazioni più semplici 256
Capitolo 78: Node.js Design Fundamental 258
Examples 258
La filosofia Node.js 258
Capitolo 79: Node.JS e MongoDB. 259
Osservazioni 259
Examples 259
Connessione a un database 259
Creazione di una nuova collezione 260
Inserimento di documenti 260
Lettura 261
In aggiornamento 261
metodi 262
Aggiornare() 262
UpdateOne 262
UpdateMany 262
ReplaceOne 263
Eliminazione 263
Capitolo 80: Node.js v6 Nuove funzionalità e miglioramenti 265
introduzione 265
Examples 265
Parametri funzione predefiniti 265
Parametri di riposo 265
Spread Operator 265
Funzioni della freccia 266
"questo" in Arrow Function 266
Capitolo 81: NodeJS con Redis 268
Osservazioni 268
Examples 268
Iniziare 268
Memorizzare coppie chiave-valore 269
Alcune operazioni più importanti supportate da node_redis. 271
Capitolo 82: NodeJS Frameworks 273
Examples 273
Framework di server Web 273
Esprimere 273
Koa 273
Command Line Interface Frameworks 273
Commander.js 273
Vorpal.js 274
Capitolo 83: npm 275
introduzione 275
Sintassi 275
Parametri 276
Examples 277
Installazione dei pacchetti 277
introduzione 277
Installazione di NPM 277
Come installare i pacchetti 278
Installare le dipendenze 280
NPM dietro un server proxy 281
Ambiti e depositi 281
Disinstallazione dei pacchetti 282
Controllo delle versioni semantiche di base 282
Impostazione di una configurazione del pacchetto 283
Pubblicare un pacchetto 284
Esecuzione di script 285
Rimozione di pacchetti estranei 285
Elenco dei pacchetti attualmente installati 286
Aggiornamento di npm e pacchetti 286
Bloccare i moduli su versioni specifiche 287
Impostazione per pacchetti installati globalmente 287
Collegamento di progetti per il debugging e lo sviluppo più rapidi 288
Testo guida 288
Passi per il collegamento delle dipendenze del progetto 288
Passi per il collegamento di uno strumento globale 288
Problemi che possono sorgere 289
Capitolo 84: nvm - Node Version Manager 290
Osservazioni 290
Examples 290
Installa NVM 290
Controlla la versione NVM 290
Installazione di una versione specifica del nodo 290
Utilizzando una versione del nodo già installata 290
Installa nvm su Mac OSX 291
PROCESSO DI INSTALLAZIONE 291
PROVA CHE NVM È STATO INSTALLATO CORRETTAMENTE 291
Impostazione dell'alias per la versione del nodo 292
Esegui qualsiasi comando arbitrario in una subshell con la versione desiderata del nodo 292
Capitolo 85: OAuth 2.0 294
Examples 294
OAuth 2 con implementazione Redis - grant_type: password 294
Spero di aiutare! 301
Capitolo 86: package.json 302
Osservazioni 302
Examples 302
Definizione del progetto di base 302
dipendenze 302
devDependencies 303
Script 303
Script predefiniti 303
Script definiti dall'utente 304
Definizione del progetto estesa 304
Esplorando package.json 305
Capitolo 87: parser csv nel nodo js 310
introduzione 310
Examples 310
Usare FS per leggere in un CSV 310
Capitolo 88: passport.js 311
introduzione 311
Examples 311
Esempio di LocalStrategy in passport.js 311
Capitolo 89: Pool di connessione Mysql 313
Examples 313
Utilizzo di un pool di connessioni senza database 313
Capitolo 90: Prestazioni Node.js 315
Examples 315
Loop degli eventi 315
Esempio di operazione di blocco 315
Esempio di operazione IO non bloccante 315
Considerazioni sulle prestazioni 316
Aumenta max socket 316
Nozioni di base 316
Impostare il proprio agente 316
Disattivare completamente Socket Pooling 317
insidie 317
Abilita gzip 317
Capitolo 91: Programmazione asincrona 319
introduzione 319
Sintassi 319
Examples 319
Funzioni di callback 319
Funzioni di callback in JavaScript 319
Callback sincroni. 319
Callback asincroni. 320
Funzioni di callback in Node.js 321
Esempio di codice 322
Gestione degli errori asincroni 323
Prova a prendere 323
Possibilità di lavoro 323
Gestori di eventi 323
domini 323
Callback hell 324
Promesse native 325
Capitolo 92: Programmazione sincrona contro asincrona in nodejs 327
Examples 327
Uso asincrono 327
Capitolo 93: Promesse Bluebird 328
Examples 328
Conversione della libreria del nodoback in Promises 328
Promesse funzionali 328
Coroutine (generatori) 328
Smaltimento automatico delle risorse (Promise.using) 329
Eseguendo in serie 329
Capitolo 94: Protezione delle applicazioni Node.js 330
Examples 330
Prevenire la falsificazione di richieste cross-site (CSRF) 330
SSL / TLS in Node.js 331
Utilizzando HTTPS 332
Configurare un server HTTPS 332
Passaggio 1: creare un'autorità di certificazione 332
Passaggio 2: installa il certificato come certificato di origine 333
Applicazione Secure express.js 3 333
Capitolo 95: Quadri di modelli 335
Examples 335
Nunjucks 335
Capitolo 96: Quadri di test unitari 337
Examples 337
Mocha sincrono 337
Mocha asincrono (callback) 337
Mocha asincrono (Promessa) 337
Mocha asincrono (async / await) 337
Capitolo 97: Richiamata per promettere 339
Examples 339
Promuovere una richiamata 339
Promessa manuale di un callback 340
setTimeout promesso 340
Capitolo 98: Richiedere() 341
introduzione 341
Sintassi 341
Osservazioni 341
Examples 341
Beginning require () usa con una funzione e un file 341
Beginning require () usa con un pacchetto NPM 342
Capitolo 99: Route-Controller-Struttura del servizio per ExpressJS 344
Examples 344
Modello-Routes-Controllers-Services Struttura delle directory 344
Modello-Routes-Controllers-Services Struttura dei codici 344
user.model.js 344
user.routes.js 344
user.controllers.js 345
user.services.js 345
Capitolo 100: Routing NodeJs 346
introduzione 346
Osservazioni 346
Examples 346
Esecuzione del routing del server Web 346
Capitolo 101: Sequelize.js 351
Examples 351
Installazione 351
Definizione dei modelli 352
1. sequelize.define (modelName, attributes, [opzioni]) 352
2. sequelize.import (path) 352
Capitolo 102: Sfide di prestazione 354
Examples 354
Elaborazione di query a esecuzione prolungata con nodo 354
Capitolo 103: Socket TCP 358
Examples 358
Un semplice server TCP 358
Un semplice client TCP 358
Capitolo 104: Storia di Nodejs 360
introduzione 360
Examples 360
Eventi chiave in ogni anno 360
2009 360
2010 360
2011 360
2012 360
2013 361
2014 361
2015 361
Q1 361
Q2 361
Q3 362
Q4 362
2016 362
Q1 362
Q2 362
Q3 362
Q4 362
Capitolo 105: Struttura del progetto 363
introduzione 363
Osservazioni 363
Examples 363
Una semplice applicazione nodejs con MVC e API 363
Capitolo 106: Upload di file 366
Examples 366
Caricamento file singolo con multer 366
Nota: 367
Come filtrare il caricamento per estensione: 367
Usando il modulo formidabile 367
Capitolo 107: Usa casi di Node.js 369
Examples 369
Server HTTP 369
Console con prompt dei comandi 369
Capitolo 108: Usando i flussi 371
Parametri 371
Examples 371
Leggi i dati da TextFile con flussi 371
Flussi di tubazioni 372
Crea il tuo stream leggibile / scrivibile 372
Perché i flussi? 373
Capitolo 109: Usare Browserfiy per risolvere l'errore 'richiesto' con i browser 376
Examples 376
Esempio: file.js 376
Cosa sta facendo questo frammento? 376
Installa Browserfy 376
Importante 377
Cosa significa? 377
Capitolo 110: Utilizzando WebSocket con Node.JS 378
Examples 378
Installazione di WebSocket 378
Aggiunta di WebSocket al tuo file 378
Utilizzo dei server WebSocket e WebSocket 378
Un esempio di server WebSocket semplice 378
Capitolo 111: Utilizzo di IISNode per ospitare le app Web Node.js in IIS 380
Osservazioni 380
Directory virtuale / Applicazione nidificata con le trappole delle viste 380
versioni 380
Examples 380
Iniziare 380
Requisiti 380
Esempio di base Hello World utilizzando Express 381
Struttura del progetto 381
server.js - Applicazione Express 381
Configurazione e Web.config 381
Configurazione 382
IISNode Handler 382
Regole di riscrittura degli URL 382
Utilizzando una directory virtuale IIS o un'applicazione nidificata tramite 383
Utilizzo di Socket.io con IISNode 384
Titoli di coda 386
Di
You can share this PDF with anyone you feel could benefit from it, downloaded the latest version
from: node-js
It is an unofficial and free Node.js ebook created for educational purposes. All the content is
extracted from Stack Overflow Documentation, which is written by many hardworking individuals at
Stack Overflow. It is neither affiliated with Stack Overflow nor official Node.js.
The content is released under Creative Commons BY-SA, and the list of contributors to each
chapter are provided in the credits section at the end of this book. Images may be copyright of
their respective owners unless otherwise specified. All trademarks and registered trademarks are
the property of their respective company owners.
Use the content presented in this book at your own risk; it is not guaranteed to be correct nor
accurate, please send your feedback and corrections to [email protected]
https://riptutorial.com/it/home 1
Capitolo 1: Iniziare con Node.js
Osservazioni
Node.js è un framework I / O asincrono basato su eventi, non bloccante, che utilizza il motore
JavaScript V8 di Google. Viene utilizzato per lo sviluppo di applicazioni che sfruttano
pesantemente la possibilità di eseguire JavaScript sia sul client, sia sul lato server e quindi
beneficiano della riutilizzabilità del codice e della mancanza di cambio di contesto. È open source
e multipiattaforma. Le applicazioni Node.js sono scritte in puro JavaScript e possono essere
eseguite all'interno dell'ambiente Node.js su Windows, Linux, ecc ...
Versioni
Versione Data di rilascio
V8.2.1 2017/07/20
v8.2.0 2017/07/19
v8.1.4 2017/07/11
v8.1.3 2017/06/29
V8.1.2 2017/06/15
v8.1.1 2017/06/13
v8.1.0 2017/06/08
v8.0.0 2017/05/30
v7.10.0 2017/05/02
v7.9.0 2017/04/11
v7.8.0 2017/03/29
v7.7.4 2017/03/21
v7.7.3 2017/03/14
v7.7.2 2017/03/08
v7.7.1 2017/03/02
v7.7.0 2017/02/28
https://riptutorial.com/it/home 2
Versione Data di rilascio
V7.6.0 2017/02/21
v7.5.0 2017/01/31
v7.4.0 2017/01/04
v7.3.0 2016/12/20
v7.2.1 2016/12/06
v7.2.0 2016/11/22
v7.1.0 2016/11/08
v7.0.0 2016/10/25
v6.11.0 2017/06/06
v6.10.3 2017/05/02
v6.10.2 2017/04/04
v6.10.1 2017/03/21
v6.10.0 2017/02/21
v6.9.5 2017/01/31
v6.9.4 2017/01/05
v6.9.3 2017/01/05
v6.9.2 2016/12/06
v6.9.1 2016/10/19
v6.9.0 2016/10/18
v6.8.1 2016/10/14
v6.8.0 2016/10/12
v6.7.0 2016/09/27
v6.6.0 2016/09/14
v6.5.0 2016/08/26
v6.4.0 2016/08/12
https://riptutorial.com/it/home 3
Versione Data di rilascio
v6.3.1 2016/07/21
v6.3.0 2016/07/06
V6.2.2 2016/06/16
V6.2.1 2016/06/02
V6.2.0 2016/05/17
V6.1.0 2016/05/05
v6.0.0 2016/04/26
v5.12.0 2016/06/23
v5.11.1 2016/05/05
v5.11.0 2016/04/21
v5.10.1 2016/04/05
v5.10 2016/04/01
v5.9 2016/03/16
v5.8 2016/03/09
quella 5.7 2016/02/23
v5.6 2016/02/09
v5.5 2016/01/21
V5.4 2016/01/06
V5.3 2015/12/15
v5.2 2015/12/09
v5.1 2015/11/17
v5.0 2015/10/29
v4.4 2016/03/08
V4.3 2016/02/09
v4.2 2015/10/12
https://riptutorial.com/it/home 4
Versione Data di rilascio
v4.1 2015/09/17
v4.0 2015/09/08
io.js v3.3 2015/09/02
io.js v3.2 2015/08/25
io.js v3.1 2015/08/19
io.js v3.0 2015/08/04
io.js v2.5 2015/07/28
io.js v2.4 2015/07/17
io.js v2.3 2015/06/13
io.js v2.2 2015/06/01
io.js v2.1 2015/05/24
io.js v2.0 2015/05/04
io.js v1.8 2015/04/21
io.js v1.7 2015/04/17
io.js v1.6 2015/03/20
io.js v1.5 2015/03/06
io.js v1.4 2015/02/27
io.js v1.3 2015/02/20
io.js v1.2 2015/02/11
io.js v1.1 2015/02/03
io.js v1.0 2015/01/14
v0.12 2016/02/09
v0.11 2013/03/28
v0.10 2013/03/11
v0.9 2012-07-20
https://riptutorial.com/it/home 5
Versione Data di rilascio
v0.8 2012-06-22
v0.7 2012-01-17
v0.6 2011-11-04
v0.5 2011-08-26
v0.4 2011-08-26
v0.3 2011-08-26
v0.2 2011-08-26
v0.1 2011-08-26
Examples
Ciao server World HTTP
Innanzitutto, installa Node.js per la tua piattaforma.
In questo esempio creeremo un server HTTP in ascolto sulla porta 1337, che invia Hello, World!
al browser. Si noti che, invece di utilizzare la porta 1337, è possibile utilizzare qualsiasi numero di
porta a scelta che al momento non è utilizzato da nessun altro servizio.
Il modulo http è un modulo core Node.js (un modulo incluso nell'origine di Node.js, che non
richiede l'installazione di risorse aggiuntive). Il modulo http fornisce la funzionalità per creare un
server HTTP utilizzando il metodo http.createServer() . Per creare l'applicazione, creare un file
contenente il seguente codice JavaScript.
const http = require('http'); // Loads the http module
http.createServer((request, response) => {
// 1. Tell the browser everything is OK (Status code 200), and the data is in plain text
response.writeHead(200, {
'Content-Type': 'text/plain'
});
// 2. Write the announced text to the body of the page
response.write('Hello, World!\n');
// 3. Tell the server that all of the response headers and body have been sent
response.end();
}).listen(1337); // 4. Tells the server what port to be on
Salva il file con qualsiasi nome di file. In questo caso, se lo hello.js possiamo eseguire
l'applicazione andando nella directory in cui si trova il file e usando il seguente comando:
https://riptutorial.com/it/home 6
node hello.js
È possibile accedere al server creato con l'URL http: // localhost: 1337 o http://127.0.0.1:1337 nel
browser.
Una pagina web semplice apparirà con un testo "Hello, World!" In alto, come mostrato nello
screenshot qui sotto.
Esempio online modificabile.
Ciao linea di comando mondiale
Node.js può anche essere utilizzato per creare utilità da riga di comando. L'esempio seguente
legge il primo argomento dalla riga di comando e stampa un messaggio Hello.
Per eseguire questo codice su un sistema Unix:
1. Crea un nuovo file e incolla il codice qui sotto. Il nome file è irrilevante.
2. Rendi questo file eseguibile con chmod 700 FILE_NAME
3. Esegui l'app con ./APP_NAME David
Su Windows fai il passaggio 1 ed node APP_NAME David con il node APP_NAME David
#!/usr/bin/env node
'use strict';
/*
The command line arguments are stored in the `process.argv` array,
which has the following structure:
[0] The path of the executable that started the Node.js process
[1] The path to this application
[2-n] the command line arguments
https://riptutorial.com/it/home 7
Example: [ '/bin/node', '/path/to/yourscript', 'arg1', 'arg2', ... ]
src: https://nodejs.org/api/process.html#process_process_argv
*/
// Store the first argument as username.
var username = process.argv[2];
// Check if the username hasn't been provided.
if (!username) {
// Extract the filename
var appName = process.argv[1].split(require('path').sep).pop();
// Give the user an example on how to use the app.
console.error('Missing argument! Example: %s YOUR_NAME', appName);
// Exit the app (success: 0, error: 1).
// An error will stop the execution chain. For example:
// ./app.js && ls -> won't execute ls
// ./app.js David && ls -> will execute ls
process.exit(1);
}
// Print the message to the console.
console.log('Hello %s!', username);
Installazione ed esecuzione di Node.js
Per iniziare, installa Node.js sul tuo computer di sviluppo.
Windows: vai alla pagina di download e scarica / esegui il programma di installazione.
Mac: vai alla pagina di download e scarica / esegui il programma di installazione. In alternativa, è
possibile installare il nodo tramite Homebrew utilizzando il brew install node . Homebrew è un
pacchetto di comandi a riga di comando per Macintosh, e ulteriori informazioni a riguardo sono
disponibili sul sito Web di Homebrew .
Linux: seguire le istruzioni per la distro sulla pagina di installazione della riga di comando .
Esecuzione di un programma di nodo
Per eseguire un programma Node.js, esegui semplicemente il node app.js o nodejs app.js , dove
app.js è il nome file del tuo codice sorgente dell'app nodo. Non è necessario includere il suffisso
.js per il nodo per trovare lo script che desideri eseguire.
In alternativa, con i sistemi operativi basati su UNIX, un programma Node può essere eseguito
come uno script terminale. Per fare ciò, è necessario iniziare con uno shebang che punta
all'interprete Node, come #!/usr/bin/env node . Il file deve anche essere impostato come
eseguibile, che può essere fatto usando chmod . Ora lo script può essere eseguito direttamente
dalla riga di comando.
https://riptutorial.com/it/home 8
Distribuzione dell'applicazione online
Quando si distribuisce l'app in un ambiente ospitato (specifico per Node.js), in genere questo
ambiente offre una variabile di ambiente PORT che è possibile utilizzare per eseguire il server. La
modifica del numero di porta in process.env.PORT consente di accedere all'applicazione.
Per esempio,
http.createServer(function(request, response) {
// your server code
}).listen(process.env.PORT);
Inoltre, se desideri accedere a questo offline durante il debug, puoi utilizzare questo:
http.createServer(function(request, response) {
// your server code
}).listen(process.env.PORT || 3000);
dove 3000 è il numero di porta offline.
Debug della tua applicazione NodeJS
È possibile utilizzare il nodo-inspector. Esegui questo comando per installarlo tramite npm:
npm install -g node-inspector
Quindi puoi eseguire il debug dell'applicazione usando
node-debug app.js
Il repository Github può essere trovato qui: https://github.com/node-inspector/node-inspector
Debugging nativamente
Puoi anche eseguire il debug di node.js in modo nativo avviandolo in questo modo:
node debug your-script.js
Per interrompere il debugger esattamente in una riga di codice che desideri, usa questo:
debugger;
Per maggiori informazioni vedi qui .
In node.js 8 usa il seguente comando:
https://riptutorial.com/it/home 9
node --inspect-brk your-script.js
Quindi apri about://inspect in una versione recente di Google Chrome e seleziona lo script del
nodo per ottenere l'esperienza di debug di Chrome's DevTools.
Ciao mondo con Express
Nell'esempio seguente viene utilizzato Express per creare un server HTTP in ascolto sulla porta
3000, che risponde con "Hello, World!". Express è un framework web comunemente utilizzato che
è utile per creare API HTTP.
Innanzitutto, crea una nuova cartella, ad esempio myApp . Vai su myApp e crea un nuovo file
JavaScript contenente il seguente codice ( hello.js per esempio). Quindi installare il modulo
express usando npm install --save express dalla riga di comando. Fare riferimento a questa
documentazione per ulteriori informazioni su come installare i pacchetti .
// Import the top-level function of express
const express = require('express');
// Creates an Express application using the top-level function
const app = express();
// Define port number as 3000
const port = 3000;
// Routes HTTP GET requests to the specified path "/" with the specified callback function
app.get('/', function(request, response) {
response.send('Hello, World!');
});
// Make the app listen on port 3000
app.listen(port, function() {
console.log('Server listening on http://localhost:' + port);
});
Dalla riga di comando, eseguire il seguente comando:
node hello.js
Apri il browser e vai a http://localhost:3000 o http://127.0.0.1:3000 per vedere la risposta.
Per ulteriori informazioni sul framework Express, è possibile controllare la sezione Web Apps con
Express
Hello World routing di base
Una volta compreso come creare un server HTTP con nodo, è importante capire come farlo "fare"
le cose in base al percorso a cui un utente ha navigato. Questo fenomeno è chiamato "routing".
L'esempio più semplice di questo sarebbe verificare if (request.url === 'some/path/here') ,e
quindi chiamare una funzione che risponde con un nuovo file.
https://riptutorial.com/it/home 10
Un esempio di questo può essere visto qui:
const http = require('http');
function index (request, response) {
response.writeHead(200);
response.end('Hello, World!');
}
http.createServer(function (request, response) {
if (request.url === '/') {
return index(request, response);
}
response.writeHead(404);
response.end(http.STATUS_CODES[404]);
}).listen(1337);
Se continui a definire le tue "rotte" come questa, però, finirai con una funzione di callback enorme,
e non vogliamo un pasticcio gigante come quello, quindi vediamo se riusciamo a ripulire tutto.
Per prima cosa, memorizziamo tutti i nostri percorsi in un oggetto:
var routes = {
'/': function index (request, response) {
response.writeHead(200);
response.end('Hello, World!');
},
'/foo': function foo (request, response) {
response.writeHead(200);
response.end('You are now viewing "foo"');
}
}
Ora che abbiamo memorizzato 2 percorsi in un oggetto, ora possiamo controllarli nel nostro
callback principale:
http.createServer(function (request, response) {
if (request.url in routes) {
return routes[request.url](request, response);
}
response.writeHead(404);
response.end(http.STATUS_CODES[404]);
}).listen(1337);
Ora ogni volta che provi a navigare nel tuo sito web, controllerà l'esistenza di quel percorso nei
tuoi percorsi e chiamerà la rispettiva funzione. Se non viene trovata alcuna route, il server
risponderà con un 404 (non trovato).
Ed ecco fatto: il routing con l'API di HTTP Server è molto semplice.
https://riptutorial.com/it/home 11
Socket TLS: server e client
Le uniche differenze principali tra questa e una normale connessione TCP sono la chiave privata e
il certificato pubblico che dovrai impostare in un oggetto opzione.
Come creare una chiave e un certificato
Il primo passo in questo processo di sicurezza è la creazione di una chiave privata. E qual è
questa chiave privata? Fondamentalmente, è un insieme di rumore casuale che viene utilizzato
per crittografare le informazioni. In teoria, potresti creare una chiave e usarla per crittografare
quello che vuoi. Ma è una buona pratica avere diverse chiavi per cose specifiche. Perché se
qualcuno ruba la tua chiave privata, è come se qualcuno rubasse le chiavi della tua casa.
Immagina se hai usato la stessa chiave per bloccare la tua auto, garage, ufficio, ecc.
openssl genrsa -out private-key.pem 1024
Una volta che abbiamo la nostra chiave privata, possiamo creare una CSR (richiesta di firma del
certificato), che è la nostra richiesta di far firmare la chiave privata da un'autorità immaginaria.
Questo è il motivo per cui devi inserire le informazioni relative alla tua azienda. Queste
informazioni verranno visualizzate dall'autorità di firma e utilizzate per verificare l'utente. Nel
nostro caso, non importa ciò che scrivi, dal momento che nel prossimo passaggio firmeremo noi
stessi il nostro certificato.
openssl req -new -key private-key.pem -out csr.pem
Ora che abbiamo completato il nostro lavoro cartaceo, è tempo di fingere di essere un'autentica
autorità firmataria.
openssl x509 -req -in csr.pem -signkey private-key.pem -out public-cert.pem
Ora che hai la chiave privata e il certificato pubblico, puoi stabilire una connessione sicura tra due
app NodeJS. E, come puoi vedere nel codice di esempio, è un processo molto semplice.
Importante!
Dal momento che abbiamo creato noi stessi il certificato pubblico, in tutta onestà, il nostro
certificato non ha valore, perché siamo nomini. Il server NodeJS non si fiderà di tale certificato per
impostazione predefinita, ed è per questo motivo che è necessario dirlo per fidarsi effettivamente
del nostro cert con la seguente opzione rejectUnauthorized: false. Molto importante : non
impostare mai questa variabile su true in un ambiente di produzione.
TLS Socket Server
'use strict';
https://riptutorial.com/it/home 12
var tls = require('tls');
var fs = require('fs');
const PORT = 1337;
const HOST = '127.0.0.1'
var options = {
key: fs.readFileSync('private-key.pem'),
cert: fs.readFileSync('public-cert.pem')
};
var server = tls.createServer(options, function(socket) {
// Send a friendly message
socket.write("I am the server sending you a message.");
// Print the data that we received
socket.on('data', function(data) {
console.log('Received: %s [it is %d bytes long]',
data.toString().replace(/(\n)/gm,""),
data.length);
});
// Let us know when the transmission is over
socket.on('end', function() {
console.log('EOT (End Of Transmission)');
});
});
// Start listening on a specific port and address
server.listen(PORT, HOST, function() {
console.log("I'm listening at %s, on port %s", HOST, PORT);
});
// When an error occurs, show it.
server.on('error', function(error) {
console.error(error);
// Close the connection after the error occurred.
server.destroy();
});
TLS Socket Client
'use strict';
var tls = require('tls');
var fs = require('fs');
https://riptutorial.com/it/home 13
const PORT = 1337;
const HOST = '127.0.0.1'
// Pass the certs to the server and let it know to process even unauthorized certs.
var options = {
key: fs.readFileSync('private-key.pem'),
cert: fs.readFileSync('public-cert.pem'),
rejectUnauthorized: false
};
var client = tls.connect(PORT, HOST, options, function() {
// Check if the authorization worked
if (client.authorized) {
console.log("Connection authorized by a Certificate Authority.");
} else {
console.log("Connection not authorized: " + client.authorizationError)
}
// Send a friendly message
client.write("I am the client sending you a message.");
});
client.on("data", function(data) {
console.log('Received: %s [it is %d bytes long]',
data.toString().replace(/(\n)/gm,""),
data.length);
// Close the connection after receiving the message
client.end();
});
client.on('close', function() {
console.log("Connection closed");
});
// When an error ocoures, show it.
client.on('error', function(error) {
console.error(error);
// Close the connection after the error occurred.
client.destroy();
});
Ciao mondo nella REPL
Quando chiamato senza argomenti, Node.js avvia un REPL (Read-Eval-Print-Loop) noto anche
come " Node shell ".
Al prompt dei comandi digitare node .
https://riptutorial.com/it/home 14
$ node
>
Al prompt della shell Nodo > tipo "Ciao Mondo!"
$ node
> "Hello World!"
'Hello World!'
Moduli core
Node.js è un motore Javascript (motore V8 di Google per Chrome, scritto in C ++) che consente di
eseguire Javascript all'esterno del browser. Mentre numerose librerie sono disponibili per
estendere le funzionalità di Node, il motore viene fornito con una serie di moduli principali che
implementano funzionalità di base.
Ci sono attualmente 34 moduli principali inclusi nel nodo:
[ 'assert',
'buffer',
'c/c++_addons',
'child_process',
'cluster',
'console',
'crypto',
'deprecated_apis',
'dns',
'domain',
'Events',
'fs',
'http',
'https',
'module',
'net',
'os',
'path',
'punycode',
'querystring',
'readline',
'repl',
'stream',
'string_decoder',
'timers',
'tls_(ssl)',
'tracing',
'tty',
'dgram',
'url',
'util',
'v8',
'vm',
'zlib' ]
Questo elenco è stato ottenuto dall'API di documentazione del nodo https://nodejs.org/api/all.html
(file JSON: https://nodejs.org/api/all.json ).
https://riptutorial.com/it/home 15
Tutti i moduli di base a colpo d'occhio
affermare
Il modulo assert fornisce una semplice serie di test di asserzione che possono essere utilizzati per
testare gli invarianti.
buffer
Prima dell'introduzione di TypedArray in ECMAScript 2015 (ES6), il linguaggio JavaScript non
aveva alcun meccanismo per leggere o manipolare flussi di dati binari. La classe Buffer è stata
introdotta come parte dell'API Node.js per rendere possibile l'interazione con i flussi di ottetti nel
contesto di operazioni come flussi TCP e operazioni del file system.
Ora che TypedArray è stato aggiunto in ES6, la classe Buffer implementa l'API Uin t8Array in un
modo più ottimizzato e adatto ai casi d'uso di Node.js.
C / C ++ _ addons
I componenti aggiuntivi di Node.js sono oggetti condivisi collegati dinamicamente, scritti in C o C
++, che possono essere caricati in Node.js usando la funzione require() e usati come se fossero
un normale modulo Node.js. Vengono utilizzati principalmente per fornire un'interfaccia tra
JavaScript in esecuzione nelle librerie Node.js e C / C ++.
child_process
Il modulo child_process fornisce la possibilità di generare processi figlio in un modo simile, ma non
identico, a popen (3).
grappolo
Una singola istanza di Node.js viene eseguita in un singolo thread. Per sfruttare i sistemi multi-
core, l'utente a volte desidera avviare un cluster di processi Node.js per gestire il carico. Il modulo
cluster consente di creare facilmente processi figlio che condividono tutte le porte del server.
consolle
Il modulo console fornisce una semplice console di debug che è simile al meccanismo della
console JavaScript fornito dai browser web.
crypto
Il modulo crypto fornisce funzionalità crittografiche che include un set di wrapper per le funzioni di
hash, HMAC, cifratura, decifratura, firma e verifica di OpenSSL.
deprecated_apis
Node.js può deprecare API quando: (a) l'utilizzo dell'API è considerato non sicuro, (b) è stata resa
disponibile un'API alternativa migliorata oppure (c) sono previste interruzioni delle modifiche
https://riptutorial.com/it/home 16
all'API in una futura versione principale .
dns
Il modulo dns contiene funzioni appartenenti a due diverse categorie:
1. Funzioni che utilizzano le funzionalità del sistema operativo sottostante per eseguire la
risoluzione dei nomi e che non eseguono necessariamente alcuna comunicazione di rete.
Questa categoria contiene solo una funzione: dns.lookup() .
2. Funzioni che si connettono a un server DNS effettivo per eseguire la risoluzione dei nomi e
che utilizzano sempre la rete per eseguire query DNS. Questa categoria contiene tutte le
funzioni nel modulo dns tranne dns.lookup() .
dominio
Questo modulo è in attesa di deprecazione . Una volta completata l'API di sostituzione, questo
modulo sarà completamente deprecato. La maggior parte degli utenti non dovrebbe avere motivo
di usare questo modulo. Gli utenti che devono assolutamente disporre delle funzionalità fornite dai
domini possono affidarsi al momento, ma in futuro dovrebbero aspettarsi di dover eseguire la
migrazione a una soluzione diversa.
eventi
Gran parte dell'API core di Node.js è basata su un'architettura asincrona basata sugli eventi
asincrona in cui determinati tipi di oggetti (chiamati "emettitori") emettono periodicamente eventi
denominati che causano la chiamata di oggetti Function ("listener").
fs
I / O di file sono forniti da semplici wrapper attorno alle funzioni POSIX standard. Per utilizzare
questo modulo è require('fs') . Tutti i metodi hanno forme asincrone e sincrone.
http
Le interfacce HTTP in Node.js sono progettate per supportare molte funzionalità del protocollo che
sono state tradizionalmente difficili da utilizzare. In particolare, messaggi di grandi dimensioni,
possibilmente codificati per il chunk. L'interfaccia fa attenzione a non bufferizzare intere richieste o
risposte - l'utente è in grado di trasmettere dati.
https
HTTPS è il protocollo HTTP su TLS / SSL. In Node.js questo è implementato come un modulo
separato.
modulo
Node.js ha un semplice sistema di caricamento dei moduli. In Node.js, i file e i moduli sono in
corrispondenza uno a uno (ogni file viene trattato come un modulo separato).
netto
https://riptutorial.com/it/home 17
Il modulo net fornisce un wrapper di rete asincrono. Contiene funzioni per la creazione di server e
client (chiamati flussi). Puoi includere questo modulo con require('net'); .
os
Il modulo os fornisce numerosi metodi di utilità relativi al sistema operativo.
sentiero
Il modulo path fornisce utility per lavorare con i percorsi di file e directory.
Punycode
La versione del modulo punycode in bundle in Node.js è deprecata .
stringa della domanda
Il modulo querystring fornisce utility per l'analisi e la formattazione delle stringhe di query URL.
linea di lettura
Il modulo readline fornisce un'interfaccia per leggere i dati da un flusso leggibile (come
process.stdin ) una riga alla volta.
repl
Il modulo repl fornisce un'implementazione Read-Eval-Print-Loop (REPL) che è disponibile sia
come programma standalone che includibile in altre applicazioni.
ruscello
Un flusso è un'interfaccia astratta per lavorare con i dati di streaming in Node.js. Il modulo stream
fornisce un'API di base che semplifica la creazione di oggetti che implementano l'interfaccia di
streaming.
Esistono molti oggetti di flusso forniti da Node.js. Ad esempio, una richiesta a un server HTTP e
process.stdout sono entrambe istanze di flusso.
string_decoder
Il modulo string_decoder fornisce un'API per decodificare gli oggetti Buffer in stringhe in modo da
preservare i caratteri codificati UTF-8 e UTF-16 codificati.
temporizzatori
Il modulo timer espone un'API globale per le funzioni di pianificazione da richiamare in un
determinato periodo di tempo. Poiché le funzioni del timer sono globali, non è necessario
chiamare require('timers') per utilizzare l'API.
Le funzioni del timer all'interno di Node.js implementano un'API simile all'API dei timer fornita dai
browser Web, ma utilizzano un'implementazione interna diversa costruita attorno al Loop eventi di
https://riptutorial.com/it/home 18
Node.js.
tls_ (SSL)
Il modulo tls fornisce un'implementazione dei protocolli Transport Layer Security (TLS) e Secure
Socket Layer (SSL) costruiti su OpenSSL.
tracciato
Trace Event fornisce un meccanismo per centralizzare le informazioni di traccia generate da V8,
nucleo del nodo e codice dello spazio utente.
La traccia può essere abilitata passando il --trace-events-enabled all'avvio di un'applicazione
Node.js.
tty
Il modulo tty fornisce le classi tty.ReadStream e tty.WriteStream . Nella maggior parte dei casi, non
sarà necessario o possibile utilizzare direttamente questo modulo.
dgram
Il modulo dgram fornisce un'implementazione di socket UDP Datagram.
url
Il modulo url fornisce utility per la risoluzione e l'analisi dell'URL.
util
Il modulo util è progettato principalmente per supportare le esigenze delle API interne di Node.js.
Tuttavia, molte delle utilità sono utili anche per gli sviluppatori di applicazioni e moduli.
v8
Il modulo v8 espone le API specifiche per la versione di V8 integrata nel binario Node.js.
Nota : le API e l'implementazione sono soggette a modifiche in qualsiasi momento.
vm
Il modulo vm fornisce API per la compilazione e l'esecuzione del codice all'interno dei contesti della
macchina virtuale V8. Il codice JavaScript può essere compilato ed eseguito immediatamente o
compilato, salvato ed eseguito successivamente.
Nota : il modulo vm non è un meccanismo di sicurezza. Non usarlo per eseguire codice non
affidabile .
zlib
Il modulo zlib fornisce funzionalità di compressione implementate usando Gzip e Deflate / Inflate.
https://riptutorial.com/it/home 19
Come ottenere un server Web HTTPS di base attivo e funzionante!
Una volta che node.js è installato sul tuo sistema, puoi semplicemente seguire la procedura
seguente per ottenere un server Web di base in esecuzione con supporto per HTTP e HTTPS!
Passaggio 1: creare un'autorità di certificazione
1. creare la cartella in cui si desidera memorizzare la chiave e il certificato:
mkdir conf
2. vai a quella directory:
cd conf
3. prendi questo file ca.cnf da usare come scorciatoia di configurazione:
wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf
4. creare una nuova autorità di certificazione utilizzando questa configurazione:
openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem
5. ora che abbiamo la nostra autorità di certificazione in ca-key.pem e ca-cert.pem , ca-key.pem
una chiave privata per il server:
openssl genrsa -out key.pem 4096
6. prendi questo file server.cnf da usare come scorciatoia di configurazione:
wget https://raw.githubusercontent.com/anders94/https-authorized-
clients/master/keys/server.cnf
7. generare la richiesta di firma del certificato utilizzando questa configurazione:
openssl req -new -config server.cnf -key key.pem -out csr.pem
8. firmare la richiesta:
openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in csr.pem -CA ca-
cert.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem
Passaggio 2: installa il certificato come certificato di origine
https://riptutorial.com/it/home 20
1. copia il tuo certificato nella cartella dei certificati di root:
sudo cp ca-crt.pem /usr/local/share/ca-certificates/ca-crt.pem
2. aggiornare l'archivio di CA:
sudo update-ca-certificates
Passaggio 3: avvio del server nodo
Innanzitutto, si desidera creare un file server.js che contenga il proprio codice server attuale.
L'installazione minima per un server HTTPS in Node.js sarebbe qualcosa del genere:
var https = require('https');
var fs = require('fs');
var httpsOptions = {
key: fs.readFileSync('path/to/server-key.pem'),
cert: fs.readFileSync('path/to/server-crt.pem')
};
var app = function (req, res) {
res.writeHead(200);
res.end("hello world\n");
}
https.createServer(httpsOptions, app).listen(4433);
Se vuoi anche supportare le richieste http, devi fare solo questa piccola modifica:
var http = require('http');
var https = require('https');
var fs = require('fs');
var httpsOptions = {
key: fs.readFileSync('path/to/server-key.pem'),
cert: fs.readFileSync('path/to/server-crt.pem')
};
var app = function (req, res) {
res.writeHead(200);
res.end("hello world\n");
}
http.createServer(app).listen(8888);
https.createServer(httpsOptions, app).listen(4433);
1. vai alla directory in cui si trova il tuo server.js :
cd /path/to
https://riptutorial.com/it/home 21
2. eseguire server.js :
node server.js
Leggi Iniziare con Node.js online: https://riptutorial.com/it/node-js/topic/340/iniziare-con-node-js
https://riptutorial.com/it/home 22
Capitolo 2: Ambiente
Examples
Accesso alle variabili d'ambiente
La proprietà process.env restituisce un oggetto contenente l'ambiente utente.
Restituisce un oggetto come questo:
{
TERM: 'xterm-256color',
SHELL: '/usr/local/bin/bash',
USER: 'maciej',
PATH: '~/.bin/:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin',
PWD: '/Users/maciej',
EDITOR: 'vim',
SHLVL: '1',
HOME: '/Users/maciej',
LOGNAME: 'maciej',
_: '/usr/local/bin/node'
}
process.env.HOME // '/Users/maciej'
Se imposti la variabile di ambiente FOO su foobar , sarà accessibile con:
process.env.FOO // 'foobar'
argomenti della riga di comando process.argv
process.argv è una matrice contenente gli argomenti della riga di comando. Il primo elemento sarà
node , il secondo elemento sarà il nome del file JavaScript. Gli elementi successivi saranno gli
argomenti aggiuntivi della riga di comando.
Esempio di codice:
Output sum di tutti gli argomenti della riga di comando
index.js
var sum = 0;
for (i = 2; i < process.argv.length; i++) {
sum += Number(process.argv[i]);
}
console.log(sum);
Uso Exaple:
https://riptutorial.com/it/home 23
node index.js 2 5 6 7
L'uscita sarà 20
Una breve spiegazione del codice:
Qui in for loop for (i = 2; i < process.argv.length; i++) loop inizia con 2 perché i primi due
elementi nell'array process.argv sono sempre ['path/to/node.exe', 'path/to/js/file', ...]
Conversione in numero Number(process.argv[i]) perché gli elementi nell'array process.argv sono
sempre stringhe
Utilizzo di diverse proprietà / configurazione per ambienti diversi come dev,
qa, staging, ecc.
Le applicazioni su larga scala spesso hanno bisogno di proprietà diverse quando funzionano su
ambienti diversi. possiamo ottenere ciò passando argomenti all'applicazione NodeJs e utilizzando
lo stesso argomento nel processo del nodo per caricare un file di proprietà dell'ambiente specifico.
Supponiamo di avere due file di proprietà per diversi ambienti.
• dev.json
{
PORT : 3000,
DB : {
host : "localhost",
user : "bob",
password : "12345"
}
}
• qa.json
{
PORT : 3001,
DB : {
host : "where_db_is_hosted",
user : "bob",
password : "54321"
}
}
Il codice seguente nell'applicazione esporterà il rispettivo file di proprietà che vogliamo utilizzare.
Supponiamo che il codice sia in environment.js
process.argv.forEach(function (val, index, array) {
https://riptutorial.com/it/home 24
var arg = val.split("=");
if (arg.length > 0) {
if (arg[0] === 'env') {
var env = require('./' + arg[1] + '.json');
module.exports = env;
}
}
});
Diamo argomenti all'applicazione come seguendo
node app.js env=dev
se usiamo process manager come per sempre che sia semplice come
forever start app.js env=dev
Come utilizzare il file di configurazione
var env= require("environment.js");
Caricamento delle proprietà dell'ambiente da un "file di proprietà"
• Installa il lettore di proprietà:
npm install properties-reader --save
• Crea una directory env per memorizzare i tuoi file di proprietà:
mkdir env
• Crea environments.js :
process.argv.forEach(function (val, index, array) {
var arg = val.split("=");
if (arg.length > 0) {
if (arg[0] === 'env') {
var env = require('./env/' + arg[1] + '.properties');
module.exports = env;
}
}
});
• Esempio di file di proprietà development.properties :
# Dev properties
[main]
# Application port to run the node server
app.port=8080
[database]
https://riptutorial.com/it/home 25
# Database connection to mysql
mysql.host=localhost
mysql.port=2500
...
• Esempio di utilizzo delle proprietà caricate:
var enviorment = require('./environments');
var PropertiesReader = require('properties-reader');
var properties = new PropertiesReader(enviorment);
var someVal = properties.get('main.app.port');
• Avvio del server Express
npm start env=development
npm start env=production
Leggi Ambiente online: https://riptutorial.com/it/node-js/topic/2340/ambiente
https://riptutorial.com/it/home 26
Capitolo 3: Analizzare gli argomenti della riga
di comando
Examples
Passando azione (verbo) e valori
const options = require("commander");
options
.option("-v, --verbose", "Be verbose");
options
.command("convert")
.alias("c")
.description("Converts input file to output file")
.option("-i, --in-file <file_name>", "Input file")
.option("-o, --out-file <file_name>", "Output file")
.action(doConvert);
options.parse(process.argv);
if (!options.args.length) options.help();
function doConvert(options){
//do something with options.inFile and options.outFile
};
Passare gli switch booleani
const options = require("commander");
options
.option("-v, --verbose")
.parse(process.argv);
if (options.verbose){
console.log("Let's make some noise!");
}
Leggi Analizzare gli argomenti della riga di comando online: https://riptutorial.com/it/node-
js/topic/6174/analizzare-gli-argomenti-della-riga-di-comando
https://riptutorial.com/it/home 27
Capitolo 4: API CRUD basata su REST
semplice
Examples
API REST per CRUD in Express 3+
var express = require("express"),
bodyParser = require("body-parser"),
server = express();
//body parser for parsing request body
server.use(bodyParser.json());
server.use(bodyParser.urlencoded({ extended: true }));
//temperary store for `item` in memory
var itemStore = [];
//GET all items
server.get('/item', function (req, res) {
res.json(itemStore);
});
//GET the item with specified id
server.get('/item/:id', function (req, res) {
res.json(itemStore[req.params.id]);
});
//POST new item
server.post('/item', function (req, res) {
itemStore.push(req.body);
res.json(req.body);
});
//PUT edited item in-place of item with specified id
server.put('/item/:id', function (req, res) {
itemStore[req.params.id] = req.body
res.json(req.body);
});
//DELETE item with specified id
server.delete('/item/:id', function (req, res) {
itemStore.splice(req.params.id, 1)
res.json(req.body);
});
//START SERVER
server.listen(3000, function () {
console.log("Server running");
})
Leggi API CRUD basata su REST semplice online: https://riptutorial.com/it/node-js/topic/5850/api-
crud-basata-su-rest-semplice
https://riptutorial.com/it/home 28
Capitolo 5: App Web con Express
introduzione
Express è un framework di applicazioni web Node.js minimale e flessibile, che fornisce un robusto
set di funzionalità per la creazione di applicazioni Web.
Il sito web ufficiale di Express è expressjs.com . La fonte può essere trovata su GitHub .
Sintassi
• app.get (percorso [, middleware], callback [, callback ...])
• app.put (percorso [, middleware], callback [, callback ...])
• app.post (percorso [, middleware], callback [, callback ...])
• app ['delete'] (percorso [, middleware], callback [, callback ...])
• app.use (percorso [, middleware], callback [, callback ...])
• app.use (callback)
Parametri
Parametro Dettagli
Specifica la parte del percorso o l'URL che verrà gestito dal callback
path
specificato.
Una o più funzioni che verranno chiamate prima della richiamata.
middleware Essenzialmente un concatenamento di più funzioni di callback . Utile per una
gestione più specifica, ad esempio l'autorizzazione o la gestione degli errori.
Una funzione che verrà utilizzata per gestire le richieste nel path specificato.
callback Sarà chiamato come callback(request, response, next) , dove request ,
response e next sono descritti di seguito.
request Un oggetto che incapsula i dettagli sulla richiesta HTTP che il callback è stato
richiamata chiamato a gestire.
Un oggetto che viene utilizzato per specificare in che modo il server deve
response
rispondere alla richiesta.
Un callback che passa il controllo sulla prossima route corrispondente.
next
Accetta un oggetto errore opzionale.
Examples
https://riptutorial.com/it/home 29
Iniziare
Dovrai prima creare una directory, accedervi nella tua shell e installare Express usando npm
eseguendo npm install express --save
Crea un file e app.js e aggiungi il codice seguente che crea un nuovo server Express e aggiunge
un endpoint ( /ping ) con il metodo app.get :
const express = require('express');
const app = express();
app.get('/ping', (request, response) => {
response.send('pong');
});
app.listen(8080, 'localhost');
Per eseguire il tuo script usa il seguente comando nella tua shell:
> node app.js
La tua applicazione accetterà le connessioni sulla porta localhost 8080. Se l'argomento nome host
per app.listen viene omesso, il server accetterà le connessioni sull'indirizzo IP della macchina e
su localhost. Se il valore della porta è 0, il sistema operativo assegnerà una porta disponibile.
Una volta che lo script è in esecuzione, puoi testarlo in una shell per confermare che ottieni la
risposta prevista, "pong", dal server:
> curl http://localhost:8080/ping
pong
È anche possibile aprire un browser Web, accedere all'URL http: // localhost: 8080 / ping per
visualizzare l'output
Routing di base
Per prima cosa crea un'app express:
const express = require('express');
const app = express();
Quindi puoi definire percorsi come questo:
app.get('/someUri', function (req, res, next) {})
Questa struttura funziona per tutti i metodi HTTP e prevede un percorso come primo argomento e
un gestore per quel percorso, che riceve gli oggetti richiesta e risposta. Quindi, per i metodi HTTP
di base, questi sono i percorsi
https://riptutorial.com/it/home 30
// GET www.domain.com/myPath
app.get('/myPath', function (req, res, next) {})
// POST www.domain.com/myPath
app.post('/myPath', function (req, res, next) {})
// PUT www.domain.com/myPath
app.put('/myPath', function (req, res, next) {})
// DELETE www.domain.com/myPath
app.delete('/myPath', function (req, res, next) {})
Puoi controllare l'elenco completo dei verbi supportati qui . Se si desidera definire lo stesso
comportamento per una route e tutti i metodi HTTP, è possibile utilizzare:
app.all('/myPath', function (req, res, next) {})
app.use('/myPath', function (req, res, next) {})
app.use('*', function (req, res, next) {})
// * wildcard will route for all paths
È possibile concatenare le definizioni del percorso per un singolo percorso
app.route('/myPath')
.get(function (req, res, next) {})
.post(function (req, res, next) {})
.put(function (req, res, next) {})
È inoltre possibile aggiungere funzioni a qualsiasi metodo HTTP. Eseguiranno prima del callback
finale e prenderanno come parametri i parametri (req, res, next).
// GET www.domain.com/myPath
app.get('/myPath', myFunction, function (req, res, next) {})
Le tue callback finali possono essere archiviate in un file esterno per evitare di inserire troppo
codice in un file:
// other.js
exports.doSomething = function(req, res, next) {/* do some stuff */};
E poi nel file contenente i tuoi percorsi:
const other = require('./other.js');
app.get('/someUri', myFunction, other.doSomething);
https://riptutorial.com/it/home 31
Questo renderà il tuo codice molto più pulito.
Ottenere informazioni dalla richiesta
Per ottenere informazioni dall'URL richiedente (notare che req è l'oggetto richiesta nella funzione
di gestione dei percorsi). Considera questa definizione di percorso /settings/:user_id e questo
particolare esempio /settings/32135?field=name
// get the full path
req.originalUrl // => /settings/32135?field=name
// get the user_id param
req.params.user_id // => 32135
// get the query value of the field
req.query.field // => 'name'
Puoi anche ottenere intestazioni della richiesta, come questa
req.get('Content-Type')
// "text/plain"
Per semplificare l'acquisizione di altre informazioni puoi usare i middleware. Ad esempio, per
ottenere le informazioni sulla body della richiesta, è possibile utilizzare il middleware body-parser ,
che trasformerà il corpo della richiesta grezza in formato utilizzabile.
var app = require('express')();
var bodyParser = require('body-parser');
app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({ extended: true })); // for parsing application/x-www-form-
urlencoded
Supponiamo ora una richiesta come questa
PUT /settings/32135
{
"name": "Peter"
}
Puoi accedere al nome postato come questo
req.body.name
// "Peter"
In modo simile, puoi accedere ai cookie dalla richiesta, hai anche bisogno di un middleware come
cookie-parser
req.cookies.name
https://riptutorial.com/it/home 32
Applicazione espressa modulare
Per rendere le fabbriche di router di applicazioni modulari per uso express:
Modulo:
// greet.js
const express = require('express');
module.exports = function(options = {}) { // Router factory
const router = express.Router();
router.get('/greet', (req, res, next) => {
res.end(options.greeting);
});
return router;
};
Applicazione:
// app.js
const express = require('express');
const greetMiddleware = require('./greet.js');
express()
.use('/api/v1/', greetMiddleware({ greeting:'Hello world' }))
.listen(8080);
Ciò renderà la tua applicazione modulare, personalizzabile e il tuo codice riutilizzabile.
Quando si accede a http://<hostname>:8080/api/v1/greet l'output sarà Hello world
Esempio più complicato
Esempio con servizi che mostrano vantaggi di fabbrica del middleware.
Modulo:
// greet.js
const express = require('express');
module.exports = function(options = {}) { // Router factory
const router = express.Router();
// Get controller
const {service} = options;
router.get('/greet', (req, res, next) => {
res.end(
service.createGreeting(req.query.name || 'Stranger')
);
});
https://riptutorial.com/it/home 33
return router;
};
Applicazione:
// app.js
const express = require('express');
const greetMiddleware = require('./greet.js');
class GreetingService {
constructor(greeting = 'Hello') {
this.greeting = greeting;
}
createGreeting(name) {
return `${this.greeting}, ${name}!`;
}
}
express()
.use('/api/v1/service1', greetMiddleware({
service: new GreetingService('Hello'),
}))
.use('/api/v1/service2', greetMiddleware({
service: new GreetingService('Hi'),
}))
.listen(8080);
Quando si accede a http://<hostname>:8080/api/v1/service1/greet?name=World l'output sarà Hello,
World e accederà a http://<hostname>:8080/api/v1/service2/greet?name=World l'output sarà Hi, World
.
Utilizzo di un motore di modelli
Utilizzo di un motore di modelli
Il codice seguente configurerà Jade come motore di template. (Nota: Jade è stata ribattezzata
come pug a dicembre 2015.)
const express = require('express'); //Imports the express module
const app = express(); //Creates an instance of the express module
const PORT = 3000; //Randomly chosen port
app.set('view engine','jade'); //Sets jade as the View Engine / Template Engine
app.set('views','src/views'); //Sets the directory where all the views (.jade files) are
stored.
//Creates a Root Route
app.get('/',function(req, res){
res.render('index'); //renders the index.jade file into html and returns as a response.
The render function optionally takes the data to pass to the view.
});
//Starts the Express server with a callback
https://riptutorial.com/it/home 34
app.listen(PORT, function(err) {
if (!err) {
console.log('Server is running at port', PORT);
} else {
console.log(JSON.stringify(err));
}
});
Allo stesso modo, potrebbero essere utilizzati anche altri modelli di template come Handlebars ( hbs
) o ejs . Ricorda di npm install il motore di template. Per Handlebars utilizziamo il pacchetto hbs ,
per Jade abbiamo un pacchetto jade e per EJS abbiamo un pacchetto ejs .
Esempio di modello EJS
Con EJS (come altri modelli express), puoi eseguire il codice del server e accedere alle tue
variabili del server dal tuo HTML.
In EJS è fatto usando " <% " come tag di inizio e " %> " come tag di fine, le variabili passate come
parametri di rendering sono accessibili usando <%=var_name%>
Ad esempio, se si dispone di array di forniture nel codice del server
puoi ricollegarlo usando
<h1><%= title %></h1>
<ul>
<% for(var i=0; i<supplies.length; i++) { %>
<li>
<a href='supplies/<%= supplies[i] %>'>
<%= supplies[i] %>
</a>
</li>
<% } %>
Come puoi vedere nell'esempio ogni volta che cambi codice server e HTML devi chiudere il tag
EJS corrente e aprirne uno successivo, qui abbiamo voluto creare li dentro il comando for quindi
abbiamo dovuto chiudere il nostro tag EJS alla fine del for e crea un nuovo tag solo per le
parentesi graffe
un altro esempio
se vogliamo inserire la versione predefinita di input come variabile dal lato server, usiamo <%=
per esempio:
Message:<br>
<input type="text" value="<%= message %>" name="message" required>
Qui la variabile del messaggio passata dal lato server sarà il valore predefinito del tuo input, tieni
presente che se non hai passato la variabile del messaggio dal lato server, EJS genererà
un'eccezione. Puoi passare i parametri usando res.render('index', {message: message}); (per il file
ejs chiamato index.ejs).
Nei tag EJS puoi anche utilizzare if , while o qualsiasi altro comando javascript che desideri.
https://riptutorial.com/it/home 35
API JSON con ExpressJS
var express = require('express');
var cors = require('cors'); // Use cors module for enable Cross-origin resource sharing
var app = express();
app.use(cors()); // for all routes
var port = process.env.PORT || 8080;
app.get('/', function(req, res) {
var info = {
'string_value': 'StackOverflow',
'number_value': 8476
}
res.json(info);
// or
/* res.send(JSON.stringify({
string_value: 'StackOverflow',
number_value: 8476
})) */
//you can add a status code to the json response
/* res.status(200).json(info) */
})
app.listen(port, function() {
console.log('Node.js listening on port ' + port)
})
Su http://localhost:8080/ oggetto di output
{
string_value: "StackOverflow",
number_value: 8476
}
Servire file statici
Quando si crea un server Web con Express, è spesso richiesto di offrire una combinazione di
contenuti dinamici e file statici.
Ad esempio, potresti avere index.html e script.js che sono file statici mantenuti nel file system.
È comune utilizzare la cartella denominata "public" per avere file statici. In questo caso la struttura
della cartella potrebbe essere simile a:
project root
├── server.js
├── package.json
└── public
├── index.html
└── script.js
https://riptutorial.com/it/home 36
Ecco come configurare Express per servire file statici:
const express = require('express');
const app = express();
app.use(express.static('public'));
Nota: una volta configurata la cartella, index.html, script.js e tutti i file nella cartella "pubblica"
saranno disponibili nel percorso principale (non è necessario specificare /public/ nell'URL).
Questo perché, express cerca i file relativi alla cartella statica configurata. È possibile specificare il
prefisso del percorso virtuale come mostrato di seguito:
app.use('/static', express.static('public'));
renderà le risorse disponibili sotto /static/ prefisso.
Più cartelle
È possibile definire più cartelle contemporaneamente:
app.use(express.static('public'));
app.use(express.static('images'));
app.use(express.static('files'));
Quando serve le risorse Express esaminerà la cartella nell'ordine di definizione. In caso di file con
lo stesso nome, verrà pubblicato quello nella prima cartella di corrispondenza.
Percorsi con nomi in stile Django
Un grosso problema è che le rotte con nome prezioso non sono supportate da Express out of the
box. La soluzione è installare il pacchetto di terze parti supportato, ad esempio express-reverse :
npm install express-reverse
Collegalo al tuo progetto:
var app = require('express')();
require('express-reverse')(app);
Quindi usarlo come:
app.get('test', '/hello', function(req, res) {
res.end('hello');
});
Lo svantaggio di questo approccio è che non è possibile utilizzare il modulo Express route come
mostrato nell'utilizzo avanzato del router . La soluzione alternativa è passare la tua app come
parametro alla tua fabbrica di router:
https://riptutorial.com/it/home 37
require('./middlewares/routing')(app);
E usalo come:
module.exports = (app) => {
app.get('test', '/hello', function(req, res) {
res.end('hello');
});
};
Da ora in poi puoi capire come definire le funzioni per unirle con spazi dei nomi personalizzati
specificati e puntare ai controller appropriati.
Gestione degli errori
Gestione degli errori di base
Per impostazione predefinita, Express cercherà una vista "errore" nella directory /views per il
rendering. Basta creare la vista 'errore' e posizionarla nella directory views per gestire gli errori. Gli
errori vengono scritti con il messaggio di errore, lo stato e la traccia dello stack, ad esempio:
views / error.pug
html
body
h1= message
h2= error.status
p= error.stack
Gestione avanzata degli errori
Definisci le tue funzioni middleware di gestione degli errori alla fine dello stack di funzioni
middleware. Questi hanno quattro argomenti invece di tre (err, req, res, next) per esempio:
app.js
// catch 404 and forward to error handler
app.use(function(req, res, next) {
var err = new Error('Not Found');
err.status = 404;
//pass error to the next matching route.
next(err);
});
// handle error, print stacktrace
app.use(function(err, req, res, next) {
res.status(err.status || 500);
res.render('error', {
message: err.message,
error: err
});
https://riptutorial.com/it/home 38
});
È possibile definire diverse funzioni middleware di gestione degli errori, proprio come si farebbe
con le normali funzioni middleware.
Utilizzo del middleware e della prossima richiamata
Express passa una next richiamata a tutte le funzioni di gestore di route e middleware che
possono essere utilizzate per interrompere la logica per rotte singole su più gestori. La chiamata a
next() senza argomenti indica a express di continuare con il prossimo middleware o gestore di
route corrispondente. Se si chiama next(err) con un errore, verrà attivato qualsiasi middleware del
gestore degli errori. La chiamata next('route') ignorerà qualsiasi middleware successivo sulla
rotta corrente e passerà alla successiva route corrispondente. Ciò consente di disaccoppiare la
logica del dominio in componenti riutilizzabili che sono autonomi, più semplici da testare e più facili
da mantenere e modificare.
Più percorsi di corrispondenza
Le richieste a /api/foo o a /api/bar eseguiranno il gestore iniziale per cercare il membro e quindi
passare il controllo al gestore effettivo per ogni percorso.
app.get('/api', function(req, res, next) {
// Both /api/foo and /api/bar will run this
lookupMember(function(err, member) {
if (err) return next(err);
req.member = member;
next();
});
});
app.get('/api/foo', function(req, res, next) {
// Only /api/foo will run this
doSomethingWithMember(req.member);
});
app.get('/api/bar', function(req, res, next) {
// Only /api/bar will run this
doSomethingDifferentWithMember(req.member);
});
Gestore degli errori
I gestori degli errori sono middleware con la function(err, req, res, next) firma function(err, req,
res, next) . Possono essere impostati per percorso (ad esempio app.get('/foo', function(err,
req, res, next) ) ma in genere, un singolo gestore di errori che esegue il rendering di una pagina
di errore è sufficiente.
app.get('/foo', function(req, res, next) {
doSomethingAsync(function(err, data) {
if (err) return next(err);
renderPage(data);
});
https://riptutorial.com/it/home 39
});
// In the case that doSomethingAsync return an error, this special
// error handler middleware will be called with the error as the
// first parameter.
app.use(function(err, req, res, next) {
renderErrorPage(err);
});
middleware
Ciascuna delle funzioni di cui sopra è in realtà una funzione middleware che viene eseguita ogni
volta che una richiesta corrisponde alla rotta definita, ma qualsiasi numero di funzioni middleware
può essere definito su una singola rotta. Ciò consente di definire il middleware in file separati e la
logica comune da riutilizzare su più percorsi.
app.get('/bananas', function(req, res, next) {
getMember(function(err, member) {
if (err) return next(err);
// If there's no member, don't try to look
// up data. Just go render the page now.
if (!member) return next('route');
// Otherwise, call the next middleware and fetch
// the member's data.
req.member = member;
next();
});
}, function(req, res, next) {
getMemberData(req.member, function(err, data) {
if (err) return next(err);
// If this member has no data, don't bother
// parsing it. Just go render the page now.
if (!data) return next('route');
// Otherwise, call the next middleware and parse
// the member's data. THEN render the page.
req.member.data = data;
next();
});
}, function(req, res, next) {
req.member.parsedData = parseMemberData(req.member.data);
next();
});
app.get('/bananas', function(req, res, next) {
renderBananas(req.member);
});
In questo esempio, ciascuna funzione middleware potrebbe trovarsi nel proprio file o in una
variabile altrove nel file in modo che possa essere riutilizzata in altre route.
Gestione degli errori
I documenti di base possono essere trovati qui
app.get('/path/:id(\\d+)', function (req, res, next) { // please note: "next" is passed
if (req.params.id == 0) // validate param
https://riptutorial.com/it/home 40
return next(new Error('Id is 0')); // go to first Error handler, see below
// Catch error on sync operation
var data;
try {
data = JSON.parse('/file.json');
} catch (err) {
return next(err);
}
// If some critical error then stop application
if (!data)
throw new Error('Smth wrong');
// If you need send extra info to Error handler
// then send custom error (see Appendix B)
if (smth)
next(new MyError('smth wrong', arg1, arg2))
// Finish request by res.render or res.end
res.status(200).end('OK');
});
// Be sure: order of app.use have matter
// Error handler
app.use(function(err, req, res, next)) {
if (smth-check, e.g. req.url != 'POST')
return next(err); // go-to Error handler 2.
console.log(req.url, err.message);
if (req.xhr) // if req via ajax then send json else render error-page
res.json(err);
else
res.render('error.html', {error: err.message});
});
// Error handler 2
app.use(function(err, req, res, next)) {
// do smth here e.g. check that error is MyError
if (err instanceof MyError) {
console.log(err.message, err.arg1, err.arg2);
}
...
res.end();
});
Appendice A
// "In Express, 404 responses are not the result of an error,
// so the error-handler middleware will not capture them."
// You can change it.
app.use(function(req, res, next) {
next(new Error(404));
});
Appendice B
// How to define custom error
https://riptutorial.com/it/home 41
var util = require('util');
...
function MyError(message, arg1, arg2) {
this.message = message;
this.arg1 = arg1;
this.arg2 = arg2;
Error.captureStackTrace(this, MyError);
}
util.inherits(MyError, Error);
MyError.prototype.name = 'MyError';
Hook: come eseguire il codice prima di qualsiasi req e dopo qualsiasi res
app.use() e middleware possono essere utilizzati per "before" e una combinazione di eventi close
e finish può essere utilizzata per "after".
app.use(function (req, res, next) {
function afterResponse() {
res.removeListener('finish', afterResponse);
res.removeListener('close', afterResponse);
// actions after response
}
res.on('finish', afterResponse);
res.on('close', afterResponse);
// action before request
// eventually calling `next()`
next();
});
...
app.use(app.router);
Un esempio di questo è il middleware del logger , che verrà aggiunto al log dopo la risposta per
impostazione predefinita.
Assicurati che questo "middleware" sia utilizzato prima di app.router quanto l'ordine è importante.
Il post originale è qui
Gestire richieste POST
Proprio come gestisci le richieste get in Express con il metodo app.get, puoi utilizzare il metodo
app.post per gestire le richieste post.
Ma prima di poter gestire le richieste POST, sarà necessario utilizzare il middleware body-parser .
Semplicemente analizza il corpo di POST , PUT , DELETE e altre richieste.
Body-Parser middleware Body-Parser analizza il corpo della richiesta e lo trasforma in un oggetto
disponibile in req.body
var bodyParser = require('body-parser');
https://riptutorial.com/it/home 42
const express = require('express');
const app = express();
// Parses the body for POST, PUT, DELETE, etc.
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));
app.post('/post-data-here', function(req, res, next){
console.log(req.body); // req.body contains the parsed body of the request.
});
app.listen(8080, 'localhost');
Impostazione dei cookie con cookie-parser
Di seguito è riportato un esempio per l'impostazione e la lettura dei cookie utilizzando il modulo
cookie-parser :
var express = require('express');
var cookieParser = require('cookie-parser'); // module for parsing cookies
var app = express();
app.use(cookieParser());
app.get('/setcookie', function(req, res){
// setting cookies
res.cookie('username', 'john doe', { maxAge: 900000, httpOnly: true });
return res.send('Cookie has been set');
});
app.get('/getcookie', function(req, res) {
var username = req.cookies['username'];
if (username) {
return res.send(username);
}
return res.send('No cookie found');
});
app.listen(3000);
Middleware personalizzato in Express
In Express, è possibile definire i middleware che possono essere utilizzati per controllare le
richieste o impostare alcune intestazioni in risposta.
app.use(function(req, res, next){ }); // signature
Esempio
Il codice seguente aggiunge l' user all'oggetto richiesta e passa il controllo alla successiva route
https://riptutorial.com/it/home 43
corrispondente.
var express = require('express');
var app = express();
//each request will pass through it
app.use(function(req, res, next){
req.user = 'testuser';
next(); // it will pass the control to next matching route
});
app.get('/', function(req, res){
var user = req.user;
console.log(user); // testuser
return res.send(user);
});
app.listen(3000);
Gestione degli errori in Express
In Express, è possibile definire un gestore di errori unificato per la gestione degli errori verificatisi
nell'applicazione. Definire quindi il gestore alla fine di tutti i percorsi e il codice logico.
Esempio
var express = require('express');
var app = express();
//GET /names/john
app.get('/names/:name', function(req, res, next){
if (req.params.name == 'john'){
return res.send('Valid Name');
} else{
next(new Error('Not valid name')); //pass to error handler
}
});
//error handler
app.use(function(err, req, res, next){
console.log(err.stack); // e.g., Not valid name
return res.status(500).send('Internal Server Occured');
});
app.listen(3000);
Aggiunta di middleware
Le funzioni middleware sono funzioni che hanno accesso all'oggetto richiesta (req), all'oggetto
risposta (res) e alla funzione middleware successiva nel ciclo richiesta-risposta dell'applicazione.
Le funzioni middleware possono eseguire qualsiasi codice, apportare modifiche agli oggetti res e
req , al ciclo di risposta finale e chiamare il prossimo middleware.
Esempio molto comune di middleware è il modulo cors . Per aggiungere il supporto CORS, è
https://riptutorial.com/it/home 44
sufficiente installarlo, richiederlo e inserire questa riga:
app.use(cors());
prima di qualsiasi router o funzione di routing.
Ciao mondo
Qui creiamo un semplice server mondiale Hello usando Express. Itinerari:
• '/'
• '/ Wiki'
E per il riposo darà "404", cioè la pagina non trovata.
'use strict';
const port = process.env.PORT || 3000;
var app = require('express')();
app.listen(port);
app.get('/',(req,res)=>res.send('HelloWorld!'));
app.get('/wiki',(req,res)=>res.send('This is wiki page.'));
app.use((req,res)=>res.send('404-PageNotFound'));
Nota: abbiamo inserito la rotta 404 come ultima rotta mentre Express impila i percorsi in ordine e li
elabora in sequenza per ogni richiesta.
Leggi App Web con Express online: https://riptutorial.com/it/node-js/topic/483/app-web-con-
express
https://riptutorial.com/it/home 45
Capitolo 6: Arresto grazioso
Examples
Graceful Shutdown - SIGTERM
Usando server.close () e process.exit () , possiamo catturare l'eccezione del server e fare un
arresto regolare.
var http = require('http');
var server = http.createServer(function (req, res) {
setTimeout(function () { //simulate a long request
res.writeHead(200, {'Content-Type': 'text/plain'});
res.end('Hello World\n');
}, 4000);
}).listen(9090, function (err) {
console.log('listening http://localhost:9090/');
console.log('pid is ' + process.pid);
});
process.on('SIGTERM', function () {
server.close(function () {
process.exit(0);
});
});
Leggi Arresto grazioso online: https://riptutorial.com/it/node-js/topic/5996/arresto-grazioso
https://riptutorial.com/it/home 46
Capitolo 7: Async / Await
introduzione
Async / await è un insieme di parole chiave che consente la scrittura di codice asincrono in modo
procedurale senza dover fare affidamento su callback ( callback hell ) o promettere-concatenare (
.then().then().then() ).
Funziona usando la parola chiave await per sospendere lo stato di una funzione asincrona, fino
alla risoluzione di una promessa e usando la parola chiave async per dichiarare tali funzioni
asincrone, che restituiscono una promessa.
Async / await è disponibile da node.js 8 per impostazione predefinita o 7 utilizzando il flag --
harmony-async-await .
Examples
Funzioni asincrone con gestione degli errori Try-Catch
Una delle migliori caratteristiche della sintassi asincrona / attendi è che lo stile di codifica try-catch
standard è possibile, proprio come se si stesse scrivendo il codice sincrono.
const myFunc = async (req, res) => {
try {
const result = await somePromise();
} catch (err) {
// handle errors here
}
});
Ecco un esempio con Express e promise-mysql:
router.get('/flags/:id', async (req, res) => {
try {
const connection = await pool.createConnection();
try {
const sql = `SELECT f.id, f.width, f.height, f.code, f.filename
FROM flags f
WHERE f.id = ?
LIMIT 1`;
const flags = await connection.query(sql, req.params.id);
if (flags.length === 0)
return res.status(404).send({ message: 'flag not found' });
return res.send({ flags[0] });
} finally {
https://riptutorial.com/it/home 47
pool.releaseConnection(connection);
}
} catch (err) {
// handle errors here
}
});
Confronto tra Promises e Async / Await
Funzione che usa le promesse:
function myAsyncFunction() {
return aFunctionThatReturnsAPromise()
// doSomething is a sync function
.then(result => doSomething(result))
.catch(handleError);
}
Quindi ecco quando Async / Await entrano in azione per rendere più pulita la nostra funzione:
async function myAsyncFunction() {
let result;
try {
result = await aFunctionThatReturnsAPromise();
} catch (error) {
handleError(error);
}
// doSomething is a sync function
return doSomething(result);
}
Quindi la parola chiave async sarebbe simile a write return new Promise((resolve, reject) => {...}
.
E await simile a ottenere il tuo risultato in then richiamata.
Qui lascio una breve gif che non lascerà alcun dubbio in mente dopo averla vista:
GIF
Progressione da Callbacks
All'inizio c'erano i callback e le callback erano ok:
const getTemperature = (callback) => {
http.get('www.temperature.com/current', (res) => {
callback(res.data.temperature)
})
}
const getAirPollution = (callback) => {
https://riptutorial.com/it/home 48
http.get('www.pollution.com/current', (res) => {
callback(res.data.pollution)
});
}
getTemperature(function(temp) {
getAirPollution(function(pollution) {
console.log(`the temp is ${temp} and the pollution is ${pollution}.`)
// The temp is 27 and the pollution is 0.5.
})
})
Ma ci sono stati alcuni problemi davvero frustranti con i callback, quindi abbiamo iniziato a
utilizzare le promesse.
const getTemperature = () => {
return new Promise((resolve, reject) => {
http.get('www.temperature.com/current', (res) => {
resolve(res.data.temperature)
})
})
}
const getAirPollution = () => {
return new Promise((resolve, reject) => {
http.get('www.pollution.com/current', (res) => {
resolve(res.data.pollution)
})
})
}
getTemperature()
.then(temp => console.log(`the temp is ${temp}`))
.then(() => getAirPollution())
.then(pollution => console.log(`and the pollution is ${pollution}`))
// the temp is 32
// and the pollution is 0.5
Questo è stato un po 'meglio. Alla fine, abbiamo trovato async / await. Che usa ancora promesse
sotto il cofano.
const temp = await getTemperature()
const pollution = await getAirPollution()
Interrompe l'esecuzione in attesa
Se la promessa non restituisce nulla, l'attività asincrona può essere completata utilizzando await .
try{
await User.findByIdAndUpdate(user._id, {
$push: {
tokens: token
}
}).exec()
}catch(e){
handleError(e)
https://riptutorial.com/it/home 49
}
Leggi Async / Await online: https://riptutorial.com/it/node-js/topic/6729/async---await
https://riptutorial.com/it/home 50
Capitolo 8: async.js
Sintassi
• Ogni callback deve essere scritto con questa sintassi:
• funzione callback (err, risultato [, arg1 [, ...]])
• In questo modo, sei costretto a restituire prima l'errore, e non puoi ignorarne la
gestione in seguito. null è la convenzione in assenza di errori
• callback (null, myResult);
• Le tue callback possono contenere più argomenti di err e result , ma è utile solo per
un set specifico di funzioni (cascata, seq, ...)
• callback (null, myResult, myCustomArgument);
• E, naturalmente, inviare errori. È necessario farlo e gestire gli errori (o almeno
registrarli).
• callback (err);
Examples
Parallelo: multi-tasking
async.parallel (tasks, afterTasksCallback) eseguirà una serie di attività in parallelo e attenderà la
fine di tutte le attività (segnalate dalla chiamata della funzione di callback ).
Al termine delle attività, async chiama il callback principale con tutti gli errori e tutti i risultati delle
attività.
function shortTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfShortTime');
}, 200);
}
function mediumTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfMediumTime');
}, 500);
}
function longTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfLongTime');
}, 1000);
}
https://riptutorial.com/it/home 51
async.parallel([
shortTimeFunction,
mediumTimeFunction,
longTimeFunction
],
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Risultato: ["resultOfShortTime", "resultOfMediumTime", "resultOfLongTime"] .
Chiama async.parallel() con un oggetto
È possibile sostituire il parametro dell'array tasks con un oggetto. In questo caso, i risultati
saranno anche un oggetto con le stesse chiavi delle attività .
È molto utile calcolare alcune attività e trovare facilmente ogni risultato.
async.parallel({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Risultato: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Risoluzione di più valori
Ogni funzione parallela è passata a un callback. Questo callback può restituire un errore come
primo argomento o valore successivo. Se un callback viene passato a diversi valori di successo,
questi risultati vengono restituiti come array.
async.parallel({
short: function shortTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfShortTime1', 'resultOfShortTime2');
}, 200);
},
medium: function mediumTimeFunction(callback) {
setTimeout(function() {
https://riptutorial.com/it/home 52
callback(null, 'resultOfMediumTime1', 'resultOfMeiumTime2');
}, 500);
}
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Risultato:
{
short: ["resultOfShortTime1", "resultOfShortTime2"],
medium: ["resultOfMediumTime1", "resultOfMediumTime2"]
}
Serie: mono-tasking indipendente
async.series (tasks, afterTasksCallback) eseguirà una serie di attività. Ogni attività viene eseguita
dopo l'altra . Se un'attività non riesce, async interrompe immediatamente l'esecuzione e
passa al callback principale .
Quando le attività sono terminate con successo, async chiama il callback "master" con tutti gli
errori e tutti i risultati delle attività.
function shortTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfShortTime');
}, 200);
}
function mediumTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfMediumTime');
}, 500);
}
function longTimeFunction(callback) {
setTimeout(function() {
callback(null, 'resultOfLongTime');
}, 1000);
}
async.series([
mediumTimeFunction,
shortTimeFunction,
longTimeFunction
],
function(err, results) {
if (err) {
return console.error(err);
https://riptutorial.com/it/home 53
}
console.log(results);
});
Risultato: ["resultOfMediumTime", "resultOfShortTime", "resultOfLongTime"] .
Chiama async.series() con un oggetto
È possibile sostituire il parametro dell'array tasks con un oggetto. In questo caso, i risultati
saranno anche un oggetto con le stesse chiavi delle attività .
È molto utile calcolare alcune attività e trovare facilmente ogni risultato.
async.series({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
Risultato: {short: "resultOfShortTime", medium: "resultOfMediumTime", long: "resultOfLongTime"} .
Cascata: mono-tasking dipendente
async.waterfall (tasks, afterTasksCallback) eseguirà una serie di attività. Ogni attività viene
eseguita dopo l'altra e il risultato di un'attività viene passato all'attività successiva . As
async.series () , se un'attività non riesce, async interrompe l'esecuzione e chiama
immediatamente il callback principale.
Quando le attività sono terminate con successo, async chiama il callback "master" con tutti gli
errori e tutti i risultati delle attività.
function getUserRequest(callback) {
// We simulate the request with a timeout
setTimeout(function() {
var userResult = {
name : 'Aamu'
};
callback(null, userResult);
}, 500);
}
function getUserFriendsRequest(user, callback) {
// Another request simulate with a timeout
https://riptutorial.com/it/home 54
setTimeout(function() {
var friendsResult = [];
if (user.name === "Aamu"){
friendsResult = [{
name : 'Alice'
}, {
name: 'Bob'
}];
}
callback(null, friendsResult);
}, 500);
}
async.waterfall([
getUserRequest,
getUserFriendsRequest
],
function(err, results) {
if (err) {
return console.error(err);
}
console.log(JSON.stringify(results));
});
Risultato: i results contengono il secondo parametro di callback dell'ultima funzione della
cascata, che in questo caso è friendsResult .
async.times (Per gestire il ciclo in modo migliore)
Per eseguire una funzione all'interno di un ciclo di node.js, è bene utilizzare una for ciclo per brevi
cicli. Ma il ciclo è lungo, l'uso for ciclo for aumenta il tempo di elaborazione che potrebbe causare
il blocco del processo del nodo. In tali scenari, è possibile utilizzare: asycn.times
function recursiveAction(n, callback)
{
//do whatever want to do repeatedly
callback(err, result);
}
async.times(5, function(n, next) {
recursiveAction(n, function(err, result) {
next(err, result);
});
}, function(err, results) {
// we should now have 5 result
});
Questo è chiamato in parallelo. Quando vogliamo chiamarlo uno alla volta, utilizzare:
async.timesSeries
async.each (Per gestire in modo efficiente l'array di dati)
Quando vogliamo gestire una matrice di dati, è meglio usare async.each . Quando vogliamo
https://riptutorial.com/it/home 55
eseguire qualcosa con tutti i dati e vogliamo ottenere il callback finale una volta che tutto è stato
fatto, allora questo metodo sarà utile. Questo è gestito in modo parallelo.
function createUser(userName, callback)
{
//create user in db
callback(null)//or error based on creation
}
var arrayOfData = ['Ritu', 'Sid', 'Tom'];
async.each(arrayOfData, function(eachUserName, callback) {
// Perform operation on each user.
console.log('Creating user '+eachUserName);
//Returning callback is must. Else it wont get the final callback, even if we miss to
return one callback
createUser(eachUserName, callback);
}, function(err) {
//If any of the user creation failed may throw error.
if( err ) {
// One of the iterations produced an error.
// All processing will now stop.
console.log('unable to create user');
} else {
console.log('All user created successfully');
}
});
Per eseguire uno alla volta è possibile utilizzare async.eachSeries
async.series (per gestire gli eventi uno per uno)
/ In async.series, tutte le funzioni vengono eseguite in serie e gli output consolidati di ciascuna
funzione vengono passati al callback finale. ad esempio /
var async = require ('async'); async.series ([function (callback) {console.log ('First Execute ..');
callback (null, 'userPersonalData');}, function (callback) {console.log ('Second Execute ..'); callback
(null, 'userDependentData');}], function (err, result) {console.log (risultato);});
//Produzione:
First Execute .. Second Execute .. ['userPersonalData', 'userDependentData'] // result
Leggi async.js online: https://riptutorial.com/it/node-js/topic/3972/async-js
https://riptutorial.com/it/home 56
Capitolo 9: Autenticazione di Windows sotto
node.js
Osservazioni
Esistono diversi altri APIS di Active Directory, ad esempio activedirectory2 e adldap .
Examples
Utilizzando activedirectory
L'esempio qui sotto è tratto dai documenti completi, disponibili qui (GitHub) o qui (NPM) .
Installazione
npm install --save activedirectory
uso
// Initialize
var ActiveDirectory = require('activedirectory');
var config = {
url: 'ldap://dc.domain.com',
baseDN: 'dc=domain,dc=com'
};
var ad = new ActiveDirectory(config);
var username = '[email protected]';
var password = 'password';
// Authenticate
ad.authenticate(username, password, function(err, auth) {
if (err) {
console.log('ERROR: '+JSON.stringify(err));
return;
}
if (auth) {
console.log('Authenticated!');
}
else {
console.log('Authentication failed!');
}
});
Leggi Autenticazione di Windows sotto node.js online: https://riptutorial.com/it/node-
js/topic/10612/autenticazione-di-windows-sotto-node-js
https://riptutorial.com/it/home 57
Capitolo 10: Autoreload su modifiche
Examples
Il caricamento automatico sul codice sorgente cambia usando nodemon
Il pacchetto nodemon consente di ricaricare automaticamente il programma quando si modifica
qualsiasi file nel codice sorgente.
Installazione di nodemon a livello globale
npm install -g nodemon (o npm i -g nodemon )
Installare nodemon localmente
Nel caso in cui non si desideri installarlo a livello globale
npm install --save-dev nodemon (o npm i -D nodemon )
Utilizzando nodemon
Esegui il tuo programma con nodemon entry.js (o nodemon entry )
Questo sostituisce il solito uso del node entry.js (o node entry ).
È anche possibile aggiungere l'avvio del nodemon come uno script npm, che potrebbe essere utile
se si desidera fornire i parametri e non digitarli ogni volta.
Aggiungi package.json:
"scripts": {
"start": "nodemon entry.js -devmode -something 1"
}
In questo modo puoi semplicemente utilizzare npm start dalla tua console.
Browsersync
Panoramica
Browsersync è uno strumento che consente la visualizzazione di file live e il ricaricamento del
browser. È disponibile come pacchetto NPM .
https://riptutorial.com/it/home 58
Installazione
Per installare Browsersync devi prima installare Node.js e NPM. Per ulteriori informazioni,
consultare la documentazione SO su Installazione ed esecuzione di Node.js.
Una volta impostato il tuo progetto, puoi installare Browsersync con il seguente comando:
$ npm install browser-sync -D
Questo installerà Browsersync nella directory node_modules locale e lo salverà nelle dipendenze
dello sviluppatore.
Se preferisci installarlo globalmente usa il flag -g al posto del flag -D .
Utenti Windows
In caso di problemi nell'installazione di Browsersync su Windows, potrebbe essere necessario
installare Visual Studio in modo da poter accedere agli strumenti di compilazione per installare
Browsersync. Dovrai quindi specificare la versione di Visual Studio che stai utilizzando in questo
modo:
$ npm install browser-sync --msvs_version=2013 -D
Questo comando specifica la versione 2013 di Visual Studio.
Uso di base
Per ricaricare automaticamente il tuo sito ogni volta che cambi un file JavaScript nel tuo progetto
usa il seguente comando:
$ browser-sync start --proxy "myproject.dev" --files "**/*.js"
Sostituisci myproject.dev con l'indirizzo web che stai utilizzando per accedere al tuo progetto.
Browsersync emetterà un indirizzo alternativo che può essere utilizzato per accedere al tuo sito
tramite il proxy.
Uso avanzato
Oltre all'interfaccia della riga di comando descritta sopra, Browsersync può essere utilizzato anche
con Grunt.js e Gulp.js.
Grunt.js
https://riptutorial.com/it/home 59
L'utilizzo con Grunt.js richiede un plug-in che può essere installato in questo modo:
$ npm install grunt-browser-sync -D
Quindi aggiungerai questa linea al tuo gruntfile.js :
grunt.loadNpmTasks('grunt-browser-sync');
Gulp.js
Browsersync funziona come un modulo CommonJS , quindi non c'è bisogno di un plugin Gulp.js.
Basta richiedere il modulo in questo modo:
var browserSync = require('browser-sync').create();
Ora puoi utilizzare l' API Browsersync per configurarlo in base alle tue esigenze.
API
L'API Browsersync può essere trovata qui: https://browsersync.io/docs/api
Leggi Autoreload su modifiche online: https://riptutorial.com/it/node-js/topic/1743/autoreload-su-
modifiche
https://riptutorial.com/it/home 60
Capitolo 11: Biblioteca Mongoose
Examples
Connetti a MongoDB usando Mongoose
Innanzitutto, installa Mongoose con:
npm install mongoose
Quindi, aggiungilo a server.js come dipendenze:
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
Successivamente, crea lo schema del database e il nome della raccolta:
var schemaName = new Schema({
request: String,
time: Number
}, {
collection: 'collectionName'
});
Crea un modello e connettiti al database:
var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');
Quindi, avviare MongoDB ed eseguire server.js utilizzando node server.js
Per verificare se ci siamo connessi con successo al database, possiamo usare gli eventi open ,
error dall'oggetto mongoose.connection .
var db = mongoose.connection;
db.on('error', console.error.bind(console, 'connection error:'));
db.once('open', function() {
// we're connected!
});
Salva i dati su MongoDB usando Mongoose e Express.js Routes
Impostare
Innanzitutto, installa i pacchetti necessari con:
https://riptutorial.com/it/home 61
npm install express cors mongoose
Codice
Quindi, aggiungi dipendenze al file server.js , crea lo schema del database e il nome della
raccolta, crea un server Express.js e connettiti a MongoDB:
var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var app = express();
var schemaName = new Schema({
request: String,
time: Number
}, {
collection: 'collectionName'
});
var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');
var port = process.env.PORT || 8080;
app.listen(port, function() {
console.log('Node.js listening on port ' + port);
});
Ora aggiungi i percorsi Express.js che useremo per scrivere i dati:
app.get('/save/:query', cors(), function(req, res) {
var query = req.params.query;
var savedata = new Model({
'request': query,
'time': Math.floor(Date.now() / 1000) // Time of save the data in unix timestamp
format
}).save(function(err, result) {
if (err) throw err;
if(result) {
res.json(result)
}
})
})
Qui la variabile di query sarà il parametro <query> della richiesta HTTP in entrata, che verrà salvata
in MongoDB:
var savedata = new Model({
'request': query,
//...
https://riptutorial.com/it/home 62
Se si verifica un errore durante il tentativo di scrittura su MongoDB, riceverai un messaggio di
errore sulla console. Se tutto è andato a buon fine, vedrai i dati salvati in formato JSON sulla
pagina.
//...
}).save(function(err, result) {
if (err) throw err;
if(result) {
res.json(result)
}
})
//...
Ora, è necessario avviare MongoDB ed eseguire il file server.js utilizzando node server.js .
uso
Per utilizzare questo per salvare i dati, vai al seguente URL nel browser:
http://localhost:8080/save/<query>
Dove <query> è la nuova richiesta che desideri salvare.
Esempio:
http://localhost:8080/save/JavaScript%20is%20Awesome
Uscita in formato JSON:
{
__v: 0,
request: "JavaScript is Awesome",
time: 1469411348,
_id: "57957014b93bc8640f2c78c4"
}
Trova i dati in MongoDB usando i percorsi Mongoose e Express.js
Impostare
Innanzitutto, installa i pacchetti necessari con:
npm install express cors mongoose
Codice
https://riptutorial.com/it/home 63
Quindi, aggiungi dipendenze a server.js , crea lo schema del database e il nome della raccolta,
crea un server Express.js e connettiti a MongoDB:
var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var app = express();
var schemaName = new Schema({
request: String,
time: Number
}, {
collection: 'collectionName'
});
var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');
var port = process.env.PORT || 8080;
app.listen(port, function() {
console.log('Node.js listening on port ' + port);
});
Ora aggiungi le rotte Express.js che useremo per interrogare i dati:
app.get('/find/:query', cors(), function(req, res) {
var query = req.params.query;
Model.find({
'request': query
}, function(err, result) {
if (err) throw err;
if (result) {
res.json(result)
} else {
res.send(JSON.stringify({
error : 'Error'
}))
}
})
})
Supponiamo che i seguenti documenti siano presenti nella collezione nel modello:
{
"_id" : ObjectId("578abe97522ad414b8eeb55a"),
"request" : "JavaScript is Awesome",
"time" : 1468710551
}
{
"_id" : ObjectId("578abe9b522ad414b8eeb55b"),
"request" : "JavaScript is Awesome",
"time" : 1468710555
}
{
"_id" : ObjectId("578abea0522ad414b8eeb55c"),
https://riptutorial.com/it/home 64
"request" : "JavaScript is Awesome",
"time" : 1468710560
}
E l'obiettivo è trovare e visualizzare tutti i documenti contenenti "JavaScript is Awesome" sotto la
chiave "request" .
Per fare ciò, avviare MongoDB ed eseguire server.js con node server.js :
uso
Per utilizzare questo per trovare i dati, vai al seguente URL in un browser:
http://localhost:8080/find/<query>
Dove <query> è la query di ricerca.
Esempio:
http://localhost:8080/find/JavaScript%20is%20Awesome
Produzione:
[{
_id: "578abe97522ad414b8eeb55a",
request: "JavaScript is Awesome",
time: 1468710551,
__v: 0
},
{
_id: "578abe9b522ad414b8eeb55b",
request: "JavaScript is Awesome",
time: 1468710555,
__v: 0
},
{
_id: "578abea0522ad414b8eeb55c",
request: "JavaScript is Awesome",
time: 1468710560,
__v: 0
}]
Trova i dati in MongoDB usando Mongoose, Express.js Routes e $ text
Operator
Impostare
Innanzitutto, installa i pacchetti necessari con:
https://riptutorial.com/it/home 65
npm install express cors mongoose
Codice
Quindi, aggiungi dipendenze a server.js , crea lo schema del database e il nome della raccolta,
crea un server Express.js e connettiti a MongoDB:
var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var app = express();
var schemaName = new Schema({
request: String,
time: Number
}, {
collection: 'collectionName'
});
var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');
var port = process.env.PORT || 8080;
app.listen(port, function() {
console.log('Node.js listening on port ' + port);
});
Ora aggiungi le rotte Express.js che useremo per interrogare i dati:
app.get('/find/:query', cors(), function(req, res) {
var query = req.params.query;
Model.find({
'request': query
}, function(err, result) {
if (err) throw err;
if (result) {
res.json(result)
} else {
res.send(JSON.stringify({
error : 'Error'
}))
}
})
})
Supponiamo che i seguenti documenti siano presenti nella collezione nel modello:
{
"_id" : ObjectId("578abe97522ad414b8eeb55a"),
"request" : "JavaScript is Awesome",
"time" : 1468710551
}
https://riptutorial.com/it/home 66
{
"_id" : ObjectId("578abe9b522ad414b8eeb55b"),
"request" : "JavaScript is Awesome",
"time" : 1468710555
}
{
"_id" : ObjectId("578abea0522ad414b8eeb55c"),
"request" : "JavaScript is Awesome",
"time" : 1468710560
}
E che l'obiettivo è trovare e visualizzare tutti i documenti contenenti solo la parola "JavaScript"
sotto la chiave "request" .
Per fare ciò, prima crea un indice di testo per "request" nella raccolta. Per questo, aggiungi il
seguente codice a server.js :
schemaName.index({ request: 'text' });
E sostituire:
Model.find({
'request': query
}, function(err, result) {
Con:
Model.find({
$text: {
$search: query
}
}, function(err, result) {
Qui, stiamo usando $text e $search operatori MongoDB per trovare tutti i documenti nella collection
collectionName che contiene almeno una parola dalla query di ricerca specificata.
uso
Per utilizzare questo per trovare i dati, vai al seguente URL in un browser:
http://localhost:8080/find/<query>
Dove <query> è la query di ricerca.
Esempio:
http://localhost:8080/find/JavaScript
Produzione:
https://riptutorial.com/it/home 67
[{
_id: "578abe97522ad414b8eeb55a",
request: "JavaScript is Awesome",
time: 1468710551,
__v: 0
},
{
_id: "578abe9b522ad414b8eeb55b",
request: "JavaScript is Awesome",
time: 1468710555,
__v: 0
},
{
_id: "578abea0522ad414b8eeb55c",
request: "JavaScript is Awesome",
time: 1468710560,
__v: 0
}]
Indici nei modelli.
MongoDB supporta indici secondari. In Mongoose, definiamo questi indici all'interno del nostro
schema. La definizione di indici a livello di schema è necessaria quando è necessario creare indici
composti.
Connessione Mongoose
var strConnection = 'mongodb://localhost:27017/dbName';
var db = mongoose.createConnection(strConnection)
Creazione di uno schema di base
var Schema = require('mongoose').Schema;
var usersSchema = new Schema({
username: {
type: String,
required: true,
unique: true
},
email: {
type: String,
required: true
},
password: {
type: String,
required: true
},
created: {
type: Date,
default: Date.now
}
});
var usersModel = db.model('users', usersSchema);
module.exports = usersModel;
https://riptutorial.com/it/home 68
Per impostazione predefinita, mangusta aggiunge due nuovi campi nel nostro modello, anche
quando quelli non sono definiti nel modello. Questi campi sono:
_ID
Mongoose assegna a ciascuno degli schemi un campo _id per impostazione predefinita se uno
non viene passato al costruttore Schema. Il tipo assegnato è un ObjectId che coincide con il
comportamento predefinito di MongoDB. Se non vuoi che un _id venga aggiunto al tuo schema,
puoi disabilitarlo usando questa opzione.
var usersSchema = new Schema({
username: {
type: String,
required: true,
unique: true
}, {
_id: false
});
__v o versionKey
VersionKey è una proprietà impostata su ciascun documento quando viene creata da Mongoose.
Questo valore di chiavi contiene la revisione interna del documento. Il nome di questa proprietà
del documento è configurabile.
Puoi disabilitare facilmente questo campo nella configurazione del modello:
var usersSchema = new Schema({
username: {
type: String,
required: true,
unique: true
}, {
versionKey: false
});
Indici composti
Possiamo creare altri indici oltre a quelli creati da Mangusta.
usersSchema.index({username: 1 });
usersSchema.index({email: 1 });
In questo caso il nostro modello ha altri due indici, uno per il campo username e l'altro per il
campo email. Ma possiamo creare indici composti.
usersSchema.index({username: 1, email: 1 });
Impatto sulle prestazioni dell'indice
Per impostazione predefinita, la mangusta chiama sempre il parametro sureIndex per ciascun
https://riptutorial.com/it/home 69
indice in sequenza ed emette un evento 'index' sul modello quando tutte le chiamate sureIndex
hanno avuto esito positivo o quando si è verificato un errore.
In MongoDB, sureIndex è deprecato dalla versione 3.0.0, ora è un alias per createIndex.
Si consiglia di disabilitare il comportamento impostando l'opzione autoIndex dello schema su false
o globalmente sulla connessione impostando l'opzione config.autoIndex su false.
usersSchema.set('autoIndex', false);
Funzioni utili di Mongoose
Mongoose contiene alcune funzioni incorporate che si basano sul find() standard find() .
doc.find({'some.value':5},function(err,docs){
//returns array docs
});
doc.findOne({'some.value':5},function(err,doc){
//returns document doc
});
doc.findById(obj._id,function(err,doc){
//returns document doc
});
trova i dati in mongodb usando le promesse
Impostare
Innanzitutto, installa i pacchetti necessari con:
npm install express cors mongoose
Codice
Quindi, aggiungi dipendenze a server.js , crea lo schema del database e il nome della raccolta,
crea un server Express.js e connettiti a MongoDB:
var express = require('express');
var cors = require('cors'); // We will use CORS to enable cross origin domain requests.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var app = express();
var schemaName = new Schema({
request: String,
time: Number
https://riptutorial.com/it/home 70
}, {
collection: 'collectionName'
});
var Model = mongoose.model('Model', schemaName);
mongoose.connect('mongodb://localhost:27017/dbName');
var port = process.env.PORT || 8080;
app.listen(port, function() {
console.log('Node.js listening on port ' + port);
});
app.use(function(err, req, res, next) {
console.error(err.stack);
res.status(500).send('Something broke!');
});
app.use(function(req, res, next) {
res.status(404).send('Sorry cant find that!');
});
Ora aggiungi le rotte Express.js che useremo per interrogare i dati:
app.get('/find/:query', cors(), function(req, res, next) {
var query = req.params.query;
Model.find({
'request': query
})
.exec() //remember to add exec, queries have a .then attribute but aren't promises
.then(function(result) {
if (result) {
res.json(result)
} else {
next() //pass to 404 handler
}
})
.catch(next) //pass to error handler
})
Supponiamo che i seguenti documenti siano presenti nella collezione nel modello:
{
"_id" : ObjectId("578abe97522ad414b8eeb55a"),
"request" : "JavaScript is Awesome",
"time" : 1468710551
}
{
"_id" : ObjectId("578abe9b522ad414b8eeb55b"),
"request" : "JavaScript is Awesome",
"time" : 1468710555
}
{
"_id" : ObjectId("578abea0522ad414b8eeb55c"),
"request" : "JavaScript is Awesome",
"time" : 1468710560
}
https://riptutorial.com/it/home 71
E l'obiettivo è trovare e visualizzare tutti i documenti contenenti "JavaScript is Awesome" sotto la
chiave "request" .
Per fare ciò, avviare MongoDB ed eseguire server.js con node server.js :
uso
Per utilizzare questo per trovare i dati, vai al seguente URL in un browser:
http://localhost:8080/find/<query>
Dove <query> è la query di ricerca.
Esempio:
http://localhost:8080/find/JavaScript%20is%20Awesome
Produzione:
[{
_id: "578abe97522ad414b8eeb55a",
request: "JavaScript is Awesome",
time: 1468710551,
__v: 0
},
{
_id: "578abe9b522ad414b8eeb55b",
request: "JavaScript is Awesome",
time: 1468710555,
__v: 0
},
{
_id: "578abea0522ad414b8eeb55c",
request: "JavaScript is Awesome",
time: 1468710560,
__v: 0
}]
Leggi Biblioteca Mongoose online: https://riptutorial.com/it/node-js/topic/3486/biblioteca-mongoose
https://riptutorial.com/it/home 72
Capitolo 12: Buon stile di codifica
Osservazioni
Consiglierei ad un principiante di iniziare con questo stile di codifica. E se qualcuno può suggerire
un modo migliore (ps ho optato per questa tecnica e sta funzionando in modo efficiente per me in
un'app utilizzata da più di 100k utenti), sentitevi liberi per qualsiasi suggerimento. TIA.
Examples
Programma base per la registrazione
Attraverso questo esempio, verrà spiegato di dividere il codice node.js in diversi moduli / cartelle
per una migliore sottotollerabilità. Seguendo questa tecnica è più facile per gli altri sviluppatori
capire il codice dato che può riferirsi direttamente al file interessato invece di passare attraverso
l'intero codice. L'uso principale è quando si lavora in una squadra e un nuovo sviluppatore si
unisce in una fase successiva, per lui sarà più facile assimilare il codice stesso.
index.js : - Questo file gestirà la connessione al server.
//Import Libraries
var express = require('express'),
session = require('express-session'),
mongoose = require('mongoose'),
request = require('request');
//Import custom modules
var userRoutes = require('./app/routes/userRoutes');
var config = require('./app/config/config');
//Connect to Mongo DB
mongoose.connect(config.getDBString());
//Create a new Express application and Configure it
var app = express();
//Configure Routes
app.use(config.API_PATH, userRoutes());
//Start the server
app.listen(config.PORT);
console.log('Server started at - '+ config.URL+ ":" +config.PORT);
config.js : -Questo file gestirà tutti i param relativi alla configurazione che rimarranno gli stessi in
tutto.
var config = {
VERSION: 1,
BUILD: 1,
URL: 'http://127.0.0.1',
https://riptutorial.com/it/home 73
API_PATH : '/api',
PORT : process.env.PORT || 8080,
DB : {
//MongoDB configuration
HOST : 'localhost',
PORT : '27017',
DATABASE : 'db'
},
/*
* Get DB Connection String for connecting to MongoDB database
*/
getDBString : function(){
return 'mongodb://'+ this.DB.HOST +':'+ this.DB.PORT +'/'+ this.DB.DATABASE;
},
/*
* Get the http URL
*/
getHTTPUrl : function(){
return 'http://' + this.URL + ":" + this.PORT;
}
module.exports = config;
user.js : - File di modello in cui è definito lo schema
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
//Schema for User
var UserSchema = new Schema({
name: {
type: String,
// required: true
},
email: {
type: String
},
password: {
type: String,
//required: true
},
dob: {
type: Date,
//required: true
},
gender: {
type: String, // Male/Female
// required: true
}
});
//Define the model for User
var User;
if(mongoose.models.User)
User = mongoose.model('User');
else
User = mongoose.model('User', UserSchema);
https://riptutorial.com/it/home 74
//Export the User Model
module.exports = User;
userController : - Questo file contiene la funzione per l'utente registrati
var User = require('../models/user');
var crypto = require('crypto');
//Controller for User
var UserController = {
//Create a User
create: function(req, res){
var repassword = req.body.repassword;
var password = req.body.password;
var userEmail = req.body.email;
//Check if the email address already exists
User.find({"email": userEmail}, function(err, usr){
if(usr.length > 0){
//Email Exists
res.json('Email already exists');
return;
}
else
{
//New Email
//Check for same passwords
if(password != repassword){
res.json('Passwords does not match');
return;
}
//Generate Password hash based on sha1
var shasum = crypto.createHash('sha1');
shasum.update(req.body.password);
var passwordHash = shasum.digest('hex');
//Create User
var user = new User();
user.name = req.body.name;
user.email = req.body.email;
user.password = passwordHash;
user.dob = Date.parse(req.body.dob) || "";
user.gender = req.body.gender;
//Validate the User
user.validate(function(err){
if(err){
res.json(err);
return;
}else{
//Finally save the User
user.save(function(err){
if(err)
{
res.json(err);
return;
https://riptutorial.com/it/home 75
}
//Remove Password before sending User details
user.password = undefined;
res.json(user);
return;
});
}
});
}
});
}
module.exports = UserController;
userRoutes.js : - Questo è il percorso per userController
var express = require('express');
var UserController = require('../controllers/userController');
//Routes for User
var UserRoutes = function(app)
{
var router = express.Router();
router.route('/users')
.post(UserController.create);
return router;
module.exports = UserRoutes;
L'esempio sopra può sembrare troppo grande ma se un principiante su node.js con una piccola
miscela di conoscenza espressa cerca di farlo, troverà la cosa facile e veramente utile.
Leggi Buon stile di codifica online: https://riptutorial.com/it/node-js/topic/6489/buon-stile-di-codifica
https://riptutorial.com/it/home 76
Capitolo 13: CLI
Sintassi
• nodo [opzioni] [opzioni v8] [script.js | -e "script"] [argomenti]
Examples
Opzioni della riga di comando
-v, --version
Aggiunto in: v0.1.3 Stampa della versione del nodo.
-h, --help
Aggiunto in: v0.1.3 Opzioni della riga di comando del nodo di stampa. L'output di questa opzione è
meno dettagliato di questo documento.
-e, --eval "script"
Aggiunto in: v0.5.2 Valuta il seguente argomento come JavaScript. I moduli che sono predefiniti in
REPL possono essere utilizzati anche in script.
-p, --print "script"
Aggiunto in: v0.6.4 Identico a -e ma stampa il risultato.
-c, --check
Aggiunto in: v5.0.0 Sintassi controlla lo script senza eseguire.
-i, --interactive
Aggiunto in: v0.7.7 Apre REPL anche se stdin non sembra essere un terminale.
-r, --require module
Aggiunto in: v1.6.0 Precarica il modulo specificato all'avvio.
Segue le regole di risoluzione dei moduli di require (). il modulo può essere un percorso per un file
o un nome di modulo nodo.
--no-deprecation
https://riptutorial.com/it/home 77
Aggiunto in: v0.8.0 avvisi di deprecazione del silenzio.
--trace-deprecation
Aggiunto in: v0.8.0 Stampa tracce di stack per le deprecazioni.
--throw-deprecation
Aggiunto in: v0.11.14 Lancia gli errori per le deprecazioni.
--no-warnings
Aggiunto in: v6.0.0 Silenzia tutti gli avvisi di processo (incluse le deprecazioni).
--trace-warnings
Aggiunto in: v6.0.0 Stampa tracce di stack per gli avvisi di processo (incluse le deprecazioni).
--trace-sync-io
Aggiunto in: v2.1.0 Stampa una traccia di stack ogni volta che viene rilevato I / O sincrono dopo il
primo turno del ciclo degli eventi.
--zero-fill-buffers
Aggiunto in: v6.0.0 Automaticamente zero riempie tutte le istanze di Buffer e SlowBuffer appena
allocate.
--preserve-symlinks
Aggiunto in: v6.3.0 Indica al modulo loader di conservare i collegamenti simbolici durante la
risoluzione e la memorizzazione nella cache dei moduli.
Per impostazione predefinita, quando Node.js carica un modulo da un percorso che è collegato
simbolicamente a una diversa posizione su disco, Node.js cancellerà il collegamento e utilizzerà
l'effettivo "percorso reale" su disco del modulo come identificativo e come percorso root per
individuare altri moduli di dipendenza. Nella maggior parte dei casi, questo comportamento
predefinito è accettabile. Tuttavia, quando si utilizzano dipendenze peer collegate simbolicamente,
come illustrato nell'esempio seguente, il comportamento predefinito causa l'emissione di
un'eccezione se il moduloA tenta di richiedere moduleB come dipendenza peer:
{appDir}
├── app
│ ├── index.js
│ └── node_modules
│ ├── moduleA -> {appDir}/moduleA
│ └── moduleB
│ ├── index.js
https://riptutorial.com/it/home 78
│ └── package.json
└── moduleA
├── index.js
└── package.json
L'indicatore della riga di comando --preserve-symlinks ordina a Node.js di utilizzare il percorso del
collegamento simbolico per i moduli anziché il percorso reale, consentendo di trovare le
dipendenze peer collegate simbolicamente.
Si noti, tuttavia, che l'utilizzo di --preserve-symlinks può avere altri effetti collaterali. In particolare, i
moduli nativi collegati simbolicamente non riescono a caricare se sono collegati da più di una
posizione nell'albero delle dipendenze (Node.js li vedrebbe come due moduli separati e
tenterebbe di caricare il modulo più volte, causando un'eccezione ).
--track-heap-objects
Aggiunto in: v2.4.0 Traccia le allocazioni degli oggetti heap per le istantanee heap.
--prof-process
Aggiunto in: v6.0.0 Output del processo v8 del processo generato utilizzando l'opzione v8 --prof.
--v8-options
Aggiunto in: v0.1.3 Stampa le opzioni della riga di comando v8.
Nota: le opzioni v8 consentono alle parole di essere separate da entrambi i trattini (-) o caratteri di
sottolineatura (_).
Ad esempio, --stack-trace-limit è equivalente a --stack_trace_limit.
--tls-cipher-list=list
Aggiunto in: v4.0.0 Specificare un elenco di crittografia TLS predefinito alternativo. (Richiede
Node.js per essere costruito con supporto crittografico. (Predefinito))
--enable-fips
Aggiunto in: v6.0.0 Abilita crypto compatibile con FIPS all'avvio. (Richiede che Node.js sia
compilato con ./configure --openssl-fips)
--force-fips
Aggiunto in: v6.0.0 Forza la crittografia compatibile con FIPS all'avvio. (Non può essere
disabilitato dal codice di script.) (Stessi requisiti di --enable-fips)
--icu-data-dir=file
https://riptutorial.com/it/home 79
Aggiunto in: v0.11.15 Specificare il percorso di caricamento dei dati ICU. (sostituisce
NODE_ICU_DATA)
Environment Variables
NODE_DEBUG=module[,…]
Aggiunto in: v0.1.32 ',' - elenco separato dei moduli principali che dovrebbero stampare le
informazioni di debug.
NODE_PATH=path[:…]
Aggiunto in: v0.1.32 ':' - elenco separato di directory con prefisso al percorso di ricerca del
modulo.
Nota: su Windows, questa è una ';' - lista separata invece.
NODE_DISABLE_COLORS=1
Aggiunto in: v0.3.0 Se impostato su 1 colori non verrà utilizzato in REPL.
NODE_ICU_DATA=file
Aggiunto in: v0.11.15 Percorso dati per i dati ICU (oggetto Intl). Estenderà i dati collegati quando
compilati con supporto small-icu.
NODE_REPL_HISTORY=file
Aggiunto in: v5.0.0 Percorso del file utilizzato per memorizzare la cronologia REPL persistente. Il
percorso predefinito è ~ / .node_repl_history, che viene sovrascritto da questa variabile.
L'impostazione del valore su una stringa vuota ("" o "") disabilita la cronologia REPL persistente.
Leggi CLI online: https://riptutorial.com/it/node-js/topic/6013/cli
https://riptutorial.com/it/home 80
Capitolo 14: Codice Node.js per STDIN e
STDOUT senza utilizzare alcuna libreria
introduzione
Questo è un semplice programma in node.js a cui prende input dall'utente e lo stampa sulla
console.
L'oggetto del processo è un globale che fornisce informazioni e controlla il processo Node.js
corrente. Come globale, è sempre disponibile per le applicazioni Node.js senza usare require ().
Examples
Programma
La proprietà process.stdin restituisce un flusso leggibile equivalente o associato a stdin.
La proprietà process.stdout restituisce un flusso Writable equivalente o associato a stdout.
process.stdin.resume()
console.log('Enter the data to be displayed ');
process.stdin.on('data', function(data) { process.stdout.write(data) })
Leggi Codice Node.js per STDIN e STDOUT senza utilizzare alcuna libreria online:
https://riptutorial.com/it/node-js/topic/8961/codice-node-js-per-stdin-e-stdout-senza-utilizzare-
alcuna-libreria
https://riptutorial.com/it/home 81
Capitolo 15: Come vengono caricati i moduli
Examples
Modalità globale
Se hai installato il nodo usando la directory predefinita, mentre in modalità globale, NPM installa i
pacchetti in /usr/local/lib/node_modules . Se nella shell si digita quanto segue, NPM cercherà,
scaricherà e installerà l'ultima versione del pacchetto chiamato sax all'interno della directory
/usr/local/lib/node_modules/express :
$ npm install -g express
Assicurarsi di disporre di diritti di accesso sufficienti per la cartella. Questi moduli saranno
disponibili per tutto il processo del nodo che verrà eseguito su quella macchina
Nell'installazione in modalità locale. Npm scaricherà e installerà i moduli nelle attuali cartelle di
lavoro creando una nuova cartella denominata node_modules ad esempio se ti trovi in
/home/user/apps/my_app verrà creata una nuova cartella chiamata node_modules
/home/user/apps/my_app/node_modules se non è già esistente
Caricamento dei moduli
Quando si fa riferimento al modulo nel codice, il nodo ricerca prima la cartella node_module
all'interno della cartella di riferimento node_module richiesta Se il nome del modulo non è relativo e
non è un modulo principale, il nodo cercherà di trovarlo all'interno della cartella node_modules
nell'attuale directory. Ad esempio, se fai quanto segue, Node proverà a cercare il file
./node_modules/myModule.js :
var myModule = require('myModule.js');
Se il nodo non riesce a trovare il file, cercherà all'interno della cartella genitore chiamata
../node_modules/myModule.js . Se fallisce di nuovo, proverà la cartella genitore e continuerà a
discendere fino a raggiungere la radice o trovare il modulo richiesto.
Se lo desideri, puoi anche omettere l'estensione .js , nel qual caso il nodo aggiungerà
l'estensione .js e cercherà il file.
Caricamento di un modulo di cartelle
Puoi usare il percorso di una cartella per caricare un modulo come questo:
var myModule = require('./myModuleDir');
https://riptutorial.com/it/home 82
In tal caso, il nodo cercherà all'interno di quella cartella. Il nodo presumerà che questa cartella sia
un pacchetto e proverà a cercare una definizione del pacchetto. Quella definizione del pacchetto
dovrebbe essere un file denominato package.json . Se quella cartella non contiene un file di
definizione del pacchetto denominato package.json , il punto di ingresso del pacchetto assumerà il
valore predefinito di index.js , e il Node guarderà, in questo caso, per un file sotto il percorso
./myModuleDir/index.js .
L'ultima risorsa, se il modulo non si trova in nessuna delle cartelle, è la cartella di installazione del
modulo globale.
Leggi Come vengono caricati i moduli online: https://riptutorial.com/it/node-js/topic/7738/come-
vengono-caricati-i-moduli
https://riptutorial.com/it/home 83
Capitolo 16: Comunicazione Arduino con
nodeJs
introduzione
Modo per mostrare come Node.Js può comunicare con Arduino Uno.
Examples
Comunicazione Node Js con Arduino via serialport
Codice js del nodo
Esempio per iniziare questo argomento è il server Node.js che comunica con Arduino tramite
serialport.
npm install express --save
npm install serialport --save
Esempio app.js:
const express = require('express');
const app = express();
var SerialPort = require("serialport");
var port = 3000;
var arduinoCOMPort = "COM3";
var arduinoSerialPort = new SerialPort(arduinoCOMPort, {
baudrate: 9600
});
arduinoSerialPort.on('open',function() {
console.log('Serial Port ' + arduinoCOMPort + ' is opened.');
});
app.get('/', function (req, res) {
return res.send('Working');
})
app.get('/:action', function (req, res) {
var action = req.params.action || req.param('action');
if(action == 'led'){
arduinoSerialPort.write("w");
return res.send('Led light is on!');
https://riptutorial.com/it/home 84
}
if(action == 'off') {
arduinoSerialPort.write("t");
return res.send("Led light is off!");
}
return res.send('Action: ' + action);
});
app.listen(port, function () {
console.log('Example app listening on port http://0.0.0.0:' + port + '!');
});
Avvio del server Express di esempio:
node app.js
Codice Arduino
// the setup function runs once when you press reset or power the board
void setup() {
// initialize digital pin LED_BUILTIN as an output.
Serial.begin(9600); // Begen listening on port 9600 for serial
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, LOW);
}
// the loop function runs over and over again forever
void loop() {
if(Serial.available() > 0) // Read from serial port
{
char ReaderFromNode; // Store current character
ReaderFromNode = (char) Serial.read();
convertToState(ReaderFromNode); // Convert character to state
}
delay(1000);
}
void convertToState(char chr) {
if(chr=='o'){
digitalWrite(LED_BUILTIN, HIGH);
delay(100);
}
if(chr=='f'){
digitalWrite(LED_BUILTIN, LOW);
delay(100);
}
}
Cominciando
https://riptutorial.com/it/home 85
1. Collega l'arduino alla tua macchina.
2. Avvia il server
Controlla la compilazione guidata tramite il nodo js express server.
Per accendere il led:
http://0.0.0.0:3000/led
Per spegnere il led:
http://0.0.0.0:3000/off
Leggi Comunicazione Arduino con nodeJs online: https://riptutorial.com/it/node-
js/topic/10509/comunicazione-arduino-con-nodejs
https://riptutorial.com/it/home 86
Capitolo 17: Comunicazione client-server
Examples
/ w Express, jQuery e Jade
//'client.jade'
//a button is placed down; similar in HTML
button(type='button', id='send_by_button') Modify data
#modify Lorem ipsum Sender
//loading jQuery; it can be done from an online source as well
script(src='./js/jquery-2.2.0.min.js')
//AJAX request using jQuery
script
$(function () {
$('#send_by_button').click(function (e) {
e.preventDefault();
//test: the text within brackets should appear when clicking on said button
//window.alert('You clicked on me. - jQuery');
//a variable and a JSON initialized in the code
var predeclared = "Katamori";
var data = {
Title: "Name_SenderTest",
Nick: predeclared,
FirstName: "Zoltan",
Surname: "Schmidt"
};
//an AJAX request with given parameters
$.ajax({
type: 'POST',
data: JSON.stringify(data),
contentType: 'application/json',
url: 'http://localhost:7776/domaintest',
//on success, received data is used as 'data' function input
success: function (data) {
window.alert('Request sent; data received.');
var jsonstr = JSON.stringify(data);
var jsonobj = JSON.parse(jsonstr);
//if the 'nick' member of the JSON does not equal to the predeclared
string (as it was initialized), then the backend script was executed, meaning that
communication has been established
if(data.Nick != predeclared){
document.getElementById("modify").innerHTML = "JSON changed!\n" +
jsonstr;
};
https://riptutorial.com/it/home 87
});
});
});
//'domaintest_route.js'
var express = require('express');
var router = express.Router();
//an Express router listening to GET requests - in this case, it's empty, meaning that nothing
is displayed when you reach 'localhost/domaintest'
router.get('/', function(req, res, next) {
});
//same for POST requests - notice, how the AJAX request above was defined as POST
router.post('/', function(req, res) {
res.setHeader('Content-Type', 'application/json');
//content generated here
var some_json = {
Title: "Test",
Item: "Crate"
};
var result = JSON.stringify(some_json);
//content got 'client.jade'
var sent_data = req.body;
sent_data.Nick = "ttony33";
res.send(sent_data);
});
module.exports = router;
// basato su un gist usato personalmente: https://gist.github.com/Katamori/5c9850f02e4baf6e9896
Leggi Comunicazione client-server online: https://riptutorial.com/it/node-
js/topic/6222/comunicazione-client-server
https://riptutorial.com/it/home 88
Capitolo 18: Comunicazione Socket.io
Examples
"Ciao mondo!" con i messaggi socket
Installa i moduli del nodo
npm install express
npm install socket.io
Node.js server
const express = require('express');
const app = express();
const server = app.listen(3000,console.log("Socket.io Hello World server started!"));
const io = require('socket.io')(server);
io.on('connection', (socket) => {
//console.log("Client connected!");
socket.on('message-from-client-to-server', (msg) => {
console.log(msg);
})
socket.emit('message-from-server-to-client', 'Hello World!');
});
Client browser
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Hello World with Socket.io</title>
</head>
<body>
<script src="https://cdn.socket.io/socket.io-1.4.5.js"></script>
<script>
var socket = io("http://localhost:3000");
socket.on("message-from-server-to-client", function(msg) {
document.getElementById('message').innerHTML = msg;
});
socket.emit('message-from-client-to-server', 'Hello World!');
</script>
<p>Socket.io Hello World client started!</p>
<p id="message"></p>
</body>
</html>
Leggi Comunicazione Socket.io online: https://riptutorial.com/it/node-js/topic/4261/comunicazione-
socket-io
https://riptutorial.com/it/home 89
Capitolo 19: Connetti a Mongodb
introduzione
MongoDB è un programma di database orientato ai documenti multipiattaforma gratuito e open
source. Classificato come programma di database NoSQL, MongoDB utilizza documenti simili a
JSON con schemi.
Per maggiori dettagli vai su https://www.mongodb.com/
Sintassi
• MongoClient.connect ('mongodb: //127.0.0.1: 27017 / crud', function (err, db) {// fa
womething qui});
Examples
Semplice esempio per collegare mongoDB da Node.JS
MongoClient.connect('mongodb://localhost:27017/myNewDB',function (err,db) {
if(err)
console.log("Unable to connect DB. Error: " + err)
else
console.log('Connected to DB');
db.close();
});
myNewDB è un nome DB, se non esiste nel database, verrà creato automaticamente con questa
chiamata.
Un modo semplice per collegare mongoDB con il core Node.JS
var MongoClient = require('mongodb').MongoClient;
//connection with mongoDB
MongoClient.connect("mongodb://localhost:27017/MyDb", function (err, db) {
//check the connection
if(err){
console.log("connection failed.");
}else{
console.log("successfully connected to mongoDB.");
});
Leggi Connetti a Mongodb online: https://riptutorial.com/it/node-js/topic/6280/connetti-a-mongodb
https://riptutorial.com/it/home 90
Capitolo 20: Consegna HTML o qualsiasi altro
tipo di file
Sintassi
• response.sendFile (fileName, options, function (err) {});
Examples
Consegna HTML al percorso specificato
Ecco come creare un server Express e servire index.html per impostazione predefinita (percorso
vuoto / ) e page1.html per /page1 percorso /page1 .
Struttura delle cartelle
project root
| server.js
|____views
| index.html
| page1.html
server.js
var express = require('express');
var path = require('path');
var app = express();
// deliver index.html if no file is requested
app.get("/", function (request, response) {
response.sendFile(path.join(__dirname, 'views/index.html'));
});
// deliver page1.html if page1 is requested
app.get('/page1', function(request, response) {
response.sendFile(path.join(__dirname, 'views', 'page1.html', function(error) {
if (error) {
// do something in case of error
console.log(err);
response.end(JSON.stringify({error:"page not found"}));
}
});
});
app.listen(8080);
Si noti che sendFile() semplicemente lo streaming di un file statico come risposta, non offrendo
https://riptutorial.com/it/home 91
alcuna possibilità di modificarlo. Se stai servendo un file HTML e vuoi includere dati dinamici con
esso, dovrai utilizzare un motore di template come Pug, Moustache o EJS.
Leggi Consegna HTML o qualsiasi altro tipo di file online: https://riptutorial.com/it/node-
js/topic/6538/consegna-html-o-qualsiasi-altro-tipo-di-file
https://riptutorial.com/it/home 92
Capitolo 21: Creazione di API con Node.js
Examples
Ottieni API usando Express
Node.js possono essere facilmente costruite nel framework web Express .
L'esempio seguente crea una semplice API GET per elencare tutti gli utenti.
Esempio
var express = require('express');
var app = express();
var users =[{
id: 1,
name: "John Doe",
age : 23,
email: "[email protected]"
}];
// GET /api/users
app.get('/api/users', function(req, res){
return res.json(users); //return response as JSON
});
app.listen('3000', function(){
console.log('Server listening on port 3000');
});
API POST utilizzando Express
L'esempio seguente crea API POST usando Express . Questo esempio è simile all'esempio GET
tranne l'uso di body-parser che analizza i dati del post e lo aggiunge a req.body .
Esempio
var express = require('express');
var app = express();
// for parsing the body in POST request
var bodyParser = require('body-parser');
var users =[{
id: 1,
name: "John Doe",
age : 23,
email: "[email protected]"
}];
app.use(bodyParser.urlencoded({ extended: false }));
app.use(bodyParser.json());
https://riptutorial.com/it/home 93
// GET /api/users
app.get('/api/users', function(req, res){
return res.json(users);
});
/* POST /api/users
{
"user": {
"id": 3,
"name": "Test User",
"age" : 20,
"email": "[email protected]"
}
}
*/
app.post('/api/users', function (req, res) {
var user = req.body.user;
users.push(user);
return res.send('User has been added successfully');
});
app.listen('3000', function(){
console.log('Server listening on port 3000');
});
Leggi Creazione di API con Node.js online: https://riptutorial.com/it/node-js/topic/5991/creazione-
di-api-con-node-js
https://riptutorial.com/it/home 94
Capitolo 22: Creazione di una libreria Node.js
che supporti entrambe le promesse e le
callback first-error
introduzione
A molte persone piace lavorare con promesse e / o asincroni / attendere la sintassi, ma quando si
scrive un modulo sarebbe utile che alcuni programmatori supportino anche i metodi classici di stile
callback. Piuttosto che creare due moduli, o due set di funzioni, o avere il programmatore che
promette il tuo modulo, il tuo modulo può supportare entrambi i metodi di programmazione su uno
usando asCallback () o Q's (Windows) di Q. ().
Examples
Modulo di esempio e programma corrispondente che utilizza Bluebird
math.js
'use strict';
const Promise = require('bluebird');
module.exports = {
// example of a callback-only method
callbackSum: function(a, b, callback) {
if (typeof a !== 'number')
return callback(new Error('"a" must be a number'));
if (typeof b !== 'number')
return callback(new Error('"b" must be a number'));
return callback(null, a + b);
},
// example of a promise-only method
promiseSum: function(a, b) {
return new Promise(function(resolve, reject) {
if (typeof a !== 'number')
return reject(new Error('"a" must be a number'));
if (typeof b !== 'number')
return reject(new Error('"b" must be a number'));
resolve(a + b);
});
},
// a method that can be used as a promise or with callbacks
sum: function(a, b, callback) {
return new Promise(function(resolve, reject) {
if (typeof a !== 'number')
return reject(new Error('"a" must be a number'));
https://riptutorial.com/it/home 95
if (typeof b !== 'number')
return reject(new Error('"b" must be a number'));
resolve(a + b);
}).asCallback(callback);
},
};
index.js
'use strict';
const math = require('./math');
// classic callbacks
math.callbackSum(1, 3, function(err, result) {
if (err)
console.log('Test 1: ' + err);
else
console.log('Test 1: the answer is ' + result);
});
math.callbackSum(1, 'd', function(err, result) {
if (err)
console.log('Test 2: ' + err);
else
console.log('Test 2: the answer is ' + result);
});
// promises
math.promiseSum(2, 5)
.then(function(result) {
console.log('Test 3: the answer is ' + result);
})
.catch(function(err) {
console.log('Test 3: ' + err);
});
math.promiseSum(1)
.then(function(result) {
console.log('Test 4: the answer is ' + result);
})
.catch(function(err) {
console.log('Test 4: ' + err);
});
// promise/callback method used like a promise
math.sum(8, 2)
.then(function(result) {
console.log('Test 5: the answer is ' + result);
})
.catch(function(err) {
console.log('Test 5: ' + err);
});
https://riptutorial.com/it/home 96
// promise/callback method used with callbacks
math.sum(7, 11, function(err, result) {
if (err)
console.log('Test 6: ' + err);
else
console.log('Test 6: the answer is ' + result);
});
// promise/callback method used like a promise with async/await syntax
(async () => {
try {
let x = await math.sum(6, 3);
console.log('Test 7a: ' + x);
let y = await math.sum(4, 's');
console.log('Test 7b: ' + y);
} catch(err) {
console.log(err.message);
}
})();
Leggi Creazione di una libreria Node.js che supporti entrambe le promesse e le callback first-error
online: https://riptutorial.com/it/node-js/topic/9874/creazione-di-una-libreria-node-js-che-supporti-
entrambe-le-promesse-e-le-callback-first-error
https://riptutorial.com/it/home 97
Capitolo 23: Database (MongoDB con
Mongoose)
Examples
Connessione Mongoose
Assicurati di avere prima mongodb in esecuzione! mongod --dbpath data/
package.json
"dependencies": {
"mongoose": "^4.5.5",
}
server.js (ECMA 6)
import mongoose from 'mongoose';
mongoose.connect('mongodb://localhost:27017/stackoverflow-example');
const db = mongoose.connection;
db.on('error', console.error.bind(console, 'DB connection error!'));
server.js (ECMA 5.1)
var mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/stackoverflow-example');
var db = mongoose.connection;
db.on('error', console.error.bind(console, 'DB connection error!'));
Modello
Definisci il tuo modello (i):
app / models / user.js (ECMA 6)
import mongoose from 'mongoose';
const userSchema = new mongoose.Schema({
name: String,
password: String
});
const User = mongoose.model('User', userSchema);
export default User;
https://riptutorial.com/it/home 98
app / model / user.js (ECMA 5.1)
var mongoose = require('mongoose');
var userSchema = new mongoose.Schema({
name: String,
password: String
});
var User = mongoose.model('User', userSchema);
module.exports = User
Inserisci dati
ECMA 6:
const user = new User({
name: 'Stack',
password: 'Overflow',
}) ;
user.save((err) => {
if (err) throw err;
console.log('User saved!');
});
ECMA5.1:
var user = new User({
name: 'Stack',
password: 'Overflow',
}) ;
user.save(function (err) {
if (err) throw err;
console.log('User saved!');
});
Leggi i dati
ECMA6:
User.findOne({
name: 'stack'
}, (err, user) => {
if (err) throw err;
if (!user) {
console.log('No user was found');
} else {
console.log('User was found');
}
https://riptutorial.com/it/home 99
});
ECMA5.1:
User.findOne({
name: 'stack'
}, function (err, user) {
if (err) throw err;
if (!user) {
console.log('No user was found');
} else {
console.log('User was found');
}
});
Leggi Database (MongoDB con Mongoose) online: https://riptutorial.com/it/node-
js/topic/6411/database--mongodb-con-mongoose-
https://riptutorial.com/it/home 100
Capitolo 24: Debug dell'applicazione Node.js
Examples
Core node.js debugger e node inspector
Utilizzo del debugger principale
Node.js fornisce una build in utilità di debug non grafica. Per avviare la compilazione nel
debugger, avviare l'applicazione con questo comando:
node debug filename.js
Si consideri la seguente semplice applicazione Node.js contenuta nel debugDemo.js
'use strict';
function addTwoNumber(a, b){
// function returns the sum of the two numbers
debugger
return a + b;
}
var result = addTwoNumber(5, 9);
console.log(result);
Il debugger parole chiave bloccherà il debugger in quel punto del codice.
Riferimento del comando
1. Stepping
cont, c - Continue execution
next, n - Step next
step, s - Step in
out, o - Step out
2. I punti di interruzione
setBreakpoint(), sb() - Set breakpoint on current line
setBreakpoint(line), sb(line) - Set breakpoint on specific line
Per eseguire il debug del codice precedente, eseguire il seguente comando
node debug debugDemo.js
https://riptutorial.com/it/home 101
Una volta eseguiti i comandi precedenti, vedrai il seguente output. Per uscire dall'interfaccia del
debugger, digitare process.exit()
Utilizzare il comando watch(expression) per aggiungere la variabile o l'espressione di cui si
desidera visualizzare il valore e restart per riavviare l'app e il debug.
Usa repl per inserire il codice in modo interattivo. La modalità repl ha lo stesso contesto della
linea di cui si sta eseguendo il debug. Ciò consente di esaminare il contenuto delle variabili e
testare le linee di codice. Premi Ctrl+C per lasciare il debug repl.
Utilizzando l'ispettore del nodo incorporato
v6.3.0
Puoi eseguire l'ispettore integrato in v8 del nodo! Il plug-in ispettore nodo non è più necessario.
Basta passare il flag di ispezione e ti verrà fornito un URL per l'ispettore
node --inspect server.js
Utilizzando l'ispettore Node
https://riptutorial.com/it/home 102
Installa l'ispettore del nodo:
npm install -g node-inspector
Esegui la tua app con il comando node-debug:
node-debug filename.js
Successivamente, premi in Chrome:
http://localhost:8080/debug?port=5858
A volte la porta 8080 potrebbe non essere disponibile sul tuo computer. Potresti ricevere il
seguente errore:
Impossibile avviare il server 0.0.0.0:8080. Errore: ascolta EACCES.
In questo caso, avviare l'ispettore del nodo su una porta diversa usando il seguente comando.
$node-inspector --web-port=6500
Vedrai qualcosa di simile a questo:
https://riptutorial.com/it/home 103
Leggi Debug dell'applicazione Node.js online: https://riptutorial.com/it/node-js/topic/5900/debug-
dell-applicazione-node-js
https://riptutorial.com/it/home 104
Capitolo 25: Debug remoto in Node.JS
Examples
NodeJS esegue la configurazione
Per configurare il debug remoto dei nodi, esegui semplicemente il processo del nodo con il flag --
debug . È possibile aggiungere una porta su cui eseguire il debugger utilizzando --debug=<port> .
Quando il processo del tuo nodo si avvia, dovresti vedere il messaggio
Debugger listening on port <port>
Che ti dirà che tutto è buono per andare.
Quindi imposti il target di debug remoto nel tuo IDE specifico.
Configurazione IntelliJ / Webstorm
1. Assicurati che il plugin NodeJS sia abilitato
2. Seleziona le configurazioni della corsa (schermo)
3. Seleziona + > Debug remoto Node.js
https://riptutorial.com/it/home 105
4. Assicurati di inserire la porta selezionata sopra e l'host corretto
Una volta configurati, esegui semplicemente il target di debug come faresti normalmente e si
fermerà sui tuoi breakpoint.
Usa il proxy per il debug tramite la porta su Linux
Se avvii la tua applicazione su Linux, usa il proxy per il debug via porta, ad esempio:
socat TCP-LISTEN:9958,fork TCP:127.0.0.1:5858 &
Utilizzare quindi la porta 9958 per il debug remoto.
Leggi Debug remoto in Node.JS online: https://riptutorial.com/it/node-js/topic/6335/debug-remoto-
in-node-js
https://riptutorial.com/it/home 106
Capitolo 26: Design API restful: best practice
Examples
Gestione degli errori: OTTENERE tutte le risorse
Come gestisci gli errori, invece di collegarli alla console?
Cattiva strada:
Router.route('/')
.get((req, res) => {
Request.find((err, r) => {
if(err){
console.log(err)
} else {
res.json(r)
}
})
})
.post((req, res) => {
const request = new Request({
type: req.body.type,
info: req.body.info
});
request.info.user = req.user._id;
console.log("ABOUT TO SAVE REQUEST", request);
request.save((err, r) => {
if (err) {
res.json({ message: 'there was an error saving your r' });
} else {
res.json(r);
}
});
});
Modo migliore:
Router.route('/')
.get((req, res) => {
Request.find((err, r) => {
if(err){
console.log(err)
} else {
return next(err)
}
})
})
.post((req, res) => {
const request = new Request({
type: req.body.type,
info: req.body.info
});
request.info.user = req.user._id;
console.log("ABOUT TO SAVE REQUEST", request);
https://riptutorial.com/it/home 107
request.save((err, r) => {
if (err) {
return next(err)
} else {
res.json(r);
}
});
});
Leggi Design API restful: best practice online: https://riptutorial.com/it/node-js/topic/6490/design-
api-restful--best-practice
https://riptutorial.com/it/home 108
Capitolo 27: Disinstallazione di Node.js
Examples
Disinstallare completamente Node.js su Mac OSX
In Terminale sul tuo sistema operativo Mac, inserisci i seguenti 2 comandi:
lsbom -f -l -s -pf /var/db/receipts/org.nodejs.pkg.bom | while read f; do sudo rm
/usr/local/${f}; done
sudo rm -rf /usr/local/lib/node /usr/local/lib/node_modules /var/db/receipts/org.nodejs.*
Disinstallare Node.js su Windows
Per disinstallare Node.js su Windows, utilizzare Aggiungi o Rimuovi programmi come questo:
1. Apri Add or Remove Programs dal menu di avvio.
2. Cerca Node.js
Windows 10:
3. Fai clic su Node.js.
4. Clicca su Disinstalla.
5. Fai clic sul nuovo pulsante Disinstalla.
Windows 7-8.1:
3. Fai clic sul pulsante Disinstalla sotto Node.js.
Leggi Disinstallazione di Node.js online: https://riptutorial.com/it/node-
js/topic/2821/disinstallazione-di-node-js
https://riptutorial.com/it/home 109
Capitolo 28: Distribuzione dell'applicazione
Node.js senza tempi di inattività.
Examples
Distribuzione utilizzando PM2 senza tempi di fermo.
ecosystem.json
{
"name": "app-name",
"script": "server",
"exec_mode": "cluster",
"instances": 0,
"wait_ready": true
"listen_timeout": 10000,
"kill_timeout": 5000,
}
wait_ready
Invece di ricaricare in attesa dell'evento di ascolto, attendere process.send ('ready');
listen_timeout
Tempo in ms prima di forzare un ricaricamento se l'app non è in ascolto.
kill_timeout
Tempo in ms prima di inviare un SIGKLL finale.
server.js
const http = require('http');
const express = require('express');
const app = express();
const server = http.Server(app);
const port = 80;
server.listen(port, function() {
process.send('ready');
});
process.on('SIGINT', function() {
server.close(function() {
process.exit(0);
});
});
https://riptutorial.com/it/home 110
Potrebbe essere necessario attendere che l'applicazione abbia connessioni stabilite con i propri
DB / cache / worker / qualunque. PM2 deve attendere prima di considerare l'applicazione come
online. Per fare ciò, è necessario fornire wait_ready: true in un file di processo. Questo renderà
PM2 in ascolto per quell'evento. Nella tua applicazione dovrai aggiungere process.send('ready');
quando vuoi che la tua domanda sia considerata pronta.
Quando un processo viene arrestato / riavviato da PM2, alcuni segnali di sistema vengono inviati
al processo in un determinato ordine.
Prima un SIGINT viene inviato un segnale ai tuoi processi, segnale che puoi prendere per sapere
che il tuo processo verrà fermato. Se la tua applicazione non esce prima di 1.6s (personalizzabile)
riceverà un segnale SIGKILL per forzare l'uscita del processo. Quindi se la tua applicazione ha
bisogno di ripulire qualcosa di stato o di lavoro, puoi prendere il segnale SIGINT per preparare la
tua richiesta di uscita.
Leggi Distribuzione dell'applicazione Node.js senza tempi di inattività. online:
https://riptutorial.com/it/node-js/topic/9752/distribuzione-dell-applicazione-node-js-senza-tempi-di-
inattivita-
https://riptutorial.com/it/home 111
Capitolo 29: Distribuzione di applicazioni
Node.js in produzione
Examples
Impostazione NODE_ENV = "produzione"
Le distribuzioni di produzione variano in molti modi, ma una convenzione standard quando si
distribuisce in produzione consiste nel definire una variabile d'ambiente chiamata NODE_ENV e
impostare il suo valore su "produzione" .
Bandiere di runtime
Qualsiasi codice in esecuzione nella tua applicazione (inclusi i moduli esterni) può controllare il
valore di NODE_ENV :
if(process.env.NODE_ENV === 'production') {
// We are running in production mode
} else {
// We are running in development mode
}
dipendenze
Quando la variabile di ambiente NODE_ENV è impostata su "produzione", tutte le devDependencies nel
file package.json verranno completamente ignorate durante l'esecuzione npm install . Puoi anche
applicarlo con un flag --production :
npm install --production
Per impostare NODE_ENV puoi utilizzare uno di questi metodi
metodo 1: imposta NODE_ENV per tutte le app nodo
Finestre :
set NODE_ENV=production
Linux o altri sistemi basati su Unix:
export NODE_ENV=production
Questo imposta NODE_ENV per la sessione bash corrente, quindi tutte le app avviate dopo questa
https://riptutorial.com/it/home 112
istruzione avranno NODE_ENV impostato sulla production .
metodo 2: imposta NODE_ENV per l'app corrente
NODE_ENV=production node app.js
Questo imposterà NODE_ENV per l'app corrente. Questo aiuta quando vogliamo testare le nostre app
in diversi ambienti.
metodo 3: crea il file .env e .env
Questo usa l'idea spiegata qui . Fare riferimento a questo post per una spiegazione più
dettagliata.
Fondamentalmente si crea .env file .env ed esegui alcuni script bash per impostarli sull'ambiente.
Per evitare di scrivere uno script bash, è possibile utilizzare il pacchetto env-cmd per caricare le
variabili d'ambiente definite nel file .env .
env-cmd .env node app.js
metodo 4: utilizzare il pacchetto cross-env
Questo pacchetto consente di impostare le variabili di ambiente in un modo per ogni piattaforma.
Dopo averlo installato con npm, puoi aggiungerlo allo script di distribuzione in package.json come
segue:
"build:deploy": "cross-env NODE_ENV=production webpack"
Gestisci l'app con il gestore dei processi
È buona norma eseguire app NodeJS controllate da process manager. Process Manager aiuta a
mantenere l'applicazione in vita per sempre, ricomincia dall'errore, ricarica senza tempi di fermo e
semplifica l'amministrazione. I più potenti di questi (come PM2 ) hanno un sistema di
bilanciamento del carico integrato. PM2 consente inoltre di gestire la registrazione delle
applicazioni, il monitoraggio e il clustering.
PM2 Process Manager
Installazione di PM2:
npm install pm2 -g
Il processo può essere avviato in modalità cluster che prevede il bilanciamento del carico integrato
per distribuire il carico tra i processi:
pm2 start app.js -i 0 --name "api" ( -i serve per specificare il numero di processi da generare. Se
è 0, il numero di processo sarà basato sul numero di core della CPU)
https://riptutorial.com/it/home 113
Pur avendo più utenti in produzione, è necessario disporre di un singolo punto per PM2. Pertanto,
il comando pm2 deve essere preceduto da una posizione (per la configurazione PM2) altrimenti
verrà generato un nuovo processo pm2 per ogni utente con configurazione nella rispettiva
directory principale. E sarà incoerente.
Utilizzo: PM2_HOME=/etc/.pm2 pm2 start app.js
Distribuzione utilizzando PM2
PM2 è un gestore dei processi di produzione per le applicazioni Node.js , che consente di
mantenere attive le applicazioni per sempre e di ricaricarle senza tempi di fermo. PM2 consente
inoltre di gestire la registrazione delle applicazioni, il monitoraggio e il clustering.
Installa pm2 livello globale.
npm install -g pm2
Quindi, esegui l'app node.js utilizzando PM2.
pm2 start server.js --name "my-app"
I seguenti comandi sono utili mentre si lavora con PM2 .
Elenca tutti i processi in esecuzione:
pm2 list
Interrompi un'app:
pm2 stop my-app
Riavvia un'app:
pm2 restart my-app
Per visualizzare informazioni dettagliate su un'app:
https://riptutorial.com/it/home 114
pm2 show my-app
Per rimuovere un'app dal registro di PM2:
pm2 delete my-app
Distribuzione utilizzando il gestore dei processi
Generalmente, il process manager viene utilizzato in produzione per distribuire un'app nodejs. Le
funzioni principali di un gestore processi stanno riavviando il server in caso di arresto anomalo,
controllo del consumo delle risorse, miglioramento delle prestazioni di runtime, monitoraggio, ecc.
Alcuni dei process manager popolari realizzati dalla comunità dei nodi sono per sempre, pm2, ecc.
Forvever
forever è uno strumento di interfaccia a riga di comando per garantire che un determinato script
venga eseguito continuamente. La semplice interfaccia di forever lo rende ideale per eseguire
piccole distribuzioni di app e script Node.js
monitora forever tuo processo e lo riavvia se si blocca.
Installa forever livello globale.
$ npm install -g forever
Esegui l'applicazione:
$ forever start server.js
Questo avvia il server e fornisce un id per il processo (parte da 0).
Riavvia l'applicazione:
$ forever restart 0
Qui 0 è l'id del server.
Arresta l'applicazione:
$ forever stop 0
Simile al riavvio, 0 è l'id del server. Puoi anche fornire ID processo o nome script al posto dell'ID
dato da sempre.
Per ulteriori comandi: https://www.npmjs.com/package/forever
https://riptutorial.com/it/home 115
Utilizzo di diverse proprietà / configurazione per ambienti diversi come dev,
qa, staging, ecc.
Le applicazioni su larga scala spesso hanno bisogno di proprietà diverse quando funzionano su
ambienti diversi. possiamo ottenere ciò passando argomenti all'applicazione NodeJs e utilizzando
lo stesso argomento nel processo del nodo per caricare un file di proprietà dell'ambiente specifico.
Supponiamo di avere due file di proprietà per diversi ambienti.
• dev.json
{
"PORT": 3000,
"DB": {
"host": "localhost",
"user": "bob",
"password": "12345"
}
}
• qa.json
{
"PORT": 3001,
"DB": {
"host": "where_db_is_hosted",
"user": "bob",
"password": "54321"
}
}
Il codice seguente nell'applicazione esporterà il rispettivo file di proprietà che vogliamo utilizzare.
process.argv.forEach(function (val) {
var arg = val.split("=");
if (arg.length > 0) {
if (arg[0] === 'env') {
var env = require('./' + arg[1] + '.json');
exports.prop = env;
}
}
});
Diamo argomenti all'applicazione come seguendo
node app.js env=dev
se usiamo process manager come per sempre che sia semplice come
https://riptutorial.com/it/home 116
forever start app.js env=dev
Approfittando dei cluster
Una singola istanza di Node.js viene eseguita in un singolo thread. Per sfruttare i sistemi multi-
core, l'utente a volte desidera avviare un cluster di processi Node.js per gestire il carico.
var cluster = require('cluster');
var numCPUs = require('os').cpus().length;
if (cluster.isMaster) {
// In real life, you'd probably use more than just 2 workers,
// and perhaps not put the master and worker in the same file.
//
// You can also of course get a bit fancier about logging, and
// implement whatever custom logic you need to prevent DoS
// attacks and other bad behavior.
//
// See the options in the cluster documentation.
//
// The important thing is that the master does very little,
// increasing our resilience to unexpected errors.
console.log('your server is working on ' + numCPUs + ' cores');
for (var i = 0; i < numCPUs; i++) {
cluster.fork();
}
cluster.on('disconnect', function(worker) {
console.error('disconnect!');
//clearTimeout(timeout);
cluster.fork();
});
} else {
require('./app.js');
Leggi Distribuzione di applicazioni Node.js in produzione online: https://riptutorial.com/it/node-
js/topic/2975/distribuzione-di-applicazioni-node-js-in-produzione
https://riptutorial.com/it/home 117
Capitolo 30: ECMAScript 2015 (ES6) con
Node.js
Examples
const / let dichiarazioni
A differenza di var , const / let sono legati all'ambito lessicale piuttosto che all'ambito della
funzione.
{
var x = 1 // will escape the scope
let y = 2 // bound to lexical scope
const z = 3 // bound to lexical scope, constant
}
console.log(x) // 1
console.log(y) // ReferenceError: y is not defined
console.log(z) // ReferenceError: z is not defined
Esegui in RunKit
Funzioni della freccia
Le funzioni della freccia si associano automaticamente all'ambito lessicale "this" del codice
circostante.
performSomething(result => {
this.someVariable = result
})
vs
performSomething(function(result) {
this.someVariable = result
}.bind(this))
Esempio di funzione freccia
Consideriamo questo esempio, che emette i quadrati dei numeri 3, 5 e 7:
let nums = [3, 5, 7]
let squares = nums.map(function (n) {
return n * n
})
console.log(squares)
https://riptutorial.com/it/home 118
Esegui in RunKit
La funzione passata a .map può anche essere scritta come funzione di freccia rimuovendo la
parola chiave function e aggiungendo invece la freccia => :
let nums = [3, 5, 7]
let squares = nums.map((n) => {
return n * n
})
console.log(squares)
Esegui in RunKit
Tuttavia, questo può essere scritto in modo ancora più conciso. Se il corpo della funzione è
costituito da una sola istruzione e tale istruzione calcola il valore restituito, è possibile rimuovere le
parentesi graffe di avvolgere il corpo della funzione e la parola chiave return .
let nums = [3, 5, 7]
let squares = nums.map(n => n * n)
console.log(squares)
Esegui in RunKit
destrutturazione
let [x,y, ...nums] = [0, 1, 2, 3, 4, 5, 6];
console.log(x, y, nums);
let {a, b, ...props} = {a:1, b:2, c:3, d:{e:4}}
console.log(a, b, props);
let dog = {name: 'fido', age: 3};
let {name:n, age} = dog;
console.log(n, age);
flusso
/* @flow */
function product(a: number, b: number){
return a * b;
}
const b = 3;
let c = [1,2,3,,{}];
let d = 3;
import request from 'request';
request('http://dev.markitondemand.com/MODApis/Api/v2/Quote/json?symbol=AAPL', (err, res,
payload)=>{
payload = JSON.parse(payload);
let {LastPrice} = payload;
console.log(LastPrice);
https://riptutorial.com/it/home 119
});
Classe ES6
class Mammel {
constructor(legs){
this.legs = legs;
}
eat(){
console.log('eating...');
}
static count(){
console.log('static count...');
}
}
class Dog extends Mammel{
constructor(name, legs){
super(legs);
this.name = name;
}
sleep(){
super.eat();
console.log('sleeping');
}
}
let d = new Dog('fido', 4);
d.sleep();
d.eat();
console.log('d', d);
Leggi ECMAScript 2015 (ES6) con Node.js online: https://riptutorial.com/it/node-
js/topic/6732/ecmascript-2015--es6--con-node-js
https://riptutorial.com/it/home 120
Capitolo 31: Emettitori di eventi
Osservazioni
Quando un evento "spara" (che equivale a "pubblicare un evento" o "emettere un evento"),
ciascun listener verrà chiamato in modo sincrono ( sorgente ), insieme ai dati di
accompagnamento che sono stati passati a emit() , no importa quanti argomenti passi in:
myDog.on('bark', (howLoud, howLong, howIntense) => {
// handle the event
})
myDog.emit('bark', 'loudly', '5 seconds long', 'fiercely')
Gli ascoltatori verranno chiamati nell'ordine in cui sono stati registrati:
myDog.on('urinate', () => console.log('My first thought was "Oh-no"'))
myDog.on('urinate', () => console.log('My second thought was "Not my lawn :)"'))
myDog.emit('urinate')
// The console.logs will happen in the right order because they were registered in that order.
Ma se hai bisogno di un ascoltatore per sparare prima, prima di tutti gli altri listener che sono già
stati aggiunti, puoi usare prependListener() modo:
myDog.prependListener('urinate', () => console.log('This happens before my first and second
thoughts, even though it was registered after them'))
Se hai bisogno di ascoltare un evento, ma vuoi sentirlo solo una volta, puoi usare once invece di on
o prependOnceListener invece di prependListener . Dopo che l'evento è stato attivato e il listener
viene chiamato, il listener verrà automaticamente rimosso e non verrà richiamato la volta
successiva che l'evento viene attivato.
Infine, se vuoi rimuovere tutti gli ascoltatori e ricominciare da capo, sentiti libero di fare proprio
questo:
myDog.removeAllListeners()
Examples
Analisi HTTP tramite un emettitore di eventi
Nel codice del server HTTP (es. server.js ):
const EventEmitter = require('events')
const serverEvents = new EventEmitter()
// Set up an HTTP server
const http = require('http')
https://riptutorial.com/it/home 121
const httpServer = http.createServer((request, response) => {
// Handler the request...
// Then emit an event about what happened
serverEvents.emit('request', request.method, request.url)
});
// Expose the event emitter
module.exports = serverEvents
Nel codice supervisore (es. supervisor.js ):
const server = require('./server.js')
// Since the server exported an event emitter, we can listen to it for changes:
server.on('request', (method, url) => {
console.log(`Got a request: ${method} ${url}`)
})
Ogni volta che il server riceve una richiesta, emetterà un evento chiamato request che il
supervisore sta ascoltando, e quindi il supervisore può reagire all'evento.
Nozioni di base
Gli emettitori di eventi sono incorporati nel nodo e sono per pub-sub, un modello in cui un editore
emetterà eventi, a cui gli abbonati possono ascoltare e reagire. In gergo Node, gli editori sono
chiamati Emettitori di eventi e emettono eventi, mentre gli abbonati sono chiamati ascoltatori e
reagiscono agli eventi.
// Require events to start using them
const EventEmitter = require('events').EventEmitter;
// Dogs have events to publish, or emit
class Dog extends EventEmitter {};
class Food {};
let myDog = new Dog();
// When myDog is chewing, run the following function
myDog.on('chew', (item) => {
if (item instanceof Food) {
console.log('Good dog');
} else {
console.log(`Time to buy another ${item}`);
}
});
myDog.emit('chew', 'shoe'); // Will result in console.log('Time to buy another shoe')
const bacon = new Food();
myDog.emit('chew', bacon); // Will result in console.log('Good dog')
Nell'esempio precedente, il cane è l'editore / EventEmitter, mentre la funzione che controlla
l'elemento è l'utente / ascoltatore. Puoi anche fare più ascoltatori:
myDog.on('bark', () => {
console.log('WHO\'S AT THE DOOR?');
// Panic
https://riptutorial.com/it/home 122
});
Possono anche esserci più ascoltatori per un singolo evento e persino rimuovere gli ascoltatori:
myDog.on('chew', takeADeepBreathe);
myDog.on('chew', calmDown);
// Undo the previous line with the next one:
myDog.removeListener('chew', calmDown);
Se vuoi ascoltare un evento solo una volta, puoi usare:
myDog.once('chew', pet);
Che rimuoverà l'ascoltatore automaticamente senza condizioni di gara.
Ottieni i nomi degli eventi a cui sei iscritto
La funzione EventEmitter.eventNames () restituirà un array contenente i nomi degli eventi
attualmente sottoscritti.
const EventEmitter = require("events");
class MyEmitter extends EventEmitter{}
var emitter = new MyEmitter();
emitter
.on("message", function(){ //listen for message event
console.log("a message was emitted!");
})
.on("message", function(){ //listen for message event
console.log("this is not the right message");
})
.on("data", function(){ //listen for data event
console.log("a data just occured!!");
});
console.log(emitter.eventNames()); //=> ["message","data"]
emitter.removeAllListeners("data");//=> removeAllListeners to data event
console.log(emitter.eventNames()); //=> ["message"]
Esegui in RunKit
Ottieni il numero di ascoltatori registrati per ascoltare un evento specifico
La funzione Emitter.listenerCount (eventName) restituirà il numero di listener che sono
attualmente in ascolto per l'evento fornito come argomento
const EventEmitter = require("events");
class MyEmitter extends EventEmitter{}
var emitter = new MyEmitter();
emitter
.on("data", ()=>{ // add listener for data event
https://riptutorial.com/it/home 123
console.log("data event emitter");
});
console.log(emitter.listenerCount("data")) // => 1
console.log(emitter.listenerCount("message")) // => 0
emitter.on("message", function mListener(){ //add listener for message event
console.log("message event emitted");
});
console.log(emitter.listenerCount("data")) // => 1
console.log(emitter.listenerCount("message")) // => 1
emitter.once("data", (stuff)=>{ //add another listener for data event
console.log(`Tell me my ${stuff}`);
})
console.log(emitter.listenerCount("data")) // => 2
console.log(emitter.listenerCount("message"))// => 1
Leggi Emettitori di eventi online: https://riptutorial.com/it/node-js/topic/1623/emettitori-di-eventi
https://riptutorial.com/it/home 124
Capitolo 32: Esecuzione di file o comandi con
Child Processes
Sintassi
• child_process.exec (comando [, opzioni] [, callback])
• child_process.execFile (file [, args] [, opzioni] [, callback])
• child_process.fork (modulePath [, args] [, options])
• child_process.spawn (command [, args] [, options])
• child_process.execFileSync (file [, args] [, opzioni])
• child_process.execSync (comando [, opzioni])
• child_process.spawnSync (command [, args] [, options])
Osservazioni
Quando si ChildProcess processi figli, tutti i metodi asincroni restituiranno un'istanza di ChildProcess
, mentre tutte le versioni sincrone restituiranno l'output di qualunque cosa sia stata eseguita.
Come altre operazioni sincrone in Node.js, se si verifica un errore, verrà generato.
Examples
Creazione di un nuovo processo per eseguire un comando
Per generare un nuovo processo in cui è necessario un output non bufferizzato (ad esempio,
processi a esecuzione prolungata che potrebbero stampare l'output in un determinato periodo di
tempo anziché stampare ed uscire immediatamente), utilizzare child_process.spawn() .
Questo metodo genera un nuovo processo utilizzando un dato comando e un array di argomenti. Il
valore restituito è un'istanza di ChildProcess , che a sua volta fornisce le proprietà stdout e stderr .
Entrambi questi flussi sono istanze di stream.Readable . stream.Readable .
Il seguente codice equivale a utilizzare il comando ls -lh /usr .
const spawn = require('child_process').spawn;
const ls = spawn('ls', ['-lh', '/usr']);
ls.stdout.on('data', (data) => {
console.log(`stdout: ${data}`);
});
ls.stderr.on('data', (data) => {
console.log(`stderr: ${data}`);
});
ls.on('close', (code) => {
console.log(`child process exited with code ${code}`);
https://riptutorial.com/it/home 125
});
Un altro comando di esempio:
zip -0vr "archive" ./image.png
Potrebbe essere scritto come:
spawn('zip', ['-0vr', '"archive"', './image.png']);
Creazione di una shell per eseguire un comando
Per eseguire un comando in una shell, in cui è richiesto l'output bufferizzato (ovvero non è un
flusso), utilizzare child_process.exec . Ad esempio, se si desidera eseguire il comando cat *.js
file | wc -l , senza opzioni, sarebbe simile a questo:
const exec = require('child_process').exec;
exec('cat *.js file | wc -l', (err, stdout, stderr) => {
if (err) {
console.error(`exec error: ${err}`);
return;
}
console.log(`stdout: ${stdout}`);
console.log(`stderr: ${stderr}`);
});
La funzione accetta fino a tre parametri:
child_process.exec(command[, options][, callback]);
Il parametro command è una stringa ed è obbligatorio, mentre l'oggetto options e callback sono
entrambi facoltativi. Se non viene specificato alcun oggetto opzioni, exec userà quanto segue
come predefinito:
{
encoding: 'utf8',
timeout: 0,
maxBuffer: 200*1024,
killSignal: 'SIGTERM',
cwd: null,
env: null
}
L'oggetto options supporta anche un parametro shell , che è di default /bin/sh su UNIX e cmd.exe
su Windows, un'opzione uid per l'impostazione dell'identità utente del processo e un'opzione gid
per l'identità di gruppo.
Il callback, che viene chiamato quando viene eseguito il comando, viene chiamato con i tre
argomenti (err, stdout, stderr) . Se il comando viene eseguito correttamente, err sarà null ,
https://riptutorial.com/it/home 126
altrimenti sarà un'istanza di Error , dove err.code è il codice di uscita del processo e err.signal è il
segnale che è stato inviato per terminarlo.
Gli argomenti stdout e stderr sono l'output del comando. Viene decodificato con la codifica
specificata nell'oggetto options (default: string ), ma può essere altrimenti restituito come oggetto
Buffer .
Esiste anche una versione sincrona di exec , che è execSync . La versione sincrona non
ChildProcess una richiamata e restituirà stdout anziché un'istanza di ChildProcess . Se la versione
sincrona incontra un errore, il programma verrà lanciato e interrotto. Sembra questo:
const execSync = require('child_process').execSync;
const stdout = execSync('cat *.js file | wc -l');
console.log(`stdout: ${stdout}`);
Generare un processo per eseguire un eseguibile
Se stai cercando di eseguire un file, come un eseguibile, usa child_process.execFile . Invece di
child_process.exec una shell come child_process.exec , creerà direttamente un nuovo processo,
che è leggermente più efficiente di un comando. La funzione può essere utilizzata in questo modo:
const execFile = require('child_process').execFile;
const child = execFile('node', ['--version'], (err, stdout, stderr) => {
if (err) {
throw err;
}
console.log(stdout);
});
A differenza di child_process.exec , questa funzione accetta fino a quattro parametri, in cui il
secondo parametro è un array di argomenti che desideri fornire all'eseguibile:
child_process.execFile(file[, args][, options][, callback]);
Altrimenti, le opzioni e il formato di callback sono altrimenti identici a child_process.exec . Lo
stesso vale per la versione sincrona della funzione:
const execFileSync = require('child_process').execFileSync;
const stdout = execFileSync('node', ['--version']);
console.log(stdout);
Leggi Esecuzione di file o comandi con Child Processes online: https://riptutorial.com/it/node-
js/topic/2726/esecuzione-di-file-o-comandi-con-child-processes
https://riptutorial.com/it/home 127
Capitolo 33: Esecuzione di node.js come
servizio
introduzione
A differenza di molti server Web, Node non è installato come un servizio pronto all'uso. Ma in
produzione, è meglio farlo funzionare come un demone, gestito da un sistema di init.
Examples
Node.js come un demone di sistema
systemd è il sistema di init di fatto nella maggior parte delle distribuzioni Linux. Dopo che il nodo è
stato configurato per l'esecuzione con systemd, è possibile utilizzare il comando di service per
gestirlo.
Prima di tutto, ha bisogno di un file di configurazione, creiamo. Per le distro basate su Debian,
sarà in /etc/systemd/system/node.service
[Unit]
Description=My super nodejs app
[Service]
# set the working directory to have consistent relative paths
WorkingDirectory=/var/www/app
# start the server file (file is relative to WorkingDirectory here)
ExecStart=/usr/bin/node serverCluster.js
# if process crashes, always try to restart
Restart=always
# let 500ms between the crash and the restart
RestartSec=500ms
# send log tot syslog here (it doesn't compete with other log config in the app itself)
StandardOutput=syslog
StandardError=syslog
# nodejs process name in syslog
SyslogIdentifier=nodejs
# user and group starting the app
User=www-data
Group=www-data
# set the environement (dev, prod…)
Environment=NODE_ENV=production
[Install]
https://riptutorial.com/it/home 128
# start node at multi user system level (= sysVinit runlevel 3)
WantedBy=multi-user.target
Ora è possibile avviare, arrestare e riavviare l'app rispettivamente con:
service node start
service node stop
service node restart
Per dire a systemd di avviare automaticamente il nodo all'avvio, basta digitare: systemctl enable
node .
Questo è tutto, il nodo ora funziona come un demone.
Leggi Esecuzione di node.js come servizio online: https://riptutorial.com/it/node-
js/topic/9258/esecuzione-di-node-js-come-servizio
https://riptutorial.com/it/home 129
Capitolo 34: Esportazione e consumo di
moduli
Osservazioni
Mentre tutto in Node.js viene generalmente eseguito in modo asincrono, require() non è una di
quelle cose. Poiché in pratica i moduli devono essere caricati solo una volta, si tratta di
un'operazione di blocco e devono essere utilizzati correttamente.
I moduli vengono memorizzati nella cache dopo la prima volta che vengono caricati. Se si sta
modificando un modulo in fase di sviluppo, sarà necessario cancellare la sua voce nella cache del
modulo per poter utilizzare le nuove modifiche. Detto questo, anche se un modulo viene
cancellato dalla cache del modulo, il modulo stesso non viene raccolto, quindi è necessario
prestare attenzione per il suo utilizzo negli ambienti di produzione.
Examples
Caricamento e utilizzo di un modulo
Un modulo può essere "importato" o altrimenti "richiesto" dalla funzione require() . Ad esempio,
per caricare il modulo http fornito con Node.js, è possibile utilizzare quanto segue:
const http = require('http');
Oltre ai moduli forniti con il runtime, è anche possibile richiedere i moduli installati da npm, ad
esempio express. Se avevi già installato Express sul tuo sistema tramite npm install express ,
potresti semplicemente scrivere:
const express = require('express');
Puoi anche includere moduli scritti da te come parte della tua applicazione. In questo caso, per
includere un file denominato lib.js nella stessa directory del file corrente:
const mylib = require('./lib');
Nota che puoi omettere l'estensione e si supporrà .js . Una volta caricato un modulo, la variabile
viene popolata con un oggetto che contiene i metodi e le proprietà pubblicati dal file richiesto. Un
esempio completo:
const http = require('http');
// The `http` module has the property `STATUS_CODES`
console.log(http.STATUS_CODES[404]); // outputs 'Not Found'
https://riptutorial.com/it/home 130
// Also contains `createServer()`
http.createServer(function(req, res) {
res.writeHead(200, {'Content-Type': 'text/html'});
res.write('<html><body>Module Test</body></html>');
res.end();
}).listen(80);
Creazione di un modulo hello-world.js
Il nodo fornisce l'interfaccia module.exports per esporre funzioni e variabili ad altri file. Il modo più
semplice per farlo è esportare solo un oggetto (funzione o variabile), come mostrato nel primo
esempio.
Hello-world.js
module.exports = function(subject) {
console.log('Hello ' + subject);
};
Se non vogliamo che l'intero export sia un singolo oggetto, possiamo esportare funzioni e variabili
come proprietà dell'oggetto exports . I tre esempi seguenti dimostrano tutto ciò in modi
leggermente diversi:
• hello-venus.js: la definizione della funzione viene eseguita separatamente, quindi aggiunta
come proprietà di module.exports
• ciao-jupiter.js: le definizioni delle funzioni sono messe direttamente come valore delle
proprietà di module.exports
• hello-mars.js: la definizione della funzione viene dichiarata direttamente come una proprietà
di exports che è una versione breve di module.exports
ciao-venus.js
function hello(subject) {
console.log('Venus says Hello ' + subject);
}
module.exports = {
hello: hello
};
Hello-jupiter.js
module.exports = {
hello: function(subject) {
console.log('Jupiter says hello ' + subject);
},
bye: function(subject) {
console.log('Jupiter says goodbye ' + subject);
}
};
https://riptutorial.com/it/home 131
Hello-mars.js
exports.hello = function(subject) {
console.log('Mars says Hello ' + subject);
};
Caricamento del modulo con il nome della directory
Abbiamo una directory chiamata hello che include i seguenti file:
index.js
// hello/index.js
module.exports = function(){
console.log('Hej');
};
main.js
// hello/main.js
// We can include the other files we've defined by using the `require()` method
var hw = require('./hello-world.js'),
hm = require('./hello-mars.js'),
hv = require('./hello-venus.js'),
hj = require('./hello-jupiter.js'),
hu = require('./index.js');
// Because we assigned our function to the entire `module.exports` object, we
// can use it directly
hw('World!'); // outputs "Hello World!"
// In this case, we assigned our function to the `hello` property of exports, so we must
// use that here too
hm.hello('Solar System!'); // outputs "Mars says Hello Solar System!"
// The result of assigning module.exports at once is the same as in hello-world.js
hv.hello('Milky Way!'); // outputs "Venus says Hello Milky Way!"
hj.hello('Universe!'); // outputs "Jupiter says hello Universe!"
hj.bye('Universe!'); // outputs "Jupiter says goodbye Universe!"
hu(); //output 'hej'
Invalida della cache del modulo
In fase di sviluppo, potresti scoprire che l'uso di require() sullo stesso modulo più volte restituisce
sempre lo stesso modulo, anche se hai apportato modifiche a quel file. Questo perché i moduli
vengono memorizzati nella cache la prima volta che vengono caricati e tutti i successivi carichi del
modulo verranno caricati dalla cache.
Per ovviare a questo problema, dovrai delete la voce nella cache. Ad esempio, se hai caricato un
modulo:
https://riptutorial.com/it/home 132
var a = require('./a');
È quindi possibile eliminare la voce della cache:
var rpath = require.resolve('./a.js');
delete require.cache[rpath];
E quindi richiedi di nuovo il modulo:
var a = require('./a');
Si noti che questo non è raccomandato in produzione perché l' delete cancellerà solo il riferimento
al modulo caricato, non i dati caricati stessi. Il modulo non è garbage collection, quindi l'uso
improprio di questa funzione potrebbe portare alla perdita di memoria.
Costruire i tuoi moduli
Puoi anche fare riferimento a un oggetto per esportare pubblicamente e aggiungere
continuamente metodi a quell'oggetto:
const auth = module.exports = {}
const config = require('../config')
const request = require('request')
auth.email = function (data, callback) {
// Authenticate with an email address
}
auth.facebook = function (data, callback) {
// Authenticate with a Facebook account
}
auth.twitter = function (data, callback) {
// Authenticate with a Twitter account
}
auth.slack = function (data, callback) {
// Authenticate with a Slack account
}
auth.stack_overflow = function (data, callback) {
// Authenticate with a Stack Overflow account
}
Per utilizzare uno di questi, basta richiedere il modulo come faresti normalmente:
const auth = require('./auth')
module.exports = function (req, res, next) {
auth.facebook(req.body, function (err, user) {
if (err) return next(err)
req.user = user
next()
https://riptutorial.com/it/home 133
})
}
Ogni modulo iniettato una sola volta
NodeJS esegue il modulo solo la prima volta che lo richiedi. Ogni ulteriore richiesta di funzioni
riutilizzerà lo stesso oggetto, quindi non eseguirà il codice nel modulo un'altra volta. Anche il nodo
memorizza nella cache i moduli la prima volta che vengono caricati utilizzando require. Ciò riduce
il numero di letture di file e aiuta a velocizzare l'applicazione.
myModule.js
console.log(123) ;
exports.var1 = 4 ;
index.js
var a=require('./myModule') ; // Output 123
var b=require('./myModule') ; // No output
console.log(a.var1) ; // Output 4
console.log(b.var1) ; // Output 4
a.var2 = 5 ;
console.log(b.var2) ; // Output 5
Caricamento del modulo da node_modules
I moduli possono essere require d senza utilizzare percorsi relativi inserendoli in una directory
speciale chiamata node_modules .
Ad esempio, per require un modulo chiamato foo da un file index.js , è possibile utilizzare la
seguente struttura di directory:
index.js
\- node_modules
\- foo
|- foo.js
\- package.json
I moduli dovrebbero essere collocati all'interno di una directory, insieme a un file package.json . Il
campo main del file package.json dovrebbe puntare al punto di ingresso per il tuo modulo - questo è
il file che viene importato quando gli utenti lo require('your-module') . main default index.js se non
previsto. In alternativa, è possibile fare riferimento a file in relazione al modulo semplicemente
aggiungendo il percorso relativo alla require chiamata: require('your-module/path/to/file') .
I moduli possono anche require d dalle directory node_modules fino alla gerarchia del file system. Se
abbiamo la seguente struttura di directory:
my-project
\- node_modules
|- foo // the foo module
https://riptutorial.com/it/home 134
\- ...
\- baz // the baz module
\- node_modules
\- bar // the bar module
saremo in grado di require il modulo foo da qualsiasi file all'interno della bar usando require('foo')
.
Si noti che il nodo abbinerà solo il modulo più vicino al file nella gerarchia del filesystem, a partire
da (la directory corrente del file / node_modules). Nodo corrisponde alle directory in questo modo
fino alla radice del file system.
È possibile installare nuovi moduli dal registro di npm o altri registri di npm o crearne di nuovi.
Cartella come modulo
I moduli possono essere suddivisi su molti file .js nella stessa cartella. Un esempio in una cartella
my_module :
function_one.js
module.exports = function() {
return 1;
}
function_two.js
module.exports = function() {
return 2;
}
index.js
exports.f_one = require('./function_one.js');
exports.f_two = require('./function_two.js');
Un modulo come questo viene utilizzato facendo riferimento ad esso dal nome della cartella:
var split_module = require('./my_module');
Si noti che se lo si richiede omettendo ./ o qualsiasi indicazione di un percorso di una cartella
dall'argomento della funzione require, Node proverà a caricare un modulo dalla cartella
node_modules .
In alternativa puoi creare nella stessa cartella un file package.json con questi contenuti:
{
"name": "my_module",
"main": "./your_main_entry_point.js"
}
https://riptutorial.com/it/home 135
In questo modo non è necessario nominare il file del modulo principale "index".
Leggi Esportazione e consumo di moduli online: https://riptutorial.com/it/node-
js/topic/547/esportazione-e-consumo-di-moduli
https://riptutorial.com/it/home 136
Capitolo 35: Esportazione e importazione del
modulo in node.js
Examples
Utilizzando un modulo semplice in node.js
Che cos'è un modulo node.js ( link all'articolo ):
Un modulo incapsula codice correlato in una singola unità di codice. Quando si crea un
modulo, questo può essere interpretato come lo spostamento di tutte le funzioni
correlate in un file.
Ora vediamo un esempio. Immagina che tutti i file siano nella stessa directory:
File: printer.js
"use strict";
exports.printHelloWorld = function (){
console.log("Hello World!!!");
}
Un altro modo di utilizzare i moduli:
File animals.js
"use strict";
module.exports = {
lion: function() {
console.log("ROAARR!!!");
}
};
File: app.js
Esegui questo file andando nella tua directory e digitando: node app.js
"use strict";
//require('./path/to/module.js') node which module to load
var printer = require('./printer');
var animals = require('./animals');
printer.printHelloWorld(); //prints "Hello World!!!"
animals.lion(); //prints "ROAARR!!!"
https://riptutorial.com/it/home 137
Uso delle importazioni in ES6
Node.js è costruito contro le versioni moderne di V8. Aggiornandosi con le ultime versioni di
questo motore, ci assicuriamo che le nuove funzionalità della specifica JavaScript ECMA-262
vengano portate agli sviluppatori di Node.js in modo tempestivo, così come i continui
miglioramenti delle prestazioni e della stabilità.
Tutte le funzioni di ECMAScript 2015 (ES6) sono suddivise in tre gruppi per le funzioni di
spedizione, messa in scena e in corso:
Tutte le funzionalità di spedizione, che V8 considera stabili, sono attivate per impostazione
predefinita su Node.js e NON richiedono alcun tipo di flag di runtime. Le funzionalità messe in
scena, che sono funzionalità quasi completate che non sono considerate stabili dal team V8,
richiedono un flag di runtime: --harmony. Le funzioni in corso possono essere attivate
singolarmente mediante il rispettivo flag di armonia, sebbene questo sia altamente sconsigliato a
meno che non per scopi di test. Nota: questi flag sono esposti da V8 e cambieranno
potenzialmente senza alcun avviso di deprecazione.
Attualmente ES6 supporta le istruzioni di importazione in modo nativo. Fare riferimento qui
Quindi se abbiamo un file chiamato fun.js ...
export default function say(what){
console.log(what);
}
export function sayLoud(whoot) {
say(whoot.toUpperCase());
}
... e se c'era un altro file chiamato app.js cui vogliamo inserire le funzioni precedentemente
definite, ci sono tre modi per importarle.
Importa predefinito
import say from './fun';
say('Hello Stack Overflow!!'); // Output: Hello Stack Overflow!!
Importa la funzione say() perché è contrassegnata come l'esportazione predefinita nel file
sorgente ( export default … )
Importazioni con nome
import { sayLoud } from './fun';
sayLoud('JS modules are awesome.'); // Output: JS MODULES ARE AWESOME.
Le importazioni con nome ci consentono di importare esattamente le parti di un modulo di cui
abbiamo effettivamente bisogno. Lo facciamo nominandoli esplicitamente. Nel nostro caso
nominando sayLoud tra parentesi graffe all'interno della dichiarazione di importazione.
https://riptutorial.com/it/home 138
Importazione in bundle
import * as i from './fun';
i.say('What?'); // Output: What?
i.sayLoud('Whoot!'); // Output: WHOOT!
Se vogliamo avere tutto, questa è la strada da percorrere. Usando la sintassi * as i abbiamo la
dichiarazione di import fornirci un oggetto i che contiene tutte le esportazioni del nostro modulo
fun come proprietà corrispondenti.
percorsi
Tieni presente che devi contrassegnare esplicitamente i percorsi di importazione come percorsi
relativi anche se il file da importare risiedeva nella stessa directory come il file in cui stai
importando utilizzando ./ . Importa da percorsi non prefissati come
import express from 'express';
verrà cercato nelle cartelle node_modules locali e globali e genererà un errore se non viene trovato
alcun modulo corrispondente.
Esportazione con sintassi ES6
Questo è l'equivalente dell'altro esempio, ma usando ES6.
export function printHelloWorld() {
console.log("Hello World!!!");
}
Leggi Esportazione e importazione del modulo in node.js online: https://riptutorial.com/it/node-
js/topic/1173/esportazione-e-importazione-del-modulo-in-node-js
https://riptutorial.com/it/home 139
Capitolo 36: Eventloop
introduzione
In questo post discuteremo come è emerso il concetto di Eventloop e come può essere utilizzato
per server ad alte prestazioni e applicazioni guidate da eventi come le GUI.
Examples
Come si è evoluto il concetto di event loop.
Eventloop in pseudo codice
Un ciclo di eventi è un ciclo che attende gli eventi e quindi reagisce a quegli eventi
while true:
wait for something to happen
react to whatever happened
Esempio di un server HTTP a thread singolo
senza loop di eventi
while true:
socket = wait for the next TCP connection
read the HTTP request headers from (socket)
file_contents = fetch the requested file from disk
write the HTTP response headers to (socket)
write the (file_contents) to (socket)
close(socket)
Ecco una semplice forma di un server HTTP che è un singolo thread ma nessun ciclo di eventi. Il
problema qui è che attende fino a quando ogni richiesta è terminata prima di iniziare a elaborare il
successivo. Se è necessario un po 'di tempo per leggere le intestazioni delle richieste HTTP o per
recuperare il file dal disco, dovremmo essere in grado di avviare l'elaborazione della richiesta
successiva mentre attendiamo che finisca.
La soluzione più comune è rendere il programma multi-threaded.
Esempio di un server HTTP multi-thread con
nessun ciclo di eventi
https://riptutorial.com/it/home 140
function handle_connection(socket):
read the HTTP request headers from (socket)
file_contents = fetch the requested file from disk
write the HTTP response headers to (socket)
write the (file_contents) to (socket)
close(socket)
while true:
socket = wait for the next TCP connection
spawn a new thread doing handle_connection(socket)
Ora abbiamo reso il nostro piccolo server HTTP multi thread. In questo modo, possiamo passare
immediatamente alla richiesta successiva perché la richiesta corrente è in esecuzione in un thread
in background. Molti server, incluso Apache, utilizzano questo approccio.
Ma non è perfetto. Una limitazione è che puoi generare solo tanti thread. Per carichi di lavoro in
cui si dispone di un numero enorme di connessioni, ma ogni connessione richiede solo
l'attenzione di tanto in tanto, il modello multi-thread non funzionerà molto bene. La soluzione per
questi casi è utilizzare un ciclo di eventi:
Esempio di un server HTTP con ciclo di
eventi
while true:
event = wait for the next event to happen
if (event.type == NEW_TCP_CONNECTION):
conn = new Connection
conn.socket = event.socket
start reading HTTP request headers from (conn.socket) with userdata = (conn)
else if (event.type == FINISHED_READING_FROM_SOCKET):
conn = event.userdata
start fetching the requested file from disk with userdata = (conn)
else if (event.type == FINISHED_READING_FROM_DISK):
conn = event.userdata
conn.file_contents = the data we fetched from disk
conn.current_state = "writing headers"
start writing the HTTP response headers to (conn.socket) with userdata = (conn)
else if (event.type == FINISHED_WRITING_TO_SOCKET):
conn = event.userdata
if (conn.current_state == "writing headers"):
conn.current_state = "writing file contents"
start writing (conn.file_contents) to (conn.socket) with userdata = (conn)
else if (conn.current_state == "writing file contents"):
close(conn.socket)
Speriamo che questo pseudocodice sia comprensibile. Ecco cosa sta succedendo: Aspettiamo
che le cose accadano. Ogni volta che viene creata una nuova connessione o una connessione
esistente richiede la nostra attenzione, ci occupiamo di essa, quindi torniamo ad aspettare. In
questo modo, ci comportiamo bene quando ci sono molte connessioni e ognuna raramente
richiede attenzione.
In un'applicazione reale (non pseudocodice) in esecuzione su Linux, la parte "aspetta che
https://riptutorial.com/it/home 141
succeda l'evento successivo" sarebbe implementata chiamando la chiamata di sistema poll () o
epoll (). Le parti "inizia a leggere / scrivere qualcosa su un socket" sarebbero implementate
chiamando le chiamate di sistema recv () o send () in modalità non bloccante.
Riferimento:
[1]. "Come funziona un ciclo di eventi?" [In linea]. Disponibile: https://www.quora.com/How-does-
an-event-loop-work
Leggi Eventloop online: https://riptutorial.com/it/node-js/topic/8652/eventloop
https://riptutorial.com/it/home 142
Capitolo 37: Evita l'inferno del callback
Examples
Modulo asincrono
La fonte è disponibile per il download da GitHub. In alternativa, puoi installare usando npm:
$ npm install --save async
Oltre a usare Bower:
$ bower installa async
Esempio:
var async = require("async");
async.parallel([
function(callback) { ... },
function(callback) { ... }
], function(err, results) {
// optional callback
});
Modulo asincrono
Per fortuna esistono librerie come Async.js per cercare di arginare il problema. Async aggiunge un
sottile strato di funzioni in cima al codice, ma può ridurre notevolmente la complessità evitando il
nesting di callback.
Esistono molti metodi di supporto in Async che possono essere utilizzati in diverse situazioni,
come serie, parallelo, cascata, ecc. Ogni funzione ha un caso d'uso specifico, quindi prenditi un
po 'di tempo per imparare quale aiuterà in quali situazioni.
Buono come Async, come qualsiasi cosa, non è perfetto. È molto facile lasciarsi trasportare dalla
combinazione di serie, parallelo, per sempre, ecc., A quel punto si è di nuovo a destra dove hai
iniziato con il codice disordinato. Fai attenzione a non ottimizzarlo prematuramente. Solo perché
alcune attività asincrone possono essere eseguite in parallelo non sempre significa che
dovrebbero. In realtà, poiché il nodo è solo a thread singolo, l'esecuzione di attività in parallelo
sull'utilizzo di Async ha un guadagno di prestazioni minimo o nullo.
La fonte è disponibile per il download da https://github.com/caolan/async . In alternativa, puoi
installare usando npm:
$ npm install --save async
Oltre a usare Bower:
https://riptutorial.com/it/home 143
$ bower installa async
Esempio di cascata di Async:
var fs = require('fs');
var async = require('async');
var myFile = '/tmp/test';
async.waterfall([
function(callback) {
fs.readFile(myFile, 'utf8', callback);
},
function(txt, callback) {
txt = txt + '\nAppended something!';
fs.writeFile(myFile, txt, callback);
}
], function (err, result) {
if(err) return console.log(err);
console.log('Appended text!');
});
Leggi Evita l'inferno del callback online: https://riptutorial.com/it/node-js/topic/10045/evita-l-inferno-
del-callback
https://riptutorial.com/it/home 144
Capitolo 38: File system I / O
Osservazioni
In Node.js, le operazioni intensive come l'I / O vengono eseguite in modo asincrono , ma hanno
una controparte sincrona (es. Esiste un file fs.readFile e la sua controparte è fs.readFileSync ).
Poiché il nodo è a thread singolo, è necessario prestare attenzione quando si utilizzano le
operazioni sincrone , poiché bloccano l'intero processo.
Se un processo è bloccato da un'operazione sincrona, viene interrotto l'intero ciclo di esecuzione
(incluso il ciclo degli eventi). Ciò significa che non verranno eseguiti altri codici asincroni, inclusi
eventi e gestori di eventi, e il programma continuerà ad attendere fino al completamento
dell'operazione di blocco singolo.
Vi sono usi appropriati sia per le operazioni sincrone che asincrone, ma occorre fare attenzione
che vengano utilizzati correttamente.
Examples
Scrivere su un file usando writeFile o writeFileSync
var fs = require('fs');
// Save the string "Hello world!" in a file called "hello.txt" in
// the directory "/tmp" using the default encoding (utf8).
// This operation will be completed in background and the callback
// will be called when it is either done or failed.
fs.writeFile('/tmp/hello.txt', 'Hello world!', function(err) {
// If an error occurred, show it and return
if(err) return console.error(err);
// Successfully wrote to the file!
});
// Save binary data to a file called "binary.txt" in the current
// directory. Again, the operation will be completed in background.
var buffer = new Buffer([ 0x48, 0x65, 0x6c, 0x6c, 0x6f ]);
fs.writeFile('binary.txt', buffer, function(err) {
// If an error occurred, show it and return
if(err) return console.error(err);
// Successfully wrote binary contents to the file!
});
fs.writeFileSync comporta in modo simile a fs.writeFile , ma non fs.writeFile una richiamata
poiché completa in modo sincrono e quindi blocca il thread principale. La maggior parte degli
sviluppatori di node.js preferiscono le varianti asincrone che non causeranno praticamente alcun
ritardo nell'esecuzione del programma.
Nota: il blocco del thread principale è una pratica scorretta in node.js. La funzione sincrona deve
essere utilizzata solo durante il debug o quando non sono disponibili altre opzioni.
https://riptutorial.com/it/home 145
// Write a string to another file and set the file mode to 0755
try {
fs.writeFileSync('sync.txt', 'anni', { mode: 0o755 });
} catch(err) {
// An error occurred
console.error(err);
}
Leggi in modo asincrono dai file
Usa il modulo del filesystem per tutte le operazioni sui file:
const fs = require('fs');
Con codifica
In questo esempio, leggi hello.txt dalla directory /tmp . Questa operazione sarà completata in
background e il callback si verifica al completamento o al fallimento:
fs.readFile('/tmp/hello.txt', { encoding: 'utf8' }, (err, content) => {
// If an error occurred, output it and return
if(err) return console.error(err);
// No error occurred, content is a string
console.log(content);
});
Senza codifica
Leggi il file binary.txt binario dalla directory corrente, in modo asincrono sullo sfondo. Nota che
non impostiamo l'opzione 'encoding' - questo impedisce a Node.js di decodificare il contenuto in
una stringa:
fs.readFile('binary', (err, binaryContent) => {
// If an error occurred, output it and return
if(err) return console.error(err);
// No error occurred, content is a Buffer, output it in
// hexadecimal representation.
console.log(content.toString('hex'));
});
Percorsi relativi
Tieni presente che, in generale, lo script può essere eseguito con una directory di lavoro corrente
arbitraria. Per indirizzare un file relativo allo script corrente, usa __dirname o __filename :
fs.readFile(path.resolve(__dirname, 'someFile'), (err, binaryContent) => {
https://riptutorial.com/it/home 146
//Rest of Function
}
Elenco dei contenuti della directory con readdir o readdirSync
const fs = require('fs');
// Read the contents of the directory /usr/local/bin asynchronously.
// The callback will be invoked once the operation has either completed
// or failed.
fs.readdir('/usr/local/bin', (err, files) => {
// On error, show it and return
if(err) return console.error(err);
// files is an array containing the names of all entries
// in the directory, excluding '.' (the directory itself)
// and '..' (the parent directory).
// Display directory entries
console.log(files.join(' '));
});
Una variante sincrona è disponibile come readdirSync che blocca il thread principale e quindi
impedisce l'esecuzione di codice asincrono allo stesso tempo. La maggior parte degli sviluppatori
evita le funzioni di I / O sincrone per migliorare le prestazioni.
let files;
try {
files = fs.readdirSync('/var/tmp');
} catch(err) {
// An error occurred
console.error(err);
}
Utilizzando un generatore
const fs = require('fs');
// Iterate through all items obtained via
// 'yield' statements
// A callback is passed to the generator function because it is required by
// the 'readdir' method
function run(gen) {
var iter = gen((err, data) => {
if (err) { iter.throw(err); }
return iter.next(data);
});
iter.next();
}
const dirPath = '/usr/local/bin';
https://riptutorial.com/it/home 147
// Execute the generator function
run(function* (resume) {
// Emit the list of files in the directory from the generator
var contents = yield fs.readdir(dirPath, resume);
console.log(contents);
});
Lettura da un file in modo sincrono
Per qualsiasi operazione sui file, è necessario il modulo filesystem:
const fs = require('fs');
Leggere una stringa
fs.readFileSync comporta in modo simile a fs.readFile , ma non fs.readFile una richiamata poiché
completa in modo sincrono e quindi blocca il thread principale. La maggior parte degli sviluppatori
di node.js preferiscono le varianti asincrone che non causeranno praticamente alcun ritardo
nell'esecuzione del programma.
Se viene specificata un'opzione di encoding , verrà restituita una stringa, altrimenti verrà restituito
un Buffer .
// Read a string from another file synchronously
let content;
try {
content = fs.readFileSync('sync.txt', { encoding: 'utf8' });
} catch(err) {
// An error occurred
console.error(err);
}
Eliminazione di un file utilizzando lo scollegamento o lo scollegamento
sincronizzato
Elimina un file in modo asincrono:
var fs = require('fs');
fs.unlink('/path/to/file.txt', function(err) {
if (err) throw err;
console.log('file deleted');
});
Puoi anche eliminarlo in modo sincrono *:
var fs = require('fs');
fs.unlinkSync('/path/to/file.txt');
https://riptutorial.com/it/home 148
console.log('file deleted');
* evitare i metodi sincroni perché bloccano l'intero processo fino al termine dell'esecuzione.
Lettura di un file in un buffer utilizzando i flussi
Mentre leggendo il contenuto da un file è già asincrono usando il metodo fs.readFile() , a volte
vogliamo ottenere i dati in un flusso rispetto a un semplice callback. Questo ci consente di
convogliare questi dati in altre posizioni o di elaborarli al loro interno rispetto a tutti in una volta alla
fine.
const fs = require('fs');
// Store file data chunks in this array
let chunks = [];
// We can use this variable to store the final data
let fileBuffer;
// Read file into stream.Readable
let fileStream = fs.createReadStream('text.txt');
// An error occurred with the stream
fileStream.once('error', (err) => {
// Be sure to handle this properly!
console.error(err);
});
// File is done being read
fileStream.once('end', () => {
// create the final data Buffer from data chunks;
fileBuffer = Buffer.concat(chunks);
// Of course, you can do anything else you need to here, like emit an event!
});
// Data is flushed from fileStream in chunks,
// this callback will be executed for each chunk
fileStream.on('data', (chunk) => {
chunks.push(chunk); // push data chunk to array
// We can perform actions on the partial data we have so far!
});
Verifica le autorizzazioni di un file o di una directory
fs.access() determina se esiste un percorso e quali autorizzazioni ha un utente per il file o la
directory in quel percorso. fs.access non restituisce un risultato piuttosto, se non restituisce un
errore, il percorso esiste e l'utente ha le autorizzazioni desiderate.
Le modalità di autorizzazione sono disponibili come proprietà sull'oggetto fs , fs.constants
• - Ha fs.constants.F_OK lettura / scrittura / esecuzione (se non viene fornita
fs.constants.F_OK
alcuna modalità, questa è l'impostazione predefinita)
• fs.constants.R_OK - Ha permessi di lettura
https://riptutorial.com/it/home 149
• fs.constants.W_OK - Ha permessi di scrittura
• fs.constants.X_OK - Ha permessi di esecuzione (Funziona come fs.constants.F_OK su
Windows)
in modo asincrono
var fs = require('fs');
var path = '/path/to/check';
// checks execute permission
fs.access(path, fs.constants.X_OK, (err) => {
if (err) {
console.log("%s doesn't exist", path);
} else {
console.log('can execute %s', path);
}
});
// Check if we have read/write permissions
// When specifying multiple permission modes
// each mode is separated by a pipe : `|`
fs.access(path, fs.constants.R_OK | fs.constants.W_OK, (err) => {
if (err) {
console.log("%s doesn't exist", path);
} else {
console.log('can read/write %s', path);
}
});
sincrono
fs.accessha anche una versione sincrona fs.accessSync . Quando si utilizza fs.accessSync è
necessario racchiuderlo all'interno di un blocco try / catch.
// Check write permission
try {
fs.accessSync(path, fs.constants.W_OK);
console.log('can write %s', path);
}
catch (err) {
console.log("%s doesn't exist", path);
}
Evitare le condizioni di gara durante la creazione o l'utilizzo di una directory
esistente
A causa della natura asincrona del nodo, creando o utilizzando una directory prima:
1. controllando la sua esistenza con fs.stat() , quindi
2. creandolo o usandolo in base ai risultati del controllo di esistenza,
https://riptutorial.com/it/home 150
può portare a una condizione di competizione se la cartella viene creata tra il momento del
controllo e l'ora della creazione. Il metodo riportato di seguito fs.mkdir() e fs.mkdirSync() in
wrapper che catturano gli errori che consentono il passaggio dell'eccezione se il codice è EEXIST
(già esistente). Se l'errore è qualcos'altro, come EPERM (pemission negato), lancia o passa un
errore come fanno le funzioni native.
Versione asincrona con fs.mkdir()
var fs = require('fs');
function mkdir (dirPath, callback) {
fs.mkdir(dirPath, (err) => {
callback(err && err.code !== 'EEXIST' ? err : null);
});
}
mkdir('./existingDir', (err) => {
if (err)
return console.error(err.code);
// Do something with `./existingDir` here
});
Versione sincrona con fs.mkdirSync()
function mkdirSync (dirPath) {
try {
fs.mkdirSync(dirPath);
} catch(e) {
if ( e.code !== 'EEXIST' ) throw e;
}
}
mkdirSync('./existing-dir');
// Do something with `./existing-dir` now
Verifica se esiste un file o una directory
in modo asincrono
var fs = require('fs');
fs.stat('path/to/file', function(err) {
if (!err) {
console.log('file or directory exists');
}
else if (err.code === 'ENOENT') {
console.log('file or directory does not exist');
}
});
https://riptutorial.com/it/home 151
sincrono
qui, dobbiamo racchiudere la chiamata di funzione in un blocco try/catch per gestire l'errore.
var fs = require('fs');
try {
fs.statSync('path/to/file');
console.log('file or directory exists');
}
catch (err) {
if (err.code === 'ENOENT') {
console.log('file or directory does not exist');
}
}
Clonazione di un file utilizzando i flussi
Questo programma illustra come è possibile copiare un file utilizzando flussi leggibili e scrivibili
utilizzando le createReadStream() e createWriteStream() fornite dal modulo del file system.
//Require the file System module
var fs = require('fs');
/*
Create readable stream to file in current directory (__dirname) named 'node.txt'
Use utf8 encoding
Read the data in 16-kilobyte chunks
*/
var readable = fs.createReadStream(__dirname + '/node.txt', { encoding: 'utf8', highWaterMark:
16 * 1024 });
// create writable stream
var writable = fs.createWriteStream(__dirname + '/nodeCopy.txt');
// Write each chunk of data to the writable stream
readable.on('data', function(chunk) {
writable.write(chunk);
});
Copia di file tramite streaming di piping
Questo programma copia un file utilizzando un flusso leggibile e scrivibile con la funzione pipe()
fornita dalla classe stream
// require the file system module
var fs = require('fs');
/*
Create readable stream to file in current directory named 'node.txt'
Use utf8 encoding
Read the data in 16-kilobyte chunks
*/
var readable = fs.createReadStream(__dirname + '/node.txt', { encoding: 'utf8', highWaterMark:
https://riptutorial.com/it/home 152
16 * 1024 });
// create writable stream
var writable = fs.createWriteStream(__dirname + '/nodePipe.txt');
// use pipe to copy readable to writable
readable.pipe(writable);
Modifica del contenuto di un file di testo
Esempio. Sostituirà la parola email con un name in un file di testo index.txt con la semplice
replace(/email/gim, 'name') RegExp replace(/email/gim, 'name')
var fs = require('fs');
fs.readFile('index.txt', 'utf-8', function(err, data) {
if (err) throw err;
var newValue = data.replace(/email/gim, 'name');
fs.writeFile('index.txt', newValue, 'utf-8', function(err, data) {
if (err) throw err;
console.log('Done!');
})
})
Determinazione del numero di righe di un file di testo
app.js
const readline = require('readline');
const fs = require('fs');
var file = 'path.to.file';
var linesCount = 0;
var rl = readline.createInterface({
input: fs.createReadStream(file),
output: process.stdout,
terminal: false
});
rl.on('line', function (line) {
linesCount++; // on each linebreak, add +1 to 'linesCount'
});
rl.on('close', function () {
console.log(linesCount); // print the result when the 'close' event is called
});
Uso:
nodo app
Leggere un file riga per riga
https://riptutorial.com/it/home 153
app.js
const readline = require('readline');
const fs = require('fs');
var file = 'path.to.file';
var rl = readline.createInterface({
input: fs.createReadStream(file),
output: process.stdout,
terminal: false
});
rl.on('line', function (line) {
console.log(line) // print the content of the line on each linebreak
});
Uso:
nodo app
Leggi File system I / O online: https://riptutorial.com/it/node-js/topic/489/file-system-i---o
https://riptutorial.com/it/home 154
Capitolo 39: Gestione degli errori di Node.js
introduzione
Impareremo come creare oggetti Error e come lanciare e gestire gli errori in Node.js
Modifiche future relative alle migliori pratiche nella gestione degli errori.
Examples
Creazione dell'oggetto Error
nuovo errore (messaggio)
Crea un nuovo oggetto errore, in cui il message del valore viene impostato sulla proprietà del
message dell'oggetto creato. Di solito gli argomenti del message vengono passati al costruttore Error
come stringa. Tuttavia, se l'argomento del message è oggetto non una stringa, il costruttore Error
chiama il metodo .toString() dell'oggetto passato e lo imposta sulla proprietà message dell'oggetto
error creato.
var err = new Error("The error message");
console.log(err.message); //prints: The error message
console.log(err);
//output
//Error: The error message
// at ...
Ogni oggetto di errore ha una traccia di stack. La traccia di stack contiene le informazioni del
messaggio di errore e mostra dove si è verificato l'errore (l'output sopra mostra lo stack di errori).
Una volta creato l'oggetto errore, il sistema acquisisce la traccia dello stack dell'errore sulla linea
corrente. Per ottenere la traccia dello stack, utilizzare la proprietà stack di qualsiasi oggetto di
errore creato. Sotto due righe sono identiche:
console.log(err);
console.log(err.stack);
Errore di lancio
Errore di lancio significa eccezione se nessuna eccezione viene gestita, quindi il server nodo si
bloccherà.
La seguente riga genera un errore:
throw new Error("Some error occurred");
https://riptutorial.com/it/home 155
var err = new Error("Some error occurred");
throw err;
throw "Some error occurred";
L'ultimo esempio (tirare le stringhe) non è una buona pratica e non è raccomandato (genera
sempre errori che sono istanze di oggetto Error).
Si noti che se si throw un errore nel proprio, allora il sistema si bloccherà su quella linea (se non ci
sono gestori di eccezioni), nessun codice verrà eseguito dopo quella linea.
var a = 5;
var err = new Error("Some error message");
throw err; //this will print the error stack and node server will stop
a++; //this line will never be executed
console.log(a); //and this one also
Ma in questo esempio:
var a = 5;
var err = new Error("Some error message");
console.log(err); //this will print the error stack
a++;
console.log(a); //this line will be executed and will print 6
prova ... cattura blocco
prova ... il blocco catch è per la gestione delle eccezioni, ricorda che l'eccezione indica l'errore
generato non l'errore.
try {
var a = 1;
b++; //this will cause an error because be is undefined
console.log(b); //this line will not be executed
} catch (error) {
console.log(error); //here we handle the error caused in the try block
}
Nel blocco try b++ causano un errore e quell'errore è passato a catch block che può essere gestito
lì o addirittura può essere generato lo stesso errore nel catch block o apportare modifiche di poco
valore e quindi lanciare. Vediamo il prossimo esempio.
try {
var a = 1;
b++;
console.log(b);
} catch (error) {
error.message = "b variable is undefined, so the undefined can't be incremented"
throw error;
}
https://riptutorial.com/it/home 156
Nell'esempio sopra abbiamo modificato la proprietà message dell'oggetto error e poi lanciato l' error
modificato.
È possibile attraverso qualsiasi errore nel blocco try e gestirlo nel blocco catch:
try {
var a = 1;
throw new Error("Some error message");
console.log(a); //this line will not be executed;
} catch (error) {
console.log(error); //will be the above thrown error
}
Leggi Gestione degli errori di Node.js online: https://riptutorial.com/it/node-js/topic/8590/gestione-
degli-errori-di-node-js
https://riptutorial.com/it/home 157
Capitolo 40: Gestire la richiesta POST in
Node.js
Osservazioni
Node.js utilizza gli stream per gestire i dati in arrivo.
Citando dai documenti,
Un flusso è un'interfaccia astratta per lavorare con i dati di streaming in Node.js. Il
modulo stream fornisce un'API di base che semplifica la creazione di oggetti che
implementano l'interfaccia di streaming.
Per gestire il corpo di richiesta di una richiesta POST, utilizzare l'oggetto request , che è un flusso
leggibile. I flussi di dati vengono emessi come eventi di data sull'oggetto request .
request.on('data', chunk => {
buffer += chunk;
});
request.on('end', () => {
// POST request body is now available as `buffer`
});
Basta creare una stringa di buffer vuota e aggiungere i dati del buffer come ricevuti tramite eventi
di data .
NOTA
1. I dati del buffer ricevuti sugli eventi dei data sono di tipo Buffer
2. Crea una nuova stringa di buffer per raccogliere dati bufferizzati da eventi di dati per ogni
richiesta, ovvero crea buffer stringa di buffer all'interno del gestore di richieste.
Examples
Esempio di server node.js che gestisce solo le richieste POST
'use strict';
const http = require('http');
const PORT = 8080;
const server = http.createServer((request, response) => {
let buffer = '';
request.on('data', chunk => {
buffer += chunk;
});
request.on('end', () => {
const responseString = `Received string ${buffer}`;
https://riptutorial.com/it/home 158
console.log(`Responding with: ${responseString}`);
response.writeHead(200, "Content-Type: text/plain");
response.end(responseString);
});
}).listen(PORT, () => {
console.log(`Listening on ${PORT}`);
});
Leggi Gestire la richiesta POST in Node.js online: https://riptutorial.com/it/node-
js/topic/5676/gestire-la-richiesta-post-in-node-js
https://riptutorial.com/it/home 159
Capitolo 41: Gestore pacchetti filati
introduzione
Yarn è un gestore di pacchetti per Node.js, simile a npm. Pur condividendo un sacco di terreno
comune, ci sono alcune differenze chiave tra Yarn e npm.
Examples
Installazione del filato
Questo esempio spiega i diversi metodi per installare Yarn per il tuo sistema operativo.
Mac OS
homebrew
brew update
brew install yarn
MacPorts
sudo port install yarn
Aggiunta di filati al PERCORSO
Aggiungi quanto segue al tuo profilo di shell preferito ( .profile , .bashrc , .zshrc etc)
export PATH="$PATH:`yarn global bin`"
finestre
Installer
Innanzitutto, installa Node.js se non è già installato.
Scarica il programma di installazione di Yarn come .msi dal sito Web di Yarn .
cioccolatoso
https://riptutorial.com/it/home 160
choco install yarn
Linux
Debian / Ubuntu
Assicurati che Node.js sia installato per la tua distribuzione, o esegui quanto segue
curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -
sudo apt-get install -y nodejs
Configura il repository YarnPkg
curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | sudo apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | sudo tee
/etc/apt/sources.list.d/yarn.list
Installa il filo
sudo apt-get update && sudo apt-get install yarn
CentOS / Fedora / RHEL
Installa Node.js se non è già installato
curl --silent --location https://rpm.nodesource.com/setup_6.x | bash -
Installa il filo
sudo wget https://dl.yarnpkg.com/rpm/yarn.repo -O /etc/yum.repos.d/yarn.repo
sudo yum install yarn
Arco
Installa il filo tramite AUR.
Esempio usando yaourt:
yaourt -S yarn
Solus
sudo eopkg install yarn
https://riptutorial.com/it/home 161
Tutte le distribuzioni
Aggiungi quanto segue al tuo profilo di shell preferito ( .profile , .bashrc , .zshrc etc)
export PATH="$PATH:`yarn global bin`"
Metodo alternativo di installazione
Script di shell
curl -o- -L https://yarnpkg.com/install.sh | bash
o specificare una versione da installare
curl -o- -L https://yarnpkg.com/install.sh | bash -s -- --version [version]
tarball
cd /opt
wget https://yarnpkg.com/latest.tar.gz
tar zvxf latest.tar.gz
npm
Se hai già installato npm, esegui semplicemente
npm install -g yarn
Post installazione
Controlla la versione installata di Yarn eseguendo
yarn --version
Creare un pacchetto base
Il comando yarn init ti guiderà attraverso la creazione di un file package.json per configurare
alcune informazioni sul tuo pacchetto. Questo è simile al comando npm init in npm.
Crea e naviga in una nuova directory per conservare il tuo pacchetto, quindi esegui yarn init
https://riptutorial.com/it/home 162
mkdir my-package && cd my-package
yarn init
Rispondi alle domande che seguono nella CLI
question name (my-package): my-package
question version (1.0.0):
question description: A test package
question entry point (index.js):
question repository url:
question author: StackOverflow Documentation
question license (MIT):
success Saved package.json
Done in 27.31s.
Questo genererà un file package.json simile al seguente
{
"name": "my-package",
"version": "1.0.0",
"description": "A test package",
"main": "index.js",
"author": "StackOverflow Documentation",
"license": "MIT"
}
Ora proviamo ad aggiungere una dipendenza. La sintassi di base per questo è il yarn add
[package-name]
Eseguire il comando seguente per installare ExpressJS
yarn add express
Questo aggiungerà una sezione delle dependencies al package.json e aggiungerà ExpressJS
"dependencies": {
"express": "^4.15.2"
}
Installa il pacchetto con Yarn
Il filato usa lo stesso registro usato da npm. Ciò significa che ogni pacchetto disponibile su npm è
lo stesso su Yarn.
Per installare un pacchetto, esegui il yarn add package .
Se hai bisogno di una versione specifica del pacchetto, puoi utilizzare il yarn add package@version .
Se la versione che è necessario installare è stata taggata, è possibile utilizzare il yarn add
package@tag .
Leggi Gestore pacchetti filati online: https://riptutorial.com/it/node-js/topic/9441/gestore-pacchetti-
filati
https://riptutorial.com/it/home 163
Capitolo 42: grugnito
Osservazioni
Ulteriori letture:
La guida Installazione grunt contiene informazioni dettagliate sull'installazione di versioni
specifiche, di produzione o in fase di sviluppo di Grunt e grunt-cli.
La guida Configurazione delle attività contiene una spiegazione approfondita su come configurare
attività, destinazioni, opzioni e file all'interno del Gruntfile, insieme a una spiegazione di modelli,
modelli di globbing e importazione di dati esterni.
La guida Creazione delle attività elenca le differenze tra i tipi di attività di Grunt e mostra un
numero di attività e configurazioni di esempio.
Examples
Introduzione a GruntJs
Grunt è un Task Runer JavaScript, utilizzato per l'automazione di attività ripetitive come
minification, compilation, unit test, linting, ecc.
Per iniziare, ti consigliamo di installare l'interfaccia a riga di comando (CLI) di Grunt a livello
globale.
npm install -g grunt-cli
Preparazione di un nuovo progetto Grunt: una configurazione tipica prevede l'aggiunta di due
file al progetto: package.json e Gruntfile.
package.json: questo file viene utilizzato da npm per memorizzare i metadati per i progetti
pubblicati come moduli npm. Elencherai i plugin Grunt e Grunt necessari per il tuo progetto come
devDependencies in questo file.
Gruntfile: questo file è denominato Gruntfile.js e viene utilizzato per configurare o definire attività e
caricare plugin Grunt.
Example package.json:
{
"name": "my-project-name",
"version": "0.1.0",
"devDependencies": {
"grunt": "~0.4.5",
"grunt-contrib-jshint": "~0.10.0",
"grunt-contrib-nodeunit": "~0.4.1",
"grunt-contrib-uglify": "~0.5.0"
https://riptutorial.com/it/home 164
}
}
Esempio gruntfile:
module.exports = function(grunt) {
// Project configuration.
grunt.initConfig({
pkg: grunt.file.readJSON('package.json'),
uglify: {
options: {
banner: '/*! <%= pkg.name %> <%= grunt.template.today("yyyy-mm-dd") %> */\n'
},
build: {
src: 'src/<%= pkg.name %>.js',
dest: 'build/<%= pkg.name %>.min.js'
}
}
});
// Load the plugin that provides the "uglify" task.
grunt.loadNpmTasks('grunt-contrib-uglify');
// Default task(s).
grunt.registerTask('default', ['uglify']);
};
Installazione di gruntplugins
Aggiungere dipendenza
Per usare un gruntplugin, devi prima aggiungerlo come dipendenza al tuo progetto. Usiamo il
plugin jshint come esempio.
npm install grunt-contrib-jshint --save-dev
L'opzione --save-dev viene utilizzata per aggiungere il plug-in in package.json , in questo modo il
plug-in viene sempre installato dopo l' npm install .
Caricamento del plugin
Puoi caricare il tuo plugin nel file loadNpmTasks usando loadNpmTasks .
grunt.loadNpmTasks('grunt-contrib-jshint');
Configurazione dell'attività
Si configura l'attività nel gruntfile aggiungendo una proprietà chiamata jshint all'oggetto passato a
grunt.initConfig .
grunt.initConfig({
https://riptutorial.com/it/home 165
jshint: {
all: ['Gruntfile.js', 'lib/**/*.js', 'test/**/*.js']
}
});
Non dimenticare che puoi avere altre proprietà per altri plugin che stai utilizzando.
Esecuzione dell'attività
Per eseguire semplicemente l'attività con il plugin è possibile utilizzare la riga di comando.
grunt jshint
Oppure puoi aggiungere jshint a un'altra attività.
grunt.registerTask('default', ['jshint']);
L'attività predefinita viene eseguita con il comando grunt nel terminale senza alcuna opzione.
Leggi grugnito online: https://riptutorial.com/it/node-js/topic/6059/grugnito
https://riptutorial.com/it/home 166
Capitolo 43: Guida per principianti NodeJS
Examples
Ciao mondo !
Inserire il seguente codice in un nome di file helloworld.js
console.log("Hello World");
Salva il file ed eseguilo tramite Node.js:
node helloworld.js
Leggi Guida per principianti NodeJS online: https://riptutorial.com/it/node-js/topic/7693/guida-per-
principianti-nodejs
https://riptutorial.com/it/home 167
Capitolo 44: Hack
Examples
Aggiungi nuove estensioni da richiedere ()
È possibile aggiungere nuove estensioni a require() estendendo require.extensions .
Per un esempio XML :
// Add .xml for require()
require.extensions['.xml'] = (module, filename) => {
const fs = require('fs')
const xml2js = require('xml2js')
module.exports = (callback) => {
// Read required file.
fs.readFile(filename, 'utf8', (err, data) => {
if (err) {
callback(err)
return
}
// Parse it.
xml2js.parseString(data, (err, result) => {
callback(null, result)
})
})
}
}
Se il contenuto di hello.xml è il seguente:
<?xml version="1.0" encoding="UTF-8"?>
<foo>
<bar>baz</bar>
<qux />
</foo>
Puoi leggerlo e analizzarlo tramite require() :
require('./hello')((err, xml) {
if (err)
throw err;
console.log(err);
})
{ foo: { bar: [ 'baz' ], qux: [ '' ] } } .
Leggi Hack online: https://riptutorial.com/it/node-js/topic/6645/hack
https://riptutorial.com/it/home 168
Capitolo 45: http
Examples
server http
Un esempio di base del server HTTP.
scrivi il seguente codice nel file http_server.js:
var http = require('http');
var httpPort = 80;
http.createServer(handler).listen(httpPort, start_callback);
function handler(req, res) {
var clientIP = req.connection.remoteAddress;
var connectUsing = req.connection.encrypted ? 'SSL' : 'HTTP';
console.log('Request received: '+ connectUsing + ' ' + req.method + ' ' + req.url);
console.log('Client IP: ' + clientIP);
res.writeHead(200, "OK", {'Content-Type': 'text/plain'});
res.write("OK");
res.end();
return;
}
function start_callback(){
console.log('Start HTTP on port ' + httpPort)
}
quindi dalla tua posizione http_server.js esegui questo comando:
node http_server.js
dovresti vedere questo risultato:
> Start HTTP on port 80
ora devi testare il tuo server, devi aprire il tuo browser internet e navigare verso questo URL:
http://127.0.0.1:80
se la tua macchina esegue un server Linux puoi testarlo in questo modo:
curl 127.0.0.1:80
dovresti vedere il seguente risultato:
https://riptutorial.com/it/home 169
ok
nella tua console, che esegue l'app, vedrai questi risultati:
> Request received: HTTP GET /
> Client IP: ::ffff:127.0.0.1
client http
un esempio di base per il client http:
scrivi il codice follwing nel file http_client.js:
var http = require('http');
var options = {
hostname: '127.0.0.1',
port: 80,
path: '/',
method: 'GET'
};
var req = http.request(options, function(res) {
console.log('STATUS: ' + res.statusCode);
console.log('HEADERS: ' + JSON.stringify(res.headers));
res.setEncoding('utf8');
res.on('data', function (chunk) {
console.log('Response: ' + chunk);
});
res.on('end', function (chunk) {
console.log('Response ENDED');
});
});
req.on('error', function(e) {
console.log('problem with request: ' + e.message);
});
req.end();
quindi dalla tua posizione http_client.js esegui questo comando:
node http_client.js
dovresti vedere questo risultato:
> STATUS: 200
> HEADERS: {"content-type":"text/plain","date":"Thu, 21 Jul 2016 11:27:17
GMT","connection":"close","transfer-encoding":"chunked"}
> Response: OK
> Response ENDED
nota: questo esempio dipende dall'esempio del server http.
https://riptutorial.com/it/home 170
Leggi http online: https://riptutorial.com/it/node-js/topic/2973/http
https://riptutorial.com/it/home 171
Capitolo 46: Iniezione di dipendenza
Examples
Perché utilizzare l'iniezione delle dipendenze
1. Processo di sviluppo rapido
2. Disaccoppiamento
3. Scrittura del test unitario
Processo di sviluppo rapido
Quando si utilizza lo sviluppo di dipendenze, lo sviluppatore del nodo può accelerare i processi di
sviluppo perché dopo DI vi è meno conflitto di codice e facile gestione di tutto il modulo.
Disaccoppiamento
I moduli diventano meno coppia, quindi è facile da mantenere.
Scrittura del test unitario
Le dipendenze hardcoded possono passarle nel modulo, quindi è facile scrivere un test unitario
per ogni modulo.
Leggi Iniezione di dipendenza online: https://riptutorial.com/it/node-js/topic/7681/iniezione-di-
dipendenza
https://riptutorial.com/it/home 172
Capitolo 47: Iniziare con la profilatura dei
nodi
introduzione
Lo scopo di questo post è iniziare con l'applicazione di profili di profiling e come dare un senso a
questi risultati per catturare un bug o una perdita di memoria. Un'applicazione in esecuzione su
nodejs non è altro che un processo di motore v8 che è in molti termini simile a un sito Web in
esecuzione su un browser e in pratica possiamo acquisire tutte le metriche correlate a un
processo di sito Web per un'applicazione di nodo.
Lo strumento di mia preferenza è chrome devtools o chrome inspector accoppiato con il nodo-
inspector.
Osservazioni
Il nodo-ispettore non riesce a collegarsi al processo del nodo bebug a volte, nel qual caso non
sarà possibile ottenere il punto di interruzione del debug in devtools. Prova ad aggiornare la
scheda devtools più volte e attendi qualche secondo per vedere se è in modalità debug.
Se non si riavvia il nodo-inspector dalla riga di comando.
Examples
Creazione di profili di una semplice applicazione di nodo
Passo 1 : Installa il pacchetto node-inspector utilizzando npm globalmente sul tuo computer
$ npm install -g node-inspector
Passaggio 2 : avviare il server ispettore del nodo
$ node-inspector
Passaggio 3 : avviare il debug dell'applicazione del nodo
$ node --debug-brk your/short/node/script.js
Passaggio 4 : apri http://127.0.0.1:8080/?port=5858 nel browser Chrome. E vedrai un'interfaccia
di strumenti chrom-dev con il tuo codice sorgente dell'applicazione nodejs nel pannello di sinistra.
E poiché abbiamo usato l'opzione debug break durante il debug dell'applicazione, l'esecuzione del
codice si fermerà alla prima riga di codice.
https://riptutorial.com/it/home 173
Passaggio 5 : questa è la parte facile in cui si passa alla scheda di profilazione e si inizia a
profilare l'applicazione. Nel caso in cui si desideri ottenere il profilo per un particolare metodo o
flusso, assicurarsi che l'esecuzione del codice sia interrotta poco prima che venga eseguito quel
pezzo di codice.
Passaggio 6 : Dopo aver registrato il profilo della CPU o l'heap dump / snapshot o l'allocazione
https://riptutorial.com/it/home 174
dell'heap, è possibile visualizzare i risultati nella stessa finestra o salvarli sull'unità locale per
un'analisi successiva o un confronto con altri profili.
Puoi usare questi articoli per sapere come leggere i profili:
• Leggere i profili della CPU
• Profiler per CPU di Chrome e profilatore di heap
Leggi Iniziare con la profilatura dei nodi online: https://riptutorial.com/it/node-js/topic/9347/iniziare-
con-la-profilatura-dei-nodi
https://riptutorial.com/it/home 175
Capitolo 48: Installare Node.js
Examples
Installa Node.js su Ubuntu
Utilizzando il gestore di pacchetti apt
sudo apt-get update
sudo apt-get install nodejs
sudo apt-get install npm
sudo ln -s /usr/bin/nodejs /usr/bin/node
# the node & npm versions in apt are outdated. This is how you can update them:
sudo npm install -g npm
sudo npm install -g n
sudo n stable # (or lts, or a specific version)
Utilizzando l'ultima versione specifica (ad es.
LTS 6.x) direttamente da nodesource
curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -
apt-get install -y nodejs
Inoltre, per il modo corretto di installare i moduli globali di npm, impostare la directory personale
per loro (elimina la necessità di sudo ed evita gli errori EACCES):
mkdir ~/.npm-global
echo "export PATH=~/.npm-global/bin:$PATH" >> ~/.profile
source ~/.profile
npm config set prefix '~/.npm-global'
Installazione di Node.js su Windows
Installazione standard
Tutti i binari, gli installatori e i file sorgente di Node.js possono essere scaricati qui .
È possibile scaricare solo il runtime node.exe o utilizzare il programma di installazione di Windows (
.msi ), che installerà anche npm , il gestore pacchetti consigliato per Node.js e i percorsi di
configurazione.
Installazione tramite gestore pacchetti
https://riptutorial.com/it/home 176
È inoltre possibile installare dal gestore pacchetti Chocolatey (Software Management Automation).
# choco install nodejs.install
Maggiori informazioni sulla versione attuale, puoi trovare nel repository choco qui .
Utilizzo di Node Version Manager (nvm)
Node Version Manager , altrimenti noto come nvm, è uno script di bash che semplifica la gestione
di più versioni di Node.js.
Per installare nvm, utilizzare lo script di installazione fornito:
$ curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.3/install.sh | bash
Per Windows esiste un pacchetto nvm-windows con un programma di installazione. Questa
pagina GithHub contiene i dettagli per l'installazione e l'utilizzo del pacchetto nvm-windows.
Dopo aver installato nvm, esegui "nvm on" dalla riga di comando. Ciò consente a nvm di
controllare le versioni del nodo.
Nota: potrebbe essere necessario riavviare il terminale affinché riconosca il comando nvm appena
installato.
Quindi installare la versione più recente del nodo:
$ nvm install node
Puoi anche installare una versione specifica del nodo, passando le versioni major, minor e / o
patch:
$ nvm install 6
$ nvm install 4.2
Per elencare le versioni disponibili per l'installazione:
$ nvm ls-remote
È quindi possibile passare versioni passando la versione nello stesso modo in cui si esegue
l'installazione:
$ nvm use 5
Puoi impostare una versione specifica del nodo che hai installato come versione predefinita
inserendo:
$ nvm alias default 4.2
https://riptutorial.com/it/home 177
Per visualizzare un elenco di versioni di nodo installate sul computer, immettere:
$ nvm ls
Per utilizzare versioni di nodi specifiche del progetto, è possibile salvare la versione nel file
.nvmrc. In questo modo, iniziare a lavorare con un altro progetto sarà meno soggetto ad errori
dopo averlo scaricato dal suo repository.
$ echo "4.2" > .nvmrc
$ nvm use
Found '/path/to/project/.nvmrc' with version <4.2>
Now using node v4.2 (npm v3.7.3)
Quando Node viene installato tramite nvm, non è necessario utilizzare sudo per installare i
pacchetti globali poiché sono installati nella cartella principale. Quindi npm i -g http-server
funziona senza errori di autorizzazione.
Installa Node.js da Source con il gestore pacchetti APT
Prerequisiti
sudo apt-get install build-essential
sudo apt-get install python
[optional]
sudo apt-get install git
Ottieni la fonte e costruisci
cd ~
git clone https://github.com/nodejs/node.git
OPPURE Per l'ultima versione di Node.js LTS 6.10.2
cd ~
wget https://nodejs.org/dist/v6.3.0/node-v6.10.2.tar.gz
tar -xzvf node-v6.10.2.tar.gz
Passare alla directory di origine come in cd ~/node-v6.10.2
./configure
make
sudo make install
Installare Node.js su Mac usando il gestore pacchetti
homebrew
https://riptutorial.com/it/home 178
Puoi installare Node.js utilizzando il gestore di pacchetti Homebrew .
Inizia aggiornando brew:
brew update
Potrebbe essere necessario modificare autorizzazioni o percorsi. È meglio eseguirlo prima di
procedere:
brew doctor
Successivamente è possibile installare Node.js eseguendo:
brew install node
Una volta installato Node.js, è possibile convalidare la versione installata eseguendo:
node -v
macports
Puoi anche installare node.js tramite Macports .
Innanzitutto aggiornalo per assicurarti che i pacchetti più recenti siano referenziati:
sudo port selfupdate
Quindi installare nodejs e npm
sudo port install nodejs npm
È ora possibile eseguire il nodo tramite CLI direttamente richiamando il node . Inoltre, puoi
controllare la versione corrente del tuo nodo con
node -v
Installazione tramite MacOS X Installer
Puoi trovare i programmi di installazione nella pagina di download di Node.js. Normalmente,
Node.js raccomanda due versioni di Node, la versione LTS (supporto a lungo termine) e la
versione corrente (ultima versione). Se si è nuovi a Node, basta andare su LTS e quindi fare clic
sul pulsante Macintosh Installer per scaricare il pacchetto.
Se vuoi trovare altre versioni di NodeJS, vai qui , scegli la tua versione, quindi fai clic su Scarica.
Dalla pagina di download, cerca un file con estensione .pkg .
https://riptutorial.com/it/home 179
Una volta scaricato il file (con estensione .pkg ofcourse), fai doppio clic per installarlo. Il
programma di installazione compresso con Node.js e npm , per impostazione predefinita, il
pacchetto verrà installato entrambi, ma è possibile personalizzare quale installare facendo clic sul
pulsante customize nel passaggio Installation Type . Oltre a questo, basta seguire le istruzioni di
installazione, è piuttosto semplice.
Controlla se il Nodo è installato
terminal aperto (se non sai come aprire il tuo terminale, guarda questo wikihow ). Nel node --
version tipo terminale node --version quindi immettere. Il tuo terminale apparirà così se Node è
installato:
$ node --version
v7.2.1
La versione v7.2.1 è la tua Node.js, se ricevi il command not found: node message command not
found: node invece di quello, allora significa che c'è un problema con la tua installazione.
Installazione di Node.js su Raspberry PI
Per installare v6.x aggiornare i pacchetti
curl -sL https://deb.nodesource.com/setup_6.x | sudo -E bash -
Utilizzando il gestore di pacchetti apt
sudo apt-get install -y nodejs
Installazione con Node Version Manager in Fish Shell con Oh My Fish!
Node Version Manager ( nvm ) semplifica enormemente la gestione delle versioni di Node.js, la loro
installazione e rimuove la necessità di sudo quando si ha a che fare con pacchetti (ad es. npm
install ... ). Fish Shell ( fish ) " è una shell da riga di comando intelligente e user-friendly per OS
X, Linux e il resto della famiglia " che è un'alternativa popolare tra i programmatori alle shell
comuni come bash . Infine, Oh My Fish ( omf ) consente di personalizzare e installare pacchetti
all'interno di Fish Shell.
Questa guida presuppone che tu stia già utilizzando Fish come shell .
Installa nvm
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.4/install.sh | bash
Installa Oh My Fish
curl -L https://github.com/oh-my-fish/oh-my-fish/raw/master/bin/install | fish
https://riptutorial.com/it/home 180
(Nota: a questo punto ti verrà richiesto di riavviare il tuo terminale. Vai avanti e fallo ora.)
Installa plugin-nvm per Oh My Fish
Installeremo plugin-nvm tramite Oh My Fish per esporre nvm funzionalità di nvm all'interno di Fish
Shell:
omf install nvm
Installa Node.js con Node Version Manager
Ora sei pronto per usare nvm . Puoi installare e utilizzare la versione di Node.js di tuo gradimento.
Qualche esempio:
• Installa la versione più recente del nodo: nvm install node
• Installare specificamente la versione 6.3.1: nvm install 6.3.1
• Elenca le verten installate: nvm ls
• Passare a 4.3.1: nvm use 4.3.1 installato in precedenza nvm use 4.3.1
Note finali
Ricorda ancora che non abbiamo più bisogno di sudo quando si ha a che fare con Node.js usando
questo metodo! Le versioni del nodo, i pacchetti e così via sono installati nella tua home directory.
Installa Node.js dal sorgente su Centos, RHEL e Fedora
Prerequisiti
• idiota
• clang and clang++ 3.4 ^ o gcc e g++ 4.8 ^
• Python 2.6 o 2.7
• GNU Make 3.81 ^
Ottieni la fonte
Node.js v6.x LTS
git clone -b v6.x https://github.com/nodejs/node.git
Node.js v7.x
git clone -b v7.x https://github.com/nodejs/node.git
Costruire
cd node
./configure
make -jX
su -c make install
https://riptutorial.com/it/home 181
X: il numero di core del processore, velocizza notevolmente la build
Pulizia [Opzionale]
cd
rm -rf node
Installare Node.js con n
Innanzitutto, c'è un involucro davvero bello per l'installazione di n sul tuo sistema. Corri:
curl -L https://git.io/n-install | bash
installare n . Quindi installa i binari in vari modi:
più recente
n latest
stabile
n stable
n lts
Qualsiasi altra versione
n <version>
per esempio n 4.4.7
Se questa versione è già installata, questo comando attiverà quella versione.
Versioni di commutazione
nda solo produrrà un elenco di selezione di binari installati. Usa su e giù per trovare quello che
vuoi e Enter per attivarlo.
Leggi Installare Node.js online: https://riptutorial.com/it/node-js/topic/1294/installare-node-js
https://riptutorial.com/it/home 182
Capitolo 49: Instradare richieste ajax con
Express.JS
Examples
Una semplice implementazione di AJAX
Dovresti avere il modello generatore di base espresso
In app.js, aggiungi (puoi aggiungerlo ovunque dopo var app = express.app() ):
app.post(function(req, res, next){
next();
});
Ora nel tuo file index.js (o nella sua rispettiva corrispondenza), aggiungi:
router.get('/ajax', function(req, res){
res.render('ajax', {title: 'An Ajax Example', quote: "AJAX is great!"});
});
router.post('/ajax', function(req, res){
res.render('ajax', {title: 'An Ajax Example', quote: req.body.quote});
});
Creare un file ajax.jade / ajax.pug o ajax.ejs nella directory /views , aggiungere:
Per Jade / PugJS:
extends layout
script(src="http://code.jquery.com/jquery-3.1.0.min.js")
script(src="/magic.js")
h1 Quote: !{quote}
form(method="post" id="changeQuote")
input(type='text', placeholder='Set quote of the day', name='quote')
input(type="submit", value="Save")
Per EJS:
<script src="http://code.jquery.com/jquery-3.1.0.min.js"></script>
<script src="/magic.js"></script>
<h1>Quote: <%=quote%> </h1>
<form method="post" id="changeQuote">
<input type="text" placeholder="Set quote of the day" name="quote"/>
<input type="submit" value="Save">
</form>
Ora crea un file in /public chiamato magic.js
$(document).ready(function(){
https://riptutorial.com/it/home 183
$("form#changeQuote").on('submit', function(e){
e.preventDefault();
var data = $('input[name=quote]').val();
$.ajax({
type: 'post',
url: '/ajax',
data: data,
dataType: 'text'
})
.done(function(data){
$('h1').html(data.quote);
});
});
});
E il gioco è fatto! Quando fai clic su Salva, il preventivo cambierà!
Leggi Instradare richieste ajax con Express.JS online: https://riptutorial.com/it/node-
js/topic/6738/instradare-richieste-ajax-con-express-js
https://riptutorial.com/it/home 184
Capitolo 50: Integrazione con Mongodb
Sintassi
• db. collezione .insertOne ( documento , opzioni (w, wtimeout, j, serializeFuntions,
forceServerObjectId, bypassDocumentValidation) , callback )
• db. collection .insertMany ( [documenti] , opzioni (w, wtimeout, j, serializeFuntions,
forceServerObjectId, bypassDocumentValidation) , callback )
• db. collezione .find ( query )
• db. collection .updateOne ( filtro , aggiornamento , opzioni (upsert, w, wtimeout, j,
bypassDocumentValidation) , callback )
• db. collection.updateMany ( filtro , aggiornamento , opzioni (upsert, w, wtimeout, j) , callback
)
• db. collezione .deleteOne ( filtro , opzioni (upsert, w, wtimeout, j) , callback )
• db. collection .deleteMany ( filtro , opzioni (upsert, w, wtimeout, j) , callback )
Parametri
Parametro Dettagli
documento Un oggetto javascript che rappresenta un documento
documenti Una serie di documenti
domanda Un oggetto che definisce una query di ricerca
filtro Un oggetto che definisce una query di ricerca
richiama Funzione da chiamare quando l'operazione è terminata
opzioni (facoltativo) Impostazioni opzionali (predefinito: null)
w (facoltativo) La preoccupazione di scrittura
wtimeout (facoltativo) Timeout di scrittura. (valore predefinito: null)
(facoltativo) Specificare un problema di scrittura del diario
j
(predefinito: falso)
(facoltativo) Operazione di aggiornamento (impostazione
upsert
predefinita: falso)
Multi (facoltativo) Aggiorna uno / tutti i documenti (predefinito: falso)
(opzionale) Serializza le funzioni su qualsiasi oggetto
serializeFunctions
(predefinito: falso)
https://riptutorial.com/it/home 185
Parametro Dettagli
(facoltativo) Forza server per assegnare valori _id anziché
forceServerObjectId
driver (predefinito: falso)
(facoltativo) Permetti al driver di bypassare la convalida dello
bypassDocumentValidation
schema in MongoDB 3.2 o successiva (predefinito: falso)
Examples
Connetti a MongoDB
Connettiti a MongoDB, stampa 'Connesso!' e chiudi la connessione.
const MongoClient = require('mongodb').MongoClient;
var url = 'mongodb://localhost:27017/test';
MongoClient.connect(url, function(err, db) { // MongoClient method 'connect'
if (err) throw new Error(err);
console.log("Connected!");
db.close(); // Don't forget to close the connection when you are done
});
Metodo MongoClient Connect()
MongoClient.connect ( url , opzioni , callback )
Discussione genere Descrizione
Una stringa che specifica l'ip / hostname del server, la porta e il
url stringa
database
options oggetto (facoltativo) Impostazioni opzionali (predefinito: null)
Funzione da chiamare quando viene effettuato il tentativo di
callback Funzione
connessione
La funzione di callback accetta due argomenti
• err : Errore - Se si verifica un err , verrà definito l'argomento err
• db : object - L'istanza di MongoDB
Inserisci un documento
Inserisci un documento chiamato "myFirstDocument" e imposta 2 proprietà, greetings e farewell
const MongoClient = require('mongodb').MongoClient;
https://riptutorial.com/it/home 186
const url = 'mongodb://localhost:27017/test';
MongoClient.connect(url, function (err, db) {
if (err) throw new Error(err);
db.collection('myCollection').insertOne({ // Insert method 'insertOne'
"myFirstDocument": {
"greetings": "Hellu",
"farewell": "Bye"
}
}, function (err, result) {
if (err) throw new Error(err);
console.log("Inserted a document into the myCollection collection!");
db.close(); // Don't forget to close the connection when you are done
});
});
Metodo di raccolta insertOne()
db.collection ( collection ) .insertOne ( documento , opzioni , callback )
Discussione genere Descrizione
collection stringa Una stringa che specifica la collezione
document oggetto Il documento da inserire nella collezione
options oggetto (facoltativo) Impostazioni opzionali (predefinito: null)
Funzione da chiamare quando l'operazione di inserimento è
callback Funzione
terminata
La funzione di callback accetta due argomenti
• err : Errore - Se si verifica un err , verrà definito l'argomento err
• result : oggetto - Un oggetto contenente dettagli sull'operazione di inserimento
Leggi una collezione
Ottieni tutti i documenti nella raccolta "myCollection" e stampali sulla console.
const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017/test';
MongoClient.connect(url, function (err, db) {
if (err) throw new Error(err);
var cursor = db.collection('myCollection').find(); // Read method 'find'
cursor.each(function (err, doc) {
if (err) throw new Error(err);
if (doc != null) {
console.log(doc); // Print all documents
} else {
https://riptutorial.com/it/home 187
db.close(); // Don't forget to close the connection when you are done
}
});
});
Metodo di raccolta find()
db.collection ( collection ) .find ()
Discussione genere Descrizione
collection stringa Una stringa che specifica la collezione
Aggiorna un documento
Trova un documento con la proprietà { greetings: 'Hellu' } e{ greetings: 'Hellu' } in {
greetings: 'Whut?' }
const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017/test';
MongoClient.connect(url, function (err, db) {
if (err) throw new Error(err);
db.collection('myCollection').updateOne({ // Update method 'updateOne'
greetings: "Hellu" },
{ $set: { greetings: "Whut?" }},
function (err, result) {
if (err) throw new Error(err);
db.close(); // Don't forget to close the connection when you are done
});
});
Metodo di raccolta updateOne()
db.collection ( collection ) .updateOne ( filtro , aggiornamento , opzioni callback )
Parametro genere Descrizione
filter oggetto Specifica i criteri di selezione
update oggetto Specifica le modifiche da applicare
options oggetto (facoltativo) Impostazioni opzionali (predefinito: null)
callback Funzione Funzione da chiamare quando l'operazione è terminata
La funzione di callback accetta due argomenti
https://riptutorial.com/it/home 188
• err : Errore - Se si verifica un errore, verrà definito l'argomento err
• db : object - L'istanza di MongoDB
Elimina un documento
Elimina un documento con la proprietà { greetings: 'Whut?' }
const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017/test';
MongoClient.connect(url, function (err, db) {
if (err) throw new Error(err);
db.collection('myCollection').deleteOne(// Delete method 'deleteOne'
{ greetings: "Whut?" },
function (err, result) {
if (err) throw new Error(err);
db.close(); // Don't forget to close the connection when you are done
});
});
Metodo di raccolta deleteOne()
db.collection ( collection ) .deleteOne ( filtro , opzioni , callback )
Parametro genere Descrizione
filter oggetto Un documento che specifica i criteri di selezione
options oggetto (facoltativo) Impostazioni opzionali (predefinito: null)
callback Funzione Funzione da chiamare quando l'operazione è terminata
La funzione di callback accetta due argomenti
• err : Errore - Se si verifica un errore, verrà definito l'argomento err
• db : object - L'istanza di MongoDB
Elimina più documenti
Elimina TUTTI i documenti con una proprietà 'addio' impostata su 'ok'.
const MongoClient = require('mongodb').MongoClient;
const url = 'mongodb://localhost:27017/test';
MongoClient.connect(url, function (err, db) {
if (err) throw new Error(err);
db.collection('myCollection').deleteMany(// MongoDB delete method 'deleteMany'
{ farewell: "okay" }, // Delete ALL documents with the property 'farewell: okay'
function (err, result) {
https://riptutorial.com/it/home 189
if (err) throw new Error(err);
db.close(); // Don't forget to close the connection when you are done
});
});
Metodo di raccolta deleteMany()
db.collection ( collection ) .deleteMany ( filtro , opzioni , callback )
Parametro genere Descrizione
filter documento Un documento che specifica i criteri di selezione
options oggetto (facoltativo) Impostazioni opzionali (predefinito: null)
callback funzione Funzione da chiamare quando l'operazione è terminata
La funzione di callback accetta due argomenti
• err : Errore - Se si verifica un errore, verrà definito l'argomento err
• db : object - L'istanza di MongoDB
Semplice connessione
MongoDB.connect('mongodb://localhost:27017/databaseName', function(error, database) {
if(error) return console.log(error);
const collection = database.collection('collectionName');
collection.insert({key: 'value'}, function(error, result) {
console.log(error, result);
});
});
Connessione semplice, usando le promesse
const MongoDB = require('mongodb');
MongoDB.connect('mongodb://localhost:27017/databaseName')
.then(function(database) {
const collection = database.collection('collectionName');
return collection.insert({key: 'value'});
})
.then(function(result) {
console.log(result);
});
```
Leggi Integrazione con Mongodb online: https://riptutorial.com/it/node-js/topic/5002/integrazione-
con-mongodb
https://riptutorial.com/it/home 190
Capitolo 51: Integrazione con MySQL
introduzione
In questo argomento imparerai come integrarsi con Node.js utilizzando lo strumento di gestione
del database MYSQL. Imparerai vari modi per connetterti e interagire con i dati che risiedono in
mysql usando un programma e uno script nodejs.
Examples
Interrogare un oggetto di connessione con parametri
Quando si desidera utilizzare il contenuto generato dall'utente in SQL, con i parametri. Ad
esempio per cercare un utente con il nome aminadav dovresti fare:
var username = 'aminadav';
var querystring = 'SELECT name, email from users where name = ?';
connection.query(querystring, [username], function(err, rows, fields) {
if (err) throw err;
if (rows.length) {
rows.forEach(function(row) {
console.log(row.name, 'email address is', row.email);
});
} else {
console.log('There were no results.');
}
});
Utilizzo di un pool di connessioni
un. Esecuzione di più query contemporaneamente
Tutte le query nella connessione MySQL vengono eseguite una dopo l'altra. Significa che se si
desidera eseguire 10 query e ciascuna query richiede 2 secondi, saranno necessari 20 secondi
per completare l'intera esecuzione. La soluzione è creare 10 connessioni ed eseguire ogni query
in una connessione diversa. Questo può essere fatto automaticamente usando il pool di
connessioni
var pool = mysql.createPool({
connectionLimit : 10,
host : 'example.org',
user : 'bobby',
password : 'pass',
database : 'schema'
});
for(var i=0;i<10;i++){
pool.query('SELECT ` as example', function(err, rows, fields) {
if (err) throw err;
https://riptutorial.com/it/home 191
console.log(rows[0].example); //Show 1
});
}
Eseguirà tutte le 10 query in parallelo.
Quando usi pool non hai più bisogno della connessione. Puoi interrogare direttamente il pool. Il
modulo MySQL cercherà la prossima connessione gratuita per eseguire la query.
b. Raggiungimento della multi-tenancy sul server di
database con diversi database ospitati su di esso.
La multitenancy è un requisito comune delle applicazioni aziendali al giorno d'oggi e la creazione
di un pool di connessioni per ogni database nel server di database non è consigliata. quindi, ciò
che possiamo fare è creare un pool di connessioni con un server di database e quindi cambiarle
tra i database ospitati su un server di database su richiesta.
Supponiamo che la nostra applicazione abbia diversi database per ogni azienda ospitata sul
server di database. Ci collegheremo al rispettivo database aziendale quando l'utente raggiunge
l'applicazione. Ecco l'esempio su come farlo: -
var pool = mysql.createPool({
connectionLimit : 10,
host : 'example.org',
user : 'bobby',
password : 'pass'
});
pool.getConnection(function(err, connection){
if(err){
return cb(err);
}
connection.changeUser({database : "firm1"});
connection.query("SELECT * from history", function(err, data){
connection.release();
cb(err, data);
});
});
Lasciatemi fare un esempio:
Durante la definizione della configurazione del pool non ho fornito il nome del database, ma ho
fornito solo il server del database
{
connectionLimit : 10,
host : 'example.org',
user : 'bobby',
password : 'pass'
}
quindi, quando vogliamo utilizzare il database specifico sul server di database, chiediamo la
https://riptutorial.com/it/home 192
connessione al database dei risultati utilizzando: -
connection.changeUser({database : "firm1"});
puoi consultare la documentazione ufficiale qui
Connetti a MySQL
Uno dei modi più semplici per connettersi a MySQL è usando il modulo mysql . Questo modulo
gestisce la connessione tra l'app Node.js e il server MySQL. Puoi installarlo come qualsiasi altro
modulo:
npm install --save mysql
Ora devi creare una connessione mysql, che puoi in seguito interrogare.
const mysql = require('mysql');
const connection = mysql.createConnection({
host : 'localhost',
user : 'me',
password : 'secret',
database : 'database_schema'
});
connection.connect();
// Execute some query statements
// I.e. SELECT * FROM FOO
connection.end();
Nel prossimo esempio imparerai come interrogare l'oggetto di connection .
Interrogare un oggetto di connessione senza parametri
Si invia la query come stringa e in risposta si riceve una risposta con la risposta. Il callback ti dà
error , array di rows e campi. Ogni riga contiene tutta la colonna della tabella restituita. Ecco uno
snippet per la seguente spiegazione.
connection.query('SELECT name,email from users', function(err, rows, fields) {
if (err) throw err;
console.log('There are:', rows.length,' users');
console.log('First user name is:',rows[0].name)
});
Esegui un numero di query con una singola connessione da un pool
Potrebbero esserci situazioni in cui hai impostato un pool di connessioni MySQL, ma hai un
numero di query che vorresti eseguire in sequenza:
https://riptutorial.com/it/home 193
SELECT 1;
SELECT 2;
Si potrebbe semplicemente eseguire quindi usando pool.query come visto altrove , tuttavia se si
dispone di una sola connessione libera nel pool, è necessario attendere fino a quando una
connessione diventa disponibile prima di poter eseguire la seconda query.
Tuttavia, è possibile mantenere una connessione attiva dal pool ed eseguire tutte le query che si
desidera utilizzando una singola connessione mediante pool.getConnection :
pool.getConnection(function (err, conn) {
if (err) return callback(err);
conn.query('SELECT 1 AS seq', function (err, rows) {
if (err) throw err;
conn.query('SELECT 2 AS seq', function (err, rows) {
if (err) throw err;
conn.release();
callback();
});
});
});
Nota: è necessario ricordare di release la connessione, altrimenti è disponibile una connessione
MySQL in meno per il resto del pool!
Per ulteriori informazioni sul pooling delle connessioni MySQL, consultare i documenti MySQL .
Restituisce la query quando si verifica un errore
È possibile allegare la query eseguita all'oggetto err quando si verifica un errore:
var q = mysql.query('SELECT `name` FROM `pokedex` WHERE `id` = ?', [ 25 ], function (err,
result) {
if (err) {
// Table 'test.pokedex' doesn't exist
err.query = q.sql; // SELECT `name` FROM `pokedex` WHERE `id` = 25
callback(err);
}
else {
callback(null, result);
}
});
Esporta pool di connessioni
// db.js
const mysql = require('mysql');
const pool = mysql.createPool({
https://riptutorial.com/it/home 194
connectionLimit : 10,
host : 'example.org',
user : 'bob',
password : 'secret',
database : 'my_db'
});
module.export = {
getConnection: (callback) => {
return pool.getConnection(callback);
}
}
// app.js
const db = require('./db');
db.getConnection((err, conn) => {
conn.query('SELECT something from sometable', (error, results, fields) => {
// get the results
conn.release();
});
});
Leggi Integrazione con MySQL online: https://riptutorial.com/it/node-js/topic/1406/integrazione-
con-mysql
https://riptutorial.com/it/home 195
Capitolo 52: Integrazione del passaporto
Osservazioni
La password deve essere sempre sottoposta a hash. Un modo semplice per proteggere le
password usando NodeJS sarebbe utilizzare il modulo bcrypt-nodejs .
Examples
Iniziare
Il passaporto deve essere inizializzato usando il middleware passport.initialize() . Per utilizzare
le sessioni di accesso, è necessario il middleware passport.session() .
Si noti che devono essere definiti i metodi passport.serialize() e passport.deserializeUser() .
Passport serializzerà e deserializzerà le istanze utente da e verso la sessione
const express = require('express');
const session = require('express-session');
const passport = require('passport');
const cookieParser = require('cookie-parser');
const app = express();
// Required to read cookies
app.use(cookieParser());
passport.serializeUser(function(user, next) {
// Serialize the user in the session
next(null, user);
});
passport.deserializeUser(function(user, next) {
// Use the previously serialized user
next(null, user);
});
// Configuring express-session middleware
app.use(session({
secret: 'The cake is a lie',
resave: true,
saveUninitialized: true
}));
// Initializing passport
app.use(passport.initialize());
app.use(passport.session());
// Starting express server on port 3000
app.listen(3000);
Autenticazione locale
https://riptutorial.com/it/home 196
Il modulo passport-local viene utilizzato per implementare un'autenticazione locale.
Questo modulo ti consente di autenticarti usando un nome utente e una password
nelle tue applicazioni Node.js.
Registrazione dell'utente:
const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
// A named strategy is used since two local strategy are used :
// one for the registration and the other to sign-in
passport.use('localSignup', new LocalStrategy({
// Overriding defaults expected parameters,
// which are 'username' and 'password'
usernameField: 'email',
passwordField: 'password',
passReqToCallback: true // allows us to pass back the entire request to the callback .
},
function(req, email, password, next) {
// Check in database if user is already registered
findUserByEmail(email, function(user) {
// If email already exists, abort registration process and
// pass 'false' to the callback
if (user) return next(null, false);
// Else, we create the user
else {
// Password must be hashed !
let newUser = createUser(email, password);
newUser.save(function() {
// Pass the user to the callback
return next(null, newUser);
});
}
});
});
Accesso dell'utente:
const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
passport.use('localSignin', new LocalStrategy({
usernameField : 'email',
passwordField : 'password',
},
function(email, password, next) {
// Find the user
findUserByEmail(email, function(user) {
// If user is not found, abort signing in process
// Custom messages can be provided in the verify callback
// to give the user more details concerning the failed authentication
if (!user)
return next(null, false, {message: 'This e-mail address is not associated with any
account.'});
// Else, we check if password is valid
else {
https://riptutorial.com/it/home 197
// If password is not correct, abort signing in process
if (!isPasswordValid(password)) return next(null, false);
// Else, pass the user to callback
else return next(null, user);
}
});
});
Creare percorsi:
// ...
app.use(passport.initialize());
app.use(passport.session());
// Sign-in route
// Passport strategies are middlewares
app.post('/login', passport.authenticate('localSignin', {
successRedirect: '/me',
failureRedirect: '/login'
});
// Sign-up route
app.post('/register', passport.authenticate('localSignup', {
successRedirect: '/',
failureRedirect: '/signup'
});
// Call req.logout() to log out
app.get('/logout', function(req, res) {
req.logout();
res.redirect('/');
});
app.listen(3000);
Autenticazione Facebook
Il modulo passport-facebook viene utilizzato per implementare un'autenticazione di Facebook .
In questo esempio, se l'utente non esiste al momento dell'accesso, viene creato.
Strategia di attuazione:
const passport = require('passport');
const FacebookStrategy = require('passport-facebook').Strategy;
// Strategy is named 'facebook' by default
passport.use({
clientID: 'yourclientid',
clientSecret: 'yourclientsecret',
callbackURL: '/auth/facebook/callback'
},
// Facebook will send a token and user's profile
function(token, refreshToken, profile, next) {
// Check in database if user is already registered
findUserByFacebookId(profile.id, function(user) {
// If user exists, returns his data to callback
if (user) return next(null, user);
https://riptutorial.com/it/home 198
// Else, we create the user
else {
let newUser = createUserFromFacebook(profile, token);
newUser.save(function() {
// Pass the user to the callback
return next(null, newUser);
});
}
});
});
Creare percorsi:
// ...
app.use(passport.initialize());
app.use(passport.session());
// Authentication route
app.get('/auth/facebook', passport.authenticate('facebook', {
// Ask Facebook for more permissions
scope : 'email'
}));
// Called after Facebook has authenticated the user
app.get('/auth/facebook/callback',
passport.authenticate('facebook', {
successRedirect : '/me',
failureRedirect : '/'
}));
//...
app.listen(3000);
Semplice nome utente-password di autenticazione
Nei tuoi percorsi / index.js
Qui l' user è il modello per userSchema
router.post('/login', function(req, res, next) {
if (!req.body.username || !req.body.password) {
return res.status(400).json({
message: 'Please fill out all fields'
});
}
passport.authenticate('local', function(err, user, info) {
if (err) {
console.log("ERROR : " + err);
return next(err);
}
if(user) (
https://riptutorial.com/it/home 199
console.log("User Exists!")
//All the data of the user can be accessed by user.x
res.json({"success" : true});
return;
} else {
res.json({"success" : false});
console.log("Error" + errorResponse());
return;
}
})(req, res, next);
});
Autenticazione Google Passport
Abbiamo modulo semplice disponibile in npm per goggle authetication name passport-google-
oauth20
Considera l'esempio seguente In questo esempio abbiamo creato una cartella, ovvero config con i
file passport.js e google.js nella directory root. Nella tua app.js include quanto segue
var express = require('express');
var session = require('express-session');
var passport = require('./config/passport'); // path where the passport file placed
var app = express();
passport(app);
// altro codice per inizializzare il server, handle di errore
Nel file passport.js nella cartella config è incluso il seguente codice
var passport = require ('passport'),
google = require('./google'),
User = require('./../model/user'); // User is the mongoose model
module.exports = function(app){
app.use(passport.initialize());
app.use(passport.session());
passport.serializeUser(function(user, done){
done(null, user);
});
passport.deserializeUser(function (user, done) {
done(null, user);
});
google();
};
Di seguito il file google.js nella stessa cartella di configurazione
var passport = require('passport'),
GoogleStrategy = require('passport-google-oauth20').Strategy,
User = require('./../model/user');
module.exports = function () {
passport.use(new GoogleStrategy({
clientID: 'CLIENT ID',
clientSecret: 'CLIENT SECRET',
https://riptutorial.com/it/home 200
callbackURL: "http://localhost:3000/auth/google/callback"
},
function(accessToken, refreshToken, profile, cb) {
User.findOne({ googleId : profile.id }, function (err, user) {
if(err){
return cb(err, false, {message : err});
}else {
if (user != '' && user != null) {
return cb(null, user, {message : "User "});
} else {
var username = profile.displayName.split(' ');
var userData = new User({
name : profile.displayName,
username : username[0],
password : username[0],
facebookId : '',
googleId : profile.id,
});
// send email to user just in case required to send the newly created
// credentails to user for future login without using google login
userData.save(function (err, newuser) {
if (err) {
return cb(null, false, {message : err + " !!! Please try again"});
}else{
return cb(null, newuser);
}
});
}
}
});
}
));
};
Qui in questo esempio, se l'utente non è in DB, crea un nuovo utente in DB per riferimento locale
utilizzando il nome campo googleId nel modello utente.
Leggi Integrazione del passaporto online: https://riptutorial.com/it/node-js/topic/7666/integrazione-
del-passaporto
https://riptutorial.com/it/home 201
Capitolo 53: Integrazione di Cassandra
Examples
Ciao mondo
Per l'accesso cassandra-driver modulo Cassandra cassandra-driver Cassandra da DataStax può
essere utilizzato. Supporta tutte le funzionalità e può essere facilmente configurato.
const cassandra = require("cassandra-driver");
const clientOptions = {
contactPoints: ["host1", "host2"],
keyspace: "test"
};
const client = new cassandra.Client(clientOptions);
const query = "SELECT hello FROM world WHERE name = ?";
client.execute(query, ["John"], (err, results) => {
if (err) {
return console.error(err);
}
console.log(results.rows);
});
Leggi Integrazione di Cassandra online: https://riptutorial.com/it/node-js/topic/5949/integrazione-di-
cassandra
https://riptutorial.com/it/home 202
Capitolo 54: Integrazione di PostgreSQL
Examples
Connetti a PostgreSQL
Utilizzo del modulo npm PostgreSQL .
installa la dipendenza da npm
npm install pg --save
Ora devi creare una connessione PostgreSQL, che puoi in seguito interrogare.
Supponi tu Database_Name = studenti, Host = localhost e DB_User = postgres
var pg = require("pg")
var connectionString = "pg://postgres:postgres@localhost:5432/students";
var client = new pg.Client(connectionString);
client.connect();
Query con oggetto Connection
Se si desidera utilizzare l'oggetto di connessione per il database di query, è possibile utilizzare
questo codice di esempio.
var queryString = "SELECT name, age FROM students " ;
var query = client.query(queryString);
query.on("row", (row, result)=> {
result.addRow(row);
});
query.on("end", function (result) {
//LOGIC
});
Leggi Integrazione di PostgreSQL online: https://riptutorial.com/it/node-js/topic/7706/integrazione-
di-postgresql
https://riptutorial.com/it/home 203
Capitolo 55: Integrazione MongoDB per
Node.js / Express.js
introduzione
MongoDB è uno dei più popolari database NoSQL, grazie all'aiuto dello stack MEAN. Interfacciare
con un database Mongo da un'app Express è semplice e veloce, una volta compresa la sintassi
della query. Useremo Mongoose per aiutarci.
Osservazioni
Ulteriori informazioni possono essere trovate qui: http://mongoosejs.com/docs/guide.html
Examples
Installare MongoDB
npm install --save mongodb
npm install --save mongoose //A simple wrapper for ease of development
Nel file del tuo server (normalmente denominato index.js o server.js)
const express = require('express');
const mongodb = require('mongodb');
const mongoose = require('mongoose');
const mongoConnectString = 'http://localhost/database name';
mongoose.connect(mongoConnectString, (err) => {
if (err) {
console.log('Could not connect to the database');
}
});
Creazione di un modello Mongoose
const Schema = mongoose.Schema;
const ObjectId = Schema.Types.ObjectId;
const Article = new Schema({
title: {
type: String,
unique: true,
required: [true, 'Article must have title']
},
author: {
type: ObjectId,
ref: 'User'
https://riptutorial.com/it/home 204
}
});
module.exports = mongoose.model('Article, Article);
Analizziamo questo. MongoDB e Mongoose usano JSON (in realtà BSON, ma qui è irrilevante)
come formato dei dati. Nella parte superiore, ho impostato alcune variabili per ridurre la
digitazione.
Creo un new Schema e lo assegno a una costante. È semplice JSON e ogni attributo è un altro
oggetto con proprietà che consente di applicare uno schema più coerente. Forze univoche che le
nuove istanze vengono inserite nel database, ovviamente, sono uniche. Questo è ottimo per
evitare che un utente possa creare più account su un servizio.
Required è un altro, dichiarato come array. Il primo elemento è il valore booleano e il secondo il
messaggio di errore se il valore inserito o aggiornato non esiste.
I ObjectID sono usati per le relazioni tra i Modelli. Gli esempi potrebbero essere "Gli utenti hanno
molti commenti". Altri attributi possono essere usati al posto di ObjectId. Le stringhe come un
nome utente sono un esempio.
Infine, l'esportazione del modello da utilizzare con le rotte API consente l'accesso al tuo schema.
Interrogare il tuo database Mongo
Una semplice richiesta GET. Supponiamo che il Modello dell'esempio precedente sia nel file
./db/models/Article.js .
const express = require('express');
const Articles = require('./db/models/Article');
module.exports = function (app) {
const routes = express.Router();
routes.get('/articles', (req, res) => {
Articles.find().limit(5).lean().exec((err, doc) => {
if (doc.length > 0) {
res.send({ data: doc });
} else {
res.send({ success: false, message: 'No documents retrieved' });
}
});
});
app.use('/api', routes);
};
Ora possiamo ottenere i dati dal nostro database inviando una richiesta HTTP a questo endpoint.
Alcune cose chiave, però:
1. Limit fa esattamente quello che sembra. Ricevo solo 5 documenti.
2. Lean elimina alcune cose dal BSON grezzo, riducendo la complessità e il sovraccarico. Non
https://riptutorial.com/it/home 205
richiesto. Ma utile
3. Quando usi find invece di findOne , conferma che doc.length è maggiore di 0. Questo perché
find restituisce sempre un array, quindi un array vuoto non gestirà il tuo errore a meno che
non venga controllato per la lunghezza
4. Personalmente mi piace inviare il messaggio di errore in quel formato. Modificalo in base alle
tue esigenze. Stessa cosa per il documento restituito.
5. Il codice in questo esempio è stato scritto supponendo di averlo inserito in un altro file e non
direttamente sul server Express. Per chiamare questo nel server, includere queste righe nel
codice del server:
const app = express();
require('./path/to/this/file')(app) //
Leggi Integrazione MongoDB per Node.js / Express.js online: https://riptutorial.com/it/node-
js/topic/9020/integrazione-mongodb-per-node-js---express-js
https://riptutorial.com/it/home 206
Capitolo 56: Interagire con la console
Sintassi
• console.log ([data] [, ...])
• console.error ([data] [, ...])
• console.time (etichetta)
• console.timeEnd (etichetta)
Examples
Registrazione
Modulo console
Simile all'ambiente browser di JavaScript node.js fornisce un modulo console che offre semplici
possibilità di registrazione e debug.
I metodi più importanti forniti dal modulo della console sono console.log , console.error e
console.time . Ma ce ne sono molti altri come console.info .
console.log
I parametri verranno stampati sullo standard output ( stdout ) con una nuova riga.
console.log('Hello World');
Console.Error
I parametri verranno stampati con l'errore standard ( stderr ) con una nuova riga.
console.error('Oh, sorry, there is an error.');
console.time, console.timeEnd
console.time avvia un timer con un'etichetta univoca che può essere utilizzata per calcolare la
durata di un'operazione. Quando si chiama console.timeEnd con la stessa etichetta, il timer si
arresta e stampa il tempo trascorso in millisecondi sullo stdout .
https://riptutorial.com/it/home 207
Modulo di processo
È possibile utilizzare il modulo di processo per scrivere direttamente nell'output standard della
console. Pertanto esiste il metodo process.stdout.write . A differenza di console.log questo
metodo non aggiunge una nuova riga prima dell'output.
Quindi nel seguente esempio il metodo viene chiamato due volte, ma nessuna nuova riga viene
aggiunta tra i loro output.
formattazione
Si possono usare i codici di terminale (controllo) per emettere comandi specifici come cambiare
i colori o posizionare il cursore.
Generale
Effetto Codice
Reset \033[0m
HiColor \033[1m
Sottolineare \033[4m
Inverso \033[7m
Colori dei caratteri
Effetto Codice
Nero \033[30m
Rosso \033[31m
verde \033[32m
https://riptutorial.com/it/home 208
Effetto Codice
Giallo \033[33m
Blu \033[34m
Magenta \033[35m
Ciano \033[36m
bianca \033[37m
Colori di sfondo
Effetto Codice
Nero \033[40m
Rosso \033[41m
verde \033[42m
Giallo \033[43m
Blu \033[44m
Magenta \033[45m
Ciano \033[46m
bianca \033[47m
Leggi Interagire con la console online: https://riptutorial.com/it/node-js/topic/5935/interagire-con-la-
console
https://riptutorial.com/it/home 209
Capitolo 57: Invia notifica Web
Examples
Invia notifica Web utilizzando GCM (Google Cloud Messaging System)
Tale esempio sta conoscendo un'ampia diffusione tra PWA (Progressive Web Applications) e in
questo esempio invieremo una semplice notifica di backend come usando NodeJS ed ES6
1. Installa il modulo Node-GCM: npm install node-gcm
2. Installa Socket.io: npm install socket.io
3. Crea un'applicazione GCM abilitata utilizzando Google Console.
4. Grabe il tuo ID applicazione GCM (ne avremo bisogno in seguito)
5. Inserisci il tuo codice segreto dell'applicazione GCM.
6. Apri il tuo editor di codice preferito e aggiungi il seguente codice:
'use strict';
const express = require('express');
const app = express();
const gcm = require('node-gcm');
app.io = require('socket.io')();
// [*] Configuring our GCM Channel.
const sender = new gcm.Sender('Project Secret');
const regTokens = [];
let message = new gcm.Message({
data: {
key1: 'msg1'
}
});
// [*] Configuring our static files.
app.use(express.static('public/'));
// [*] Configuring Routes.
app.get('/', (req, res) => {
res.sendFile(__dirname + '/public/index.html');
});
// [*] Configuring our Socket Connection.
app.io.on('connection', socket => {
console.log('we have a new connection ...');
socket.on('new_user', (reg_id) => {
// [*] Adding our user notification registration token to our list typically
hided in a secret place.
if (regTokens.indexOf(reg_id) === -1) {
regTokens.push(reg_id);
https://riptutorial.com/it/home 210
// [*] Sending our push messages
sender.send(message, {
registrationTokens: regTokens
}, (err, response) => {
if (err) console.error('err', err);
else console.log(response);
});
}
})
});
module.exports = app
PS: Sto usando un trucco speciale per far funzionare Socket.io con Express perché
semplicemente non funziona fuori dagli schemi.
Ora creare un file .json e denominarlo: Manifest.json , aprirlo e incollare quanto segue:
{
"name": "Application Name",
"gcm_sender_id": "GCM Project ID"
}
Chiudilo e salva nella directory ROOT dell'applicazione.
PS: il file Manifest.json deve essere nella directory principale o non funzionerà.
Nel codice sopra sto facendo quanto segue:
1. Ho impostato e inviato una normale pagina index.html che utilizzerà anche socket.io.
2. Sto ascoltando un evento di connessione sparato dalla pagina front-end aka my
index.html (verrà attivato una volta che un nuovo client si è connesso correttamente al
nostro link predefinito)
3. Sto inviando un token speciale come il token di registrazione dal mio index.html tramite
l'evento socket.io new_user , tale token sarà il nostro codice di accesso univoco dell'utente
e ogni codice viene generato solitamente da un browser di supporto per l' API di notifica
Web (leggi di più Qui.
4. Sto semplicemente usando il modulo node-gcm per inviare la mia notifica che verrà gestita
e mostrata in seguito utilizzando i Service Workers `.
Questo è dal punto di vista di NodeJS . in altri esempi mostrerò come possiamo inviare dati
personalizzati, icone .. etc nel nostro messaggio push.
PS: puoi trovare la demo completa di lavoro qui.
Leggi Invia notifica Web online: https://riptutorial.com/it/node-js/topic/6333/invia-notifica-web
https://riptutorial.com/it/home 211
Capitolo 58: Invio di un flusso di file al client
Examples
Utilizzo di fs And pipe per il flusso di file statici dal server
Un buon servizio VOD (Video On Demand) dovrebbe iniziare con le basi. Diciamo che hai una
directory sul tuo server che non è pubblicamente accessibile, ma attraverso una sorta di portale o
paywall vuoi consentire agli utenti di accedere ai tuoi file multimediali.
var movie = path.resolve('./public/' + req.params.filename);
fs.stat(movie, function (err, stats) {
var range = req.headers.range;
if (!range) {
return res.sendStatus(416);
//Chunk logic here
var positions = range.replace(/bytes=/, "").split("-");
var start = parseInt(positions[0], 10);
var total = stats.size;
var end = positions[1] ? parseInt(positions[1], 10) : total - 1;
var chunksize = (end - start) + 1;
res.writeHead(206, {
'Transfer-Encoding': 'chunked',
"Content-Range": "bytes " + start + "-" + end + "/" + total,
"Accept-Ranges": "bytes",
"Content-Length": chunksize,
"Content-Type": mime.lookup(req.params.filename)
});
var stream = fs.createReadStream(movie, { start: start, end: end, autoClose: true
})
.on('end', function () {
console.log('Stream Done');
})
.on("error", function (err) {
res.end(err);
https://riptutorial.com/it/home 212
})
.pipe(res, { end: true });
});
Il frammento di cui sopra è uno schema di base per il modo in cui desideri trasmettere il tuo video
in streaming a un cliente. La logica del blocco dipende da una varietà di fattori, tra cui il traffico di
rete e la latenza. È importante bilanciare le dimensioni del mandrino rispetto alla quantità.
Infine, la chiamata .pipe consente a node.js di mantenere aperta una connessione con il server e
di inviare chunk aggiuntivi, se necessario.
Streaming Utilizzando fluent-ffmpeg
Puoi anche usare flent-ffmpeg per convertire i file .mp4 in file .flv o altri tipi:
res.contentType ( 'flv');
var pathToMovie = './public/' + req.params.filename;
var proc = ffmpeg(pathToMovie)
.preset('flashvideo')
.on('end', function () {
console.log('Stream Done');
})
.on('error', function (err) {
console.log('an error happened: ' + err.message);
res.send(err.message);
})
.pipe(res, { end: true });
Leggi Invio di un flusso di file al client online: https://riptutorial.com/it/node-js/topic/6994/invio-di-
un-flusso-di-file-al-client
https://riptutorial.com/it/home 213
Capitolo 59: Koa Framework v2
Examples
Ciao esempio del mondo
const Koa = require('koa')
const app = new Koa()
app.use(async ctx => {
ctx.body = 'Hello World'
})
app.listen(8080)
Gestione degli errori utilizzando il middleware
app.use(async (ctx, next) => {
try {
await next() // attempt to invoke the next middleware downstream
} catch (err) {
handleError(err, ctx) // define your own error handling function
}
})
Leggi Koa Framework v2 online: https://riptutorial.com/it/node-js/topic/6730/koa-framework-v2
https://riptutorial.com/it/home 214
Capitolo 60: La gestione delle eccezioni
Examples
Gestione dell'eccezione in Node.Js
Node.js ha 3 modi di base per gestire eccezioni / errori:
1. prova - cattura blocco
2. errore come primo argomento di un callback
3. emit un evento di errore utilizzando eventEmitter
try-catch è usato per catturare le eccezioni generate dall'esecuzione del codice sincrono. Se il
chiamante (o il chiamante del chiamante, ...) utilizza try / catch, allora possono rilevare l'errore. Se
nessuno dei chiamanti ha tentato di intercettarlo, il programma si blocca.
Se si utilizza try-catch su un'operazione asincrona, è stata generata un'eccezione dal richiamo del
metodo asincrono che non verrà catturata da try-catch. Per catturare un'eccezione dalla
richiamata dell'operazione asincrona, è preferibile utilizzare le promesse .
Esempio per capirlo meglio
// ** Example - 1 **
function doSomeSynchronousOperation(req, res) {
if(req.body.username === ''){
throw new Error('User Name cannot be empty');
}
return true;
}
// calling the method above
try {
// synchronous code
doSomeSynchronousOperation(req, res)
catch(e) {
//exception handled here
console.log(e.message);
}
// ** Example - 2 **
function doSomeAsynchronousOperation(req, res, cb) {
// imitating async operation
return setTimeout(function(){
cb(null, []);
},1000);
}
try {
// asynchronous code
doSomeAsynchronousOperation(req, res, function(err, rs){
throw new Error("async operation exception");
})
} catch(e) {
// Exception will not get handled here
console.log(e.message);
https://riptutorial.com/it/home 215
}
// The exception is unhandled and hence will cause application to break
le callback sono utilizzate principalmente in Node.js in quanto il callback consegna un evento in
modo asincrono. L'utente ti passa una funzione (il callback) e la invochi più tardi quando
l'operazione asincrona viene completata.
Lo schema normale è che la richiamata è invocata come callback (err, risultato) , dove solo uno di
err e result è non nullo, a seconda che l'operazione abbia avuto esito positivo o negativo.
function doSomeAsynchronousOperation(req, res, callback) {
setTimeout(function(){
return callback(new Error('User Name cannot be empty'));
}, 1000);
return true;
}
doSomeAsynchronousOperation(req, res, function(err, result) {
if (err) {
//exception handled here
console.log(err.message);
}
//do some stuff with valid data
});
emetta Per i casi più complicati, invece di utilizzare una richiamata, la funzione stessa può
restituire un oggetto EventEmitter e il chiamante dovrebbe ascoltare gli eventi di errore
sull'emettitore.
const EventEmitter = require('events');
function doSomeAsynchronousOperation(req, res) {
let myEvent = new EventEmitter();
// runs asynchronously
setTimeout(function(){
myEvent.emit('error', new Error('User Name cannot be empty'));
}, 1000);
return myEvent;
}
// Invoke the function
let event = doSomeAsynchronousOperation(req, res);
event.on('error', function(err) {
console.log(err);
});
event.on('done', function(result) {
console.log(result); // true
});
Gestione delle eccezioni non gestita
https://riptutorial.com/it/home 216
Poiché Node.js viene eseguito su un singolo processo, le eccezioni non rilevate sono un problema
da tenere presente quando si sviluppano applicazioni.
Eccezioni di gestione silenziosa
La maggior parte delle persone lascia che i server node.js soppongano silenziosamente gli errori.
• Gestendo in silenzio l'eccezione
process.on('uncaughtException', function (err) {
console.log(err);
});
Questo è male , funzionerà ma:
• La causa principale rimarrà sconosciuta, in quanto tale non contribuirà alla risoluzione di ciò
che ha causato l'eccezione (errore).
• Nel caso in cui la connessione al database (pool) venga chiusa per qualche motivo, ciò
comporterà una costante propagazione degli errori, il che significa che il server sarà in
esecuzione ma non si riconnetterà a db.
Ritorno allo stato iniziale
In caso di "uncaughtException" è bene riavviare il server e riportarlo allo stato iniziale , dove
sappiamo che funzionerà. Viene registrata un'eccezione, l'applicazione viene chiusa ma, poiché
verrà eseguita in un contenitore che si accerterà che il server sia in esecuzione, otterremo il
riavvio del server (ritorno allo stato operativo iniziale).
• Installazione per sempre (o altro strumento CLI per assicurarsi che quel server nodo funzioni
continuamente)
npm install forever -g
• Avvio del server per sempre
forever start app.js
Il motivo per cui è stato avviato e il motivo per cui utilizziamo per sempre è dopo che il
server è stato interrotto per sempre. Il processo riavvierà il server.
• Riavvio del server
process.on('uncaughtException', function (err) {
console.log(err);
// some logging mechanisam
https://riptutorial.com/it/home 217
// ....
process.exit(1); // terminates process
});
In una nota a margine c'era anche un modo per gestire le eccezioni con Cluster e Domini .
I domini sono deprecati qui più informazioni.
Errori e promesse
Le promesse gestiscono gli errori in modo diverso rispetto al codice sincrono o callback.
const p = new Promise(function (resolve, reject) {
reject(new Error('Oops'));
});
// anything that is `reject`ed inside a promise will be available through catch
// while a promise is rejected, `.then` will not be called
p
.then(() => {
console.log("won't be called");
})
.catch(e => {
console.log(e.message); // output: Oops
})
// once the error is caught, execution flow resumes
.then(() => {
console.log('hello!'); // output: hello!
});
attualmente, gli errori generati da una promessa che non viene rilevata provocano l'errore di
essere ingeriti, il che può rendere difficile rintracciare l'errore. Questo può essere risolto
utilizzando strumenti di linting come eslint o assicurando di avere sempre una clausola di catch .
Questo comportamento è deprecato nel nodo 8 a favore del termine del processo del nodo.
Leggi La gestione delle eccezioni online: https://riptutorial.com/it/node-js/topic/2819/la-gestione-
delle-eccezioni
https://riptutorial.com/it/home 218
Capitolo 61: Le notifiche push
introduzione
Quindi, se vuoi fare una notifica per le app Web, ti suggerisco di utilizzare il framework Push.js o
SoneSignal per l'app Web / mobile.
Push è il modo più veloce per essere subito operativo con le notifiche Javascript. Una nuova
aggiunta alle specifiche ufficiali, l'API di notifica consente ai browser moderni come Chrome,
Safari, Firefox e IE 9+ di inviare notifiche al desktop di un utente.
Dovrai usare Socket.io e qualche framework di backend, userò Express per questo esempio.
Parametri
Modulo /
descrizione
quadro
node.js / Semplice framework back-end per l'applicazione Node.js, molto facile da
espresso usare ed estremamente potente
Socket.IO consente comunicazioni bidirezionali basate su eventi in tempo
Socket.io reale. Funziona su ogni piattaforma, browser o dispositivo, concentrandosi in
egual misura su affidabilità e velocità.
Push.js Il framework di notifiche desktop più versatile al mondo
OneSignal Solo un altro modulo di notifiche push per dispositivi Apple
Firebase è la piattaforma mobile di Google che ti aiuta a sviluppare
Firebase
rapidamente app di alta qualità e a far crescere la tua attività.
Examples
Notifica Web
Innanzitutto, devi installare il modulo Push.js.
$ npm install push.js --save
Oppure importalo nella tua app front-end tramite CDN
<script src="./push.min.js"></script> <!-- CDN link -->
https://riptutorial.com/it/home 219
Dopo aver finito con quello, dovresti essere bravo ad andare. Ecco come dovrebbe apparire se
vuoi fare una semplice notifica:
Push.create('Hello World!')
Presumo che tu sappia come configurare Socket.io con la tua app. Ecco alcuni esempi di codice
della mia app di backend con express:
var app = require('express')();
var server = require('http').Server(app);
var io = require('socket.io')(server);
server.listen(80);
app.get('/', function (req, res) {
res.sendfile(__dirname + '/index.html');
});
io.on('connection', function (socket) {
socket.emit('pushNotification', { success: true, msg: 'hello' });
});
Dopo aver configurato il tuo server, dovresti essere in grado di passare a cose di front-end. Ora
tutto ciò che dobbiamo fare è importare Socket.io CDN e aggiungere questo codice al mio file
index.html :
<script src="../socket.io.js"></script> <!-- CDN link -->
<script>
var socket = io.connect('http://localhost');
socket.on('pushNotification', function (data) {
console.log(data);
Push.create("Hello world!", {
body: data.msg, //this should print "hello"
icon: '/icon.png',
timeout: 4000,
onClick: function () {
window.focus();
this.close();
}
});
});
</script>
Ecco fatto, ora dovresti essere in grado di visualizzare la tua notifica, questo funziona anche su
qualsiasi dispositivo Android, e se vuoi usare la messaggistica cloud Firebase , puoi usarlo con
questo modulo, Ecco il link per quell'esempio scritto da Nick (creatore di Push.js)
Mela
Tieni presente che ciò non funzionerà sui dispositivi Apple (non li ho testati tutti), ma se vuoi fare
notifiche push controlla il plug-in OneSignal .
https://riptutorial.com/it/home 220
Leggi Le notifiche push online: https://riptutorial.com/it/node-js/topic/10892/le-notifiche-push
https://riptutorial.com/it/home 221
Capitolo 62: Linea di lettura
Sintassi
• const readline = require ('readline')
• readline.close ()
• readline.pause ()
• readline.prompt ([preserveCursor])
• readline.question (query, callback)
• readline.resume ()
• readline.setPrompt (prompt)
• readline.write (data [, chiave])
• readline.clearLine (stream, dir)
• readline.clearScreenDown (stream)
• readline.createInterface (opzioni)
• readline.cursorTo (stream, x, y)
• readline.emitKeypressEvents (stream [, interfaccia])
• readline.moveCursor (stream, dx, dy)
Examples
Lettura file riga per riga
const fs = require('fs');
const readline = require('readline');
const rl = readline.createInterface({
input: fs.createReadStream('text.txt')
});
// Each new line emits an event - every time the stream receives \r, \n, or \r\n
rl.on('line', (line) => {
console.log(line);
});
rl.on('close', () => {
console.log('Done reading file');
});
Richiesta di input da parte dell'utente tramite CLI
const readline = require('readline');
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
rl.question('What is your name?', (name) => {
https://riptutorial.com/it/home 222
console.log(`Hello ${name}!`);
rl.close();
});
Leggi Linea di lettura online: https://riptutorial.com/it/node-js/topic/1431/linea-di-lettura
https://riptutorial.com/it/home 223
Capitolo 63: Localizzazione del nodo JS
introduzione
È molto semplice da gestire nodejs di localizzazione express
Examples
utilizzando il modulo i18n per mantenere la localizzazione nell'app nodo js
Modulo di traduzione semplice e leggero con memoria json dinamica. Supporta semplici
applicazioni node.js di vanilla e dovrebbe funzionare con qualsiasi framework (come express,
restify e probabilmente più) che espone un metodo app.use () che passa in oggetti res e req.
Utilizza la sintassi comune __ ('...') in app e modelli. Memorizza i file di lingua in file json
compatibili con il formato webtranslateit json. Aggiunge nuove stringhe al volo quando vengono
utilizzate per la prima volta nella tua app. Non è necessaria alcuna analisi extra.
express + i18n-node + cookieParser ed evita problemi di concorrenza
// usual requirements
var express = require('express'),
i18n = require('i18n'),
app = module.exports = express();
i18n.configure({
// setup some locales - other locales default to en silently
locales: ['en', 'ru', 'de'],
// sets a custom cookie name to parse locale settings from
cookie: 'yourcookiename',
// where to store json files - defaults to './locales'
directory: __dirname + '/locales'
});
app.configure(function () {
// you will need to use cookieParser to expose cookies to req.cookies
app.use(express.cookieParser());
// i18n init parses req for language headers, cookies, etc.
app.use(i18n.init);
});
// serving homepage
app.get('/', function (req, res) {
res.send(res.__('Hello World'));
});
// starting server
if (!module.parent) {
app.listen(3000);
https://riptutorial.com/it/home 224
}
Leggi Localizzazione del nodo JS online: https://riptutorial.com/it/node-
js/topic/9594/localizzazione-del-nodo-js
https://riptutorial.com/it/home 225
Capitolo 64: Lodash
introduzione
Lodash è una comoda libreria di utilità JavaScript.
Examples
Filtra una raccolta
Il frammento di codice qui sotto mostra i vari modi in cui puoi filtrare su una serie di oggetti usando
lodash.
let lodash = require('lodash');
var countries = [
{"key": "DE", "name": "Deutschland", "active": false},
{"key": "ZA", "name": "South Africa", "active": true}
];
var filteredByFunction = lodash.filter(countries, function (country) {
return country.key === "DE";
});
// => [{"key": "DE", "name": "Deutschland"}];
var filteredByObjectProperties = lodash.filter(countries, { "key": "DE" });
// => [{"key": "DE", "name": "Deutschland"}];
var filteredByProperties = lodash.filter(countries, ["key", "ZA"]);
// => [{"key": "ZA", "name": "South Africa"}];
var filteredByProperty = lodash.filter(countries, "active");
// => [{"key": "ZA", "name": "South Africa"}];
Leggi Lodash online: https://riptutorial.com/it/node-js/topic/9161/lodash
https://riptutorial.com/it/home 226
Capitolo 65: Loopback - Connettore basato
REST
introduzione
Connettori basati sul riposo e come gestirli. Sappiamo tutti che Loopback non fornisce eleganza
alle connessioni basate su REST
Examples
Aggiungere un connettore basato sul web
// Questo esempio ottiene la risposta da iTunes
{
"riposo": {
"nome": "resto",
"connettore": "resto",
"debug": vero,
"opzioni": {
"useQuerystring": true,
"timeout": 10000,
"intestazioni": {
"accetta": "application / json",
"content-type": "application / json"
}
},
"operazioni": [
{
"modello": {
"metodo": "OTTIENI",
"url": "https://itunes.apple.com/search",
"query": {
"termine": "{parola chiave}",
"Paese": "{country = IN}",
"media": "{itemType = music}",
"limit": "{limit = 10}",
"esplicito": "falso"
}
},
"funzioni": {
"ricerca": [
"parola chiave",
"nazione",
"tipo di elemento",
"limite"
]
}
},
{
"modello": {
"metodo": "OTTIENI",
"url": "https://itunes.apple.com/lookup",
"query": {
https://riptutorial.com/it/home 227
"L'ho fatto}"
}
},
"funzioni": {
"findById": [
"Id"
]
}
}
]
}
}
Leggi Loopback - Connettore basato REST online: https://riptutorial.com/it/node-
js/topic/9234/loopback---connettore-basato-rest
https://riptutorial.com/it/home 228
Capitolo 66: Mantenere costantemente attiva
un'applicazione di nodo
Examples
Utilizzare PM2 come gestore processi
PM2 ti consente di eseguire gli script nodejs per sempre. Nel caso in cui l'applicazione si arresti in
modo anomalo, anche PM2 lo riavvierà automaticamente.
Installa PM2 a livello globale per gestire le istanze nodejs
npm install pm2 -g
Passare alla directory in cui risiede lo script nodejs ed eseguire il seguente comando ogni volta
che si desidera avviare un'istanza nodejs da monitorare tramite pm2:
pm2 start server.js --name "app1"
Comandi utili per il monitoraggio del processo
1. Elenca tutte le istanze nodejs gestite da pm2
pm2 list
2. Arresta una particolare istanza nodejs
pm2 stop <instance named>
3. Elimina una particolare istanza nodejs
https://riptutorial.com/it/home 229
pm2 delete <instance name>
4. Riavvia una particolare istanza nodejs
pm2 restart <instance name>
5. Monitoraggio di tutte le istanze nodejs
pm2 monit
6. Stop pm2
pm2 kill
7. A differenza del riavvio, che uccide e riavvia il processo, ricarica un tempo di ricarica di 0
secondi
pm2 reload <instance name>
8. Visualizza i log
pm2 logs <instance_name>
Esecuzione e arresto di un daemon Forever
Per iniziare il processo:
$ forever start index.js
warn: --minUptime not set. Defaulting to: 1000ms
warn: --spinSleepTime not set. Your script will exit if it does not stay up for at least
1000ms
info: Forever processing file: index.js
Elenco in esecuzione per sempre istanze:
https://riptutorial.com/it/home 230
$ forever list
info: Forever processes running
|data: | index | uid | command | script |forever pid|id | logfile
|uptime |
|------|-------|-----|------------------|-------------|-----------|-----|---------------------
---|--------------|
|data: | [0] |f4Kt |/usr/bin/nodejs | src/index.js|2131 |
2146|/root/.forever/f4Kt.log | 0:0:0:11.485 |
Fermare il primo processo:
$ forever stop 0
$ forever stop 2146
$ forever stop --uid f4Kt
$ forever stop --pidFile 2131
Funzionamento continuo con nohup
Un'alternativa a per sempre su Linux è nohup.
Per avviare un'istanza nohup
1. cd nella posizione di app.js o cartella www
2. eseguire nohup nodejs app.js &
Per uccidere il processo
1. lanciare ps -ef|grep nodejs
2. kill -9 <the process number>
Process Mangement with Forever
Installazione
npm install forever -g
cd /node/project/directory
usi
forever start app.js
Leggi Mantenere costantemente attiva un'applicazione di nodo online:
https://riptutorial.com/it/node-js/topic/2820/mantenere-costantemente-attiva-un-applicazione-di-
nodo
https://riptutorial.com/it/home 231
Capitolo 67: metalsmith
Examples
Costruisci un semplice blog
Supponendo di avere node e npm installati e disponibili, creare una cartella di progetto con un
package.json . Installa le dipendenze necessarie:
npm install --save-dev metalsmith metalsmith-in-place handlebars
Creare un file chiamato build.js nella build.js principale della cartella del progetto, contenente
quanto segue:
var metalsmith = require('metalsmith');
var handlebars = require('handlebars');
var inPlace = require('metalsmith-in-place');
Metalsmith(__dirname)
.use(inPlace('handlebars'))
.build(function(err) {
if (err) throw err;
console.log('Build finished!');
});
Crea una cartella chiamata src nella radice della cartella del tuo progetto. Crea index.html in src ,
contenente quanto segue:
---
title: My awesome blog
---
<h1>{{ title }}</h1>
L'esecuzione di node build.js ora creerà tutti i file in src . Dopo aver eseguito questo comando,
avrai index.html nella tua cartella di compilazione, con i seguenti contenuti:
<h1>My awesome blog</h1>
Leggi metalsmith online: https://riptutorial.com/it/node-js/topic/6111/metalsmith
https://riptutorial.com/it/home 232
Capitolo 68: Modulo Cluster
Sintassi
• const cluster = require ("cluster")
• cluster.fork ()
• cluster.isMaster
• cluster.isWorker
• cluster.schedulingPolicy
• cluster.setupMaster (impostazioni)
• cluster.settings
• cluster.worker // in worker
• cluster.workers // in master
Osservazioni
Si noti che cluster.fork() genera un processo figlio che inizia a eseguire lo script corrente
dall'inizio, in contrasto con la chiamata di sistema fork() in C che clona il processo corrente e
continua dall'istruzione dopo la chiamata di sistema in entrambi i genitori e processo figlio.
La documentazione di Node.js ha una guida più completa ai cluster qui
Examples
Ciao mondo
Questo è il tuo cluster.js :
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length;
if (cluster.isMaster) {
// Fork workers.
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
cluster.on('exit', (worker, code, signal) => {
console.log(`worker ${worker.process.pid} died`);
});
} else {
// Workers can share any TCP connection
// In this case it is an HTTP server
require('./server.js')();
}
Questo è il tuo server.js principale:
https://riptutorial.com/it/home 233
const http = require('http');
function startServer() {
const server = http.createServer((req, res) => {
res.writeHead(200);
res.end('Hello Http');
});
server.listen(3000);
}
if(!module.parent) {
// Start server if file is run directly
startServer();
} else {
// Export server, if file is referenced via cluster
module.exports = startServer;
}
In questo esempio, ospitiamo un server Web di base, tuttavia, giriamo i worker (processi
secondari) utilizzando il modulo cluster incorporato. Il numero di processi forker dipende dal
numero di core CPU disponibili. Ciò consente a un'applicazione Node.js di sfruttare le CPU multi-
core, poiché una singola istanza di Node.js viene eseguita in un singolo thread. L'applicazione
condividerà ora la porta 8000 su tutti i processi. I carichi verranno automaticamente distribuiti tra i
lavoratori utilizzando il metodo Round-Robin per impostazione predefinita.
Esempio di cluster
Una singola istanza di Node.js viene eseguita in un singolo thread. Per sfruttare i sistemi multi-
core, l'applicazione può essere avviata in un cluster di processi Node.js per gestire il carico.
Il modulo cluster consente di creare facilmente processi figlio che condividono tutte le porte del
server.
L'esempio seguente crea il processo child worker nel processo principale che gestisce il carico su
più core.
Esempio
const cluster = require('cluster');
const http = require('http');
const numCPUs = require('os').cpus().length; //number of CPUS
if (cluster.isMaster) {
// Fork workers.
for (var i = 0; i < numCPUs; i++) {
cluster.fork(); //creating child process
}
//on exit of cluster
cluster.on('exit', (worker, code, signal) => {
if (signal) {
console.log(`worker was killed by signal: ${signal}`);
} else if (code !== 0) {
console.log(`worker exited with error code: ${code}`);
https://riptutorial.com/it/home 234
} else {
console.log('worker success!');
}
});
} else {
// Workers can share any TCP connection
// In this case it is an HTTP server
http.createServer((req, res) => {
res.writeHead(200);
res.end('hello world\n');
}).listen(3000);
}
Leggi Modulo Cluster online: https://riptutorial.com/it/node-js/topic/2817/modulo-cluster
https://riptutorial.com/it/home 235
Capitolo 69: MSSQL Intergration
introduzione
Per integrare qualsiasi database con nodejs è necessario un pacchetto driver o si può chiamare
un modulo npm che fornirà API di base per connettersi con il database ed eseguire interazioni. Lo
stesso vale per il database mssql, qui integreremo mssql con nodejs ed eseguiremo alcune query
di base su tabelle SQL.
Osservazioni
Abbiamo assunto che avremo un'istanza locale del server di database mssql in esecuzione sul
computer locale. Puoi fare riferimento a questo documento per fare lo stesso.
Assicurati inoltre di aver aggiunto l'utente appropriato creato con i privilegi.
Examples
Connessione con SQL tramite. modulo mssql npm
Inizieremo con la creazione di una semplice applicazione di nodo con una struttura di base e
quindi la connessione con il database del server SQL locale e l'esecuzione di alcune query su
quel database.
Passaggio 1: creare una directory / cartella in base al nome del progetto che si intende creare.
Inizializza un'applicazione di nodo utilizzando il comando npm init che creerà un package.json
nella directory corrente.
mkdir mySqlApp
//folder created
cd mwSqlApp
//change to newly created directory
npm init
//answer all the question ..
npm install
//This will complete quickly since we have not added any packages to our app.
Passo 2: Ora creeremo un file App.js in questa directory e installeremo alcuni pacchetti che
dovranno essere collegati a sql db.
sudo gedit App.js
//This will create App.js file , you can use your fav. text editor :)
npm install --save mssql
//This will install the mssql package to you app
Passo 3: Ora aggiungeremo alla nostra applicazione una variabile di configurazione di base che
verrà utilizzata dal modulo mssql per stabilire una connessione.
https://riptutorial.com/it/home 236
console.log("Hello world, This is an app to connect to sql server.");
var config = {
"user": "myusername", //default is sa
"password": "yourStrong(!)Password",
"server": "localhost", // for local machine
"database": "staging", // name of database
"options": {
"encrypt": true
}
}
sql.connect(config, err => {
if(err){
throw err ;
}
console.log("Connection Successful !");
new sql.Request().query('select 1 as number', (err, result) => {
//handle err
console.dir(result)
// This example uses callbacks strategy for getting results.
})
});
sql.on('error', err => {
// ... error handler
console.log("Sql database connection error " ,err);
})
Passaggio 4: questo è il passaggio più semplice, in cui avviamo l'applicazione e l'applicazione si
connetterà al server sql e stamperà alcuni risultati semplici.
node App.js
// Output :
// Hello world, This is an app to connect to sql server.
// Connection Successful !
// 1
Per utilizzare le promesse o asincrone per l'esecuzione della query, fare riferimento ai
documenti ufficiali del pacchetto mssql:
• promesse
• Async / Await
Leggi MSSQL Intergration online: https://riptutorial.com/it/node-js/topic/9884/mssql-intergration
https://riptutorial.com/it/home 237
Capitolo 70: multithreading
introduzione
Node.js è stato progettato per essere thread singolo. Quindi, per tutti gli scopi pratici, le
applicazioni che si avviano con Node verranno eseguite su un singolo thread.
Tuttavia, Node.js stesso esegue multi-thread. Le operazioni di I / O e simili verranno eseguite da
un pool di thread. Inoltre, qualsiasi istanza di un'applicazione nodo viene eseguita su un thread
diverso, pertanto per eseguire applicazioni multi-thread si avviano più istanze.
Osservazioni
Capire il Loop degli Eventi è importante per capire come e perchè usare più thread.
Examples
Grappolo
Il modulo cluster consente di avviare la stessa applicazione più volte.
Il clustering è auspicabile quando le diverse istanze hanno lo stesso flusso di esecuzione e non
dipendono l'una dall'altra. In questo scenario, hai un master che può avviare fork e fork (o figli). I
bambini lavorano indipendentemente e hanno il loro unico spazio di Ram ed Event Loop.
La configurazione dei cluster può essere utile per i siti Web / le API. Qualsiasi thread può servire
qualsiasi cliente, in quanto non dipende da altri thread. Un database (come Redis) verrebbe
utilizzato per condividere cookie, in quanto le variabili non possono essere condivise! tra i fili.
// runs in each instance
var cluster = require('cluster');
var numCPUs = require('os').cpus().length;
console.log('I am always called');
if (cluster.isMaster) {
// runs only once (within the master);
console.log('I am the master, launching workers!');
for(var i = 0; i < numCPUs; i++) cluster.fork();
} else {
// runs in each fork
console.log('I am a fork!');
// here one could start, as an example, a web server
console.log('I am always called as well');
https://riptutorial.com/it/home 238
Processo figlio
I processi figlio sono la strada da seguire quando si desidera eseguire processi in modo
indipendente con diverse inizializzazioni e preoccupazioni. Come i fork nei cluster, un
child_process viene eseguito nel thread, ma a differenza dei fork, ha un modo di comunicare con i
suoi genitori.
La comunicazione va in entrambe le direzioni, quindi genitore e figlio possono ascoltare i
messaggi e inviare messaggi.
Parent (../parent.js)
var child_process = require('child_process');
console.log('[Parent]', 'initalize');
var child1 = child_process.fork(__dirname + '/child');
child1.on('message', function(msg) {
console.log('[Parent]', 'Answer from child: ', msg);
});
// one can send as many messages as one want
child1.send('Hello'); // Hello to you too :)
child1.send('Hello'); // Hello to you too :)
// one can also have multiple children
var child2 = child_process.fork(__dirname + '/child');
Bambino (../child.js)
// here would one initialize this child
// this will be executed only once
console.log('[Child]', 'initalize');
// here one listens for new tasks from the parent
process.on('message', function(messageFromParent) {
//do some intense work here
console.log('[Child]', 'Child doing some intense work');
if(messageFromParent == 'Hello') process.send('Hello to you too :)');
else process.send('what?');
})
Accanto al messaggio si possono ascoltare molti eventi come "errore", "connesso" o
"disconnessione".
L'avvio di un processo secondario comporta un certo costo associato. Si vorrebbe generare il
maggior numero possibile di loro.
Leggi multithreading online: https://riptutorial.com/it/node-js/topic/10592/multithreading
https://riptutorial.com/it/home 239
Capitolo 71: N-API
introduzione
La N-API è un modo nuovo e migliore per creare un modulo nativo per NodeJS. N-API è nella fase
iniziale in modo che possa avere documentazione incoerente.
Examples
Ciao a N-API
Questo modulo registra la funzione ciao sul modulo hello. ciao funzione stampa Hello world su
console con printf e restituisce 1373 dalla funzione nativa nel chiamante javascript.
#include <node_api.h>
#include <stdio.h>
napi_value say_hello(napi_env env, napi_callback_info info)
{
napi_value retval;
printf("Hello world\n");
napi_create_number(env, 1373, &retval);
return retval;
}
void init(napi_env env, napi_value exports, napi_value module, void* priv)
{
napi_status status;
napi_property_descriptor desc = {
/*
* String describing the key for the property, encoded as UTF8.
*/
.utf8name = "hello",
/*
* Set this to make the property descriptor object's value property
* to be a JavaScript function represented by method.
* If this is passed in, set value, getter and setter to NULL (since these members
won't be used).
*/
.method = say_hello,
/*
* A function to call when a get access of the property is performed.
* If this is passed in, set value and method to NULL (since these members won't be
used).
* The given function is called implicitly by the runtime when the property is
accessed
* from JavaScript code (or if a get on the property is performed using a N-API call).
*/
.getter = NULL,
/*
https://riptutorial.com/it/home 240
* A function to call when a set access of the property is performed.
* If this is passed in, set value and method to NULL (since these members won't be
used).
* The given function is called implicitly by the runtime when the property is set
* from JavaScript code (or if a set on the property is performed using a N-API call).
*/
.setter = NULL,
/*
* The value that's retrieved by a get access of the property if the property is a
data property.
* If this is passed in, set getter, setter, method and data to NULL (since these
members won't be used).
*/
.value = NULL,
/*
* The attributes associated with the particular property. See
napi_property_attributes.
*/
.attributes = napi_default,
/*
* The callback data passed into method, getter and setter if this function is
invoked.
*/
.data = NULL
};
/*
* This method allows the efficient definition of multiple properties on a given object.
*/
status = napi_define_properties(env, exports, 1, &desc);
if (status != napi_ok)
return;
}
NAPI_MODULE(hello, init)
Leggi N-API online: https://riptutorial.com/it/node-js/topic/10539/n-api
https://riptutorial.com/it/home 241
Capitolo 72: Node server senza framework
Osservazioni
Sebbene Node abbia molti framework per aiutarti a far funzionare il tuo server, principalmente:
Express : la struttura più utilizzata
Totale : il framework ALL-IN-ONE UNITY, che ha tutto e non dipende da nessun altro framework o
modulo.
Tuttavia, non esiste sempre una taglia adatta a tutti, quindi lo sviluppatore potrebbe aver bisogno
di creare il proprio server, senza altre dipendenze.
Se l'app a cui si accede tramite un server esterno, CORS potrebbe essere un problema, un codice
per evitare che fosse stato fornito.
Examples
Node server senza Framework
var http = require('http');
var fs = require('fs');
var path = require('path');
http.createServer(function (request, response) {
console.log('request ', request.url);
var filePath = '.' + request.url;
if (filePath == './')
filePath = './index.html';
var extname = String(path.extname(filePath)).toLowerCase();
var contentType = 'text/html';
var mimeTypes = {
'.html': 'text/html',
'.js': 'text/javascript',
'.css': 'text/css',
'.json': 'application/json',
'.png': 'image/png',
'.jpg': 'image/jpg',
'.gif': 'image/gif',
'.wav': 'audio/wav',
'.mp4': 'video/mp4',
'.woff': 'application/font-woff',
'.ttf': 'applilcation/font-ttf',
'.eot': 'application/vnd.ms-fontobject',
'.otf': 'application/font-otf',
'.svg': 'application/image/svg+xml'
};
contentType = mimeTypes[extname] || 'application/octect-stream';
https://riptutorial.com/it/home 242
fs.readFile(filePath, function(error, content) {
if (error) {
if(error.code == 'ENOENT'){
fs.readFile('./404.html', function(error, content) {
response.writeHead(200, { 'Content-Type': contentType });
response.end(content, 'utf-8');
});
}
else {
response.writeHead(500);
response.end('Sorry, check with the site admin for error: '+error.code+' ..\n');
response.end();
}
}
else {
response.writeHead(200, { 'Content-Type': contentType });
response.end(content, 'utf-8');
}
});
}).listen(8125);
console.log('Server running at http://127.0.0.1:8125/');
Superare i problemi CORS
// Website you wish to allow to connect to
response.setHeader('Access-Control-Allow-Origin', '*');
// Request methods you wish to allow
response.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS, PUT, PATCH, DELETE');
// Request headers you wish to allow
response.setHeader('Access-Control-Allow-Headers', 'X-Requested-With,content-type');
// Set to true if you need the website to include cookies in the requests sent
// to the API (e.g. in case you use sessions)
response.setHeader('Access-Control-Allow-Credentials', true);
Leggi Node server senza framework online: https://riptutorial.com/it/node-js/topic/5910/node-
server-senza-framework
https://riptutorial.com/it/home 243
Capitolo 73: Node.js (express.js) con il codice
di esempio angular.js
introduzione
Questo esempio mostra come creare un'applicazione Express di base e quindi servire AngularJS.
Examples
Creare il nostro progetto.
Siamo a posto, corriamo, di nuovo dalla console:
mkdir our_project
cd our_project
Ora siamo nel posto in cui il nostro codice vivrà. Per creare l'archivio principale del nostro progetto
puoi eseguire
Ok, ma come creiamo il progetto express skeleton?
È semplice:
npm install -g express express-generator
Le distribuzioni Linux e Mac dovrebbero usare sudo per installarlo perché sono installate nella
directory nodejs che è accessibile solo dall'utente root . Se tutto è andato bene possiamo
finalmente creare lo scheletro Express-App, basta correre
express
Questo comando creerà all'interno della nostra cartella un'app di esempio esplicita. La struttura è
la seguente:
bin/
public/
routes/
views/
app.js
package.json
Ora, se eseguiamo npm, iniziamo a visitare http: // localhost: 3000 vedremo l'applicazione
Express funzionante, abbastanza bene abbiamo generato un'app express senza troppi problemi,
ma come possiamo mescolarlo con AngularJS? .
https://riptutorial.com/it/home 244
Come funziona espresso, brevemente?
Express è un framework basato su Nodejs , puoi vedere la documentazione ufficiale sul sito
Express . Ma per il nostro scopo abbiamo bisogno di sapere che Express è il responsabile
quando scriviamo, ad esempio, http: // localhost: 3000 / home del rendering della home page della
nostra applicazione. Dall'app creata di recente, possiamo verificare:
FILE: routes/index.js
var express = require('express');
var router = express.Router();
/* GET home page. */
router.get('/', function(req, res, next) {
res.render('index', { title: 'Express' });
});
module.exports = router;
Quello che questo codice ci sta dicendo è che quando l'utente va su http: // localhost: 3000 deve
rendere la vista indice e passare un JSON con una proprietà title e valore Express. Ma quando
controlliamo la directory views e apriamo index.jade possiamo vedere questo:
extends layout
block content
h1= title
p Welcome to #{title}
Questa è un'altra potente funzionalità Express, i motori di template , che ti permettono di
eseguire il rendering del contenuto nella pagina passando variabili ad esso o ereditare un altro
modello in modo che le tue pagine siano più compatte e meglio comprensibili da altri. L'estensione
del file è .jade per quanto ne so Jade ha cambiato il nome per Pug , fondamentalmente è lo
stesso motore di template ma con alcuni aggiornamenti e modifiche fondamentali.
Installazione di Pug e aggiornamento del motore di template
Express.
Ok, per iniziare a usare Pug come motore di template del nostro progetto dobbiamo eseguire:
npm install --save pug
Questo installerà Pug come dipendenza del nostro progetto e lo salverà su package.json . Per
usarlo abbiamo bisogno di modificare il file app.js :
var app = express();
// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'pug');
https://riptutorial.com/it/home 245
E sostituisci il motore della linea di vista con Carlino e basta. Possiamo avviare nuovamente il
nostro progetto con l'avvio di npm e vedremo che tutto funziona correttamente .
In che modo AngularJS si inserisce in tutto questo?
AngularJS è un framework MVW Javascript (Model-View-Whatever) utilizzato principalmente per
creare l'installazione di SPA (Simple Page Application) è abbastanza semplice, è possibile visitare
il sito Web di AngularJS e scaricare l'ultima versione v1.6.4 .
Dopo aver scaricato AngularJS quando dovremmo copiare il file nella nostra cartella public /
javascripts all'interno del nostro progetto, una piccola spiegazione, questa è la cartella che serve
le risorse statiche del nostro sito, immagini, css, file javacript e così via. Naturalmente questo è
configurabile tramite il file app.js , ma lo manterremo semplice. Ora creiamo un file chiamato ng-
app.js , il file in cui la nostra applicazione vivrà, all'interno della nostra cartella pubblica dei
javascript, proprio dove vive AngularJS. Per portare su AngularJS, è necessario modificare il
contenuto delle viste / layout.pug come segue:
doctype html
html(ng-app='first-app')
head
title= title
link(rel='stylesheet', href='/stylesheets/style.css')
body(ng-controller='indexController')
block content
script(type='text-javascript', src='javascripts/angular.min.js')
script(type='text-javascript', src='javascripts/ng-app.js')
Cosa stiamo facendo qui ?, beh, stiamo includendo il core di AngularJS e il nostro file ng-app.js
di recente creazione , quindi quando il template è renderizzato porterà AngularJS in su, noterete
l'uso della direttiva ng-app , questo è indicativo AngularJS che questo è il nostro nome
dell'applicazione e dovrebbe attenersi ad esso.
Quindi, il contenuto del nostro ng-app.js sarà:
angular.module('first-app', [])
.controller('indexController', ['$scope', indexController]);
function indexController($scope) {
$scope.name = 'sigfried';
}
Stiamo utilizzando la funzione AngularJS più basilare qui, associazione dati bidirezionale ,
questo ci permette di aggiornare istantaneamente il contenuto della nostra vista e controller,
questa è una spiegazione molto semplice, ma puoi fare una ricerca in Google o StackOverflow per
vedere come funziona davvero.
Quindi, abbiamo i blocchi di base della nostra applicazione AngularJS, ma c'è qualcosa che
dobbiamo fare, dobbiamo aggiornare la nostra pagina index.pug per vedere i cambiamenti della
nostra app angolare, facciamolo:
https://riptutorial.com/it/home 246
extends layout
block content
div(ng-controller='indexController')
h1= title
p Welcome {{name}}
input(type='text' ng-model='name')
Qui leghiamo semplicemente l'input al nostro nome di proprietà definito nell'oscilloscopio
AngularJS all'interno del nostro controller:
$scope.name = 'sigfried';
Lo scopo di questo è che ogni volta che cambiamo il testo nell'input il paragrafo precedente
aggiornerà il suo contenuto all'interno del {{nome}}, questo è chiamato interpolazione , un'altra
caratteristica AngularJS per rendere il nostro contenuto nel modello.
Quindi, tutto è configurato, ora possiamo eseguire npm, andare su http: // localhost: 3000 e
vedere la nostra applicazione Express che serve la pagina e AngularJS che gestisce il frontend
dell'applicazione.
Leggi Node.js (express.js) con il codice di esempio angular.js online: https://riptutorial.com/it/node-
js/topic/9757/node-js--express-js--con-il-codice-di-esempio-angular-js
https://riptutorial.com/it/home 247
Capitolo 74: Node.js Architecture & Inner
Workings
Examples
Node.js - sotto il cofano
Node.js - in movimento
https://riptutorial.com/it/home 248
Leggi Node.js Architecture & Inner Workings online: https://riptutorial.com/it/node-
js/topic/5892/node-js-architecture--amp--inner-workings
https://riptutorial.com/it/home 249
Capitolo 75: Node.js con CORS
Examples
Abilita CORS in express.js
Poiché node.js viene spesso utilizzato per creare API, l'impostazione CORS corretta può essere
un salvataggio se si desidera poter richiedere l'API da domini diversi.
Nell'esempio, lo configureremo per la configurazione più ampia (autorizza tutti i tipi di richieste da
qualsiasi dominio.
Nel server.js dopo l'inizializzazione di express:
// Create express server
const app = express();
app.use((req, res, next) => {
res.header('Access-Control-Allow-Origin', '*');
// authorized headers for preflight requests
// https://developer.mozilla.org/en-US/docs/Glossary/preflight_request
res.header('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type,
Accept');
next();
app.options('*', (req, res) => {
// allowed XHR methods
res.header('Access-Control-Allow-Methods', 'GET, PATCH, PUT, POST, DELETE, OPTIONS');
res.send();
});
});
Di solito, il nodo viene eseguito dietro un proxy sui server di produzione. Pertanto il server proxy
inverso (come Apache o Nginx) sarà responsabile della configurazione di CORS.
Per adattare convenientemente questo scenario, è possibile abilitare solo node.js CORS quando è
in fase di sviluppo.
Questo è fatto facilmente controllando NODE_ENV :
const app = express();
if (process.env.NODE_ENV === 'development') {
// CORS settings
}
Leggi Node.js con CORS online: https://riptutorial.com/it/node-js/topic/9272/node-js-con-cors
https://riptutorial.com/it/home 250
Capitolo 76: Node.JS con ES6
introduzione
ES6, ECMAScript 6 o ES2015 è l'ultima specifica per JavaScript che introduce dello zucchero
sintattico nella lingua. È un grande aggiornamento del linguaggio e introduce molte nuove
funzionalità
Maggiori dettagli su Node e ES6 possono essere trovati sul loro sito
https://nodejs.org/en/docs/es6/
Examples
Nodo ES6 Supporto e creazione di un progetto con Babel
L'intera specifica ES6 non è stata ancora implementata nella sua interezza, quindi sarà possibile
utilizzare solo alcune delle nuove funzionalità. Puoi vedere un elenco delle funzionalità ES6
attualmente supportate su http://node.green/
Dal momento che NodeJS v6 ha avuto un supporto abbastanza buono. Pertanto, se si utilizza
NodeJS v6 o versione successiva, è possibile utilizzare ES6. Tuttavia, potresti anche voler
utilizzare alcune delle funzioni inedite e alcune da oltre. Per questo dovrai usare un transpiler
È possibile eseguire un transpiler in fase di esecuzione e creare, utilizzare tutte le funzionalità di
ES6 e altro ancora. Il traspiatore più popolare per JavaScript si chiama Babel
Babel ti consente di utilizzare tutte le funzionalità delle specifiche ES6 e alcune funzionalità
aggiuntive non specificate con "stage-0", ad esempio import thing from 'thing invece di var thing
= require('thing')
Se volessimo creare un progetto in cui usassimo funzionalità 'stage-0' come l'importazione,
avremmo bisogno di aggiungere Babel come traspiatore. Vedrai i progetti usando react e Vue e
altri pattern basati su CommonJS implementeranno lo stage-0 abbastanza spesso.
crea un nuovo progetto di nodo
mkdir my-es6-app
cd my-es6-app
npm init
Installa babel sul preset ES6 e sullo stage 0
npm install --save-dev babel-preset-es2015 babel-preset-stage-2 babel-cli babel-register
Crea un nuovo file chiamato server.js e aggiungi un server HTTP di base.
import http from 'http'
https://riptutorial.com/it/home 251
http.createServer((req, res) => {
res.writeHead(200, {'Content-Type': 'text/plain'})
res.end('Hello World\n')
}).listen(3000, '127.0.0.1')
console.log('Server running at http://127.0.0.1:3000/')
Nota che usiamo un import http from 'http' questa è una funzione di stage-0 e se funziona
significa che abbiamo il transpiler che funziona correttamente.
Se si esegue node server.js non riuscirà a sapere come gestire l'importazione.
Creare un file .babelrc nella directory principale della directory e aggiungere le seguenti
impostazioni
{
"presets": ["es2015", "stage-2"],
"plugins": []
}
ora puoi eseguire il server con il node src/index.js --exec babel-node
Completare l'operazione non è una buona idea eseguire un transpiler in fase di esecuzione su
un'app di produzione. Tuttavia, possiamo implementare alcuni script nel nostro package.json per
semplificare il lavoro.
"scripts": {
"start": "node dist/index.js",
"dev": "babel-node src/index.js",
"build": "babel src -d dist",
"postinstall": "npm run build"
},
Quanto sopra sopra npm install il codice transpiled nella directory dist consentendo a npm start a
usare il codice transpiled per la nostra app di produzione.
npm run dev avvierà il server e il runtime di babel che va bene e preferito quando si lavora su un
progetto localmente.
Andando avanti, è possibile installare nodemon npm install nodemon --save-dev per controllare le
modifiche e quindi riavviare l'app nodo.
Questo velocizza davvero il lavoro con Babel e NodeJS. In you package.json basta aggiornare lo
script "dev" per usare nodemon
"dev": "nodemon src/index.js --exec babel-node",
Usa JS es6 sulla tua app NodeJS
JS es6 (noto anche come es2015) è un insieme di nuove funzionalità del linguaggio JS volte a
renderlo più intuitivo quando si utilizza OOP o mentre si affrontano le attività di sviluppo moderne.
https://riptutorial.com/it/home 252
Prerequisiti:
1. Scopri le nuove funzionalità di es6 su http://es6-features.org - potrebbe chiarirti se hai
intenzione di usarlo nella tua prossima app NodeJS
2. Verifica il livello di compatibilità della versione del tuo nodo su http://node.green
3. Se tutto va bene, facciamo il codice!
Ecco un esempio molto breve di una semplice app hello world con JS es6
'use strict'
class Program
{
constructor()
{
this.message = 'hello es6 :)';
}
print()
{
setTimeout(() =>
{
console.log(this.message);
this.print();
}, Math.random() * 1000);
}
}
new Program().print();
È possibile eseguire questo programma e osservare come stampa lo stesso messaggio più e più
volte.
Ora .. lasciamolo giù riga per riga:
'use strict'
Questa linea è effettivamente necessaria se si intende utilizzare js es6. strict modalità strict ,
intenzionalmente, ha una semantica diversa dal codice normale (si prega di leggere di più su MDN
- https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode)
class Program
Incredibile: una parola chiave di class ! Solo per un rapido riferimento - prima di es6 l'unico modo
per definire una classe in js era con la parola chiave ... function !
function MyClass() // class definition
https://riptutorial.com/it/home 253
{
var myClassObject = new MyClass(); // generating a new object with a type of MyClass
Quando si utilizza OOP, una classe è un'abilità fondamentale che aiuta lo sviluppatore a
rappresentare una parte specifica di un sistema (la decomposizione del codice è cruciale quando
il codice diventa più grande .. ad esempio: quando si scrive il codice lato server)
constructor()
{
this.message = 'hello es6 :)';
}
Devi ammettere che è abbastanza intuitivo! Questo è l'indice della mia classe - questa "funzione"
unica si verificherà ogni volta che un oggetto viene creato da questa particolare classe (nel nostro
programma - solo una volta)
print()
{
setTimeout(() => // this is an 'arrow' function
{
console.log(this.message);
this.print(); // here we call the 'print' method from the class template itself (a
recursion in this particular case)
}, Math.random() * 1000);
}
Perché la stampa è definita nell'ambito della classe - in realtà è un metodo - che può essere
invocato dall'oggetto della classe o dalla stessa classe!
Quindi .. fino ad ora abbiamo definito la nostra classe .. tempo di usarla:
new Program().print();
Che è veramente uguale a:
var prog = new Program(); // define a new object of type 'Program'
prog.print(); // use the program to print itself
In conclusione: JS es6 può semplificare il tuo codice - renderlo più intuitivo e facile da capire
(confrontandolo con la versione precedente di JS) .. potresti provare a riscrivere un tuo codice
esistente e vedere la differenza per te stesso
GODERE :)
Leggi Node.JS con ES6 online: https://riptutorial.com/it/node-js/topic/5934/node-js-con-es6
https://riptutorial.com/it/home 254
Capitolo 77: Node.js con Oracle
Examples
Connetti a Oracle DB
Un modo molto semplice per connettersi a un database ORACLE è utilizzando il modulo oracledb .
Questo modulo gestisce la connessione tra l'app Node.js e il server Oracle. Puoi installarlo come
qualsiasi altro modulo:
npm install oracledb
Ora devi creare una connessione ORACLE, che puoi in seguito interrogare.
const oracledb = require('oracledb');
oracledb.getConnection(
{
user : "oli",
password : "password",
connectString : "ORACLE_DEV_DB_TNS_NAME"
},
connExecute
);
Il connectString "ORACLE_DEV_DB_TNA_NAME" può vivere in un file tnsnames.org nella stessa
directory o in cui è installato il tuo client istantaneo Oracle.
Se non si dispone di alcun client istantaneo Oracle installato sul proprio computer di sviluppo, è
possibile seguire la instant client installation guide per il proprio sistema operativo.
Interrogare un oggetto di connessione senza parametri
Utilizzare ora può utilizzare la funzione connExecute per l'esecuzione di una query. Hai la
possibilità di ottenere il risultato della query come oggetto o array. Il risultato è stampato su
console.log.
function connExecute(err, connection)
{
if (err) {
console.error(err.message);
return;
}
sql = "select 'test' as c1, 'oracle' as c2 from dual";
connection.execute(sql, {}, { outFormat: oracledb.OBJECT }, // or oracledb.ARRAY
function(err, result)
{
if (err) {
console.error(err.message);
connRelease(connection);
https://riptutorial.com/it/home 255
return;
}
console.log(result.metaData);
console.log(result.rows);
connRelease(connection);
});
}
Poiché abbiamo utilizzato una connessione non di pooling, dobbiamo rilasciare nuovamente la
nostra connessione.
function connRelease(connection)
{
connection.close(
function(err) {
if (err) {
console.error(err.message);
}
});
}
L'output per un oggetto sarà
[ { name: 'C1' }, { name: 'C2' } ]
[ { C1: 'test', C2: 'oracle' } ]
e l'output per un array sarà
[ { name: 'C1' }, { name: 'C2' } ]
[ [ 'test', 'oracle' ] ]
Utilizzo di un modulo locale per interrogazioni più semplici
Per semplificare le tue query da ORACLE-DB, puoi chiamare la tua query in questo modo:
const oracle = require('./oracle.js');
const sql = "select 'test' as c1, 'oracle' as c2 from dual";
oracle.queryObject(sql, {}, {})
.then(function(result) {
console.log(result.rows[0]['C2']);
})
.catch(function(err) {
next(err);
});
La creazione della connessione e l'esecuzione sono inclusi in questo file oracle.js con il contenuto
come segue:
'use strict';
const oracledb = require('oracledb');
const oracleDbRelease = function(conn) {
https://riptutorial.com/it/home 256
conn.release(function (err) {
if (err)
console.log(err.message);
});
};
function queryArray(sql, bindParams, options) {
options.isAutoCommit = false; // we only do SELECTs
return new Promise(function(resolve, reject) {
oracledb.getConnection(
{
user : "oli",
password : "password",
connectString : "ORACLE_DEV_DB_TNA_NAME"
})
.then(function(connection){
//console.log("sql log: " + sql + " params " + bindParams);
connection.execute(sql, bindParams, options)
.then(function(results) {
resolve(results);
process.nextTick(function() {
oracleDbRelease(connection);
});
})
.catch(function(err) {
reject(err);
process.nextTick(function() {
oracleDbRelease(connection);
});
});
})
.catch(function(err) {
reject(err);
});
});
}
function queryObject(sql, bindParams, options) {
options['outFormat'] = oracledb.OBJECT; // default is oracledb.ARRAY
return queryArray(sql, bindParams, options);
}
module.exports = queryArray;
module.exports.queryArray = queryArray;
module.exports.queryObject = queryObject;
Nota che hai entrambi i metodi queryArray e queryObject per chiamare sul tuo oggetto oracle.
Leggi Node.js con Oracle online: https://riptutorial.com/it/node-js/topic/8248/node-js-con-oracle
https://riptutorial.com/it/home 257
Capitolo 78: Node.js Design Fundamental
Examples
La filosofia Node.js
Small Core , Small Module : -
Costruisci moduli per piccoli e singoli scopi non solo in termini di dimensioni del codice, ma anche
in termini di ambito che serve a un unico scopo
a - "Small is beautiful"
b - "Make each program do one thing well."
Il modello del reattore
The Reactor Pattern è il cuore della natura asincrona di node.js Consentito al sistema di essere
implementato come un processo a thread singolo con una serie di generatori di eventi e gestori di
eventi, con l'aiuto del ciclo di eventi che viene eseguito continuamente.
Il motore I / O non bloccante di Node.js - libuv -
The Observer Pattern (EventEmitter) mantiene un elenco di dipendenti / osservatori e li notifica
var events = require('events');
var eventEmitter = new events.EventEmitter();
var ringBell = function ringBell()
{
console.log('tring tring tring');
}
eventEmitter.on('doorOpen', ringBell);
eventEmitter.emit('doorOpen');
Leggi Node.js Design Fundamental online: https://riptutorial.com/it/node-js/topic/6274/node-js-
design-fundamental
https://riptutorial.com/it/home 258
Capitolo 79: Node.JS e MongoDB.
Osservazioni
Queste sono le operazioni CRUD di base per l'uso di mongo db con nodejs.
Domanda: ci sono altri modi in cui puoi fare ciò che viene fatto qui ??
Risposta: Sì, ci sono numerosi modi per farlo.
Domanda: Sta usando la mangusta ??
Risposta: No. Ci sono altri pacchetti disponibili che possono aiutarti.
Domanda: dove posso ottenere la documentazione completa di mangusta ??
Risposta: clicca qui
Examples
Connessione a un database
Per connettersi a un database mongo dall'applicazione nodo richiediamo mangusta.
Installazione di Mongoose Vai al toot della tua applicazione e installa mangusta di
npm install mongoose
Quindi ci colleghiamo al database.
var mongoose = require('mongoose');
//connect to the test database running on default mongod port of localhost
mongoose.connect('mongodb://localhost/test');
//Connecting with custom credentials
mongoose.connect('mongodb://USER:PASSWORD@HOST:PORT/DATABASE');
//Using Pool Size to define the number of connections opening
//Also you can use a call back function for error handling
mongoose.connect('mongodb://localhost:27017/consumers',
{server: { poolSize: 50 }},
function(err) {
if(err) {
console.log('error in this')
console.log(err);
// Do whatever to handle the error
} else {
https://riptutorial.com/it/home 259
console.log('Connected to the database');
}
});
Creazione di una nuova collezione
Con Mongoose, tutto è derivato da uno schema. Consente di creare uno schema.
var mongoose = require('mongoose');
var Schema = mongoose.Schema;
var AutoSchema = new Schema({
name : String,
countOf: Number,
});
// defining the document structure
// by default the collection created in the db would be the first parameter we use (or the
plural of it)
module.exports = mongoose.model('Auto', AutoSchema);
// we can over write it and define the collection name by specifying that in the third
parameters.
module.exports = mongoose.model('Auto', AutoSchema, 'collectionName');
// We can also define methods in the models.
AutoSchema.methods.speak = function () {
var greeting = this.name
? "Hello this is " + this.name+ " and I have counts of "+ this.countOf
: "I don't have a name";
console.log(greeting);
}
mongoose.model('Auto', AutoSchema, 'collectionName');
Ricorda che i metodi devono essere aggiunti allo schema prima di compilarlo con
mongoose.model () come fatto sopra.
Inserimento di documenti
Per inserire un nuovo documento nella collezione, creiamo un oggetto dello schema.
var Auto = require('models/auto')
var autoObj = new Auto({
name: "NewName",
countOf: 10
});
Lo salviamo come il seguente
autoObj.save(function(err, insertedAuto) {
if (err) return console.error(err);
insertedAuto.speak();
// output: Hello this is NewName and I have counts of 10
https://riptutorial.com/it/home 260
});
Questo inserirà un nuovo documento nella collezione
Lettura
Leggere i dati dalla collezione è molto semplice. Ottenere tutti i dati della collezione.
var Auto = require('models/auto')
Auto.find({}, function (err, autos) {
if (err) return console.error(err);
// will return a json array of all the documents in the collection
console.log(autos);
})
Lettura dei dati con una condizione
Auto.find({countOf: {$gte: 5}}, function (err, autos) {
if (err) return console.error(err);
// will return a json array of all the documents in the collection whose count is
greater than 5
console.log(autos);
})
È inoltre possibile specificare il secondo parametro come oggetto di ciò che tutti i campi necessari
Auto.find({},{name:1}, function (err, autos) {
if (err) return console.error(err);
// will return a json array of name field of all the documents in the collection
console.log(autos);
})
Trovare un documento in una raccolta.
Auto.findOne({name:"newName"}, function (err, auto) {
if (err) return console.error(err);
//will return the first object of the document whose name is "newName"
console.log(auto);
})
Trovare un documento in una raccolta tramite id.
Auto.findById(123, function (err, auto) {
if (err) return console.error(err);
//will return the first json object of the document whose id is 123
console.log(auto);
})
In aggiornamento
Per l'aggiornamento di raccolte e documenti possiamo utilizzare uno di questi metodi:
https://riptutorial.com/it/home 261
metodi
• aggiornare()
• updateOne ()
• updateMany ()
• replaceOne ()
Aggiornare()
Il metodo update () modifica uno o più documenti (parametri di aggiornamento)
db.lights.update(
{ room: "Bedroom" },
{ status: "On" }
)
Questa operazione cerca la raccolta 'luci' per un documento in cui room è Bedroom (1 °
parametro) . Quindi aggiorna la proprietà dello status documenti corrispondenti su On (2 °
parametro) e restituisce un oggetto WriteResult simile al seguente:
{ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 }
UpdateOne
Il metodo UpdateOne () modifica UN documento (parametri di aggiornamento)
db.countries.update(
{ country: "Sweden" },
{ capital: "Stockholm" }
)
Questa operazione cerca nella raccolta "Paesi" un documento in cui il country è la Svezia (1 °
parametro) . Quindi aggiorna la capital proprietà dei documenti corrispondenti a Stoccolma (2 °
parametro) e restituisce un oggetto WriteResult simile al seguente:
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
UpdateMany
Il metodo UpdateMany () modifica i documenti multible (parametri di aggiornamento)
https://riptutorial.com/it/home 262
db.food.updateMany(
{ sold: { $lt: 10 } },
{ $set: { sold: 55 } }
)
Questa operazione aggiorna tutti i documenti (in una raccolta "cibo") dove la sold è inferiore a 10
* (1 ° parametro) impostando sold a 55 . Quindi restituisce un oggetto WriteResult simile al
seguente:
{ "acknowledged" : true, "matchedCount" : a, "modifiedCount" : b }
a = Numero di documenti corrispondenti
b = numero di documenti modificati
ReplaceOne
Sostituisce il primo documento di corrispondenza (documento sostitutivo)
Questo esempio di raccolta denominata Paesi contiene 3 documenti:
{ "_id" : 1, "country" : "Sweden" }
{ "_id" : 2, "country" : "Norway" }
{ "_id" : 3, "country" : "Spain" }
La seguente operazione sostituisce il documento { country: "Spain" } con documento { country:
"Finland" }
db.countries.replaceOne(
{ country: "Spain" },
{ country: "Finland" }
)
E ritorna:
{ "acknowledged" : true, "matchedCount" : 1, "modifiedCount" : 1 }
I Paesi di raccolta di esempio ora contengono:
{ "_id" : 1, "country" : "Sweden" }
{ "_id" : 2, "country" : "Norway" }
{ "_id" : 3, "country" : "Finland" }
Eliminazione
L'eliminazione di documenti da una raccolta in mangusta avviene nel modo seguente.
https://riptutorial.com/it/home 263
Auto.remove({_id:123}, function(err, result){
if (err) return console.error(err);
console.log(result); // this will specify the mongo default delete result.
});
Leggi Node.JS e MongoDB. online: https://riptutorial.com/it/node-js/topic/7505/node-js-e-
mongodb-
https://riptutorial.com/it/home 264
Capitolo 80: Node.js v6 Nuove funzionalità e
miglioramenti
introduzione
Con il nodo 6 diventa la nuova versione LTS del nodo. Possiamo vedere una serie di
miglioramenti alla lingua attraverso i nuovi standard ES6. Passeremo attraverso alcune delle
nuove funzionalità introdotte e alcuni esempi su come implementarle.
Examples
Parametri funzione predefiniti
function addTwo(a, b = 2) {
return a + b;
}
addTwo(3) // Returns the result 5
Con l'aggiunta di parametri di funzione predefiniti ora puoi rendere opzionali gli argomenti e
impostarli come predefiniti su un valore a tua scelta.
Parametri di riposo
function argumentLength(...args) {
return args.length;
}
argumentLength(5) // returns 1
argumentLength(5, 3) //returns 2
argumentLength(5, 3, 6) //returns 3
Prefacendo l'ultimo argomento della tua funzione con ... tutti gli argomenti passati alla funzione
vengono letti come una matrice. In questo esempio otteniamo pass in più argomenti e otteniamo
la lunghezza della matrice creata da quegli argomenti.
Spread Operator
function myFunction(x, y, z) { }
var args = [0, 1, 2];
myFunction(...args);
La sintassi di diffusione consente di espandere un'espressione in luoghi in cui sono previsti più
argomenti (per chiamate di funzione) o più elementi (per letterali di array) o più variabili. Proprio
come i parametri di riposo, semplicemente prefigurano il tuo array con ...
https://riptutorial.com/it/home 265
Funzioni della freccia
La funzione Arrow è il nuovo modo di definire una funzione in ECMAScript 6.
// traditional way of declaring and defining function
var sum = function(a,b)
{
return a+b;
}
// Arrow Function
let sum = (a, b)=> a+b;
//Function defination using multiple lines
let checkIfEven = (a) => {
if( a % 2 == 0 )
return true;
else
return false;
}
"questo" in Arrow Function
questa funzione si riferisce ad oggetto istanza utilizzato per chiamare tale funzione ma questa
funzione freccia è uguale a questo di funzione in cui è definita la funzione freccia.
Capiamo usando il diagramma
Comprensione con esempi.
var normalFn = function(){
console.log(this) // refers to global/window object.
https://riptutorial.com/it/home 266
}
var arrowFn = () => console.log(this); // refers to window or global object as function is
defined in scope of global/window object
var service = {
constructorFn : function(){
console.log(this); // refers to service as service object used to call method.
var nestedFn = function(){
console.log(this); // refers window or global object because no instance object
was used to call this method.
}
nestedFn();
},
arrowFn : function(){
console.log(this); // refers to service as service object was used to call method.
let fn = () => console.log(this); // refers to service object as arrow function
defined in function which is called using instance object.
fn();
}
}
// calling defined functions
constructorFn();
arrowFn();
service.constructorFn();
service.arrowFn();
Nella funzione freccia, questo è lo scope lessicale che è l'ambito della funzione in cui è definita la
funzione freccia.
Il primo esempio è il modo tradizionale di definire le funzioni e quindi si riferisce all'oggetto globale
/ finestra .
Nel secondo esempio questo è usato all'interno della funzione freccia, quindi questo si riferisce
all'ambito in cui è definito (che è Windows o oggetto globale). Nel terzo esempio si tratta di
oggetto di servizio poiché l'oggetto di servizio viene utilizzato per chiamare la funzione.
Nel quarto esempio, la funzione freccia è definita e chiamata dalla funzione il cui ambito è servizio
, quindi stampa oggetto servizio .
Nota: - l'oggetto globale viene stampato in Node.Js e l'oggetto Windows nel browser.
Leggi Node.js v6 Nuove funzionalità e miglioramenti online: https://riptutorial.com/it/node-
js/topic/8593/node-js-v6-nuove-funzionalita-e-miglioramenti
https://riptutorial.com/it/home 267
Capitolo 81: NodeJS con Redis
Osservazioni
Abbiamo coperto le operazioni di base e più comunemente utilizzate in node_redis. Puoi utilizzare
questo modulo per sfruttare tutta la potenza di Redis e creare app Node.js davvero sofisticate.
Puoi creare molte cose interessanti con questa libreria come un forte livello di memorizzazione
nella cache, un potente sistema di messaggistica Pub / Sub e molto altro. Per saperne di più sulla
biblioteca, consultare la documentazione .
Examples
Iniziare
node_redis, come avrai intuito, è il client Redis per Node.js. È possibile installarlo tramite npm
utilizzando il seguente comando.
npm install redis
Una volta installato il modulo node_redis, sei a posto. Creiamo un semplice file, app.js, e vediamo
come connettersi con Redis da Node.js.
app.js
var redis = require('redis');
client = redis.createClient(); //creates a new client
Per impostazione predefinita, redis.createClient () utilizzerà 127.0.0.1 e 6379 rispettivamente
come nome host e porta. Se hai un host / porta diverso, puoi fornirli come segue:
var client = redis.createClient(port, host);
Ora puoi eseguire qualche azione una volta stabilita una connessione. Fondamentalmente, devi
solo ascoltare gli eventi di connessione come mostrato di seguito.
client.on('connect', function() {
console.log('connected');
});
Quindi, il seguente snippet va in app.js:
var redis = require('redis');
var client = redis.createClient();
client.on('connect', function() {
console.log('connected');
https://riptutorial.com/it/home 268
});
Ora, digitare l'app nodo nel terminale per eseguire l'app. Assicurati che il tuo server Redis sia
attivo e funzionante prima di eseguire questo snippet.
Memorizzare coppie chiave-valore
Ora che sai come connetterti con Redis da Node.js, vediamo come memorizzare coppie chiave-
valore nell'archivio Redis.
Memorizzazione di stringhe
Tutti i comandi di Redis sono esposti come funzioni differenti sull'oggetto client. Per memorizzare
una stringa semplice usa la seguente sintassi:
client.set('framework', 'AngularJS');
client.set(['framework', 'AngularJS']);
I frammenti di cui sopra memorizzano una semplice stringa AngularJS rispetto al framework
chiave. Dovresti notare che entrambi i frammenti fanno la stessa cosa. L'unica differenza è che il
primo passa un numero variabile di argomenti mentre il successivo passa un array di argomenti
alla funzione client.set() . È inoltre possibile passare una richiamata opzionale per ricevere una
notifica quando l'operazione è completata:
client.set('framework', 'AngularJS', function(err, reply) {
console.log(reply);
});
Se l'operazione non è riuscita per qualche motivo, l'argomento err del callback rappresenta
l'errore. Per recuperare il valore della chiave, procedi come segue:
client.get('framework', function(err, reply) {
console.log(reply);
});
client.get() consente di recuperare una chiave memorizzata in Redis. È possibile accedere al
valore della chiave tramite la risposta dell'argomento di richiamata. Se la chiave non esiste, il
valore della risposta sarà vuoto.
Memorizzazione di hash
Molte volte la memorizzazione di valori semplici non risolverà il tuo problema. Sarà necessario
memorizzare gli hash (oggetti) in Redis. Per questo è possibile utilizzare la funzione hmset() come
segue:
https://riptutorial.com/it/home 269
client.hmset('frameworks', 'javascript', 'AngularJS', 'css', 'Bootstrap', 'node', 'Express');
client.hgetall('frameworks', function(err, object) {
console.log(object);
});
Il frammento di cui sopra memorizza un hash in Redis che associa ogni tecnologia al suo
framework. Il primo argomento su hmset() è il nome della chiave. Gli argomenti successivi
rappresentano coppie chiave-valore. Allo stesso modo, hgetall() viene utilizzato per recuperare il
valore della chiave. Se viene trovata la chiave, il secondo argomento del callback conterrà il valore
che è un oggetto.
Si noti che Redis non supporta oggetti nidificati. Tutti i valori delle proprietà nell'oggetto verranno
convertiti in stringhe prima di essere archiviati. È anche possibile utilizzare la seguente sintassi
per memorizzare oggetti in Redis:
client.hmset('frameworks', {
'javascript': 'AngularJS',
'css': 'Bootstrap',
'node': 'Express'
});
È anche possibile passare una richiamata opzionale per sapere quando l'operazione è
completata.
Tutte le funzioni (comandi) possono essere richiamate con equivalenti maiuscoli / minuscoli. Ad
esempio, client.hmset() e client.HMSET() sono gli stessi. Memorizzazione delle liste
Se si desidera memorizzare un elenco di elementi, è possibile utilizzare gli elenchi di Redis. Per
memorizzare un elenco, utilizzare la seguente sintassi:
client.rpush(['frameworks', 'angularjs', 'backbone'], function(err, reply) {
console.log(reply); //prints 2
});
Lo snippet sopra riportato crea un elenco chiamato framework e ne spinge due elementi. Quindi,
la lunghezza della lista ora è due. Come puoi vedere ho passato un array di args a rpush . Il primo
elemento della matrice rappresenta il nome della chiave mentre il resto rappresenta gli elementi
della lista. Puoi anche usare lpush() invece di rpush() per spingere gli elementi a sinistra.
Per recuperare gli elementi della lista puoi usare la funzione lrange() come segue:
client.lrange('frameworks', 0, -1, function(err, reply) {
console.log(reply); // ['angularjs', 'backbone']
});
Basta notare che si ottengono tutti gli elementi della lista passando -1 come terzo argomento di
lrange() . Se vuoi un sottoinsieme della lista, dovresti passare l'indice finale qui.
Memorizzare i set
https://riptutorial.com/it/home 270
I set sono simili agli elenchi, ma la differenza è che non consentono duplicati. Quindi, se non vuoi
elementi duplicati nella tua lista puoi usare un set. Ecco come possiamo modificare il nostro
snippet precedente per utilizzare un set anziché un elenco.
client.sadd(['tags', 'angularjs', 'backbonejs', 'emberjs'], function(err, reply) {
console.log(reply); // 3
});
Come puoi vedere, la funzione sadd() crea un nuovo set con gli elementi specificati. Qui, la
lunghezza del set è tre. Per recuperare i membri del set, utilizzare la funzione smembers() come
segue:
client.smembers('tags', function(err, reply) {
console.log(reply);
});
Questo snippet recupererà tutti i membri del set. Basta notare che l'ordine non viene conservato
durante il recupero dei membri.
Questa era una lista delle strutture dati più importanti trovate in ogni app alimentata da Redis.
Oltre a stringhe, elenchi, insiemi e hash, è possibile memorizzare set ordinati, hyperLogLogs e
altri in Redis. Se si desidera un elenco completo di comandi e strutture dati, visitare la
documentazione ufficiale Redis. Ricorda che quasi ogni comando Redis è esposto sull'oggetto
client offerto dal modulo node_redis.
Alcune operazioni più importanti supportate da node_redis.
Verifica dell'esistenza delle chiavi
A volte potrebbe essere necessario verificare se esiste già una chiave e procedere di
conseguenza. Per fare ciò è possibile utilizzare la funzione exists() come mostrato di seguito:
client.exists('key', function(err, reply) {
if (reply === 1) {
console.log('exists');
} else {
console.log('doesn\'t exist');
}
});
Cancellazione e scadenza delle chiavi
A volte è necessario cancellare alcune chiavi e reinizializzarle. Per cancellare i tasti, puoi usare il
comando del comando come mostrato di seguito:
client.del('frameworks', function(err, reply) {
console.log(reply);
});
Puoi anche dare un tempo di scadenza a una chiave esistente come segue:
https://riptutorial.com/it/home 271
client.set('key1', 'val1');
client.expire('key1', 30);
Lo snippet sopra riportato assegna un tempo di scadenza di 30 secondi alla chiave key1.
Incremento e decremento
Redis supporta anche le chiavi di incremento e decremento. Per incrementare una chiave,
utilizzare la funzione incr() come mostrato di seguito:
client.set('key1', 10, function() {
client.incr('key1', function(err, reply) {
console.log(reply); // 11
});
});
La funzione incr() incrementa un valore chiave di 1. Se è necessario incrementare di una quantità
diversa, è possibile utilizzare la funzione incrby() . Allo stesso modo, per decrementare un tasto è
possibile utilizzare le funzioni come decr() e decrby() .
Leggi NodeJS con Redis online: https://riptutorial.com/it/node-js/topic/7107/nodejs-con-redis
https://riptutorial.com/it/home 272
Capitolo 82: NodeJS Frameworks
Examples
Framework di server Web
Esprimere
var express = require('express');
var app = express();
app.get('/', function (req, res) {
res.send('Hello World!');
});
app.listen(3000, function () {
console.log('Example app listening on port 3000!');
});
Koa
var koa = require('koa');
var app = koa();
app.use(function *(next){
var start = new Date;
yield next;
var ms = new Date - start;
console.log('%s %s - %s', this.method, this.url, ms);
});
app.use(function *(){
this.body = 'Hello World';
});
app.listen(3000);
Command Line Interface Frameworks
Commander.js
var program = require('commander');
program
.version('0.0.1')
program
.command('hi')
.description('initialize project configuration')
.action(function(){
https://riptutorial.com/it/home 273
console.log('Hi my Friend!!!');
});
program
.command('bye [name]')
.description('initialize project configuration')
.action(function(name){
console.log('Bye ' + name + '. It was good to see you!');
});
program
.command('*')
.action(function(env){
console.log('Enter a Valid command');
terminate(true);
});
program.parse(process.argv);
Vorpal.js
const vorpal = require('vorpal')();
vorpal
.command('foo', 'Outputs "bar".')
.action(function(args, callback) {
this.log('bar');
callback();
});
vorpal
.delimiter('myapp$')
.show();
Leggi NodeJS Frameworks online: https://riptutorial.com/it/node-js/topic/6042/nodejs-frameworks
https://riptutorial.com/it/home 274
Capitolo 83: npm
introduzione
Node Package Manager (npm) fornisce le seguenti due funzionalità principali: repository online
per pacchetti / moduli node.js che sono ricercabili su search.nodejs.org. Utilità della riga di
comando per installare i pacchetti Node.js, eseguire la gestione delle versioni e la gestione delle
dipendenze dei pacchetti Node.js.
Sintassi
• npm <comando> dove <comando> è uno di:
Aggiungi utente
○
Aggiungi utente
○
apihelp
○
autore
○
bidone
○
bug
○
c
○
nascondiglio
○
completamento
○
config
○
DDP
○
deduplicazione
○
disapprovare
○
docs
○
modificare
○
Esplorare
○
FAQ
○
trova
○
trovare-gonzi
○
ottenere
○
Aiuto
○
help-search
○
casa
○
io
○
installare
○
Informazioni
○
dentro
○
istallare
○
problemi
○
la
○
collegamento
○
elenco
○
https://riptutorial.com/it/home 275
○ ll
○ ln
○ accesso
○ ls
○ antiquato
○ proprietario
○ pacco
○ prefisso
○ fesso
○ pubblicare
○ r
○ rb
○ ricostruire
○ rimuovere
○ pronti contro termine
○ ricomincia
○ rm
○ radice
○ eseguire script
○ S
○ SE
○ ricerca
○ impostato
○ mostrare
○ shrinkwrap
○ stella
○ stelle
○ inizio
○ Stop
○ modulo
○ etichetta
○ test
○ tst
○ un
○ disinstallazione
○ scollegare
○ non pubblicato
○ Rimuovi da speciali
○ su
○ aggiornare
○ v
○ versione
○ vista
○ chi sono
Parametri
https://riptutorial.com/it/home 276
Parametro Esempio
accesso npm publish --access=public
bidone npm bin -g
modificare npm edit connect
Aiuto npm help init
dentro npm init
installare npm install
collegamento npm link
fesso npm prune
pubblicare npm publish ./
ricomincia npm restart
inizio npm start
Stop npm start
aggiornare npm update
versione npm version
Examples
Installazione dei pacchetti
introduzione
Pacchetto è un termine utilizzato da npm per indicare gli strumenti che gli sviluppatori possono
utilizzare per i loro progetti. Questo include tutto, dalle librerie e framework come jQuery e
AngularJS ai runner di attività come Gulp.js. I pacchetti arriveranno in una cartella chiamata
tipicamente node_modules , che conterrà anche un file package.json . Questo file contiene
informazioni su tutti i pacchetti comprese eventuali dipendenze, che sono moduli aggiuntivi
necessari per utilizzare un particolare pacchetto.
Npm utilizza la riga di comando per installare e gestire i pacchetti, quindi gli utenti che tentano di
utilizzare npm dovrebbero avere familiarità con i comandi di base sul loro sistema operativo,
ovvero: attraversare le directory e poter vedere il contenuto delle directory.
https://riptutorial.com/it/home 277
Installazione di NPM
Si noti che per installare i pacchetti, è necessario aver installato NPM.
Il modo consigliato per installare NPM è quello di utilizzare uno dei programmi di installazione
dalla pagina di download Node.js. Puoi verificare se hai già installato node.js eseguendo il npm -v
o npm version .
Dopo aver installato NPM tramite l'installer Node.js, assicurati di verificare la disponibilità di
aggiornamenti. Questo perché NPM viene aggiornato più frequentemente rispetto all'installer
Node.js. Per verificare la presenza di aggiornamenti, eseguire il seguente comando:
npm install npm@latest -g
Come installare i pacchetti
Per installare uno o più pacchetti, utilizzare quanto segue:
npm install <package-name>
# or
npm i <package-name>...
# e.g. to install lodash and express
npm install lodash express
Nota : questo installerà il pacchetto nella directory in cui si trova attualmente la riga di
comando, quindi è importante verificare se è stata scelta la directory appropriata
Se hai già un file package.json nella directory di lavoro corrente e le dipendenze sono definite al
suo interno, l' npm install risolverà e installerà automaticamente tutte le dipendenze elencate nel
file. Puoi anche usare la versione abbreviata del comando di npm install che è: npm i
Se si desidera installare una versione specifica di un pacchetto, utilizzare:
npm install <name>@<version>
# e.g. to install version 4.11.1 of the package lodash
npm install [email protected]
Se si desidera installare una versione che corrisponde a un intervallo di versione specifico,
utilizzare:
npm install <name>@<version range>
# e.g. to install a version which matches "version >= 4.10.1" and "version < 4.11.1"
# of the package lodash
npm install lodash@">=4.10.1 <4.11.1"
https://riptutorial.com/it/home 278
Se si desidera installare l'ultima versione, utilizzare:
npm install <name>@latest
I comandi sopra riportati cercheranno i pacchetti nel repository centrale di npm su npmjs.com . Se
non stai cercando di installare dal registro di npm , sono supportate altre opzioni, come ad esempio:
# packages distributed as a tarball
npm install <tarball file>
npm install <tarball url>
# packages available locally
npm install <local path>
# packages available as a git repository
npm install <git remote url>
# packages available on GitHub
npm install <username>/<repository>
# packages available as gist (need a package.json)
npm install gist:<gist-id>
# packages from a specific repository
npm install --registry=http://myreg.mycompany.com <package name>
# packages from a related group of packages
# See npm scope
npm install @<scope>/<name>(@<version>)
# Scoping is useful for separating private packages hosted on private registry from
# public ones by setting registry for specific scope
npm config set @mycompany:registry http://myreg.mycompany.com
npm install @mycompany/<package name>
Di solito, i moduli verranno installati localmente in una cartella denominata node_modules , che può
essere trovata nella directory di lavoro corrente. Questa è la directory require() che userà per
caricare i moduli al fine di renderli disponibili.
Se hai già creato un file package.json , puoi utilizzare l' --save (abbreviazione -S ) o una delle sue
varianti per aggiungere automaticamente il pacchetto installato al tuo package.json come
dipendenza. Se qualcun altro installa il pacchetto, npm leggerà automaticamente le dipendenze dal
file package.json e installerà le versioni elencate. Nota che puoi ancora aggiungere e gestire le tue
dipendenze modificando il file in un secondo momento, quindi di solito è una buona idea tenere
traccia delle dipendenze, ad esempio usando:
npm install --save <name> # Install dependencies
# or
npm install -S <name> # shortcut version --save
# or
npm i -S <name>
Per installare i pacchetti e salvarli solo se sono necessari per lo sviluppo, non per eseguirli, non se
sono necessari per l'esecuzione dell'applicazione, attenersi al seguente comando:
https://riptutorial.com/it/home 279
npm install --save-dev <name> # Install dependencies for development purposes
# or
npm install -D <name> # shortcut version --save-dev
# or
npm i -D <name>
Installare le dipendenze
Alcuni moduli non forniscono solo una libreria da utilizzare, ma forniscono anche uno o più binari
che devono essere utilizzati tramite la riga di comando. Sebbene sia ancora possibile installare tali
pacchetti localmente, è spesso preferibile installarli globalmente in modo da poter abilitare gli
strumenti da riga di comando. In tal caso, npm collegherà automaticamente i file binari ai percorsi
appropriati (ad esempio /usr/local/bin/<name> ) in modo che possano essere utilizzati dalla riga di
comando. Per installare un pacchetto a livello globale, utilizzare:
npm install --global <name>
# or
npm install -g <name>
# or
npm i -g <name>
# e.g. to install the grunt command line tool
npm install -g grunt-cli
Se si desidera visualizzare un elenco di tutti i pacchetti installati e le relative versioni associate
nello spazio di lavoro corrente, utilizzare:
npm list
npm list <name>
L'aggiunta di un argomento di nome opzionale può controllare la versione di un pacchetto
specifico.
Nota: se si verificano problemi di autorizzazione durante il tentativo di installare un modulo npm a
livello globale, resistere alla tentazione di eseguire sudo npm install -g ... per risolvere il
problema. La concessione di script di terze parti per l'esecuzione sul sistema con privilegi elevati è
pericolosa. Il problema dell'autorizzazione potrebbe significare che hai un problema con il modo in
npm è stato installato npm . Se sei interessato a installare il nodo in ambienti utente sandbox,
potresti provare a utilizzare nvm .
Se si dispone di strumenti di compilazione o altre dipendenze di solo sviluppo (ad esempio Grunt),
è possibile che non si desideri averli in bundle con l'applicazione distribuita. Se questo è il caso, ti
consigliamo di avere una dipendenza di sviluppo, che è elencata in package.json sotto
devDependencies . Per installare un pacchetto come dipendenza solo per lo sviluppo, usa --save-dev
(o -D ).
npm install --save-dev <name> // Install development dependencies which is not included in
https://riptutorial.com/it/home 280
production
# or
npm install -D <name>
Vedrai che il pacchetto viene quindi aggiunto alle devDependencies del tuo package.json .
Per installare le dipendenze di un progetto node.js scaricato / clonato, puoi semplicemente usarlo
npm install
# or
npm i
npm legge automaticamente le dipendenze da package.json e le installa.
NPM dietro un server proxy
Se l'accesso a Internet avviene tramite un server proxy, potrebbe essere necessario modificare i
comandi di installazione di npm che accedono ai repository remoti. npm utilizza un file di
configurazione che può essere aggiornato tramite la riga di comando:
npm config set
Puoi individuare le tue impostazioni proxy dal pannello delle impostazioni del browser. Dopo aver
ottenuto le impostazioni del proxy (URL del server, porta, nome utente e password); è necessario
configurare le configurazioni di npm come segue.
$ npm config set proxy http://<username>:<password>@<proxy-server-url>:<port>
$ npm config set https-proxy http://<username>:<password>@<proxy-server-url>:<port>
username , password , campi della port sono opzionali. Una volta impostati questi, l' npm install npm i
-g , npm i -g ecc. npm i -g correttamente.
Ambiti e depositi
# Set the repository for the scope "myscope"
npm config set @myscope:registry http://registry.corporation.com
# Login at a repository and associate it with the scope "myscope"
npm adduser --registry=http://registry.corporation.com --scope=@myscope
# Install a package "mylib" from the scope "myscope"
npm install @myscope/mylib
Se il nome del proprio pacchetto inizia con @myscope e l'ambito "myscope" è associato a un
repository differente, npm publish caricherà il pacchetto su quel repository.
Puoi anche mantenere queste impostazioni in un file .npmrc :
https://riptutorial.com/it/home 281
@myscope:registry=http://registry.corporation.com
//registry.corporation.com/:_authToken=xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxx
Questo è utile quando si automatizza la build su un server CI fe
Disinstallazione dei pacchetti
Per disinstallare uno o più pacchetti installati localmente, utilizzare:
npm uninstall <package name>
Il comando di disinstallazione per npm ha cinque alias che possono essere utilizzati anche:
npm remove <package name>
npm rm <package name>
npm r <package name>
npm unlink <package name>
npm un <package name>
Se si desidera rimuovere il pacchetto dal file package.json come parte della disinstallazione,
utilizzare il flag --save (abbreviazione: -S ):
npm uninstall --save <package name>
npm uninstall -S <package name>
Per una dipendenza di sviluppo, usa il --save-dev (abbreviazione: -D ):
npm uninstall --save-dev <package name>
npm uninstall -D <package name>
Per una dipendenza opzionale, usa il --save-optional (abbreviazione: -O ):
npm uninstall --save-optional <package name>
npm uninstall -O <package name>
Per i pacchetti installati a livello globale utilizzare il flag --global (abbreviazione: -g ):
npm uninstall -g <package name>
Controllo delle versioni semantiche di base
Prima di pubblicare un pacchetto devi metterlo in versione. npm supporta il versioning semantico ,
questo significa che ci sono patch, versioni minori e principali .
Ad esempio, se il tuo pacchetto è alla versione 1.2.3 per cambiare versione devi:
1. patch release: npm version patch => 1.2.4
2. versione minore: npm version minor => 1.3.0
https://riptutorial.com/it/home 282
3. major release: npm version major => 2.0.0
Puoi anche specificare una versione direttamente con:
npm version 3.1.4 => 3.1.4
Quando imposti una versione del pacchetto usando uno dei comandi npm sopra, npm modificherà
il campo versione del file package.json, lo impegnerà e creerà anche un nuovo tag Git con la
versione preceduta da una "v", come se tu Ho emesso il comando:
git tag v3.1.4
A differenza di altri gestori di pacchetti come Bower, il registro di npm non si basa su tag Git creati
per ogni versione. Ma, se ti piace usare i tag, dovresti ricordare di inserire il tag appena creato
dopo aver scaricato la versione del pacchetto:
git push origin master (per inviare la modifica a package.json)
git push origin v3.1.4 (per spingere il nuovo tag)
Oppure puoi farlo in un colpo solo con:
git push origin master --tags
Impostazione di una configurazione del pacchetto
Le configurazioni del pacchetto Node.js sono contenute in un file chiamato package.json che puoi
trovare alla radice di ogni progetto. È possibile impostare un nuovo file di configurazione
chiamando:
npm init
Questo cercherà di leggere la directory di lavoro corrente per informazioni sul repository Git (se
esiste) e le variabili di ambiente per provare e completare automaticamente alcuni dei valori
segnaposto per te. In caso contrario, fornirà una finestra di dialogo di input per le opzioni di base.
Se desideri creare un package.json con i valori predefiniti, utilizza:
npm init --yes
# or
npm init -y
Se stai creando un package.json per un progetto che non stai pubblicando come pacchetto npm
(vale a dire esclusivamente per arrotondare le tue dipendenze), puoi trasmettere questo intento
nel tuo file package.json :
1. Facoltativamente, imposta la proprietà private su true per impedire la pubblicazione
accidentale.
2. Opzionalmente imposta la proprietà della license su "NON LICENZIATO" per negare agli
altri il diritto di utilizzare il tuo pacchetto.
https://riptutorial.com/it/home 283
Per installare un pacchetto e salvarlo automaticamente nel pacchetto package.json , utilizzare:
npm install --save <package>
Il pacchetto e i metadati associati (come la versione del pacchetto) appariranno nelle dipendenze.
Se si salva se come dipendenza di sviluppo (usando --save-dev ), il pacchetto apparirà invece
nelle proprie devDependencies .
Con questo package.json bare-bones, si incontreranno messaggi di avvertimento durante
l'installazione o l'aggiornamento di pacchetti, indicando che mancano una descrizione e il campo
del repository. Mentre è sicuro ignorare questi messaggi, puoi eliminarli aprendo il pacchetto. Json
in qualsiasi editor di testo e aggiungendo le seguenti linee all'oggetto JSON:
[...]
"description": "No description",
"repository": {
"private": true
},
[...]
Pubblicare un pacchetto
Innanzitutto, assicurati di aver configurato il tuo pacchetto (come indicato in Configurazione di una
configurazione del pacchetto ). Quindi, devi accedere a npmjs.
Se hai già un utente npm
npm login
Se non hai un utente
npm adduser
Per verificare che l'utente sia registrato nel client corrente
npm config ls
Dopodiché, quando il pacchetto è pronto per essere pubblicato, usa
npm publish
E hai finito.
Se è necessario pubblicare una nuova versione, assicurarsi di aggiornare la versione del
pacchetto, come indicato nella versione semantica di base . Altrimenti, npm non ti permetterà di
pubblicare il pacchetto.
https://riptutorial.com/it/home 284
name: "package-name",
version: "1.0.4"
}
Esecuzione di script
È possibile definire script nel package.json , ad esempio:
{
"name": "your-package",
"version": "1.0.0",
"description": "",
"main": "index.js",
"author": "",
"license": "ISC",
"dependencies": {},
"devDependencies": {},
"scripts": {
"echo": "echo hello!"
}
}
Per eseguire lo script echo , eseguire npm run echo dalla riga di comando. Gli script arbitrari, come
echo sopra, devono essere eseguiti con npm run <script name> . npm ha anche una serie di script
ufficiali che vengono eseguiti in determinate fasi della vita del pacchetto (come preinstall ). Vedi
qui per l'intera panoramica di come npm gestisce i campi di script.
Gli script npm sono usati più spesso per cose come l'avvio di un server, la costruzione del
progetto e l'esecuzione di test. Ecco un esempio più realistico:
"scripts": {
"test": "mocha tests",
"start": "pm2 start index.js"
}
Nelle voci degli scripts , i programmi da riga di comando come mocha funzioneranno se installati
globalmente o localmente. Se la voce della riga di comando non esiste nel PATH di sistema, npm
controllerà anche i pacchetti installati localmente.
Se i tuoi script diventano molto lunghi, possono essere suddivisi in parti, come questo:
"scripts": {
"very-complex-command": "npm run chain-1 && npm run chain-2",
"chain-1": "webpack",
"chain-2": "node app.js"
}
Rimozione di pacchetti estranei
Per rimuovere pacchetti estranei (i pacchetti installati ma non nell'elenco delle dipendenze),
eseguire il seguente comando:
https://riptutorial.com/it/home 285
npm prune
Per rimuovere tutti i pacchetti dev aggiungere --production flag di produzione:
npm prune --production
Altro su di esso
Elenco dei pacchetti attualmente installati
Per generare una lista (vista ad albero) dei pacchetti attualmente installati, usare
npm list
ls , la e ll sono alias di comando lista . i comandi la e ll mostrano informazioni estese come
descrizione e repository.
Opzioni
Il formato della risposta può essere modificato passando le opzioni.
npm list --json
• json - Mostra le informazioni in formato json
• lunga - Mostra informazioni estese
• parseable - Mostra l'elenco parseable invece dell'albero
• globale : mostra i pacchetti installati globalmente
• depth - Massima profondità di visualizzazione dell'albero delle dipendenze
• dev / development - Mostra devDependencies
• prod / production - Mostra dipendenze
Se vuoi, puoi anche andare alla pagina principale del pacchetto.
npm home <package name>
Aggiornamento di npm e pacchetti
Poiché npm stesso è un modulo Node.js, può essere aggiornato utilizzando se stesso.
Se il sistema operativo è Windows, deve essere in esecuzione il prompt dei comandi come
amministratore
npm install -g npm@latest
Se vuoi verificare le versioni aggiornate puoi fare:
npm outdated
https://riptutorial.com/it/home 286
Per aggiornare un pacchetto specifico:
npm update <package name>
Questo aggiornerà il pacchetto alla versione più recente in base alle restrizioni in
package.json
Nel caso in cui si desideri bloccare anche la versione aggiornata in package.json:
npm update <package name> --save
Bloccare i moduli su versioni specifiche
Per impostazione predefinita, npm installa l'ultima versione disponibile dei moduli in base alla
versione semantica delle dipendenze. Questo può essere problematico se un autore di un modulo
non aderisce a semere e introduce cambiamenti di rottura in un aggiornamento del modulo, per
esempio.
Per bloccare la versione di ogni dipendenza (e le versioni delle relative dipendenze, ecc.)
node_modules versione specifica installata localmente nella cartella node_modules , utilizzare
npm shrinkwrap
Questo creerà quindi un npm-shrinkwrap.json insieme al package.json che elenca le versioni
specifiche delle dipendenze.
Impostazione per pacchetti installati globalmente
Puoi usare npm install -g per installare un pacchetto "globalmente". In genere ciò viene fatto per
installare un eseguibile che è possibile aggiungere al percorso da eseguire. Per esempio:
npm install -g gulp-cli
Se aggiorni il tuo percorso, puoi chiamare direttamente gulp .
Su molti sistemi operativi, npm install -g tenterà di scrivere in una directory che l'utente potrebbe
non essere in grado di scrivere come /usr/bin . Non si deve usare sudo npm install in questo caso
poiché non v'è un possibile rischio per la sicurezza di eseguire script arbitrari con sudo e l'utente
root può creare directory nella vostra casa che non è possibile scrivere al quale rende installazioni
future più difficile.
Puoi dire a npm dove installare i moduli globali tramite il tuo file di configurazione, ~/.npmrc . Questo
è chiamato il prefix che è possibile visualizzare con il npm prefix .
prefix=~/.npm-global-modules
Questo utilizzerà il prefisso ogni volta che si esegue npm install -g . È anche possibile utilizzare
https://riptutorial.com/it/home 287
npm install --prefix ~/.npm-global-modules per impostare il prefisso durante l'installazione. Se il
prefisso è uguale alla configurazione, non è necessario utilizzare -g .
Per poter utilizzare il modulo installato globalmente, deve essere sul tuo percorso:
export PATH=$PATH:~/.npm-global-modules/bin
Ora quando esegui npm install -g gulp-cli sarai in grado di usare gulp .
Nota: quando si npm install (senza -g ) il prefisso sarà la directory con package.json o la directory
corrente se non si trova nessuno nella gerarchia. Questo crea anche una directory
node_modules/.bin che ha gli eseguibili. Se si desidera utilizzare un eseguibile specifico per un
progetto, non è necessario utilizzare npm install -g . È possibile utilizzare quello in
node_modules/.bin .
Collegamento di progetti per il debugging e lo sviluppo più rapidi
Le dipendenze dei progetti di costruzione possono a volte essere un compito noioso. Invece di
pubblicare una versione del pacchetto su NPM e installare la dipendenza per testare le modifiche,
usa il npm link . npm link crea un npm link simbolico in modo che l'ultimo codice possa essere
testato in un ambiente locale. Ciò rende più semplice testare gli strumenti globali e le dipendenze
dei progetti, consentendo l'esecuzione del codice più recente prima di creare una versione
pubblicata.
Testo guida
NAME
npm-link - Symlink a package folder
SYNOPSIS
npm link (in package dir)
npm link [<@scope>/]<pkg>[@<version>]
alias: npm ln
Passi per il collegamento delle dipendenze del progetto
Quando si crea il collegamento delle dipendenze, si noti che il nome del pacchetto è ciò che verrà
referenziato nel progetto principale.
1. CD in una directory delle dipendenze (es: cd ../my-dep )
2. npm link
3. CD nel progetto che utilizzerà la dipendenza
4. npm link my-dep o if namespace npm link @namespace/my-dep
Passi per il collegamento di uno strumento globale
https://riptutorial.com/it/home 288
1. CD nella directory del progetto (es: cd eslint-watch )
2. npm link
3. Usa lo strumento
4. esw --quiet
Problemi che possono sorgere
I progetti di collegamento a volte possono causare problemi se la dipendenza o lo strumento
globale sono già installati. npm uninstall (-g) <pkg> e quindi il npm link normalmente risolve
qualsiasi problema che possa sorgere.
Leggi npm online: https://riptutorial.com/it/node-js/topic/482/npm
https://riptutorial.com/it/home 289
Capitolo 84: nvm - Node Version Manager
Osservazioni
Gli URL utilizzati negli esempi precedenti fanno riferimento a una versione specifica di Node
Version Manager. È molto probabile che l'ultima versione sia diversa da quella a cui viene fatto
riferimento. Per installare nvm usando l'ultima versione, clicca qui per accedere a nvm su GitHub,
che ti fornirà gli ultimi URL.
Examples
Installa NVM
Puoi usare curl :
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.3/install.sh | bash
Oppure puoi usare wget :
wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.31.3/install.sh | bash
Controlla la versione NVM
Per verificare che nvm sia stato installato, fare:
command -v nvm
che dovrebbe produrre 'nvm' se l'installazione ha avuto successo.
Installazione di una versione specifica del nodo
Elenco delle versioni remote disponibili per l'installazione
nvm ls-remote
Installazione di una versione remota
nvm install <version>
Per esempio
nvm install 0.10.13
Utilizzando una versione del nodo già installata
https://riptutorial.com/it/home 290
Per elencare le versioni locali disponibili del nodo tramite NVM:
nvm ls
Ad esempio, se nvm ls restituisce:
$ nvm ls
v4.3.0
v5.5.0
È possibile passare alla v5.5.0 con:
nvm use v5.5.0
Installa nvm su Mac OSX
PROCESSO DI INSTALLAZIONE
È possibile installare Node Version Manager utilizzando git, curl o wget. Esegui questi comandi in
Terminale su Mac OSX .
esempio di arricciatura:
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.3/install.sh | bash
esempio di wget:
wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.31.3/install.sh | bash
PROVA CHE NVM È STATO INSTALLATO CORRETTAMENTE
Per verificare che nvm sia stato installato correttamente, chiudere e riaprire Terminal e immettere
nvm . Se ottieni un messaggio nvm: comando non trovato , il tuo sistema operativo potrebbe non
avere il file .bash_profile necessario. In Terminale, inserisci touch ~/.bash_profile ed esegui
nuovamente lo script di installazione sopra.
Se ottieni ancora nvm: comando non trovato , prova quanto segue:
• In Terminale, inserisci nano .bashrc . Dovresti vedere uno script di esportazione quasi
identico al seguente:
export NVM_DIR = "/ Users / johndoe / .nvm" [-s "$ NVM_DIR / nvm.sh"] &&. “$
NVM_DIR / nvm.sh”
• Copia lo script di esportazione e rimuovilo da .bashrc
• Salva e chiudi il file .bashrc (CTRL + O - Invio - CTRL + X)
• Successivamente, inserisci nano .bash_profile per aprire il profilo Bash
https://riptutorial.com/it/home 291
• Incolla lo script di esportazione copiato nel Profilo Bash su una nuova riga
• Salva e chiudi il profilo Bash (CTRL + O - Invio - CTRL + X)
• Infine, inserisci nano .bashrc per riaprire il file .bashrc
• Incolla la seguente riga nel file:
source ~ / .nvm / nvm.sh
• Salva e chiudi (CTRL + O - Invio - CTRL + X)
• Riavvia Terminal e inserisci nvm per testare se funziona
Impostazione dell'alias per la versione del nodo
Se si desidera impostare un nome alias nella versione del nodo installato, eseguire:
nvm alias <name> <version>
Similare a unalias, fare:
nvm unalias <name>
Se si desidera impostare un'altra versione rispetto alla versione stabile come alias predefinito,
potrebbe essere un caso appropriato. default versioni alias default vengono caricate sulla console
per impostazione predefinita.
Piace:
nvm alias default 5.0.1
Quindi ogni volta che inizia console / terminale 5.0.1 sarebbe presente per impostazione
predefinita.
Nota:
nvm alias # lists all aliases created on nvm
Esegui qualsiasi comando arbitrario in una subshell con la versione
desiderata del nodo
Elenca tutte le versioni del nodo installate
nvm ls
v4.5.0
v6.7.0
Esegui il comando utilizzando qualsiasi versione installata del nodo
nvm run 4.5.0 --version or nvm exec 4.5.0 node --version
Running node v4.5.0 (npm v2.15.9)
https://riptutorial.com/it/home 292
v4.5.0
nvm run 6.7.0 --version or nvm exec 6.7.0 node --version
Running node v6.7.0 (npm v3.10.3)
v6.7.0
usando alias
nvm run default --version or nvm exec default node --version
Running node v6.7.0 (npm v3.10.3)
v6.7.0
Per installare la versione LTS del nodo
nvm install --lts
Cambio di versione
nvm use v4.5.0 or nvm use stable ( alias )
Leggi nvm - Node Version Manager online: https://riptutorial.com/it/node-js/topic/2823/nvm---node-
version-manager
https://riptutorial.com/it/home 293
Capitolo 85: OAuth 2.0
Examples
OAuth 2 con implementazione Redis - grant_type: password
In questo esempio userò oauth2 in rest api con il database redis
Importante: è necessario installare il database redis sul proprio computer, scaricarlo
da qui per gli utenti linux e da qui installare la versione di Windows, e utilizzeremo l'app
desktop di redis manager, installarla da qui .
Ora dobbiamo impostare il nostro server node.js per utilizzare il database redis.
• Creazione del file del server: app.js
var express = require('express'),
bodyParser = require('body-parser'),
oauthserver = require('oauth2-server'); // Would be: 'oauth2-server'
var app = express();
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
app.oauth = oauthserver({
model: require('./routes/Oauth2/model'),
grants: ['password', 'refresh_token'],
debug: true
});
// Handle token grant requests
app.all('/oauth/token', app.oauth.grant());
app.get('/secret', app.oauth.authorise(), function (req, res) {
// Will require a valid access_token
res.send('Secret area');
});
app.get('/public', function (req, res) {
// Does not require an access_token
res.send('Public area');
});
// Error handling
app.use(app.oauth.errorHandler());
app.listen(3000);
• Crea il modello Oauth2 nelle rotte / Oauth2 / model.js
https://riptutorial.com/it/home 294
var model = module.exports,
util = require('util'),
redis = require('redis');
var db = redis.createClient();
var keys = {
token: 'tokens:%s',
client: 'clients:%s',
refreshToken: 'refresh_tokens:%s',
grantTypes: 'clients:%s:grant_types',
user: 'users:%s'
};
model.getAccessToken = function (bearerToken, callback) {
db.hgetall(util.format(keys.token, bearerToken), function (err, token) {
if (err) return callback(err);
if (!token) return callback();
callback(null, {
accessToken: token.accessToken,
clientId: token.clientId,
expires: token.expires ? new Date(token.expires) : null,
userId: token.userId
});
});
};
model.getClient = function (clientId, clientSecret, callback) {
db.hgetall(util.format(keys.client, clientId), function (err, client) {
if (err) return callback(err);
if (!client || client.clientSecret !== clientSecret) return callback();
callback(null, {
clientId: client.clientId,
clientSecret: client.clientSecret
});
});
};
model.getRefreshToken = function (bearerToken, callback) {
db.hgetall(util.format(keys.refreshToken, bearerToken), function (err, token) {
if (err) return callback(err);
if (!token) return callback();
callback(null, {
refreshToken: token.accessToken,
clientId: token.clientId,
expires: token.expires ? new Date(token.expires) : null,
userId: token.userId
});
});
};
model.grantTypeAllowed = function (clientId, grantType, callback) {
db.sismember(util.format(keys.grantTypes, clientId), grantType, callback);
};
https://riptutorial.com/it/home 295
model.saveAccessToken = function (accessToken, clientId, expires, user, callback) {
db.hmset(util.format(keys.token, accessToken), {
accessToken: accessToken,
clientId: clientId,
expires: expires ? expires.toISOString() : null,
userId: user.id
}, callback);
};
model.saveRefreshToken = function (refreshToken, clientId, expires, user, callback) {
db.hmset(util.format(keys.refreshToken, refreshToken), {
refreshToken: refreshToken,
clientId: clientId,
expires: expires ? expires.toISOString() : null,
userId: user.id
}, callback);
};
model.getUser = function (username, password, callback) {
db.hgetall(util.format(keys.user, username), function (err, user) {
if (err) return callback(err);
if (!user || password !== user.password) return callback();
callback(null, {
id: username
});
});
};
Devi solo installare redis sul tuo computer ed eseguire il seguente file del nodo
#! /usr/bin/env node
var db = require('redis').createClient();
db.multi()
.hmset('users:username', {
id: 'username',
username: 'username',
password: 'password'
})
.hmset('clients:client', {
clientId: 'client',
clientSecret: 'secret'
})//clientId + clientSecret to base 64 will generate Y2xpZW50OnNlY3JldA==
.sadd('clients:client:grant_types', [
'password',
'refresh_token'
])
.exec(function (errs) {
if (errs) {
console.error(errs[0].message);
return process.exit(1);
}
console.log('Client and user added successfully');
process.exit();
});
https://riptutorial.com/it/home 296
Nota : questo file imposterà le credenziali per il tuo frontend per richiedere il token. Quindi la tua
richiesta da
Esempio di database redis dopo aver chiamato il file sopra:
La richiesta sarà la seguente:
Esempio di chiamata a API
https://riptutorial.com/it/home 297
Intestazione:
1. autorizzazione: base seguita dalla password impostata al primo avvio del ripristino:
un. clientId + secretId a base64
2. Modulo dati
username: utente che richiede token
password: password dell'utente
grant_type: dipende da quali opzioni vuoi, scelgo passwod che richiede solo
https://riptutorial.com/it/home 298
username e password per essere redistiti, i dati su redis saranno i seguenti:
{
"access_token":"1d3fe602da12a086ecb2b996fd7b7ae874120c4f",
"token_type":"bearer", // Will be used to access api + access+token e.g. bearer
1d3fe602da12a086ecb2b996fd7b7ae874120c4f
"expires_in":3600,
"refresh_token":"b6ad56e5c9aba63c85d7e21b1514680bbf711450"
}
Quindi dobbiamo chiamare la nostra API e prendere alcuni dati protetti con il nostro token di
accesso che abbiamo appena creato, vedi sotto:
https://riptutorial.com/it/home 299
quando il token scade, api genera un errore che il token scade e non è possibile accedere a
nessuna delle chiamate API, vedere l'immagine seguente:
Vediamo cosa fare se il token scade, permettetemi prima di spiegarvelo, se il token di
accesso scade un refresh_token esiste in redis che fa riferimento al token di accesso
scaduto Quindi quello di cui abbiamo bisogno è chiamare oauth / token di nuovo con il
grant_type refresh_token e impostare il autorizzazione al clientId di base: clientsecret
(per basare 64!) e infine inviare il refresh_token, questo genererà un nuovo
access_token con nuovi dati di scadenza.
L'immagine seguente mostra come ottenere un nuovo token di accesso:
https://riptutorial.com/it/home 300
Spero di aiutare!
Leggi OAuth 2.0 online: https://riptutorial.com/it/node-js/topic/9566/oauth-2-0
https://riptutorial.com/it/home 301
Capitolo 86: package.json
Osservazioni
Puoi creare package.json con
npm init
che ti chiederà informazioni di base sui tuoi progetti, incluso l' identificatore della licenza .
Examples
Definizione del progetto di base
{
"name": "my-project",
"version": "0.0.1",
"description": "This is a project.",
"author": "Someone <[email protected]>",
"contributors": [{
"name": "Someone Else",
"email": "[email protected]"
}],
"keywords": ["improves", "searching"]
}
Campo Descrizione
un campo obbligatorio per un pacchetto da installare. Deve essere
nome
minuscolo, parola singola senza spazi. (Sono consentiti trattini e trattini bassi)
un campo obbligatorio per la versione del pacchetto che utilizza la versione
versione
semantica .
descrizione una breve descrizione del progetto
autore specifica l'autore del pacchetto
contributori una serie di oggetti, uno per ogni contributore
parole
una serie di stringhe, questo aiuterà le persone a trovare il tuo pacchetto
chiave
dipendenze
"dipendenze": {"nome-modulo": "0.1.0"}
https://riptutorial.com/it/home 302
• esatto : 0.1.0 installerà quella versione specifica del modulo.
• la versione minore più recente : ^0.1.0 installerà la versione minore più recente, ad
esempio 0.2.0 , ma non installerà un modulo con una versione maggiore maggiore, ad
esempio 1.0.0
• patch più recente : 0.1.x o ~0.1.0 installerà la versione di patch più recente disponibile, ad
esempio 0.1.4 , ma non installerà un modulo con versione maggiore o minore maggiore, ad
es. 0.2.0 o 1.0.0 .
• carattere jolly : * installerà l'ultima versione del modulo.
• repository git : il seguente installerà un tarball dal ramo master di un repository git.
Possono anche essere forniti #sha , #tag o #branch :
○GitHub : user/project o user/project#v1.0.0
○url : git://gitlab.com/user/project.git o git://gitlab.com/user/project.git#develop
• percorso locale : file:../lib/project
Dopo averli aggiunti al pacchetto package.json, utilizzare il comando npm install nella directory
del progetto nel terminale.
devDependencies
"devDependencies": {
"module-name": "0.1.0"
}
Per le dipendenze richieste solo per lo sviluppo, come test di estensioni per i proxy di stile. Queste
dev-dependencies non verranno installate quando si esegue "npm install" in modalità produzione.
Script
È possibile definire script che possono essere eseguiti o attivati prima o dopo un altro script.
{
"scripts": {
"pretest": "scripts/pretest.js",
"test": "scripts/test.js",
"posttest": "scripts/posttest.js"
}
}
In questo caso, puoi eseguire lo script eseguendo uno di questi comandi:
$ npm run-script test
$ npm run test
$ npm test
$ npm t
Script predefiniti
https://riptutorial.com/it/home 303
Nome script Descrizione
prepublish Esegui prima che il pacchetto sia pubblicato.
pubblicare, postpublish Esegui dopo che il pacchetto è stato pubblicato.
preinstallare Esegui prima che il pacchetto sia installato.
installa, postinstall Esegui dopo l'installazione del pacchetto.
preinstallare, disinstallare Esegui prima che il pacchetto venga disinstallato.
postuninstall Esegui dopo che il pacchetto è stato disinstallato.
preversione, versione Esegui prima di eseguire il bump della versione del pacchetto.
Esegui dopo aver eseguito il bump della versione del
postversion
pacchetto.
pretest, test, post test Esegui dal comando di npm test
prestop, stop, poststop Esegui con il comando npm stop
prestart, start, poststart Esegui dal comando di npm start
prerestart, restart,
Esegui dal comando di npm restart
postrestart
Script definiti dall'utente
Puoi anche definire i tuoi script nello stesso modo in cui lo fai con gli script predefiniti:
{
"scripts": {
"preci": "scripts/preci.js",
"ci": "scripts/ci.js",
"postci": "scripts/postci.js"
}
}
In questo caso, puoi eseguire lo script eseguendo uno di questi comandi:
$ npm run-script ci
$ npm run ci
Gli script definiti dall'utente supportano anche gli script pre e post , come mostrato nell'esempio
sopra.
Definizione del progetto estesa
https://riptutorial.com/it/home 304
Alcuni degli attributi aggiuntivi sono analizzati dal sito Web di npm come repository , bugs o
homepage e mostrati nel riquadro informazioni per questi pacchetti
{
"main": "server.js",
"repository" : {
"type": "git",
"url": "git+https://github.com/<accountname>/<repositoryname>.git"
},
"bugs": {
"url": "https://github.com/<accountname>/<repositoryname>/issues"
},
"homepage": "https://github.com/<accountname>/<repositoryname>#readme",
"files": [
"server.js", // source files
"README.md", // additional files
"lib" // folder with all included files
]
}
Campo Descrizione
Script di entrata per questo pacchetto. Questo script viene restituito quando un
principale
utente richiede il pacchetto.
deposito Ubicazione e tipo del repository pubblico
bug Bugtracker per questo pacchetto (es. Github)
homepage Homepage per questo pacchetto o il progetto generale
File Elenco di file e cartelle che devono essere scaricati quando un utente esegue l'
npm install <packagename>
Esplorando package.json
Un file package.json , solitamente presente nella root del progetto, contiene metadati relativi all'app
o al modulo e all'elenco delle dipendenze da installare da npm durante l'esecuzione npm install .
Per inizializzare un package.json digitare npm init nel prompt dei comandi.
Per creare un package.json con i valori predefiniti utilizzare:
npm init --yes
# or
npm init -y
Per installare un pacchetto e salvarlo su package.json usa:
npm install {package name} --save
Puoi anche usare la notazione abbreviata:
https://riptutorial.com/it/home 305
npm i -S {package name}
Alias NPM -S per --save e -D per --save-dev per salvare rispettivamente nelle dipendenze di
produzione o di sviluppo.
Il pacchetto apparirà nelle dipendenze; se usi --save-dev anziché --save , il pacchetto apparirà
nelle tue devDependencies.
Proprietà importanti di package.json :
{
"name": "module-name",
"version": "10.3.1",
"description": "An example module to illustrate the usage of a package.json",
"author": "Your Name <[email protected]>",
"contributors": [{
"name": "Foo Bar",
"email": "[email protected]"
}],
"bin": {
"module-name": "./bin/module-name"
},
"scripts": {
"test": "vows --spec --isolate",
"start": "node index.js",
"predeploy": "echo About to deploy",
"postdeploy": "echo Deployed",
"prepublish": "coffee --bare --compile --output lib/foo src/foo/*.coffee"
},
"main": "lib/foo.js",
"repository": {
"type": "git",
"url": "https://github.com/username/repo"
},
"bugs": {
"url": "https://github.com/username/issues"
},
"keywords": [
"example"
],
"dependencies": {
"express": "4.2.x"
},
"devDependencies": {
"assume": "<1.0.0 || >=2.3.1 <2.4.5 || >=2.5.2 <3.0.0"
},
"peerDependencies": {
"moment": ">2.0.0"
},
"preferGlobal": true,
"private": true,
"publishConfig": {
"registry": "https://your-private-hosted-npm.registry.domain.com"
},
"subdomain": "foobar",
"analyze": true,
"license": "MIT",
"files": [
"lib/foo.js"
https://riptutorial.com/it/home 306
]
}
Informazioni su alcune proprietà importanti:
name
Il nome univoco del tuo pacchetto e dovrebbe essere in minuscolo. Questa proprietà è richiesta e
il pacchetto non verrà installato senza di esso.
1. Il nome deve essere inferiore o uguale a 214 caratteri.
2. Il nome non può iniziare con un punto o un trattino basso.
3. I nuovi pacchetti non devono contenere lettere maiuscole nel nome.
version
La versione del pacchetto è specificata da Semantic Versioning (semere). Che presuppone che un
numero di versione sia scritto come MAJOR.MINOR.PATCH e si incrementa il:
1. Versione MAJOR quando si apportano modifiche API incompatibili
2. Versione MINORE quando si aggiungono funzionalità in modo compatibile con le versioni
precedenti
3. Versione PATCH quando si effettuano correzioni di errori compatibili con le versioni
precedenti
description
La descrizione del progetto. Cerca di mantenerlo breve e conciso.
author
L'autore di questo pacchetto.
bin
Un oggetto che viene utilizzato per esporre script binari dal pacchetto. L'oggetto presuppone che
la chiave sia il nome dello script binario e il valore di un percorso relativo allo script.
Questa proprietà viene utilizzata dai pacchetti che contengono una CLI (interfaccia a riga di
comando).
script
Un oggetto che espone ulteriori comandi di npm. L'oggetto presuppone che la chiave sia il
comando npm e che il valore sia il percorso dello script. Questi script possono essere eseguiti
quando si esegue npm run {command name} o npm run-script {command name} .
https://riptutorial.com/it/home 307
I pacchetti che contengono un'interfaccia a riga di comando e sono installati localmente possono
essere chiamati senza un percorso relativo. Quindi, invece di chiamare ./node-modules/.bin/mocha
puoi chiamare direttamente mocha .
main
Il principale punto di accesso al tuo pacchetto. Quando si chiama require('{module name}') nel
nodo, questo sarà il file effettivo richiesto.
È altamente consigliato che richiedere il file principale non generi effetti collaterali. Ad esempio,
richiedendo il file principale non dovrebbe avviare un server HTTP o connettersi a un database.
Invece, dovresti creare qualcosa come exports.init = function () {...} nel tuo script principale.
keywords
Una serie di parole chiave che descrivono il tuo pacchetto. Questi aiuteranno le persone a trovare
il tuo pacco.
devDependencies
Queste sono le dipendenze destinate esclusivamente allo sviluppo e al test del modulo. Le
dipendenze verranno installate automaticamente a meno che non sia stata impostata la variabile
di ambiente di NODE_ENV=production . Se questo è il caso puoi ancora questi pacchetti usando npm
install --dev
peerDependencies
Se stai usando questo modulo, peerDependencies elenca i moduli che devi installare insieme a
questo. Ad esempio, il moment-timezone deve essere installato insieme al moment perché è un plugin
per il momento, anche se non require("moment") direttamente require("moment") .
preferGlobal
Una proprietà che indica che questa pagina preferisce essere installata globalmente usando npm
install -g {module-name} . Questa proprietà viene utilizzata dai pacchetti che contengono una CLI
(interfaccia a riga di comando).
In tutte le altre situazioni NON dovresti usare questa proprietà.
publishConfig
PublishConfig è un oggetto con valori di configurazione che verranno utilizzati per la pubblicazione
dei moduli. I valori di configurazione impostati sostituiscono la configurazione predefinita di npm.
L'uso più comune di publishConfig è di pubblicare il tuo pacchetto su un registro privato di npm in
modo da avere ancora i vantaggi di npm ma per i pacchetti privati. Questo viene fatto
semplicemente impostando l'URL del tuo npm privato come valore per la chiave di registro.
https://riptutorial.com/it/home 308
files
Questa è una matrice di tutti i file da includere nel pacchetto pubblicato. È possibile utilizzare un
percorso di file o un percorso di cartella. Verranno inclusi tutti i contenuti di un percorso di cartella.
Ciò riduce la dimensione totale del pacchetto includendo solo i file corretti da distribuire. Questo
campo funziona in congiunzione con un file di regole .npmignore .
fonte
Leggi package.json online: https://riptutorial.com/it/node-js/topic/1515/package-json
https://riptutorial.com/it/home 309
Capitolo 87: parser csv nel nodo js
introduzione
La lettura dei dati da un CSV può essere gestita in molti modi. Una soluzione è leggere il file csv in
un array. Da lì puoi lavorare sull'array.
Examples
Usare FS per leggere in un CSV
fs è l' API del file system nel nodo. Possiamo usare il metodo readFile sulla nostra variabile fs,
passargli un file data.csv , il formato e la funzione che legge e divide il csv per ulteriori
elaborazioni.
Questo presuppone che tu abbia un file denominato data.csv nella stessa cartella.
'use strict'
const fs = require('fs');
fs.readFile('data.csv', 'utf8', function (err, data) {
var dataArray = data.split(/\r?\n/);
console.log(dataArray);
});
Ora puoi usare l'array come qualsiasi altro per lavorare su di esso.
Leggi parser csv nel nodo js online: https://riptutorial.com/it/node-js/topic/9162/parser-csv-nel-
nodo-js
https://riptutorial.com/it/home 310
Capitolo 88: passport.js
introduzione
Passport è un popolare modulo di autorizzazione per il nodo. In poche parole gestisce tutte le
richieste di autorizzazione sulla tua app da parte degli utenti. Passport supporta oltre 300 strategie
in modo da poter facilmente integrare il login con Facebook / Google o qualsiasi altro social
network che lo utilizza. La strategia di cui parleremo qui è il Local in cui si autentica un utente
utilizzando il proprio database di utenti registrati (utilizzando nome utente e password).
Examples
Esempio di LocalStrategy in passport.js
var passport = require('passport');
var LocalStrategy = require('passport-local').Strategy;
passport.serializeUser(function(user, done) { //In serialize user you decide what to store in
the session. Here I'm storing the user id only.
done(null, user.id);
});
passport.deserializeUser(function(id, done) { //Here you retrieve all the info of the user
from the session storage using the user id stored in the session earlier using serialize user.
db.findById(id, function(err, user) {
done(err, user);
});
});
passport.use(new LocalStrategy(function(username, password, done) {
db.findOne({'username':username},function(err,student){
if(err)return done(err,{message:message});//wrong roll_number or password;
var pass_retrieved = student.pass_word;
bcrypt.compare(password, pass_retrieved, function(err3, correct) {
if(err3){
message = [{"msg": "Incorrect Password!"}];
return done(null,false,{message:message}); // wrong password
}
if(correct){
return done(null,student);
}
});
});
}));
app.use(session({ secret: 'super secret' })); //to make passport remember the user on other
pages too.(Read about session store. I used express-sessions.)
app.use(passport.initialize());
app.use(passport.session());
app.post('/',passport.authenticate('local',{successRedirect:'/users' failureRedirect: '/'}),
function(req,res,next){
});
https://riptutorial.com/it/home 311
Leggi passport.js online: https://riptutorial.com/it/node-js/topic/8812/passport-js
https://riptutorial.com/it/home 312
Capitolo 89: Pool di connessione Mysql
Examples
Utilizzo di un pool di connessioni senza database
Raggiungimento della multi-tenancy sul server di database con più database ospitati su di esso.
La multitenancy è un requisito comune delle applicazioni aziendali al giorno d'oggi e la creazione
di un pool di connessioni per ogni database nel server di database non è consigliata. quindi, ciò
che possiamo fare è creare un pool di connessioni con un server di database e passare da un
database all'altro su un server di database su richiesta.
Supponiamo che la nostra applicazione abbia diversi database per ogni azienda ospitata sul
server di database. Ci collegheremo al rispettivo database aziendale quando l'utente raggiunge
l'applicazione. ecco l'esempio su come farlo: -
var pool = mysql.createPool({
connectionLimit : 10,
host : 'example.org',
user : 'bobby',
password : 'pass'
});
pool.getConnection(function(err, connection){
if(err){
return cb(err);
}
connection.changeUser({database : "firm1"});
connection.query("SELECT * from history", function(err, data){
connection.release();
cb(err, data);
});
});
Lasciatemi fare un esempio:
Durante la definizione della configurazione del pool non ho fornito il nome del database, ma ho
fornito solo il server del database
{
connectionLimit : 10,
host : 'example.org',
user : 'bobby',
password : 'pass'
}
quindi, quando vogliamo utilizzare il database specifico sul server di database, chiediamo la
connessione al database dei risultati utilizzando: -
https://riptutorial.com/it/home 313
connection.changeUser({database : "firm1"});
puoi consultare la documentazione ufficiale qui
Leggi Pool di connessione Mysql online: https://riptutorial.com/it/node-js/topic/6353/pool-di-
connessione-mysql
https://riptutorial.com/it/home 314
Capitolo 90: Prestazioni Node.js
Examples
Loop degli eventi
Esempio di operazione di blocco
let loop = (i, max) => {
while (i < max) i++
return i
}
// This operation will block Node.js
// Because, it's CPU-bound
// You should be careful about this kind of code
loop(0, 1e+12)
Esempio di operazione IO non bloccante
let i = 0
const step = max => {
while (i < max) i++
console.log('i = %d', i)
}
const tick = max => process.nextTick(step, max)
// this will postpone tick run step's while-loop to event loop cycles
// any other IO-bound operation (like filesystem reading) can take place
// in parallel
tick(1e+6)
tick(1e+7)
console.log('this will output before all of tick operations. i = %d', i)
console.log('because tick operations will be postponed')
tick(1e+8)
https://riptutorial.com/it/home 315
In termini più semplici, Event Loop è un meccanismo di coda a thread singolo che esegue il codice
associato alla CPU fino alla fine della sua esecuzione e al codice associato all'IO in modo non
bloccante.
Tuttavia, Node.js sotto il tappeto utilizza multi-threading per alcune delle sue operazioni attraverso
la libreria libuv .
Considerazioni sulle prestazioni
• Le operazioni non bloccanti non bloccheranno la coda e non influenzeranno le prestazioni
del ciclo.
• Tuttavia, le operazioni associate alla CPU bloccheranno la coda, quindi dovresti fare
attenzione a non eseguire operazioni legate alla CPU nel tuo codice Node.js.
Node.js non blocca l'IO perché scarica il lavoro nel kernel del sistema operativo e quando
l'operazione IO fornisce i dati ( come evento ), notificherà il tuo codice con i callback forniti.
Aumenta max socket
Nozioni di base
require('http').globalAgent.maxSockets = 25
// You can change 25 to Infinity or to a different value by experimenting
Node.js utilizza per impostazione predefinita maxSockets = Infinity allo stesso tempo (dalla
versione 1.0.0.0 ). Fino al nodo v0.12.0, il valore predefinito era maxSockets = 5 (vedere v0.11.0 ).
Quindi, dopo più di 5 richieste, verranno accodate. Se si desidera la concorrenza, aumentare
questo numero.
https://riptutorial.com/it/home 316
Impostare il proprio agente
http API http utilizza un " Agente globale " . Puoi fornire il tuo agente. Come questo:
const http = require('http')
const myGloriousAgent = new http.Agent({ keepAlive: true })
myGloriousAgent.maxSockets = Infinity
http.request({ ..., agent: myGloriousAgent }, ...)
Disattivare completamente Socket Pooling
const http = require('http')
const options = {.....}
options.agent = false
const request = http.request(options)
insidie
• Dovresti fare la stessa cosa per l'API https se vuoi gli stessi effetti
• Attenzione, ad esempio, AWS utilizzerà 50 anziché Infinity .
Abilita gzip
const http = require('http')
const fs = require('fs')
const zlib = require('zlib')
http.createServer((request, response) => {
const stream = fs.createReadStream('index.html')
const acceptsEncoding = request.headers['accept-encoding']
let encoder = {
hasEncoder : false,
contentEncoding: {},
createEncoder : () => throw 'There is no encoder'
}
if (!acceptsEncoding) {
acceptsEncoding = ''
}
if (acceptsEncoding.match(/\bdeflate\b/)) {
encoder = {
hasEncoder : true,
contentEncoding: { 'content-encoding': 'deflate' },
createEncoder : zlib.createDeflate
https://riptutorial.com/it/home 317
}
} else if (acceptsEncoding.match(/\bgzip\b/)) {
encoder = {
hasEncoder : true,
contentEncoding: { 'content-encoding': 'gzip' },
createEncoder : zlib.createGzip
}
}
response.writeHead(200, encoder.contentEncoding)
if (encoder.hasEncoder) {
stream = stream.pipe(encoder.createEncoder())
}
stream.pipe(response)
}).listen(1337)
Leggi Prestazioni Node.js online: https://riptutorial.com/it/node-js/topic/9410/prestazioni-node-js
https://riptutorial.com/it/home 318
Capitolo 91: Programmazione asincrona
introduzione
Il nodo è un linguaggio di programmazione in cui tutto può essere eseguito in modo asincrono. Di
seguito è possibile trovare alcuni esempi e le cose tipiche del funzionamento asincrono.
Sintassi
• doSomething ([args], function ([argsCB]) {/ * fa qualcosa quando è fatto * /});
• doSomething ([args], ([argsCB]) => {/ * fa qualcosa quando viene fatto * /});
Examples
Funzioni di callback
Funzioni di callback in JavaScript
Le funzioni di callback sono comuni in JavaScript. Le funzioni di callback sono possibili in
JavaScript perché le funzioni sono cittadini di prima classe .
Callback sincroni.
Le funzioni di callback possono essere sincrone o asincrone. Poiché le funzioni di callback
asincrone possono essere più complesse, ecco un semplice esempio di una funzione di callback
sincrono.
// a function that uses a callback named `cb` as a parameter
function getSyncMessage(cb) {
cb("Hello World!");
}
console.log("Before getSyncMessage call");
// calling a function and sending in a callback function as an argument.
getSyncMessage(function(message) {
console.log(message);
});
console.log("After getSyncMessage call");
L'output per il codice sopra riportato è:
> Before getSyncMessage call
> Hello World!
> After getSyncMessage call
https://riptutorial.com/it/home 319
Innanzitutto analizzeremo come viene eseguito il codice precedente. Questo è più per coloro che
non comprendono già il concetto di callback se già lo capisci, sentiti libero di saltare questo
paragrafo. Prima viene analizzato il codice e quindi la prima cosa interessante che si verifica è che
viene eseguita la riga 6 che emette Before getSyncMessage call alla console. Quindi viene eseguita
la riga 8 che chiama la funzione getSyncMessage invia in una funzione anonima come argomento
per il parametro cb nella funzione getSyncMessage . L'esecuzione è ora eseguita all'interno della
funzione getSyncMessage sulla riga 3 che esegue la funzione cb che è stata appena getSyncMessage ,
questa chiamata invia una stringa di argomento "Hello World" per il parametro denominato message
nella funzione anonima passata. L'esecuzione quindi va alla riga 9 che registra Hello World! alla
console. Quindi l'esecuzione passa attraverso il processo di uscita dal callstack ( vedere anche )
che colpisce la linea 10 quindi la linea 4 e infine torna alla riga 11.
Alcune informazioni da sapere sui callback in generale:
• La funzione che invii a una funzione come richiamata può essere chiamata zero volte, una
volta o più volte. Tutto dipende dall'implementazione.
• La funzione di callback può essere chiamata in modo sincrono o asincrono e possibilmente
in modo sincrono e asincrono.
• Proprio come le normali funzioni, i nomi che dai parametri alla tua funzione non sono
importanti ma l'ordine è. Così, per esempio, sulla riga 8 il message parametri potrebbe essere
stato chiamato statement , msg , o se non hai senso qualcosa di simile a jellybean . Quindi
dovresti sapere quali parametri sono stati inviati alla tua callback in modo da poterli ottenere
nell'ordine giusto con nomi propri.
Callback asincroni.
Una cosa da notare su JavaScript è che è sincrono di default, ma ci sono delle API date
nell'ambiente (browser, Node.js, ecc.) Che potrebbero renderlo asincrono (c'è di più a riguardo qui
).
Alcune cose comuni che sono asincrone negli ambienti JavaScript che accettano i callback:
• eventi
• setTimeout
• setInterval
• l'API di recupero
• promesse
Anche qualsiasi funzione che utilizza una delle funzioni sopra può essere avvolta con una
funzione che richiede una richiamata e il callback sarebbe quindi una richiamata asincrona
(sebbene il wrapping di una promessa con una funzione che richiede una richiamata sia
probabilmente considerato un anti-pattern come ci sono più modi preferiti per gestire le
promesse).
Quindi data questa informazione possiamo costruire una funzione asincrona simile alla
precedente sincrona.
https://riptutorial.com/it/home 320
// a function that uses a callback named `cb` as a parameter
function getAsyncMessage(cb) {
setTimeout(function () { cb("Hello World!") }, 1000);
}
console.log("Before getSyncMessage call");
// calling a function and sending in a callback function as an argument.
getAsyncMessage(function(message) {
console.log(message);
});
console.log("After getSyncMessage call");
Che stampa quanto segue alla console:
> Before getSyncMessage call
> After getSyncMessage call
// pauses for 1000 ms with no output
> Hello World!
L'esecuzione della linea passa ai registri della linea 6 "Prima della chiamata getSyncMessage".
Quindi l'esecuzione passa alla riga 8 chiamando getAsyncMessage con un callback per il
parametro cb . Viene quindi eseguita la riga 3 che chiama setTimeout con un callback come primo
argomento e il numero 300 come secondo argomento. setTimeout fa tutto ciò che fa e trattiene
quel callback in modo che possa chiamarlo più tardi in 1000 millisecondi, ma dopo aver impostato
il timeout e prima che metta in pausa i 1000 millisecondi restituisce l'esecuzione al punto in cui era
stata interrotta, quindi va alla riga 4 , quindi la riga 11, quindi si interrompe per 1 secondo e
setTimeout chiama la sua funzione di richiamata che riprende l'esecuzione alla riga 3 dove
getAsyncMessages richiamato il callback getAsyncMessages con il valore "Hello World" per il message
parametro che viene quindi registrato sulla console alla riga 9 .
Funzioni di callback in Node.js
NodeJS ha callback asincroni e in genere fornisce due parametri alle tue funzioni a volte
convenzionalmente chiamati err e data . Un esempio con la lettura di un file di testo.
const fs = require("fs");
fs.readFile("./test.txt", "utf8", function(err, data) {
if(err) {
// handle the error
} else {
// process the file text given with data
}
});
Questo è un esempio di callback che viene chiamato una volta sola.
È buona pratica gestire l'errore in qualche modo anche se lo si registra o lo si gira. Il resto non è
necessario se si lancia o si torna e può essere rimosso per ridurre il rientro finché si interrompe
l'esecuzione della funzione corrente nel se facendo qualcosa come il lancio o il ritorno.
https://riptutorial.com/it/home 321
Sebbene possa essere comune vedere err , i data potrebbero non essere sempre il caso in cui i
callback useranno tale modello, è meglio guardare la documentazione.
Un altro esempio di callback proviene dalla libreria express (espressa 4.x):
// this code snippet was on http://expressjs.com/en/4x/api.html
const express = require('express');
const app = express();
// this app.get method takes a url route to watch for and a callback
// to call whenever that route is requested by a user.
app.get('/', function(req, res){
res.send('hello world');
});
app.listen(3000);
Questo esempio mostra una richiamata che viene chiamata più volte. Il callback è fornito con due
oggetti come parametri qui denominati come req e res questi nomi corrispondono rispettivamente
a richiesta e risposta, e forniscono modi per visualizzare la richiesta in entrata e impostare la
risposta che verrà inviata all'utente.
Come puoi vedere ci sono vari modi in cui un callback può essere usato per eseguire il codice
sincrono e asincrono in JavaScript e le callback sono molto diffuse in tutto il codice JavaScript.
Esempio di codice
Domanda: Qual è l'output del codice qui sotto e perché?
setTimeout(function() {
console.log("A");
}, 1000);
setTimeout(function() {
console.log("B");
}, 0);
getDataFromDatabase(function(err, data) {
console.log("C");
setTimeout(function() {
console.log("D");
}, 1000);
});
console.log("E");
Uscita: questo è noto con certezza: EBAD . C è sconosciuto quando verrà registrato.
Spiegazione: Il compilatore non si fermerà sui getDataFromDatabase setTimeout e
getDataFromDatabase . Quindi la prima riga che registrerà è E Le funzioni di callback (primo
argomento di setTimeout ) verranno eseguite dopo il timeout impostato su un modo asincrono!
Più dettagli:
https://riptutorial.com/it/home 322
1. E non ha setTimeout
2. B ha un timeout impostato di 0 millisecondi
3. A ha un timeout impostato di 1000 millisecondi
4. D deve richiedere un database, dopo che D deve attendere 1000 millisecondi quindi viene
dopo A
5. C è sconosciuto perché è sconosciuto quando vengono richiesti i dati del database. Potrebbe
essere prima o dopo A
Gestione degli errori asincroni
Prova a prendere
Gli errori devono sempre essere gestiti. Se si utilizza la programmazione sincrona, è possibile
utilizzare un try catch . Ma questo non funziona se lavori asincroni! Esempio:
try {
setTimeout(function() {
throw new Error("I'm an uncaught error and will stop the server!");
}, 100);
}
catch (ex) {
console.error("This error will not be work in an asynchronous situation: " + ex);
}
Gli errori asincroni verranno gestiti solo all'interno della funzione di callback!
Possibilità di lavoro
v0.8
Gestori di eventi
Le prime versioni di Node.JS hanno un gestore di eventi.
process.on("UncaughtException", function(err, data) {
if (err) {
// error handling
}
});
v0.8
domini
All'interno di un dominio, gli errori vengono rilasciati tramite gli emettitori di eventi. Usando questo
sono tutti gli errori, i timer, i metodi di callback implicitamente registrati solo all'interno del dominio.
https://riptutorial.com/it/home 323
In caso di errore, inviare un evento di errore e non arrestare l'applicazione.
var domain = require("domain");
var d1 = domain.create();
var d2 = domain.create();
d1.run(function() {
d2.add(setTimeout(function() {
throw new Error("error on the timer of domain 2");
}, 0));
});
d1.on("error", function(err) {
console.log("error at domain 1: " + err);
});
d2.on("error", function(err) {
console.log("error at domain 2: " + err);
});
Callback hell
L'inferno del callback (anche una piramide di doom o effetto boomerang) si verifica quando si
annidano troppe funzioni di callback all'interno di una funzione di callback. Ecco un esempio per
leggere un file (in ES6).
const fs = require('fs');
let filename = `${__dirname}/myfile.txt`;
fs.exists(filename, exists => {
if (exists) {
fs.stat(filename, (err, stats) => {
if (err) {
throw err;
}
if (stats.isFile()) {
fs.readFile(filename, null, (err, data) => {
if (err) {
throw err;
}
console.log(data);
});
}
else {
throw new Error("This location contains not a file");
}
});
}
else {
throw new Error("404: file not found");
}
});
Come evitare "Callback Hell"
Si consiglia di annidare non più di 2 funzioni di callback. Questo ti aiuterà a mantenere la
leggibilità del codice e sarà molto più facile mantenerlo in futuro. Se hai bisogno di nidificare più di
https://riptutorial.com/it/home 324
2 callback, prova a utilizzare gli eventi distribuiti .
Esiste anche una libreria chiamata async che aiuta a gestire i callback e la loro esecuzione
disponibile su npm. Aumenta la leggibilità del codice di callback e offre un maggiore controllo sul
flusso del codice di callback, incluso il permesso di eseguirli in parallelo o in serie.
Promesse native
v6.0.0
Le promesse sono uno strumento per la programmazione asincrona. In JavaScript promesse sono
noti per le loro then metodi. Le promesse prevedono due stati principali "in attesa" e "risolti". Una
volta che la promessa è 'risolta', non può tornare 'in sospeso'. Ciò significa che le promesse sono
valide soprattutto per eventi che si verificano solo una volta. Lo stato 'sistemato' ha due stati pure
'risolti' e 'rifiutati'. Puoi creare una nuova promessa usando la new parola chiave e passando una
funzione nel costruttore new Promise(function (resolve, reject) {}) .
La funzione passata nel costruttore Promise riceve sempre un primo e un secondo parametro,
solitamente denominati rispettivamente resolve e reject . La denominazione di questi due
parametri è convenzione, ma metteranno la promessa nello stato 'risolto' o nello stato 'rifiutato'.
Quando uno di questi è chiamato la promessa passa dall'essere "in sospeso" a "risolto". resolve
viene chiamata quando l'azione desiderata, che è spesso asincrona, è stata eseguita e il reject
viene utilizzato se l'azione è stata errata.
Nel sotto timeout è una funzione che restituisce una Promessa.
function timeout (ms) {
return new Promise(function (resolve, reject) {
setTimeout(function () {
resolve("It was resolved!");
}, ms)
});
}
timeout(1000).then(function (dataFromPromise) {
// logs "It was resolved!"
console.log(dataFromPromise);
})
console.log("waiting...");
uscita della console
waiting...
// << pauses for one second>>
It was resolved!
Quando viene chiamato timeout, la funzione passata al costruttore Promise viene eseguita senza
ritardo. Quindi viene eseguito il metodo setTimeout e la richiamata viene attivata nei successivi ms
millisecondi, in questo caso ms=1000 . Poiché la richiamata al setTimeout non viene attivata, la
funzione di timeout restituisce il controllo all'ambito della chiamata. La catena dei metodi then
https://riptutorial.com/it/home 325
viene quindi archiviata per essere chiamata più tardi quando / se la Promessa è stata risolta. Se
esistessero metodi di catch , anche questi sarebbero archiviati, ma verrebbero licenziati quando /
se la promessa 'respinge'.
Lo script stampa quindi "in attesa ...". Un secondo dopo, setTimeout chiama il suo callback che
chiama la funzione di risoluzione con la stringa "È stato risolto!". Tale stringa viene quindi passata
al callback del metodo then e quindi viene registrata all'utente.
Nello stesso senso è possibile racchiudere la funzione setTimeout asincrona che richiede una
richiamata, quindi è possibile racchiudere qualsiasi azione asincrona singolare con una promessa.
Maggiori informazioni sulle promesse nella documentazione di JavaScript Promises .
Leggi Programmazione asincrona online: https://riptutorial.com/it/node-
js/topic/8813/programmazione-asincrona
https://riptutorial.com/it/home 326
Capitolo 92: Programmazione sincrona
contro asincrona in nodejs
Examples
Uso asincrono
Il pacchetto async fornisce funzioni per il codice asincrono.
Utilizzando la funzione automatica è possibile definire relazioni asincrone tra due o più funzioni:
var async = require('async');
async.auto({
get_data: function(callback) {
console.log('in get_data');
// async code to get some data
callback(null, 'data', 'converted to array');
},
make_folder: function(callback) {
console.log('in make_folder');
// async code to create a directory to store a file in
// this is run at the same time as getting the data
callback(null, 'folder');
},
write_file: ['get_data', 'make_folder', function(results, callback) {
console.log('in write_file', JSON.stringify(results));
// once there is some data and the directory exists,
// write the data to a file in the directory
callback(null, 'filename');
}],
email_link: ['write_file', function(results, callback) {
console.log('in email_link', JSON.stringify(results));
// once the file is written let's email a link to it...
// results.write_file contains the filename returned by write_file.
callback(null, {'file':results.write_file, 'email':'[email protected]'});
}]
}, function(err, results) {
console.log('err = ', err);
console.log('results = ', results);
});
Questo codice potrebbe essere stato creato in modo sincrono, semplicemente chiamando
get_data , make_folder , write_file e email_link nell'ordine corretto. Async tiene traccia dei risultati
per te e, se si verifica un errore (primo parametro di callback non uguale a null ), interrompe
l'esecuzione delle altre funzioni.
Leggi Programmazione sincrona contro asincrona in nodejs online: https://riptutorial.com/it/node-
js/topic/8287/programmazione-sincrona-contro-asincrona-in-nodejs
https://riptutorial.com/it/home 327
Capitolo 93: Promesse Bluebird
Examples
Conversione della libreria del nodoback in Promises
const Promise = require('bluebird'),
fs = require('fs')
Promise.promisifyAll(fs)
// now you can use promise based methods on 'fs' with the Async suffix
fs.readFileAsync('file.txt').then(contents => {
console.log(contents)
}).catch(err => {
console.error('error reading', err)
})
Promesse funzionali
Esempio di mappa:
Promise.resolve([ 1, 2, 3 ]).map(el => {
return Promise.resolve(el * el) // return some async operation in real world
})
Esempio di filtro:
Promise.resolve([ 1, 2, 3 ]).filter(el => {
return Promise.resolve(el % 2 === 0) // return some async operation in real world
}).then(console.log)
Esempio di riduzione:
Promise.resolve([ 1, 2, 3 ]).reduce((prev, curr) => {
return Promise.resolve(prev + curr) // return some async operation in real world
}).then(console.log)
Coroutine (generatori)
const promiseReturningFunction = Promise.coroutine(function* (file) {
const data = yield fs.readFileAsync(file) // this returns a Promise and resolves to the file
contents
return data.toString().toUpperCase()
})
promiseReturningFunction('file.txt').then(console.log)
https://riptutorial.com/it/home 328
Smaltimento automatico delle risorse (Promise.using)
function somethingThatReturnsADisposableResource() {
return getSomeResourceAsync(...).disposer(resource => {
resource.dispose()
})
}
Promise.using(somethingThatReturnsADisposableResource(), resource => {
// use the resource here, the disposer will automatically close it when Promise.using exits
})
Eseguendo in serie
Promise.resolve([1, 2, 3])
.mapSeries(el => Promise.resolve(el * el)) // in real world, use Promise returning async
function
.then(console.log)
Leggi Promesse Bluebird online: https://riptutorial.com/it/node-js/topic/6728/promesse-bluebird
https://riptutorial.com/it/home 329
Capitolo 94: Protezione delle applicazioni
Node.js
Examples
Prevenire la falsificazione di richieste cross-site (CSRF)
CSRF è un attacco che costringe l'utente finale a eseguire azioni indesiderate su un'applicazione
web in cui è attualmente autenticato.
Può accadere perché i cookie vengono inviati con ogni richiesta a un sito Web, anche quando tali
richieste provengono da un altro sito.
Possiamo usare il modulo csurf per creare il token csrf e convalidarlo.
Esempio
var express = require('express')
var cookieParser = require('cookie-parser') //for cookie parsing
var csrf = require('csurf') //csrf module
var bodyParser = require('body-parser') //for body parsing
// setup route middlewares
var csrfProtection = csrf({ cookie: true })
var parseForm = bodyParser.urlencoded({ extended: false })
// create express app
var app = express()
// parse cookies
app.use(cookieParser())
app.get('/form', csrfProtection, function(req, res) {
// generate and pass the csrfToken to the view
res.render('send', { csrfToken: req.csrfToken() })
})
app.post('/process', parseForm, csrfProtection, function(req, res) {
res.send('data is being processed')
})
Quindi, quando accediamo a GET /form , passeremo il token csrfToken alla vista.
Ora, all'interno della vista, imposta il valore csrfToken come valore di un campo di input nascosto
chiamato _csrf .
ad esempio per handlebar modelli handlebar
<form action="/process" method="POST">
<input type="hidden" name="_csrf" value="{{csrfToken}}">
Name: <input type="text" name="name">
https://riptutorial.com/it/home 330
<button type="submit">Submit</button>
</form>
ad esempio per i modelli di jade
form(action="/process" method="post")
input(type="hidden", name="_csrf", value=csrfToken)
span Name:
input(type="text", name="name", required=true)
br
input(type="submit")
ad esempio per i modelli di ejs
<form action="/process" method="POST">
<input type="hidden" name="_csrf" value="<%= csrfToken %>">
Name: <input type="text" name="name">
<button type="submit">Submit</button>
</form>
SSL / TLS in Node.js
Se si sceglie di gestire SSL / TLS nell'applicazione Node.js, considerare che si è anche
responsabili della gestione della prevenzione degli attacchi SSL / TLS a questo punto. In molte
architetture server-client, SSL / TLS termina su un proxy inverso, sia per ridurre la complessità
delle applicazioni sia per ridurre l'ambito della configurazione della sicurezza.
Se l'applicazione Node.js deve gestire SSL / TLS, può essere protetta caricando i file key e cert.
Se il proprio fornitore di certificati richiede una catena di autorità di certificazione (CA), può essere
aggiunto all'opzione ca come array. Una catena con più voci in un singolo file deve essere
suddivisa in più file e inserita nello stesso ordine nell'array poiché Node.js attualmente non
supporta più voci ca in un unico file. Un esempio è fornito nel seguente codice per i file 1_ca.crt e
2_ca.crt . Se l'array ca è richiesto e non impostato correttamente, i browser client potrebbero
visualizzare messaggi che non potrebbero verificare l'autenticità del certificato.
Esempio
const https = require('https');
const fs = require('fs');
const options = {
key: fs.readFileSync('privatekey.pem'),
cert: fs.readFileSync('certificate.pem'),
ca: [fs.readFileSync('1_ca.crt'), fs.readFileSync('2_ca.crt')]
};
https.createServer(options, (req, res) => {
res.writeHead(200);
res.end('hello world\n');
}).listen(8000);
https://riptutorial.com/it/home 331
Utilizzando HTTPS
L'installazione minima per un server HTTPS in Node.js sarebbe qualcosa del genere:
const https = require('https');
const fs = require('fs');
const httpsOptions = {
key: fs.readFileSync('path/to/server-key.pem'),
cert: fs.readFileSync('path/to/server-crt.pem')
};
const app = function (req, res) {
res.writeHead(200);
res.end("hello world\n");
}
https.createServer(httpsOptions, app).listen(4433);
Se vuoi anche supportare le richieste http, devi fare solo questa piccola modifica:
const http = require('http');
const https = require('https');
const fs = require('fs');
const httpsOptions = {
key: fs.readFileSync('path/to/server-key.pem'),
cert: fs.readFileSync('path/to/server-crt.pem')
};
const app = function (req, res) {
res.writeHead(200);
res.end("hello world\n");
}
http.createServer(app).listen(8888);
https.createServer(httpsOptions, app).listen(4433);
Configurare un server HTTPS
Una volta che node.js è installato sul sistema, basta seguire la procedura seguente per ottenere
un server Web di base in esecuzione con supporto per HTTP e HTTPS!
Passaggio 1: creare un'autorità di certificazione
1. creare la cartella in cui si desidera memorizzare la chiave e il certificato:
mkdir conf
2. vai a quella directory:
cd conf
https://riptutorial.com/it/home 332
3. prendi questo file ca.cnf da usare come scorciatoia di configurazione:
wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf
4. creare una nuova autorità di certificazione utilizzando questa configurazione:
openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem
5. ora che abbiamo la nostra autorità di certificazione in ca-key.pem e ca-cert.pem , ca-key.pem
una chiave privata per il server:
openssl genrsa -out key.pem 4096
6. prendi questo file server.cnf da usare come scorciatoia di configurazione:
wget https://raw.githubusercontent.com/anders94/https-authorized-
clients/master/keys/server.cnf
7. generare la richiesta di firma del certificato utilizzando questa configurazione:
openssl req -new -config server.cnf -key key.pem -out csr.pem
8. firmare la richiesta:
openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in csr.pem -CA ca-
cert.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem
Passaggio 2: installa il certificato come certificato di origine
1. copia il tuo certificato nella cartella dei certificati di root:
sudo cp ca-crt.pem /usr/local/share/ca-certificates/ca-crt.pem
2. aggiornare l'archivio di CA:
sudo update-ca-certificates
Applicazione Secure express.js 3
La configurazione per creare una connessione sicura usando express.js (Dalla versione 3):
var fs = require('fs');
var http = require('http');
var https = require('https');
var privateKey = fs.readFileSync('sslcert/server.key', 'utf8');
var certificate = fs.readFileSync('sslcert/server.crt', 'utf8');
// Define your key and cert
https://riptutorial.com/it/home 333
var credentials = {key: privateKey, cert: certificate};
var express = require('express');
var app = express();
// your express configuration here
var httpServer = http.createServer(app);
var httpsServer = https.createServer(credentials, app);
// Using port 8080 for http and 8443 for https
httpServer.listen(8080);
httpsServer.listen(8443);
In questo modo fornisci il middleware espresso al server http / https nativo
Se si desidera che l'app venga eseguita su porte inferiori a 1024, sarà necessario utilizzare il
comando sudo (non consigliato) o utilizzare un proxy inverso (ad esempio nginx, haproxy).
Leggi Protezione delle applicazioni Node.js online: https://riptutorial.com/it/node-
js/topic/3473/protezione-delle-applicazioni-node-js
https://riptutorial.com/it/home 334
Capitolo 95: Quadri di modelli
Examples
Nunjucks
Motore lato server con ereditarietà di blocchi, autoescaping, macro, controllo asincrono e altro.
Molto ispirato da jinja2, molto simile a Twig (php).
Documenti - http://mozilla.github.io/nunjucks/
Installa - npm i nunjucks
Utilizzo di base con Express di seguito.
app.js
var express = require ('express');
var nunjucks = require('nunjucks');
var app = express();
app.use(express.static('/public'));
// Apply nunjucks and add custom filter and function (for example).
var env = nunjucks.configure(['views/'], { // set folders with templates
autoescape: true,
express: app
});
env.addFilter('myFilter', function(obj, arg1, arg2) {
console.log('myFilter', obj, arg1, arg2);
// Do smth with obj
return obj;
});
env.addGlobal('myFunc', function(obj, arg1) {
console.log('myFunc', obj, arg1);
// Do smth with obj
return obj;
});
app.get('/', function(req, res){
res.render('index.html', {title: 'Main page'});
});
app.get('/foo', function(req, res){
res.locals.smthVar = 'This is Sparta!';
res.render('foo.html', {title: 'Foo page'});
});
app.listen(3000, function() {
console.log('Example app listening on port 3000...');
});
/views/index.html
https://riptutorial.com/it/home 335
<html>
<head>
<title>Nunjucks example</title>
</head>
<body>
{% block content %}
{{title}}
{% endblock %}
</body>
</html>
/views/foo.html
{% extends "index.html" %}
{# This is comment #}
{% block content %}
<h1>{{title}}</h1>
{# apply custom function and next build-in and custom filters #}
{{ myFunc(smthVar) | lower | myFilter(5, 'abc') }}
{% endblock %}
Leggi Quadri di modelli online: https://riptutorial.com/it/node-js/topic/5885/quadri-di-modelli
https://riptutorial.com/it/home 336
Capitolo 96: Quadri di test unitari
Examples
Mocha sincrono
describe('Suite Name', function() {
describe('#method()', function() {
it('should run without an error', function() {
expect([ 1, 2, 3 ].length).to.be.equal(3)
})
})
})
Mocha asincrono (callback)
var expect = require("chai").expect;
describe('Suite Name', function() {
describe('#method()', function() {
it('should run without an error', function(done) {
testSomething(err => {
expect(err).to.not.be.equal(null)
done()
})
})
})
})
Mocha asincrono (Promessa)
describe('Suite Name', function() {
describe('#method()', function() {
it('should run without an error', function() {
return doSomething().then(result => {
expect(result).to.be.equal('hello world')
})
})
})
})
Mocha asincrono (async / await)
const { expect } = require('chai')
describe('Suite Name', function() {
describe('#method()', function() {
it('should run without an error', async function() {
const result = await answerToTheUltimateQuestion()
expect(result).to.be.equal(42)
})
})
https://riptutorial.com/it/home 337
})
Leggi Quadri di test unitari online: https://riptutorial.com/it/node-js/topic/6731/quadri-di-test-unitari
https://riptutorial.com/it/home 338
Capitolo 97: Richiamata per promettere
Examples
Promuovere una richiamata
Richiamata a base di:
db.notification.email.find({subject: 'promisify callback'}, (error, result) => {
if (error) {
console.log(error);
}
// normal code here
});
Questo utilizza il promisifyAll metodo bluebird per promettere ciò che è convenzionalmente codice
basato su callback come sopra. bluebird creerà una versione promettente di tutti i metodi
nell'oggetto, i nomi dei metodi basati su promesse hanno accodati ad Async:
let email = bluebird.promisifyAll(db.notification.email);
email.findAsync({subject: 'promisify callback'}).then(result => {
// normal code here
})
.catch(console.error);
Se solo i metodi specifici devono essere promessi, basta usare la sua promessa:
let find = bluebird.promisify(db.notification.email.find);
find({locationId: 168}).then(result => {
// normal code here
});
.catch(console.error);
Ci sono alcune librerie (ad es., MassiveJS) che non possono essere promesse se l'oggetto
immediato del metodo non viene passato sul secondo parametro. In tal caso, basta passare
l'oggetto immediato del metodo che deve essere promesso sul secondo parametro e racchiuderlo
nella proprietà context.
let find = bluebird.promisify(db.notification.email.find, { context: db.notification.email });
find({locationId: 168}).then(result => {
// normal code here
});
.catch(console.error);
https://riptutorial.com/it/home 339
Promessa manuale di un callback
A volte potrebbe essere necessario promettere manualmente una funzione di callback. Potrebbe
trattarsi di un caso in cui la richiamata non segue il formato standard di errore prima o se è
necessaria una logica aggiuntiva per promettere:
Esempio con fs.exists (percorso, callback) :
var fs = require('fs');
var existsAsync = function(path) {
return new Promise(function(resolve, reject) {
fs.exists(path, function(exists) {
// exists is a boolean
if (exists) {
// Resolve successfully
resolve();
} else {
// Reject with error
reject(new Error('path does not exist'));
}
});
});
// Use as a promise now
existsAsync('/path/to/some/file').then(function() {
console.log('file exists!');
}).catch(function(err) {
// file does not exist
console.error(err);
});
setTimeout promesso
function wait(ms) {
return new Promise(function (resolve, reject) {
setTimeout(resolve, ms)
})
}
Leggi Richiamata per promettere online: https://riptutorial.com/it/node-js/topic/2346/richiamata-per-
promettere
https://riptutorial.com/it/home 340
Capitolo 98: Richiedere()
introduzione
Questa documentazione si concentra sulla spiegazione degli usi e della dichiarazione require()
che NodeJS include nella loro lingua.
È necessario importare determinati file o pacchetti utilizzati con i moduli di NodeJS. È usato per
migliorare la struttura del codice e gli usi. require() viene utilizzato su file installati localmente, con
un percorso diretto dal file che è require .
Sintassi
• module.exports = {testFunction: testFunction};
• var test_file = require ('./ testFile.js'); // Lasciateci avere un file chiamato testFile
• test_file.testFunction (our_data); // Lascia che testFile abbia function testFunction
Osservazioni
L'uso di require() consente di strutturare il codice in modo simile all'utilizzo di classi e metodi
pubblici da parte di Java. Se una funzione è .export ', può essere require ' ed in un altro file da
utilizzare. Se un file non è .export ', non può essere utilizzato in un altro file.
Examples
Beginning require () usa con una funzione e un file
Require è una dichiarazione che Node interpreta come, in un certo senso, una funzione getter .
Ad esempio, supponiamo di avere un file denominato analysis.js e l'aspetto interno del file è
simile a questo,
function analyzeWeather(weather_data) {
console.log('Weather information for ' + weather_data.time + ': ');
console.log('Rainfall: ' + weather_data.precip);
console.log('Temperature: ' + weather_data.temp);
//More weather_data analysis/printing...
}
Questo file contiene solo il metodo, analyzeWeather(weather_data) . Se vogliamo usare questa
funzione, deve essere usata all'interno di questo file, o copiata nel file che vuole essere usata da.
Tuttavia, il nodo ha incluso uno strumento molto utile per aiutare con il codice e l'organizzazione
dei file, che è moduli .
Per utilizzare la nostra funzione, dobbiamo prima export la funzione attraverso una dichiarazione
all'inizio. Il nostro nuovo file ha questo aspetto,
https://riptutorial.com/it/home 341
module.exports = {
analyzeWeather: analyzeWeather
}
function analyzeWeather(weather_data) {
console.log('Weather information for ' + weather_data.time + ': ');
console.log('Rainfall: ' + weather_data.precip);
console.log('Temperature: ' + weather_data.temp);
//More weather_data analysis/printing...
}
Con questa piccola istruzione module.exports , la nostra funzione è ora pronta per l'uso al di fuori
del file. Tutto ciò che resta da fare è usare require() .
Quando si require una funzione o un file, la sintassi è molto simile. Di solito è fatto all'inizio del file
e impostato su var o su const per l'uso in tutto il file. Ad esempio, abbiamo un altro file (sullo
stesso livello di analyze.js chiamato handleWeather.js che assomiglia a questo,
const analysis = require('./analysis.js');
weather_data = {
time: '01/01/2001',
precip: 0.75,
temp: 78,
//More weather data...
};
analysis.analyzeWeather(weather_data);
In questo file, stiamo usando require() per prendere il nostro file analysis.js . Quando viene
utilizzato, chiamiamo semplicemente la variabile o la costante assegnata a questa require e
usiamo qualsiasi funzione all'interno di quella che viene esportata.
Beginning require () usa con un pacchetto NPM
Nodo di require è anche molto utile se usato in tandem con un pacchetto di NPM . Diciamo, per
esempio, si desidera utilizzare il pacchetto NPM require in un file chiamato getWeather.js . Dopo l'
installazione di NPM del pacchetto tramite la riga di comando ( git install request ), sei pronto
per usarlo. Il getWeather.js file getWeather.js potrebbe sembrare come questo,
var https = require('request');
//Construct your url variable...
https.get(url, function(error, response, body) {
if (error) {
console.log(error);
} else {
console.log('Response => ' + response);
console.log('Body => ' + body);
}
});
Quando viene eseguito questo file, prima require (s) il pacchetto che hai appena installato
chiamato request . All'interno del file di request , ci sono molte funzioni a cui puoi ora accedere,
una delle quali è chiamata get . Nelle linee successive, la funzione viene utilizzata per fare una
https://riptutorial.com/it/home 342
richiesta HTTP GET .
Leggi Richiedere() online: https://riptutorial.com/it/node-js/topic/10742/richiedere--
https://riptutorial.com/it/home 343
Capitolo 99: Route-Controller-Struttura del
servizio per ExpressJS
Examples
Modello-Routes-Controllers-Services Struttura delle directory
├───models
│ ├───user.model.js
├───routes
│ ├───user.route.js
├───services
│ ├───user.service.js
├───controllers
│ ├───user.controller.js
Per la struttura del codice modulare, la logica deve essere suddivisa in queste directory e file.
Modelli : la definizione dello schema del modello
Percorsi : l'API instrada le mappe ai Controller
Controllori : i controller gestiscono tutta la logica alla base della convalida dei
parametri della richiesta, della query, dell'invio delle risposte con i codici corretti.
Servizi : i servizi contengono le query del database e restituiscono oggetti o errori di
lancio
Questo codificatore finirà per scrivere più codici. Ma alla fine i codici saranno molto più
manutenibili e separati.
Modello-Routes-Controllers-Services Struttura dei codici
user.model.js
var mongoose = require('mongoose')
const UserSchema = new mongoose.Schema({
name: String
})
const User = mongoose.model('User', UserSchema)
module.exports = User;
https://riptutorial.com/it/home 344
user.routes.js
var express = require('express');
var router = express.Router();
var UserController = require('../controllers/user.controller')
router.get('/', UserController.getUsers)
module.exports = router;
user.controllers.js
var UserService = require('../services/user.service')
exports.getUsers = async function (req, res, next) {
// Validate request parameters, queries using express-validator
var page = req.params.page ? req.params.page : 1;
var limit = req.params.limit ? req.params.limit : 10;
try {
var users = await UserService.getUsers({}, page, limit)
return res.status(200).json({ status: 200, data: users, message: "Succesfully Users
Retrieved" });
} catch (e) {
return res.status(400).json({ status: 400, message: e.message });
}
}
user.services.js
var User = require('../models/user.model')
exports.getUsers = async function (query, page, limit) {
try {
var users = await User.find(query)
return users;
} catch (e) {
// Log Errors
throw Error('Error while Paginating Users')
}
}
Leggi Route-Controller-Struttura del servizio per ExpressJS online: https://riptutorial.com/it/node-
js/topic/10785/route-controller-struttura-del-servizio-per-expressjs
https://riptutorial.com/it/home 345
Capitolo 100: Routing NodeJs
introduzione
Come configurare il server Web di base Express sotto il nodo js e il router Exploring the Express.
Osservazioni
Infine, utilizzando Express Router è possibile utilizzare la funzione di routing nell'applicazione ed è
facile da implementare.
Examples
Esecuzione del routing del server Web
Creazione di server Web Express
Il server Express è diventato pratico e utilizza molti utenti e community. Sta diventando popolare.
Consente di creare un server Express. Per la gestione dei pacchetti e la flessibilità per la
dipendenza Useremo NPM (Node Package Manager).
1. Vai alla directory del progetto e crea il file package.json. package.json {"name":
"expressRouter", "version": "0.0.1", "scripts": {"start": "node Server.js"}, "dependencies":
{"express": "^ 4.12.3 "}}
2. Salvare il file e installare la dipendenza rapida utilizzando il seguente comando npm install .
Questo creerà node_modules nella directory del progetto insieme alla dipendenza richiesta.
3. Creiamo Express Web Server. Vai alla directory del progetto e crea il file server.js. server.js
var express = require ("express"); var app = express ();
// Creazione dell'oggetto Router ()
var router = express.Router ();
// Fornisci tutti i percorsi qui, questo è per la Home page.
router.get("/",function(req,res){
res.json({"message" : "Hello World"});
});
app.use ( "/ api", router);
// Ascolta questo porto
https://riptutorial.com/it/home 346
app.listen (3000, function () {console.log ("Live at Port 3000");});
For more detail on setting node server you can see [here][1].
4. Eseguire il server digitando il comando seguente.
nodo server.js
Se il server funziona correttamente, vedrai qualcosa di simile.
5. Ora vai al browser o al postino e fai una richiesta
http: // localhost: 3000 / api /
L'output sarà
https://riptutorial.com/it/home 347
.
Questo è tutto, la base del routing espresso.
Ora gestiamo GET, POST, ecc.
Cambia il tuo file server.js come
var express = require("express");
var app = express();
//Creating Router() object
var router = express.Router();
// Router middleware, mentioned it before defining routes.
router.use(function(req,res,next) {
console.log("/" + req.method);
next();
});
// Provide all routes here, this is for Home page.
router.get("/",function(req,res){
res.json({"message" : "Hello World"});
});
app.use("/api",router);
app.listen(3000,function(){
console.log("Live at Port 3000");
https://riptutorial.com/it/home 348
});
Ora se riavvii il server e hai fatto la richiesta a
http://localhost:3000/api/
Vedrai qualcosa di simile
Accesso ai parametri nel routing
Puoi anche accedere al parametro dall'URL, come http://example.com/api/:name/ . Quindi il
parametro name può essere accesso. Aggiungi il seguente codice nel tuo server.js
router.get("/user/:id",function(req,res){
res.json({"message" : "Hello "+req.params.id});
});
Ora riavvia il server e vai a [ http: // localhost: 3000 / api / user / Adem] [4] , l'output sarà come
https://riptutorial.com/it/home 349
.
Leggi Routing NodeJs online: https://riptutorial.com/it/node-js/topic/9846/routing-nodejs
https://riptutorial.com/it/home 350
Capitolo 101: Sequelize.js
Examples
Installazione
Assicurati di aver prima installato Node.js e npm. Quindi installare sequelize.js con npm
npm install --save sequelize
Sarà inoltre necessario installare i moduli Node.js del database supportati. Devi solo installare
quello che stai utilizzando
Per MYSQL e Mariadb
npm install --save mysql
Per PostgreSQL
npm install --save pg pg-hstore
Per SQLite
npm install --save sqlite
Per MSSQL
npm install --save tedious
Una volta installato, puoi includere e creare una nuova istanza di Sequalize in questo modo.
Sintassi ES5
var Sequelize = require('sequelize');
var sequelize = new Sequelize('database', 'username', 'password');
Sintassi di Babele ES6 stage-0
import Sequelize from 'sequelize';
const sequelize = new Sequelize('database', 'username', 'password');
Ora hai un'istanza di sequelize disponibile. Potresti se ti senti così incline chiamarlo con un nome
diverso come
var db = new Sequelize('database', 'username', 'password');
https://riptutorial.com/it/home 351
o
var database = new Sequelize('database', 'username', 'password');
quella parte è la tua prerogativa. Una volta installato, puoi utilizzarlo all'interno dell'applicazione
come da documentazione dell'API http://docs.sequelizejs.com/en/v3/api/sequelize/
Il prossimo passo dopo l'installazione sarebbe quello di impostare il proprio modello
Definizione dei modelli
Ci sono due modi per definire i modelli in sequelize; con sequelize.define(...) o
sequelize.import(...) . Entrambe le funzioni restituiscono un oggetto modello sequelizzato.
1. sequelize.define (modelName, attributes,
[opzioni])
Questa è la strada da percorrere se si desidera definire tutti i modelli in un unico file o se si
desidera avere un ulteriore controllo sulla definizione del modello.
/* Initialize Sequelize */
const config = {
username: "database username",
password: "database password",
database: "database name",
host: "database's host URL",
dialect: "mysql" // Other options are postgres, sqlite, mariadb and mssql.
}
var Sequelize = require("sequelize");
var sequelize = new Sequelize(config);
/* Define Models */
sequelize.define("MyModel", {
name: Sequelize.STRING,
comment: Sequelize.TEXT,
date: {
type: Sequelize.DATE,
allowNull: false
}
});
Per la documentazione e altri esempi, consultare la documentazione di doclets o la
documentazione di sequelize.com .
2. sequelize.import (path)
Se le definizioni del modello sono suddivise in un file per ciascuna, quindi l' import è tuo amico.
https://riptutorial.com/it/home 352
Nel file in cui si inizializza Sequelize, è necessario chiamare l'importazione in questo modo:
/* Initialize Sequelize */
// Check previous code snippet for initialization
/* Define Models */
sequelize.import("./models/my_model.js"); // The path could be relative or absolute
Quindi nei file di definizione del modello, il codice sarà simile a questo:
module.exports = function(sequelize, DataTypes) {
return sequelize.define("MyModel", {
name: DataTypes.STRING,
comment: DataTypes.TEXT,
date: {
type: DataTypes.DATE,
allowNull: false
}
});
};
Per ulteriori informazioni su come utilizzare l' import , controlla l' esempio esplicito di sequelize su
GitHub .
Leggi Sequelize.js online: https://riptutorial.com/it/node-js/topic/7705/sequelize-js
https://riptutorial.com/it/home 353
Capitolo 102: Sfide di prestazione
Examples
Elaborazione di query a esecuzione prolungata con nodo
Poiché il nodo è a thread singolo, è necessario risolvere il problema in caso di calcoli a lunga
esecuzione.
Nota: questo è l'esempio "pronto per l'esecuzione". Solo, non dimenticare di ottenere jQuery e
installare i moduli richiesti.
Logica principale di questo esempio:
1. Il cliente invia una richiesta al server.
2. Il server avvia la routine in un'istanza del nodo separato e invia una risposta immediata con
l'ID dell'attività correlata.
3. Il cliente invia continuamente assegni a un server per gli aggiornamenti di stato dell'ID
attività specificato.
Struttura del progetto:
project
│ package.json
│ index.html
│
├───js
│ main.js
│ jquery-1.12.0.min.js
│
└───srv
│ app.js
├─── models
│ task.js
└─── tasks
data-processor.js
app.js:
var express = require('express');
var app = express();
var http = require('http').Server(app);
var mongoose = require('mongoose');
var bodyParser = require('body-parser');
var childProcess= require('child_process');
var Task = require('./models/task');
app.use(bodyParser.urlencoded({ extended: true }));
app.use(bodyParser.json());
https://riptutorial.com/it/home 354
app.use(express.static(__dirname + '/../'));
app.get('/', function(request, response){
response.render('index.html');
});
//route for the request itself
app.post('/long-running-request', function(request, response){
//create new task item for status tracking
var t = new Task({ status: 'Starting ...' });
t.save(function(err, task){
//create new instance of node for running separate task in another thread
taskProcessor = childProcess.fork('./srv/tasks/data-processor.js');
//process the messages comming from the task processor
taskProcessor.on('message', function(msg){
task.status = msg.status;
task.save();
}.bind(this));
//remove previously openned node instance when we finished
taskProcessor.on('close', function(msg){
this.kill();
});
//send some params to our separate task
var params = {
message: 'Hello from main thread'
};
taskProcessor.send(params);
response.status(200).json(task);
});
});
//route to check is the request is finished the calculations
app.post('/is-ready', function(request, response){
Task
.findById(request.body.id)
.exec(function(err, task){
response.status(200).json(task);
});
});
mongoose.connect('mongodb://localhost/test');
http.listen('1234');
task.js:
var mongoose = require('mongoose');
var taskSchema = mongoose.Schema({
status: {
type: String
}
});
mongoose.model('Task', taskSchema);
https://riptutorial.com/it/home 355
module.exports = mongoose.model('Task');
data-processor.js:
process.on('message', function(msg){
init = function(){
processData(msg.message);
}.bind(this)();
function processData(message){
//send status update to the main app
process.send({ status: 'We have started processing your data.' });
//long calculations ..
setTimeout(function(){
process.send({ status: 'Done!' });
//notify node, that we are done with this task
process.disconnect();
}, 5000);
}
});
process.on('uncaughtException',function(err){
console.log("Error happened: " + err.message + "\n" + err.stack + ".\n");
console.log("Gracefully finish the routine.");
});
index.html:
<!DOCTYPE html>
<html>
<head>
<script src="./js/jquery-1.12.0.min.js"></script>
<script src="./js/main.js"></script>
</head>
<body>
<p>Example of processing long-running node requests.</p>
<button id="go" type="button">Run</button>
<br />
<p>Log:</p>
<textarea id="log" rows="20" cols="50"></textarea>
</body>
</html>
main.js:
$(document).on('ready', function(){
$('#go').on('click', function(e){
//clear log
$("#log").val('');
$.post("/long-running-request", {some_params: 'params' })
.done(function(task){
https://riptutorial.com/it/home 356
$("#log").val( $("#log").val() + '\n' + task.status);
//function for tracking the status of the task
function updateStatus(){
$.post("/is-ready", {id: task._id })
.done(function(response){
$("#log").val( $("#log").val() + '\n' + response.status);
if(response.status != 'Done!'){
checkTaskTimeout = setTimeout(updateStatus, 500);
}
});
}
//start checking the task
var checkTaskTimeout = setTimeout(updateStatus, 100);
});
});
});
package.json:
{
"name": "nodeProcessor",
"dependencies": {
"body-parser": "^1.15.2",
"express": "^4.14.0",
"html": "0.0.10",
"mongoose": "^4.5.5"
}
}
Disclaimer: questo esempio ha lo scopo di darti un'idea di base. Per usarlo nell'ambiente di
produzione, ha bisogno di miglioramenti.
Leggi Sfide di prestazione online: https://riptutorial.com/it/node-js/topic/6325/sfide-di-prestazione
https://riptutorial.com/it/home 357
Capitolo 103: Socket TCP
Examples
Un semplice server TCP
// Include Nodejs' net module.
const Net = require('net');
// The port on which the server is listening.
const port = 8080;
// Use net.createServer() in your code. This is just for illustration purpose.
// Create a new TCP server.
const server = new Net.Server();
// The server listens to a socket for a client to make a connection request.
// Think of a socket as an end point.
server.listen(port, function() {
console.log(`Server listening for connection requests on socket localhost:${port}`.);
});
// When a client requests a connection with the server, the server creates a new
// socket dedicated to that client.
server.on('connection', function(socket) {
console.log('A new connection has been established.');
// Now that a TCP connection has been established, the server can send data to
// the client by writing to its socket.
socket.write('Hello, client.');
// The server can also receive data from the client by reading from its socket.
socket.on('data', function(chunk) {
console.log(`Data received from client: ${chunk.toString()`.});
});
// When the client requests to end the TCP connection with the server, the server
// ends the connection.
socket.on('end', function() {
console.log('Closing connection with the client');
});
// Don't forget to catch error, for your own sake.
socket.on('error', function(err) {
console.log(`Error: ${err}`);
});
});
Un semplice client TCP
// Include Nodejs' net module.
const Net = require('net');
// The port number and hostname of the server.
const port = 8080;
const host = 'localhost';
// Create a new TCP client.
https://riptutorial.com/it/home 358
const client = new Net.Socket();
// Send a connection request to the server.
client.connect({ port: port, host: host }), function() {
// If there is no error, the server has accepted the request and created a new
// socket dedicated to us.
console.log('TCP connection established with the server.');
// The client can now send data to the server by writing to its socket.
client.write('Hello, server.');
});
// The client can also receive data from the server by reading from its socket.
client.on('data', function(chunk) {
console.log(`Data received from the server: ${chunk.toString()}.`);
// Request an end to the connection after the data has been received.
client.end();
});
client.on('end', function() {
console.log('Requested an end to the TCP connection');
});
Leggi Socket TCP online: https://riptutorial.com/it/node-js/topic/6545/socket-tcp
https://riptutorial.com/it/home 359
Capitolo 104: Storia di Nodejs
introduzione
Qui discuteremo della storia di Node.js, delle informazioni sulla versione e del suo stato attuale.
Examples
Eventi chiave in ogni anno
2009
• 3 marzo: il progetto è stato nominato "nodo"
• 1 ottobre: prima anteprima molto presto di npm, il pacchetto Node
manager
• 8 novembre: Ryan Dahl's (Creator of Node.js) Original Node.js Talk al JSConf 2009
2010
• Express: un framework di sviluppo web Node.js
• Socket.io versione iniziale
• 28 aprile: supporto Experimental Node.js su Heroku
• 28 luglio: Google Tech Talk di Ryan Dahl su Node.js
• 20 agosto: rilasciato Node.js 0.2.0
2011
• 31 marzo: Guida Node.js
• 1 maggio: npm 1.0: rilasciato
• 1 maggio: AMA di Ryan Dahl su Reddit
• 10 luglio: Il Node Beginner Book, un'introduzione a Node.js, è completato .
○Un tutorial completo su Node.js per principianti.
• 16 agosto: LinkedIn utilizza Node.js
○LinkedIn ha lanciato la sua app mobile completamente rinnovata con nuove
funzionalità e nuove parti sotto il cofano.
• 5 ottobre: Ryan Dahl parla della storia di Node.js e del motivo per cui l'ha creata
• 5 dicembre: Node.js in produzione presso Uber
○Il responsabile della progettazione di Uber Curtis Chambers spiega perché la sua
azienda ha completamente riprogettato la propria applicazione utilizzando Node.js per
aumentare l'efficienza e migliorare l'esperienza dei partner e dei clienti.
https://riptutorial.com/it/home 360
2012
• 30 gennaio: il creatore di Node.js Ryan Dahl si allontana quotidianamente da Node
• 25 giugno: Node.js v0.8.0 [stable] è fuori
• 20 dicembre: Hapi, viene rilasciato un framework Node.js
2013
• 30 aprile: Lo stack MEAN: MongoDB, ExpressJS, AngularJS e Node.js
• 17 maggio: Come abbiamo costruito la prima applicazione Node.js di eBay
• 15 novembre: PayPal rilascia Kraken, un framework Node.js
• 22 novembre: perdita di memoria Node.js a Walmart
○ I laboratori di Eran Hammer of Wal-Mart sono venuti al nucleo di Node.js per
lamentarsi di una perdita di memoria che stava rintracciando da mesi.
• 19 dicembre: Koa - Web framework per Node.js
2014
• 15 gennaio: TJ Fontaine rileva il progetto Node
• 23 ottobre: Node.js Advisory Board
○ Joyent e diversi membri della comunità Node.js hanno annunciato una proposta per un
Advisory Board Node.js come passo successivo verso un modello di governance
completamente aperto per il progetto open source Node.js.
• 19 novembre: Node.js in Flame Graphs - Netflix
• 28 novembre: IO.js - I / O evento per V8 Javascript
2015
Q1
• 14 gennaio: IO.js 1.0.0
• 10th Febraury: Joyent si muove per stabilire la fondazione Node.js
○Joyent, IBM, Microsoft, PayPal, Fidelity, SAP e The Linux Foundation uniscono le forze
per supportare la community Node.js con Neutral e Open Governance
• 27 febbraio: IO.js e proposta di riconciliazione Node.js
Q2
• 14 aprile: npm Private Modules
• 28 maggio: il leader del Nodo TJ Fontaine si dimette e lascia Joyent
• 13 maggio: Node.js e io.js si uniscono sotto la Node Foundation
https://riptutorial.com/it/home 361
Q3
• 2 agosto: Trace - Monitoraggio e debug delle prestazioni di Node.js
○Trace è uno strumento di monitoraggio dei microservizi visualizzato che consente di
ottenere tutti i parametri necessari quando si utilizzano i microservizi.
• 13 agosto: 4.0 è il nuovo 1.0
Q4
• 12 ottobre: Nodo v4.2.0, prima versione del supporto a lungo termine
• 8 dicembre: Apigee, RisingStack e Yahoo si uniscono alla Node.js Foundation
• 8 e 9 dicembre: Node Interactive
○ La prima conferenza annuale Node.js della Node.js Foundation
2016
Q1
• 10 febbraio: Express diventa un progetto incubato
• 23 marzo: incidente a sinistra
• 29 marzo: Google Cloud Platform si unisce alla Node.js Foundation
Q2
• 26 aprile: npm ha 210.000 utenti
Q3
• 18 luglio: CJ Silverio diventa CTO di npm
• 1 ° agosto: Trace, la soluzione di debug di Node.js diventa generalmente disponibile
• 15 settembre: il primo Node Interactive in Europa
Q4
• 11 ottobre: viene rilasciato il gestore del pacchetto di filati
• 18 ottobre: Node.js 6 diventa la versione LTS
Riferimento
1. "Cronologia di Node.js su una linea temporale" [Online]. Disponibile: [
https://blog.risingstack.com/history-of-node-js]
Leggi Storia di Nodejs online: https://riptutorial.com/it/node-js/topic/8653/storia-di-nodejs
https://riptutorial.com/it/home 362
Capitolo 105: Struttura del progetto
introduzione
La struttura del progetto nodejs è influenzata dalle preferenze personali, dall'architettura del
progetto e dalla strategia di iniezione del modulo in uso. Inoltre, l'arco basato su eventi 'che
utilizza il meccanismo di istanziazione dei moduli dinamici. Per avere una struttura MVC è
imperativo separare il lato server e il codice sorgente lato client, poiché il codice lato client verrà
probabilmente ridotto a icona e inviato al browser ed è pubblico nella sua natura di base. E il lato
server o il back-end forniranno API per eseguire operazioni CRUD
Osservazioni
Il progetto in alto utilizza i moduli browserify e vue.js come librerie view e minification
dell'applicazione base. Quindi la struttura del progetto può cambiare minuziosamente in base al
framework mvc che usi, ad esempio La directory di compilazione in pubblico dovrà contenere tutto
il codice mvc. Puoi avere un compito che fa questo per te.
Examples
Una semplice applicazione nodejs con MVC e API
• La prima distinzione principale è tra le directory generate dinamicamente che verranno
utilizzate per le directory di hosting e di origine.
• Le directory di origine avranno un file di configurazione o una cartella a seconda della
quantità di configurazione che potresti avere. Ciò include la configurazione dell'ambiente e la
configurazione della business logic che è possibile scegliere di inserire nella directory di
configurazione.
|-- Config
|-- config.json
|-- appConfig
|-- pets.config
|-- payment.config
• Ora le directory più vitali in cui distinguiamo tra lato server / back-end e moduli front-end. Il
server di 2 directory e webapp rappresentano rispettivamente il backend e il frontend che
possiamo scegliere di inserire all'interno di una directory di origine. src .
Puoi scegliere nomi diversi per scelta personale per server o webapp a seconda
di cosa ha senso per te. Assicurati di non volerlo fare troppo a lungo o troppo
complesso come nella struttura interna del progetto finale.
• All'interno della directory del server puoi avere il controller, l'app.js / index.js che sarà il tuo
file mainjs principale e il punto di partenza. La dir del server. può anche avere la directory
https://riptutorial.com/it/home 363
dto che contiene tutti gli oggetti di trasferimento dati che saranno usd dai controller API.
|-- server
|-- dto
|-- pet.js
|-- payment.js
|-- controller
|-- PetsController.js
|-- PaymentController.js
|-- App.js
• La directory webapp può essere divisa in due parti principali public e mvc , questo è di nuovo
influenzato dalla strategia di build che si desidera utilizzare. Stiamo usando browserfiy per
costruire la parte MVC di webapp e minimizzare il contenuto della directory mvc
semplicemente messo.
| - webapp | - public | - mvc
• Ora la directory pubblica può contenere tutte le risorse statiche, le immagini, i css (anche i
file saas) e, soprattutto, i file HTML.
|-- public
|-- build // will contianed minified scripts(mvc)
|-- images
|-- mouse.jpg
|-- cat.jpg
|-- styles
|-- style.css
|-- views
|-- petStore.html
|-- paymentGateway.html
|-- header.html
|-- footer.html
|-- index.html
• La directory mvc conterrà la logica front-end inclusi i modelli , i controller di visualizzazione e
qualsiasi altro modulo di utilità che potrebbe essere necessario come parte dell'interfaccia
utente. Anche index.js o shell.js, qualunque sia la tua suite, fa parte di questa directory.
|-- mvc
|-- controllers
|-- Dashborad.js
|-- Help.js
|-- Login.js
|-- utils
|-- index.js
Quindi, in conclusione, l'intera struttura del progetto apparirà come segue. E una semplice attività
di build come gulp browserify ridurrà gli script mvc e pubblicherà nella directory pubblica .
Possiamo quindi fornire questa directory pubblica come risorsa statica tramite express.use (satic
('public')) api.
|-- node_modules
https://riptutorial.com/it/home 364
|-- src
|-- server
|-- controller
|-- App.js // node app
|-- webapp
|-- public
|-- styles
|-- images
|-- index.html
|-- mvc
|-- controller
|-- shell.js // mvc shell
|-- config
|-- Readme.md
|-- .gitignore
|-- package.json
Leggi Struttura del progetto online: https://riptutorial.com/it/node-js/topic/9935/struttura-del-
progetto
https://riptutorial.com/it/home 365
Capitolo 106: Upload di file
Examples
Caricamento file singolo con multer
Ricordati di
• crea una cartella per il caricamento ( uploads in esempio).
• installare npm i -S multer
server.js :
var express = require("express");
var multer = require('multer');
var app = express();
var fs = require('fs');
app.get('/',function(req,res){
res.sendFile(__dirname + "/index.html");
});
var storage = multer.diskStorage({
destination: function (req, file, callback) {
fs.mkdir('./uploads', function(err) {
if(err) {
console.log(err.stack)
} else {
callback(null, './uploads');
}
})
},
filename: function (req, file, callback) {
callback(null, file.fieldname + '-' + Date.now());
}
});
app.post('/api/file',function(req,res){
var upload = multer({ storage : storage}).single('userFile');
upload(req,res,function(err) {
if(err) {
return res.end("Error uploading file.");
}
res.end("File is uploaded");
});
});
app.listen(3000,function(){
console.log("Working on port 3000");
});
index.html :
<form id = "uploadForm"
https://riptutorial.com/it/home 366
enctype = "multipart/form-data"
action = "/api/file"
method = "post"
>
<input type="file" name="userFile" />
<input type="submit" value="Upload File" name="submit">
</form>
Nota:
Per caricare file con estensione è possibile utilizzare la libreria integrata del percorso Node.js
Per questo basta richiedere il path file server.js :
var path = require('path');
e cambia:
callback(null, file.fieldname + '-' + Date.now());
aggiungendo un'estensione di file nel modo seguente:
callback(null, file.fieldname + '-' + Date.now() + path.extname(file.originalname));
Come filtrare il caricamento per estensione:
In questo esempio, vedi come caricare i file per consentire solo determinate estensioni.
Ad esempio solo le estensioni delle immagini. Basta aggiungere a var upload = multer({ storage :
storage}).single('userFile'); condizione file filtro
var upload = multer({
storage: storage,
fileFilter: function (req, file, callback) {
var ext = path.extname(file.originalname);
if(ext !== '.png' && ext !== '.jpg' && ext !== '.gif' && ext !== '.jpeg') {
return callback(new Error('Only images are allowed'))
}
callback(null, true)
}
}).single('userFile');
Ora puoi caricare solo file immagine con estensioni png , jpg , gif o jpeg
Usando il modulo formidabile
Installa il modulo e leggi i documenti
https://riptutorial.com/it/home 367
npm i formidable@latest
Esempio di server sulla porta 8080
var formidable = require('formidable'),
http = require('http'),
util = require('util');
http.createServer(function(req, res) {
if (req.url == '/upload' && req.method.toLowerCase() == 'post') {
// parse a file upload
var form = new formidable.IncomingForm();
form.parse(req, function(err, fields, files) {
if (err)
do-smth; // process error
// Copy file from temporary place
// var fs = require('fs');
// fs.rename(file.path, <targetPath>, function (err) { ... });
// Send result on client
res.writeHead(200, {'content-type': 'text/plain'});
res.write('received upload:\n\n');
res.end(util.inspect({fields: fields, files: files}));
});
return;
}
// show a file upload form
res.writeHead(200, {'content-type': 'text/html'});
res.end(
'<form action="/upload" enctype="multipart/form-data" method="post">'+
'<input type="text" name="title"><br>'+
'<input type="file" name="upload" multiple="multiple"><br>'+
'<input type="submit" value="Upload">'+
'</form>'
);
}).listen(8080);
Leggi Upload di file online: https://riptutorial.com/it/node-js/topic/4080/upload-di-file
https://riptutorial.com/it/home 368
Capitolo 107: Usa casi di Node.js
Examples
Server HTTP
const http = require('http');
console.log('Starting server...');
var config = {
port: 80,
contentType: 'application/json; charset=utf-8'
};
// JSON-API server on port 80
var server = http.createServer();
server.listen(config.port);
server.on('error', (err) => {
if (err.code == 'EADDRINUSE') console.error('Port '+ config.port +' is already in use');
else console.error(err.message);
});
server.on('request', (request, res) => {
var remoteAddress = request.headers['x-forwarded-for'] ||
request.connection.remoteAddress; // Client address
console.log(remoteAddress +' '+ request.method +' '+ request.url);
var out = {};
// Here you can change output according to `request.url`
out.test = request.url;
res.writeHead(200, {
'Content-Type': config.contentType
});
res.end(JSON.stringify(out));
});
server.on('listening', () => {
c.info('Server is available: http://localhost:'+ config.port);
});
Console con prompt dei comandi
const process = require('process');
const rl = require('readline').createInterface(process.stdin, process.stdout);
rl.pause();
console.log('Something long is happening here...');
var cliConfig = {
promptPrefix: ' > '
}
/*
Commands recognition
BEGIN
*/
var commands = {
https://riptutorial.com/it/home 369
eval: function(arg) { // Try typing in console: eval 2 * 10 ^ 3 + 2 ^ 4
arg = arg.join(' ');
try { console.log(eval(arg)); }
catch (e) { console.log(e); }
},
exit: function(arg) {
process.exit();
}
};
rl.on('line', (str) => {
rl.pause();
var arg = str.trim().match(/([^"]+)|("(?:[^"\\]|\\.)+")/g); // Applying regular expression
for removing all spaces except for what between double quotes:
http://stackoverflow.com/a/14540319/2396907
if (arg) {
for (let n in arg) {
arg[n] = arg[n].replace(/^\"|\"$/g, '');
}
var commandName = arg[0];
var command = commands[commandName];
if (command) {
arg.shift();
command(arg);
}
else console.log('Command "'+ commandName +'" doesn\'t exist');
}
rl.prompt();
});
/*
END OF
Commands recognition
*/
rl.setPrompt(cliConfig.promptPrefix);
rl.prompt();
Leggi Usa casi di Node.js online: https://riptutorial.com/it/node-js/topic/7703/usa-casi-di-node-js
https://riptutorial.com/it/home 370
Capitolo 108: Usando i flussi
Parametri
Parametro Definizione
Stream leggibile tipo di flusso da cui è possibile leggere i dati
Flusso scrivibile tipo di flusso in cui i dati possono essere scritti
Duplex Stream tipo di stream che è sia leggibile che scrivibile
Trasforma tipo di flusso duplex in grado di trasformare i dati mentre vengono letti e
stream quindi scritti
Examples
Leggi i dati da TextFile con flussi
L'I / O nel nodo è asincrono, quindi l'interazione con il disco e la rete implica il passaggio di
callback alle funzioni. Potresti essere tentato di scrivere il codice che serve un file dal disco in
questo modo:
var http = require('http');
var fs = require('fs');
var server = http.createServer(function (req, res) {
fs.readFile(__dirname + '/data.txt', function (err, data) {
res.end(data);
});
});
server.listen(8000);
Questo codice funziona ma è ingombrante e memorizza l'intero file data.txt in memoria per ogni
richiesta prima di scrivere il risultato ai client. Se data.txt è molto grande, il tuo programma
potrebbe iniziare a consumare molta memoria poiché serve molti utenti contemporaneamente, in
particolare per gli utenti con connessioni lente.
Anche l'esperienza utente è scadente perché gli utenti dovranno attendere che l'intero file venga
memorizzato in memoria sul server prima che possano iniziare a ricevere qualsiasi contenuto.
Fortunatamente entrambi gli argomenti (req, res) sono stream, il che significa che possiamo
scrivere questo in un modo molto migliore usando fs.createReadStream () invece di fs.readFile ():
var http = require('http');
var fs = require('fs');
https://riptutorial.com/it/home 371
var server = http.createServer(function (req, res) {
var stream = fs.createReadStream(__dirname + '/data.txt');
stream.pipe(res);
});
server.listen(8000);
Qui .pipe () si occupa di ascoltare gli eventi "data" e "end" da fs.createReadStream (). Questo
codice non è solo più pulito, ma ora il file data.txt verrà scritto ai client un chunk alla volta
immediatamente quando vengono ricevuti dal disco.
Flussi di tubazioni
Gli stream leggibili possono essere "convogliati" o collegati a flussi scrivibili. Ciò rende il flusso di
dati dal flusso di origine al flusso di destinazione senza molti sforzi.
var fs = require('fs')
var readable = fs.createReadStream('file1.txt')
var writable = fs.createWriteStream('file2.txt')
readable.pipe(writable) // returns writable
Quando i flussi scrivibili sono anche flussi leggibili, vale a dire quando sono flussi duplex , è
possibile continuare a collegarli ad altri flussi scrivibili.
var zlib = require('zlib')
fs.createReadStream('style.css')
.pipe(zlib.createGzip()) // The returned object, zlib.Gzip, is a duplex stream.
.pipe(fs.createWriteStream('style.css.gz')
Anche i flussi leggibili possono essere inviati in più flussi.
var readable = fs.createReadStream('source.css')
readable.pipe(zlib.createGzip()).pipe(fs.createWriteStream('output.css.gz'))
readable.pipe(fs.createWriteStream('output.css')
Si noti che è necessario reindirizzare i flussi di output in modo sincrono (allo stesso tempo) prima
che i dati "scorrano". In caso contrario, i dati incompleti potrebbero essere trasmessi in streaming.
Si noti inoltre che gli oggetti stream possono emettere eventi di error ; assicurati di gestire
responsabilmente questi eventi su ogni stream, se necessario:
var readable = fs.createReadStream('file3.txt')
var writable = fs.createWriteStream('file4.txt')
readable.pipe(writable)
readable.on('error', console.error)
writable.on('error', console.error)
Crea il tuo stream leggibile / scrivibile
https://riptutorial.com/it/home 372
Vedremo oggetti stream restituiti da moduli come fs etc, ma se vogliamo creare il nostro oggetto
streamable.
Per creare un oggetto Stream è necessario utilizzare il modulo stream fornito da NodeJs
var fs = require("fs");
var stream = require("stream").Writable;
/*
* Implementing the write function in writable stream class.
* This is the function which will be used when other stream is piped into this
* writable stream.
*/
stream.prototype._write = function(chunk, data){
console.log(data);
}
var customStream = new stream();
fs.createReadStream("am1.js").pipe(customStream);
Questo ci darà il nostro flusso scrivibile personalizzato. possiamo implementare qualsiasi cosa
all'interno della funzione _write . Il metodo sopra funziona nella versione 4.xx di NodeJs ma in
NodeJs 6.x ES6 ha introdotto le classi, pertanto la sintassi è stata modificata. Di seguito è
riportato il codice per la versione 6.x di NodeJs
const Writable = require('stream').Writable;
class MyWritable extends Writable {
constructor(options) {
super(options);
}
_write(chunk, encoding, callback) {
console.log(chunk);
}
}
Perché i flussi?
Esaminiamo i seguenti due esempi per leggere il contenuto di un file:
Il primo, che utilizza un metodo asincrono per leggere un file e fornisce una funzione di callback
che viene chiamata una volta che il file è stato completamente letto nella memoria:
fs.readFile(`${__dirname}/utils.js`, (err, data) => {
if (err) {
handleError(err);
} else {
console.log(data.toString());
}
})
E il secondo, che utilizza i streams per leggere il contenuto del file, pezzo per pezzo:
https://riptutorial.com/it/home 373
var fileStream = fs.createReadStream(`${__dirname}/file`);
var fileContent = '';
fileStream.on('data', data => {
fileContent += data.toString();
})
fileStream.on('end', () => {
console.log(fileContent);
})
fileStream.on('error', err => {
handleError(err)
})
Vale la pena ricordare che entrambi gli esempi fanno esattamente la stessa cosa . Qual è la
differenza allora?
• Il primo è più corto e sembra più elegante
• Il secondo consente di eseguire qualche elaborazione sul file mentre viene letto (!)
Quando i file con cui si gestiscono sono piccoli, non c'è alcun effetto reale quando si usano gli
streams , ma cosa succede quando il file è grande? (così grande che ci vogliono 10 secondi per
leggerlo in memoria)
Senza streams ti aspetteresti, senza fare assolutamente nulla (a meno che il tuo processo non
faccia altro), fino a quando non passeranno i 10 secondi e il file sarà completamente letto , e
solo allora potrai iniziare l'elaborazione del file.
Con i streams , si ottiene il contenuto del file pezzo per pezzo, proprio quando sono disponibili ,
e ciò consente di elaborare il file mentre viene letto.
L'esempio precedente non illustra come gli streams possono essere utilizzati per lavori che non
possono essere eseguiti quando si fa il callback, quindi guardiamo un altro esempio:
Vorrei scaricare un file gzip , decomprimerlo e salvarne il contenuto sul disco. Dato l' url del file,
questo è ciò che è necessario fare:
• Scarica il file
• Decomprimere il file
• Salvalo su disco
Ecco un [file piccolo] [1], che è memorizzato nella mia memoria S3 . Il seguente codice fa quanto
sopra nel modo callback.
var startTime = Date.now()
s3.getObject({Bucket: 'some-bucket', Key: 'tweets.gz'}, (err, data) => {
// here, the whole file was downloaded
zlib.gunzip(data.Body, (err, data) => {
// here, the whole file was unzipped
fs.writeFile(`${__dirname}/tweets.json`, data, err => {
https://riptutorial.com/it/home 374
if (err) console.error(err)
// here, the whole file was written to disk
var endTime = Date.now()
console.log(`${endTime - startTime} milliseconds`) // 1339 milliseconds
})
})
})
// 1339 milliseconds
Ecco come appare usando i streams :
s3.getObject({Bucket: 'some-bucket', Key: 'tweets.gz'}).createReadStream()
.pipe(zlib.createGunzip())
.pipe(fs.createWriteStream(`${__dirname}/tweets.json`));
// 1204 milliseconds
Sì, non è più veloce quando si ha a che fare con file di piccole dimensioni: il file testato pesa 80KB .
Provando questo su un file più grande, 71MB gzipped ( 382MB decompresso), mostra che la versione
degli streams è molto più veloce
• Sono stati necessari 20925 millisecondi per scaricare 71MB , decomprimerlo e quindi scrivere
382MB su disco, utilizzando la modalità callback .
• In confronto, ci sono voluti 13434 millisecondi per fare lo stesso quando si utilizza la
versione di streams (35% più veloce, per un file non così grande)
Leggi Usando i flussi online: https://riptutorial.com/it/node-js/topic/2974/usando-i-flussi
https://riptutorial.com/it/home 375
Capitolo 109: Usare Browserfiy per risolvere
l'errore 'richiesto' con i browser
Examples
Esempio: file.js
In questo esempio abbiamo un file chiamato file.js.
Supponiamo di dover analizzare un URL utilizzando il modulo querystring di JavaScript e NodeJS.
Per fare questo, tutto ciò che devi fare è inserire la seguente dichiarazione nel tuo file:
const querystring = require('querystring');
var ref = querystring.parse("foo=bar&abc=xyz&abc=123");
Cosa sta facendo questo frammento?
Bene, per prima cosa, creiamo un modulo querystring che fornisce utility per l'analisi e la
formattazione delle stringhe di query URL. Si può accedere usando:
const querystring = require('querystring');
Quindi, analizziamo un URL usando il metodo .parse (). Analizza una stringa di query URL (str) in
un insieme di coppie chiave e valore.
Ad esempio, la stringa di query 'foo=bar&abc=xyz&abc=123' viene analizzata in:
{ foo: 'bar', abc: ['xyz', '123'] }
Sfortunatamente, i browser non hanno il metodo richiesto definito, ma lo fa Node.js.
Installa Browserfy
Con Browserify puoi scrivere il codice che usa richiede nello stesso modo in cui lo useresti nel
nodo. Quindi, come risolvi questo? È semplice.
1. Primo nodo di installazione, fornito con npm. Quindi fa:
npm install -g browserify
2. Cambia nella directory in cui si trova il file.js e Installa il nostro modulo querystring con npm:
https://riptutorial.com/it/home 376
npm install querystring
Nota: se non si modifica la directory specifica, il comando avrà esito negativo poiché non riesce a
trovare il file che contiene il modulo.
3. Ora raggruppa in modo ricorsivo tutti i moduli necessari a partire da file.js in un unico file
chiamato bundle.js (o quello che ti piace chiamarlo ) con il comando browserify :
browserify file.js -o bundle.js
Browserify analizza l'Abstract Syntax Tree per le chiamate require () per attraversare l'intero
grafico delle dipendenze del tuo
4. Infine scendi un singolo tag nel tuo html e il gioco è fatto!
<script src="bundle.js"></script>
Quello che succede è che ottieni una combinazione del tuo vecchio file .js ( file.js ) e del tuo file
bundle.js appena creato. Questi due file sono uniti in un singolo file.
Importante
Si prega di tenere presente che se si desidera apportare modifiche al file.js e non
influenzerà il comportamento del programma. Le tue modifiche diventeranno
effettive solo se modifichi il bundle.js appena creato
Cosa significa?
Ciò significa che se si desidera modificare file.js per qualsiasi motivo, le modifiche non avranno
alcun effetto. Devi davvero modificare bundle.js poiché è un'unione di bundle.js e file.js.
Leggi Usare Browserfiy per risolvere l'errore 'richiesto' con i browser online:
https://riptutorial.com/it/node-js/topic/7123/usare-browserfiy-per-risolvere-l-errore--richiesto--con-i-
browser
https://riptutorial.com/it/home 377
Capitolo 110: Utilizzando WebSocket con
Node.JS
Examples
Installazione di WebSocket
Ci sono alcuni modi per installare WebSocket nel tuo progetto. Ecco alcuni esempi:
npm install --save ws
o all'interno del pacchetto package.json utilizzando:
"dependencies": {
"ws": "*"
},
Aggiunta di WebSocket al tuo file
Per aggiungere ws al tuo file usa semplicemente:
var ws = require('ws');
Utilizzo dei server WebSocket e WebSocket
Per aprire un nuovo WebSocket, è sufficiente aggiungere qualcosa come:
var WebSocket = require("ws");
var ws = new WebSocket("ws://host:8080/OptionalPathName);
// Continue on with your code...
O per aprire un server, usa:
var WebSocketServer = require("ws").Server;
var ws = new WebSocketServer({port: 8080, path: "OptionalPathName"});
Un esempio di server WebSocket semplice
var WebSocketServer = require('ws').Server
, wss = new WebSocketServer({ port: 8080 }); // If you want to add a path as well, use path:
"PathName"
wss.on('connection', function connection(ws) {
ws.on('message', function incoming(message) {
console.log('received: %s', message);
});
https://riptutorial.com/it/home 378
ws.send('something');
});
Leggi Utilizzando WebSocket con Node.JS online: https://riptutorial.com/it/node-
js/topic/6106/utilizzando-websocket-con-node-js
https://riptutorial.com/it/home 379
Capitolo 111: Utilizzo di IISNode per ospitare
le app Web Node.js in IIS
Osservazioni
Directory virtuale / Applicazione nidificata
con le trappole delle viste
Se si utilizzerà Express per eseguire il rendering delle viste utilizzando un motore di
visualizzazione, sarà necessario passare il valore virtualDirPath alle visualizzazioni
`res.render('index', { virtualDirPath: virtualDirPath });`
La ragione per fare ciò è di rendere i tuoi collegamenti ipertestuali ad altre viste host dall'app e dai
percorsi delle risorse statiche per sapere dove è ospitato il sito senza dover modificare tutte le
viste dopo la distribuzione. Questa è una delle più fastidiose e noiose trappole dell'uso di Directory
Virtuali con IISNode.
versioni
Tutti gli esempi sopra funzionano con
• Express v4.x
• IIS 7.x / 8.x
• Socket.io v1.3.x o successivo
Examples
Iniziare
IISNode consente alle app Web di Node.js di essere ospitate su IIS 7/8 proprio come farebbe
un'applicazione .NET. Ovviamente, è possibile ospitare autonomamente il processo node.exe su
Windows, ma perché farlo basta quando si esegue l'app in IIS.
IISNode gestirà il ridimensionamento su più core, la gestione dei processi di node.exe e il riciclo
automatico dell'applicazione IIS ogni volta che la tua app viene aggiornata, solo per citarne alcuni
dei suoi vantaggi .
Requisiti
https://riptutorial.com/it/home 380
IISNode ha alcuni requisiti prima di poter ospitare l'app Node.js in IIS.
1. Node.js deve essere installato sull'host IIS, a 32 o 64 bit, o sono supportati.
2. IISNode installato x86 o x64 , questo dovrebbe corrispondere al testimone del tuo host IIS.
3. Il modulo URL-Rewrite di Microsoft per IIS installato sul tuo host IIS.
• Questa è la chiave, altrimenti le richieste alla tua app Node.js non funzioneranno come
previsto.
4. Un Web.config nella cartella principale della tua app Node.js.
5. Configurazione IISNode tramite un file iisnode.yml o un elemento <iisnode> all'interno di
Web.config .
Esempio di base Hello World utilizzando Express
Per ottenere questo esempio, è necessario creare un'applicazione IIS 7/8 sul proprio host IIS e
aggiungere la directory contenente l'app Web Node.js come directory fisica. Assicurarsi che
l'identità del pool di applicazioni / applicazioni possa accedere all'installazione di Node.js. Questo
esempio utilizza l'installazione a 64 bit di Node.js.
Struttura del progetto
Questa è la struttura di progetto di base di un'app Web IISNode / Node.js. Sembra quasi identico
a qualsiasi Web App non IISNode tranne per l'aggiunta di Web.config .
- /app_root
- package.json
- server.js
- Web.config
server.js - Applicazione Express
const express = require('express');
const server = express();
// We need to get the port that IISNode passes into us
// using the PORT environment variable, if it isn't set use a default value
const port = process.env.PORT || 3000;
// Setup a route at the index of our app
server.get('/', (req, res) => {
return res.status(200).send('Hello World');
});
server.listen(port, () => {
console.log(`Listening on ${port}`);
});
Configurazione e Web.config
https://riptutorial.com/it/home 381
Web.config è simile a qualsiasi altro IIS Web.config tranne che le seguenti due cose devono essere
presenti, URL <rewrite><rules> e un <handler> IISNode <handler> . Entrambi questi elementi sono
figli dell'elemento <system.webServer> .
Configurazione
È possibile configurare IISNode utilizzando un file iisnode.yml o aggiungendo l'elemento <iisnode>
come figlio di <system.webServer> nel proprio Web.config . Entrambe queste configurazioni possono
essere utilizzate in combinazione tra loro, tuttavia, in questo caso, Web.config dovrà specificare il
file iisnode.yml E qualsiasi conflitto di configurazione verrà preso dal file iisnode.yml . Questa
sovrascrittura della configurazione non può avvenire al contrario.
IISNode Handler
Per fare in modo che IIS sappia che server.js contiene la nostra app Web Node.js, dobbiamo dirlo
esplicitamente. Possiamo farlo aggiungendo IISNode <handler> <handlers> all'elemento <handlers> .
<handlers>
<add name="iisnode" path="server.js" verb="*" modules="iisnode"/>
</handlers>
Regole di riscrittura degli URL
La parte finale della configurazione sta assicurando che il traffico destinato alla nostra app Node.js
in arrivo nella nostra istanza IIS venga indirizzato a IISNode. Senza le regole di riscrittura degli
URL, dovremmo visitare la nostra app andando su http://<host>/server.js e, peggio ancora,
quando provi a richiedere una risorsa fornita da server.js otterrai un 404 . Questo è il motivo per
cui la riscrittura degli URL è necessaria per le app Web IISNode.
<rewrite>
<rules>
<!-- First we consider whether the incoming URL matches a physical file in the /public
folder -->
<rule name="StaticContent" patternSyntax="Wildcard">
<action type="Rewrite" url="public/{R:0}" logRewrittenUrl="true"/>
<conditions>
<add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true"/>
</conditions>
<match url="*.*"/>
</rule>
<!-- All other URLs are mapped to the Node.js application entry point -->
<rule name="DynamicContent">
<conditions>
<add input="{REQUEST_FILENAME}" matchType="IsFile" negate="True"/>
</conditions>
<action type="Rewrite" url="server.js"/>
</rule>
</rules>
</rewrite>
https://riptutorial.com/it/home 382
Questo è un file Web.config funzionante per questo esempio , installazione per un'installazione
Node.js a 64 bit.
È tutto, ora visita il tuo sito IIS e vedi come funziona l'applicazione Node.js.
Utilizzando una directory virtuale IIS o un'applicazione nidificata tramite
L'utilizzo di una directory virtuale o di un'applicazione nidificata in IIS è uno scenario comune e
molto probabilmente di cui si vorrà approfittare quando si utilizza IISNode.
IISNode non fornisce supporto diretto per directory virtuali o applicazioni nidificate tramite la
configurazione, per cui è necessario avvalersi di una funzionalità di IISNode che non fa parte della
configurazione ed è molto meno conosciuta. Tutti i figli dell'elemento <appSettings> con Web.config
vengono aggiunti all'oggetto process.env come proprietà utilizzando la chiave appSetting.
Consente di creare una directory virtuale nei nostri <appSettings>
<appSettings>
<add key="virtualDirPath" value="/foo" />
</appSettings>
All'interno della nostra app Node.js possiamo accedere alle impostazioni virtualDirPath
console.log(process.env.virtualDirPath); // prints /foo
Ora che possiamo usare l'elemento <appSettings> per la configurazione, sfruttiamo questo e lo
usiamo nel nostro codice server.
// Access the virtualDirPath appSettings and give it a default value of '/'
// in the event that it doesn't exist or isn't set
var virtualDirPath = process.env.virtualDirPath || '/';
// We also want to make sure that our virtualDirPath
// always starts with a forward slash
if (!virtualDirPath.startsWith('/', 0))
virtualDirPath = '/' + virtualDirPath;
// Setup a route at the index of our app
server.get(virtualDirPath, (req, res) => {
return res.status(200).send('Hello World');
});
Possiamo usare virtualDirPath anche con le nostre risorse statiche
// Public Directory
server.use(express.static(path.join(virtualDirPath, 'public')));
// Bower
server.use('/bower_components', express.static(path.join(virtualDirPath,
'bower_components')));
Mettiamo tutto insieme
https://riptutorial.com/it/home 383
const express = require('express');
const server = express();
const port = process.env.PORT || 3000;
// Access the virtualDirPath appSettings and give it a default value of '/'
// in the event that it doesn't exist or isn't set
var virtualDirPath = process.env.virtualDirPath || '/';
// We also want to make sure that our virtualDirPath
// always starts with a forward slash
if (!virtualDirPath.startsWith('/', 0))
virtualDirPath = '/' + virtualDirPath;
// Public Directory
server.use(express.static(path.join(virtualDirPath, 'public')));
// Bower
server.use('/bower_components', express.static(path.join(virtualDirPath,
'bower_components')));
// Setup a route at the index of our app
server.get(virtualDirPath, (req, res) => {
return res.status(200).send('Hello World');
});
server.listen(port, () => {
console.log(`Listening on ${port}`);
});
Utilizzo di Socket.io con IISNode
Per ottenere Socket.io che funziona con IISNode, le uniche modifiche necessarie quando non si
utilizza una directory virtuale / applicazione nidificata sono all'interno di Web.config .
Poiché Socket.io invia richieste che iniziano con /socket.io , IISNode deve comunicare a IIS che
questi devono essere gestiti anche da IISNode e non sono solo richieste di file statici o altro
traffico. Ciò richiede un <handler> diverso dalle app IISNode standard.
<handlers>
<add name="iisnode-socketio" path="server.js" verb="*" modules="iisnode" />
</handlers>
Oltre alle modifiche apportate ai <handlers> è inoltre necessario aggiungere una regola di riscrittura
URL aggiuntiva. La regola di riscrittura invia tutto il traffico /socket.io al nostro file server su cui è
in esecuzione il server Socket.io.
<rule name="SocketIO" patternSyntax="ECMAScript">
<match url="socket.io.+"/>
<action type="Rewrite" url="server.js"/>
</rule>
Se si utilizza IIS 8, sarà necessario disabilitare l'impostazione webSockets in Web.config in
aggiunta all'aggiunta delle regole di gestione e riscrittura di cui sopra. Questo non è necessario in
IIS 7 poiché non esiste il supporto webSocket.
https://riptutorial.com/it/home 384
<webSocket enabled="false" />
Leggi Utilizzo di IISNode per ospitare le app Web Node.js in IIS online:
https://riptutorial.com/it/node-js/topic/6003/utilizzo-di-iisnode-per-ospitare-le-app-web-node-js-in-iis
https://riptutorial.com/it/home 385
Titoli di coda
S.
Capitoli Contributors
No
4444, Abdelaziz Mokhnache, Abhishek Jain, Adam,
Aeolingamenfel, Alessandro Trinca Tornidor, Aljoscha Meyer,
Amila Sampath, Ankit Gomkale, Ankur Anand, arcs, Aule, B
Thuy, baranskistad, Bundit J., Chandra Sekhar, Chezzwizz,
Christopher Ronning, Community, Craig Ayre, David Gatti,
Djizeus, Florian Hämmerle, Franck Dernoncourt,
ganesshkumar, George Aidonidis, Harangue, hexacyanide, Iain
Reid, Inanc Gumus, Jason, Jasper, Jeremy Banks, John
1 Iniziare con Node.js
Slegers, JohnnyCoder, Joshua Kleveter, KolesnichenkoDS,
krishgopinath, Léo Martin, Majid, Marek Skiba, Matt Bush,
Meinkraft, Michael Irigoyen, Mikhail, Milan Laslop, ndugger,
Nick, olegzhermal, Peter Mortensen, RamenChef, Reborn,
Rishikesh Chandra, Shabin Hashim, Shiven, Sibeesh Venu,
sigfried, SteveLacy, Susanne Oberhauser, thefourtheye,
theunexpected1, Tomás Cañibano, user2314737, Volodymyr
Sichka, xam, zurfyx
Chris, Freddie Coleman, KlwntSingh, Louis Barranqueiro,
2 Ambiente
Mikhail, sBanda
Analizzare gli
3 argomenti della riga yrtimiD
di comando
API CRUD basata su
4 Iceman
REST semplice
Aikon Mogwai, Alex Logan, alexi2, Andres C. Viesca, Aph, Asaf
Manassen, Batsu, bekce, brianmearns, Community, Craig Ayre,
Daniel Verem, devnull69, Everettss, Florian Hämmerle, H.
Pauwelyn, Inanc Gumus, jemiloii, Kid Binary, kunerd, Marek
App Web con
5 Skiba, Mikhail, Mohit Gangrade, Mukesh Sharma, Naeem
Express
Shaikh, Niklas, Nivesh, noob, Ojen, Pasha Rumkin, Paul, Rafal
Wiliński, Shabin Hashim, SteveLacy, tandrewnichols, Taylor
Ackley, themole, tverdohleb, Vsevolod Goloviznin, xims, Yerko
Palma
6 Arresto grazioso RamenChef, Sathish
Cami Rodriguez, Cody G., cyanbeam, Dave, David Xu, Dom
7 Async / Await
Vinyard, m_callens, Manuel, nomanbinhussein, Toni Villena
https://riptutorial.com/it/home 386
David Knipe, devnull69, DrakaSAN, F. Kauder, jerry, lsampaio,
8 async.js
Shriganesh Kolhe, Sky, walid
Autenticazione di
9 Windows sotto CJ Harries
node.js
Autoreload su ch4nd4n, Dean Rather, Jonas S, Joshua Kleveter, Nivesh,
10
modifiche Sanketh Katta, zurfyx
Alex Logan, manuerumx, Mikhail, Naeem Shaikh, Qiong Wu,
11 Biblioteca Mongoose
Simplans, Will
12 Buon stile di codifica Ajitej Kaushik, RamenChef
13 CLI Ze Rubeus
Codice Node.js per
STDIN e STDOUT
14 Syam Pradeep
senza utilizzare
alcuna libreria
Come vengono
15 RamenChef, umesh
caricati i moduli
Comunicazione
16 sBanda
Arduino con nodeJs
Comunicazione
17 Zoltán Schmidt
client-server
Comunicazione
18 Forivin, N.J.Dawson
Socket.io
19 Connetti a Mongodb FabianCook, Nainesh Raval, Shriganesh Kolhe
Consegna HTML o
20 qualsiasi altro tipo di Himani Agrawal, RamenChef, user2314737
file
Creazione di API con
21 Mukesh Sharma
Node.js
Creazione di una
libreria Node.js che
22 supporti entrambe le Dave
promesse e le
callback first-error
23 Database (MongoDB zurfyx
https://riptutorial.com/it/home 387
con Mongoose)
Debug
4444, Alister Norris, Ankur Anand, H. Pauwelyn, Matthew
24 dell'applicazione
Shanley
Node.js
Debug remoto in
25 Rick, VooVoo
Node.JS
Design API restful:
26 fresh5447, nilakantha singh deo
best practice
Disinstallazione di
27 John Vincent Jardin, RamenChef, snuggles08, Trevor Clarke
Node.js
Distribuzione
dell'applicazione
28 gentlejo
Node.js senza tempi
di inattività.
Apidcloud, Brett Jackson, Community, Cristian Boariu,
Distribuzione di
duncanhall, Florian Hämmerle, guleria, haykam, KlwntSingh,
29 applicazioni Node.js
Mad Scientist, MatthieuLemoine, Mukesh Sharma, raghu,
in produzione
sjmarshy, tverdohleb, tyehia
ECMAScript 2015
30 David Xu, Florian Hämmerle, Osama Bari
(ES6) con Node.js
DrakaSAN, Duly Kinsky, Florian Hämmerle, jamescostian,
31 Emettitori di eventi
MindlessRanger, Mothman
Esecuzione di file o
32 comandi con Child guleria, hexacyanide, iSkore
Processes
Esecuzione di
33 node.js come Buzut
servizio
Aminadav, Craig Ayre, cyanbeam, devnull69, DrakaSAN,
Esportazione e Fenton, Florian Hämmerle, hexacyanide, Jason, jdrydn,
34
consumo di moduli Loufylouf, Louis Barranqueiro, m02ph3u5, Marek Skiba,
MrWhiteNerdy, MSB, Pedro Otero, Shabin Hashim, tkone, uzaif
Esportazione e
AndrewLeonardi, Bharat, commonSenseCode, James
35 importazione del
Billingham, Oliver, sharif.io, Shog9
modulo in node.js
36 Eventloop Kelum Senanayake
https://riptutorial.com/it/home 388
Evita l'inferno del
37 tyehia
callback
4444, Accepted Answer, Aeolingamenfel, Christophe Marois,
Craig Ayre, DrakaSAN, Duly Kinsky, Florian Hämmerle,
gnerkus, Harshal Bhamare, hexacyanide, jakerella, Julien
38 File system I / O
CROUZET, Louis Barranqueiro, midnightsyntax, Mikhail, peteb,
Shiven, still_learning, Tim Jones, Tropic, Vsevolod Goloviznin,
Zanon
Gestione degli errori
39 Karlen
di Node.js
Gestire la richiesta
40 Manas Jayanth
POST in Node.js
Gestore pacchetti
41 Andrew Brooke, skiilaa
filati
42 grugnito Naeem Shaikh, Waterscroll
Guida per
43 Niroshan Ranapathi
principianti NodeJS
44 Hack signal
45 http Ahmed Metwally
Iniezione di
46 Niroshan Ranapathi
dipendenza
Iniziare con la
47 damitj07
profilatura dei nodi
Alister Norris, Aminadav, Anh Cao, asherbar, Batsu, Buzut,
Chance Snow, Chezzwizz, Dmitriy Borisov, Florian Hämmerle,
GilZ, guleria, hexacyanide, HungryCoder, Inanc Gumus, Jacek
48 Installare Node.js Labuda, John Vincent Jardin, Josh, KahWee Teng, Maciej
Rostański, mmhyamin, Naing Lin Aung, NuSkooler, Shabin
Hashim, Siddharth Srivastva, Sveratum, tandrewnichols,
user2314737, user6939352, V1P3R, victorkohl
Instradare richieste
49 RamenChef, SynapseTech
ajax con Express.JS
Integrazione con
50 cyanbeam, FabianCook, midnightsyntax
Mongodb
Integrazione con Aminadav, Andrés Encarnación, Florian Hämmerle, Ivan
51
MySQL Schwarz, jdrydn, JohnnyCoder, Kapil Vats, KlwntSingh, Marek
https://riptutorial.com/it/home 389
Skiba, Rafael Gadotti Bachovas, RamenChef, Simplans,
Sorangwala Abbasali, surjikal
Integrazione del Ankit Rana, Community, Léo Martin, M. A. Cordeiro, Rupali
52
passaporto Pemare, shikhar bansal
Integrazione di
53 Vsevolod Goloviznin
Cassandra
Integrazione di
54 Niroshan Ranapathi
PostgreSQL
Integrazione
55 MongoDB per William Carron
Node.js / Express.js
Interagire con la
56 ScientiaEtVeritas
console
57 Invia notifica Web Houssem Yahiaoui
Invio di un flusso di
58 Beshoy Hanna
file al client
59 Koa Framework v2 David Xu
La gestione delle
60 KlwntSingh, Nivesh, riyadhalnur, sBanda, sjmarshy, topheman
eccezioni
61 Le notifiche push Mario Rozic
62 Linea di lettura 4444, Craig Ayre, Florian Hämmerle, peteb
Localizzazione del
63 Osama Bari
nodo JS
64 Lodash M1kstur
Loopback -
65 Connettore basato Roopesh
REST
Mantenere
Alex Logan, Bearington, cyanbeam, Himani Agrawal, Mikhail,
costantemente attiva
66 mscdex, optimus, pietrovismara, RamenChef, Sameer
un'applicazione di
Srivastava, somebody, Taylor Swanson
nodo
67 metalsmith RamenChef, vsjn3290ckjnaoij2jikndckjb
68 Modulo Cluster Benjamin, Florian Hämmerle, Kid Binary, MayorMonty, Mukesh
https://riptutorial.com/it/home 390
Sharma, riyadhalnur, Vsevolod Goloviznin
69 MSSQL Intergration damitj07
70 multithreading arcs
71 N-API Parham Alvani
Node server senza
72 Hasan A Yousef, Taylor Ackley
framework
Node.js (express.js)
73 con il codice di sigfried
esempio angular.js
Node.js Architecture
74 Ivan Hristov
& Inner Workings
75 Node.js con CORS Buzut
76 Node.JS con ES6 Inanc Gumus, xam, ymz, zurfyx
77 Node.js con Oracle oliolioli
Node.js Design
78 Ankur Anand, pietrovismara
Fundamental
Node.JS e
79 midnightsyntax, RamenChef, Satyam S
MongoDB.
Node.js v6 Nuove
80 funzionalità e creyD, DominicValenciana, KlwntSingh
miglioramenti
81 NodeJS con Redis evalsocket
82 NodeJS Frameworks dthree
Abhishek Jain, AJS, Amreesh Tyagi, Ankur Anand, Asaf
Manassen, Ates Goral, ccnokes, CD.., Cristian Cavalli, David
G., DrakaSAN, Eric Fortin, Everettss, Explosion Pills, Florian
Hämmerle, George Bailey, hexacyanide, HungryCoder, Ionică
Bizău, James Taylor, João Andrade, John Slegers, Jojodmo,
Josh, Kid Binary, Loufylouf, m02ph3u5, Matt, Matthew Harwood
83 npm
, Mehdi El Fadil, Mikhail, Mindsers, Nick, notgiorgi, num8er,
oscarm, Pete TNT, Philipp Flenker, Pieter Herroelen, Pyloid,
QoP, Quill, Rafal Wiliński, RamenChef, Ratan Kumar,
RationalDev, rdegges, refaelos, Rizowski, Shiven, Skanda,
Sorangwala Abbasali, still_learning, subbu, the12, tlo, Un3qual,
uzaif, VladNeacsu, Vsevolod Goloviznin, Wasabi Fan, Yerko
https://riptutorial.com/it/home 391
Palma
nvm - Node Version cyanbeam, guleria, John Vincent Jardin, Luis González,
84
Manager pranspach, Shog9, Tushar Gupta
85 OAuth 2.0 tyehia
Ankur Anand, Asaf Manassen, Chance Snow, efeder, Eric
Smekens, Florian Hämmerle, Jaylem Chaudhari, Kornel, lauriys
86 package.json , mezzode, OzW, RamenChef, Robbie, Shabin Hashim,
Simplans, SteveLacy, Sven 31415, Tomás Cañibano,
user6939352, V1P3R, victorkohl
parser csv nel nodo
87 aisflat439
js
88 passport.js Red
Pool di connessione
89 KlwntSingh
Mysql
90 Prestazioni Node.js Florian Hämmerle, Inanc Gumus
Ala Eddine JEBALI, cyanbeam, Florian Hämmerle, H.
Programmazione
91 Pauwelyn, John, Marek Skiba, Native Coder, omgimanerd,
asincrona
slowdeath007
Programmazione
92 sincrona contro Craig Ayre, Veger
asincrona in nodejs
93 Promesse Bluebird David Xu
akinjide, devnull69, Florian Hämmerle, John Slegers, Mukesh
Protezione delle
94 Sharma, Pauly Garcia, Peter G, pranspach, RamenChef,
applicazioni Node.js
Simplans
95 Quadri di modelli Aikon Mogwai
96 Quadri di test unitari David Xu, Florian Hämmerle, skiilaa
Richiamata per
97 Clement JACOB, Michael Buen, Sanketh Katta
promettere
98 Richiedere() Philip Cornelius Glover
Route-Controller-
99 Struttura del servizio nomanbinhussein
per ExpressJS
https://riptutorial.com/it/home 392
100 Routing NodeJs parlad neupane
101 Sequelize.js Fikra, Niroshan Ranapathi, xam
102 Sfide di prestazione Antenka, SteveLacy
103 Socket TCP B Thuy
104 Storia di Nodejs Kelum Senanayake
105 Struttura del progetto damitj07
106 Upload di file Aikon Mogwai, Iceman, Mikhail, walid
107 Usa casi di Node.js vintproykt
cyanbeam, Duly Kinsky, efeder, johni, KlwntSingh, Max, Ze
108 Usando i flussi
Rubeus
Usare Browserfiy per
risolvere l'errore
109 Big Dude
'richiesto' con i
browser
Utilizzando
110 WebSocket con Rowan Harley
Node.JS
Utilizzo di IISNode
111 per ospitare le app peteb
Web Node.js in IIS
https://riptutorial.com/it/home 393
Potrebbero piacerti anche
- Quesiti Tecnici Per Il Reclutamento Di Sviluppatori67% (3)Quesiti Tecnici Per Il Reclutamento Di Sviluppatori10 pagine
- Sviluppare Applicazioni Full Stack IntroduzioneNessuna valutazione finoraSviluppare Applicazioni Full Stack Introduzione3 pagine
- Angular - Introduzione Al FrameworkNessuna valutazione finoraAngular - Introduzione Al Framework34 pagine
- Tecnologie di Sviluppo Web per Sviluppo MobileNessuna valutazione finoraTecnologie di Sviluppo Web per Sviluppo Mobile33 pagine
- Ingegneria Del Software e Fondamenti WebNessuna valutazione finoraIngegneria Del Software e Fondamenti Web273 pagine
- Sviluppare Applicazioni Blockchain IndiceNessuna valutazione finoraSviluppare Applicazioni Blockchain Indice8 pagine
- Libro IoProgrammo 114 Lavorare Java 6 OKNessuna valutazione finoraLibro IoProgrammo 114 Lavorare Java 6 OK162 pagine
- Programmare Per Il Web - Lato Client (2012)Nessuna valutazione finoraProgrammare Per Il Web - Lato Client (2012)334 pagine
- Slide Del Corso Base Di ProgrammazioneNessuna valutazione finoraSlide Del Corso Base Di Programmazione52 pagine
- HTML5, CSS3, JavaScript, Ajax, JQuery - Programmare Per Il Web, Lato Client (Italian Edition)100% (1)HTML5, CSS3, JavaScript, Ajax, JQuery - Programmare Per Il Web, Lato Client (Italian Edition)384 pagine
- Simulazione di un colloquio tecnico per sviluppatoreNessuna valutazione finoraSimulazione di un colloquio tecnico per sviluppatore6 pagine
- Gestire La Complessità Del Software Con Domain Driven Design e CQRS - Stefano OttavianiNessuna valutazione finoraGestire La Complessità Del Software Con Domain Driven Design e CQRS - Stefano Ottaviani154 pagine
- Accelerate Full Stack Web Mobile App Development ItNessuna valutazione finoraAccelerate Full Stack Web Mobile App Development It12 pagine
- Infrastruttura e Panoramica Dell'architettura TecnicaNessuna valutazione finoraInfrastruttura e Panoramica Dell'architettura Tecnica3 pagine
- LPI Learning Material 010 160 ItNessuna valutazione finoraLPI Learning Material 010 160 It453 pagine
- Introduction To TouchDesigner - It PDFNessuna valutazione finoraIntroduction To TouchDesigner - It PDF164 pagine
- AWS Certified Cloud Practitioner Exam Guida al successo 2: AWS Certified Cloud Practitioner Exam Guida al successo, #2Da EverandAWS Certified Cloud Practitioner Exam Guida al successo 2: AWS Certified Cloud Practitioner Exam Guida al successo, #2Nessuna valutazione finora
- Guida a JavaScript: Dal Principiante all Esperto: La collezione informaticaDa EverandGuida a JavaScript: Dal Principiante all Esperto: La collezione informaticaNessuna valutazione finora
- listino_panda_03_07_2024-6685564c84ab1Nessuna valutazione finoralistino_panda_03_07_2024-6685564c84ab16 pagine
- cars-models-pricelist-KL1-NA-NA-2021Nessuna valutazione finoracars-models-pricelist-KL1-NA-NA-202120 pagine
- cars-accessories-brochure-all-NA-NA-2019Nessuna valutazione finoracars-accessories-brochure-all-NA-NA-201937 pagine
- ORGANIZZAZIONE-ORARI-DI-INGRESSO-E-USCITA-SCUOLA-PRIMARIA-DAL-26-AL-30-OTTOBRE-2020-Nessuna valutazione finoraORGANIZZAZIONE-ORARI-DI-INGRESSO-E-USCITA-SCUOLA-PRIMARIA-DAL-26-AL-30-OTTOBRE-2020-2 pagine
