node-js-it
node-js-it
js
#node.js
Sommario
Di 1
Osservazioni 2
Versioni 2
Examples 6
Debugging nativamente 9
Importante! 12
Moduli core 15
Capitolo 2: Ambiente 23
Examples 23
Utilizzo di diverse proprietà / configurazione per ambienti diversi come dev, qa, staging, 24
Examples 27
Examples 28
introduzione 29
Sintassi 29
Parametri 29
Examples 29
Iniziare 30
Routing di base 30
Più cartelle 37
Hook: come eseguire il codice prima di qualsiasi req e dopo qualsiasi res 42
Aggiunta di middleware 44
Ciao mondo 45
Examples 46
introduzione 47
Examples 47
Progressione da Callbacks 48
Capitolo 8: async.js 51
Sintassi 51
Examples 51
Parallelo: multi-tasking 51
Osservazioni 57
Examples 57
Utilizzando activedirectory 57
Installazione 57
uso 57
Examples 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
Examples 61
Impostare 61
Codice 62
uso 63
Impostare 63
Codice 63
uso 65
Impostare 65
Codice 66
uso 67
Impostare 70
Codice 70
uso 72
Osservazioni 73
Examples 73
Sintassi 77
Examples 77
Capitolo 14: Codice Node.js per STDIN e STDOUT senza utilizzare alcuna libreria 81
introduzione 81
Examples 81
Programma 81
Examples 82
Modalità globale 82
introduzione 84
Examples 84
Codice Arduino 85
Cominciando 85
Examples 87
Examples 89
introduzione 90
Sintassi 90
Examples 90
Sintassi 91
Examples 91
server.js 91
Examples 93
Capitolo 22: Creazione di una libreria Node.js che supporti entrambe le promesse e le call 95
introduzione 95
Examples 95
Examples 98
Connessione Mongoose 98
Modello 98
Inserisci dati 99
Leggi i dati 99
Examples 101
Examples 105
Examples 107
Examples 109
Examples 110
Examples 112
dipendenze 112
Forvever 115
Utilizzo di diverse proprietà / configurazione per ambienti diversi come dev, qa, staging, 116
Examples 118
destrutturazione 119
flusso 119
Osservazioni 121
Examples 121
Sintassi 125
Osservazioni 125
Examples 125
introduzione 128
Examples 128
Examples 130
Examples 137
introduzione 140
Examples 140
Examples 143
Osservazioni 145
Examples 145
sincrono 150
Evitare le condizioni di gara durante la creazione o l'utilizzo di una directory esistente 150
sincrono 152
app.js 153
app.js 153
introduzione 155
Examples 155
Osservazioni 158
Examples 158
introduzione 160
Examples 160
Mac OS 160
homebrew 160
MacPorts 160
finestre 160
Installer 160
cioccolatoso 160
Linux 161
Arco 161
Solus 161
tarball 162
npm 162
Osservazioni 164
Examples 164
Examples 167
Examples 168
Examples 169
Examples 172
introduzione 173
Osservazioni 173
Examples 173
Examples 176
Utilizzando l'ultima versione specifica (ad es. LTS 6.x) direttamente da nodesource 176
homebrew 178
macports 179
Installazione con Node Version Manager in Fish Shell con Oh My Fish! 180
Examples 183
Sintassi 185
Parametri 185
Examples 186
introduzione 191
Examples 191
b. Raggiungimento della multi-tenancy sul server di database con diversi database ospitati 192
Connetti a MySQL 193
Osservazioni 196
Examples 196
Iniziare 196
Examples 202
Examples 203
introduzione 204
Osservazioni 204
Examples 204
Sintassi 207
Examples 207
Registrazione 207
Console.Error 207
formattazione 208
Generale 208
Examples 210
Invia notifica Web utilizzando GCM (Google Cloud Messaging System) 210
Examples 212
Utilizzo di fs And pipe per il flusso di file statici dal server 212
Examples 214
Examples 215
introduzione 219
Parametri 219
Examples 219
Sintassi 222
Examples 222
introduzione 224
Examples 224
introduzione 226
Examples 226
introduzione 227
Examples 227
Examples 229
Examples 232
Sintassi 233
Osservazioni 233
Examples 233
introduzione 236
Osservazioni 236
Examples 236
introduzione 238
Osservazioni 238
Examples 238
Grappolo 238
introduzione 240
Examples 240
Osservazioni 242
Examples 242
introduzione 244
Examples 244
Examples 248
Examples 250
introduzione 251
Examples 251
Prerequisiti: 252
Examples 255
Examples 258
Osservazioni 259
Examples 259
Lettura 261
In aggiornamento 261
metodi 262
Aggiornare() 262
UpdateOne 262
UpdateMany 262
ReplaceOne 263
Eliminazione 263
introduzione 265
Examples 265
Osservazioni 268
Examples 268
Iniziare 268
Examples 273
Esprimere 273
Koa 273
Commander.js 273
Vorpal.js 274
introduzione 275
Sintassi 275
Parametri 276
Examples 277
Installazione dei pacchetti 277
introduzione 277
Osservazioni 290
Examples 290
Esegui qualsiasi comando arbitrario in una subshell con la versione desiderata del nodo 292
Examples 294
Osservazioni 302
Examples 302
dipendenze 302
devDependencies 303
Script 303
introduzione 310
Examples 310
introduzione 311
Examples 311
Examples 313
Examples 315
Loop degli eventi 315
insidie 317
introduzione 319
Sintassi 319
Examples 319
domini 323
Examples 327
Examples 328
Examples 330
Examples 335
Nunjucks 335
Examples 337
Examples 339
introduzione 341
Sintassi 341
Osservazioni 341
Examples 341
Examples 344
user.model.js 344
user.routes.js 344
user.controllers.js 345
user.services.js 345
introduzione 346
Osservazioni 346
Examples 346
Examples 351
Installazione 351
Examples 354
Examples 358
introduzione 360
Examples 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
introduzione 363
Osservazioni 363
Examples 363
Examples 366
Nota: 367
Examples 369
Parametri 371
Examples 371
Capitolo 109: Usare Browserfiy per risolvere l'errore 'richiesto' con i browser 376
Examples 376
Importante 377
Examples 378
Capitolo 111: Utilizzo di IISNode per ospitare le app Web Node.js in IIS 380
Osservazioni 380
versioni 380
Examples 380
Iniziare 380
Requisiti 380
Configurazione 382
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
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
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
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
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.
// 1. Tell the browser everything is OK (Status code 200), and the data is in plain text
response.writeHead(200, {
'Content-Type': 'text/plain'
});
// 3. Tell the server that all of the response headers and body have been sent
response.end();
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.
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.
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
*/
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 .
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);
È possibile utilizzare il nodo-inspector. Esegui questo comando per installarlo tramite npm:
node-debug app.js
Debugging nativamente
Puoi anche eseguire il debug di node.js in modo nativo avviandolo in questo modo:
Per interrompere il debugger esattamente in una riga di codice che desideri, usa questo:
debugger;
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.
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 .
// Routes HTTP GET requests to the specified path "/" with the specified callback function
app.get('/', function(request, response) {
response.send('Hello, World!');
});
node hello.js
Per ulteriori informazioni sul framework Express, è possibile controllare la sezione Web Apps con
Express
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".
https://riptutorial.com/it/home 10
Un esempio di questo può essere visto qui:
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.
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:
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).
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.
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.
Ora che abbiamo completato il nostro lavoro cartaceo, è tempo di fingere di essere un'autentica
autorità firmataria.
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.
https://riptutorial.com/it/home 12
var tls = require('tls');
var fs = require('fs');
var options = {
key: fs.readFileSync('private-key.pem'),
cert: fs.readFileSync('public-cert.pem')
};
});
});
});
});
console.error(error);
});
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
};
});
client.on("data", function(data) {
});
client.on('close', function() {
console.log("Connection closed");
});
console.error(error);
});
Quando chiamato senza argomenti, Node.js avvia un REPL (Read-Eval-Print-Loop) noto anche
come " Node shell ".
https://riptutorial.com/it/home 14
$ node
>
$ 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.
[ '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' ]
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
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
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
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
sentiero
Il modulo path fornisce utility per lavorare con i percorsi di file e directory.
Punycode
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
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
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.
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
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.
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!
mkdir conf
cd conf
wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf
openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem
wget https://raw.githubusercontent.com/anders94/https-authorized-
clients/master/keys/server.cnf
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
https://riptutorial.com/it/home 20
1. copia il tuo certificato nella cartella dei certificati di root:
sudo update-ca-certificates
L'installazione minima per un server HTTPS in Node.js sarebbe qualcosa del genere:
var httpsOptions = {
key: fs.readFileSync('path/to/server-key.pem'),
cert: fs.readFileSync('path/to/server-crt.pem')
};
https.createServer(httpsOptions, app).listen(4433);
Se vuoi anche supportare le richieste http, devi fare solo questa piccola modifica:
var httpsOptions = {
key: fs.readFileSync('path/to/server-key.pem'),
cert: fs.readFileSync('path/to/server-crt.pem')
};
http.createServer(app).listen(8888);
https.createServer(httpsOptions, app).listen(4433);
cd /path/to
https://riptutorial.com/it/home 21
2. eseguire server.js :
node server.js
https://riptutorial.com/it/home 22
Capitolo 2: Ambiente
Examples
Accesso alle variabili d'ambiente
{
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'
process.env.FOO // 'foobar'
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:
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
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', ...]
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.
• 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.
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;
}
}
});
se usiamo process manager come per sempre che sia semplice come
mkdir env
• Crea environments.js :
# 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
...
https://riptutorial.com/it/home 26
Capitolo 3: Analizzare gli argomenti della riga
di comando
Examples
Passando azione (verbo) e valori
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
};
options
.option("-v, --verbose")
.parse(process.argv);
if (options.verbose){
console.log("Let's make some noise!");
}
https://riptutorial.com/it/home 27
Capitolo 4: API CRUD basata su REST
semplice
Examples
API REST per CRUD in Express 3+
//START SERVER
server.listen(3000, function () {
console.log("Server running");
})
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 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.
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 :
app.listen(8080, 'localhost');
Per eseguire il tuo script usa il seguente comando nella tua shell:
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:
È anche possibile aprire un browser Web, accedere all'URL http: // localhost: 8080 / ping per
visualizzare l'output
Routing di base
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.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 */};
https://riptutorial.com/it/home 31
Questo renderà il tuo codice molto più pulito.
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
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.
PUT /settings/32135
{
"name": "Peter"
}
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
Modulo:
// greet.js
const express = require('express');
return router;
};
Applicazione:
// app.js
const express = require('express');
const greetMiddleware = require('./greet.js');
express()
.use('/api/v1/', greetMiddleware({ greeting:'Hello world' }))
.listen(8080);
Modulo:
// greet.js
const express = require('express');
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);
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 .
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
// or
/* res.send(JSON.stringify({
string_value: 'StackOverflow',
number_value: 8476
})) */
app.listen(port, function() {
console.log('Node.js listening on port ' + port)
})
{
string_value: "StackOverflow",
number_value: 8476
}
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:
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'));
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.
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 :
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:
Da ora in poi puoi capire come definire le funzioni per unirle con spazi dei nomi personalizzati
specificati e puntare ai controller appropriati.
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
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
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.
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.
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.
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.
https://riptutorial.com/it/home 39
});
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.
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.
https://riptutorial.com/it/home 40
return next(new Error('Id is 0')); // go to first Error handler, see below
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
Appendice B
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".
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.
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.
https://riptutorial.com/it/home 42
const express = require('express');
});
app.listen(8080, 'localhost');
Di seguito è riportato un esempio per l'impostazione e la lettura dei cookie utilizzando il modulo
cookie-parser :
app.listen(3000);
In Express, è possibile definire i middleware che possono essere utilizzati per controllare le
richieste o impostare alcune intestazioni in risposta.
Esempio
Il codice seguente aggiunge l' user all'oggetto richiesta e passa il controllo alla successiva route
https://riptutorial.com/it/home 43
corrispondente.
app.listen(3000);
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
//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());
Ciao mondo
• '/'
• '/ Wiki'
'use strict';
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.
https://riptutorial.com/it/home 45
Capitolo 6: Arresto grazioso
Examples
Graceful Shutdown - SIGTERM
process.on('SIGTERM', function () {
server.close(function () {
process.exit(0);
});
});
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.
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.
try {
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' });
} finally {
https://riptutorial.com/it/home 47
pool.releaseConnection(connection);
}
} catch (err) {
// handle errors here
}
});
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:
try {
result = await aFunctionThatReturnsAPromise();
} catch (error) {
handleError(error);
}
Quindi la parola chiave async sarebbe simile a write return new Promise((resolve, reject) => {...}
.
Qui lascio una breve gif che non lascerà alcun dubbio in mente dopo averla vista:
GIF
Progressione da Callbacks
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.
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.
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
}
https://riptutorial.com/it/home 50
Capitolo 8: async.js
Sintassi
• Ogni callback deve essere scritto con questa sintassi:
• 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
• Le tue callback possono contenere più argomenti di err e result , ma è utile solo per
un set specifico di funzioni (cascata, seq, ...)
• callback (err);
Examples
Parallelo: multi-tasking
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);
});
async.parallel({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
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"]
}
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);
});
async.series({
short: shortTimeFunction,
medium: mediumTimeFunction,
long: longTimeFunction
},
function(err, results) {
if (err) {
return console.error(err);
}
console.log(results);
});
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);
}
https://riptutorial.com/it/home 54
setTimeout(function() {
var friendsResult = [];
callback(null, friendsResult);
}, 500);
}
async.waterfall([
getUserRequest,
getUserFriendsRequest
],
function(err, results) {
if (err) {
return console.error(err);
}
console.log(JSON.stringify(results));
});
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
Questo è chiamato in parallelo. Quando vogliamo chiamarlo uno alla volta, utilizzare:
async.timesSeries
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(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');
}
});
/ 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:
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!');
}
});
https://riptutorial.com/it/home 57
Capitolo 10: Autoreload su modifiche
Examples
Il caricamento automatico sul codice sorgente cambia usando nodemon
Utilizzando nodemon
Esegui il tuo programma con nodemon entry.js (o nodemon 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:
Questo installerà Browsersync nella directory node_modules locale e lo salverà nelle dipendenze
dello sviluppatore.
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:
Uso di base
Per ricaricare automaticamente il tuo sito ogni volta che cambi un file JavaScript nel tuo progetto
usa il seguente comando:
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:
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:
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
https://riptutorial.com/it/home 60
Capitolo 11: Biblioteca Mongoose
Examples
Connetti a MongoDB usando Mongoose
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!
});
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:
if(result) {
res.json(result)
}
})
})
Qui la variabile di query sarà il parametro <query> della richiesta HTTP in entrata, che verrà salvata
in MongoDB:
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>
Esempio:
http://localhost:8080/save/JavaScript%20is%20Awesome
{
__v: 0,
request: "JavaScript is Awesome",
time: 1469411348,
_id: "57957014b93bc8640f2c78c4"
}
Impostare
Innanzitutto, installa i pacchetti necessari con:
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:
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
}
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>
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
}]
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:
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 :
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>
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
}]
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
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.
__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.
Indici composti
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.
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.
usersSchema.set('autoIndex', false);
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
});
Impostare
Innanzitutto, installa i pacchetti necessari con:
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:
https://riptutorial.com/it/home 70
}, {
collection: 'collectionName'
});
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>
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
}]
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.
//Import Libraries
var express = require('express'),
session = require('express-session'),
mongoose = require('mongoose'),
request = require('request');
//Connect to Mongo DB
mongoose.connect(config.getDBString());
//Configure Routes
app.use(config.API_PATH, userRoutes());
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;
https://riptutorial.com/it/home 74
//Export the User Model
module.exports = User;
//Create a User
create: function(req, res){
var repassword = req.body.repassword;
var password = req.body.password;
var userEmail = req.body.email;
//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;
https://riptutorial.com/it/home 75
}
module.exports = UserController;
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.
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
-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.
Aggiunto in: v0.5.2 Valuta il seguente argomento come JavaScript. I moduli che sono predefiniti in
REPL possono essere utilizzati anche in script.
-c, --check
-i, --interactive
Aggiunto in: v0.7.7 Apre REPL anche se stdin non sembra essere un terminale.
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
--throw-deprecation
--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
Nota: le opzioni v8 consentono alle parole di essere separate da entrambi i trattini (-) o caratteri di
sottolineatura (_).
--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.
NODE_DISABLE_COLORS=1
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.
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
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 :
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
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 :
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.
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.
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
Esempio app.js:
arduinoSerialPort.on('open',function() {
console.log('Serial Port ' + arduinoCOMPort + ' is opened.');
});
return res.send('Working');
})
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!");
}
});
app.listen(port, function () {
console.log('Example app listening on port http://0.0.0.0:' + port + '!');
});
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.
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, LOW);
}
Cominciando
https://riptutorial.com/it/home 85
1. Collega l'arduino alla tua macchina.
2. Avvia il server
http://0.0.0.0:3000/led
http://0.0.0.0:3000/off
https://riptutorial.com/it/home 86
Capitolo 17: Comunicazione client-server
Examples
/ w Express, jQuery e Jade
//'client.jade'
//test: the text within brackets should appear when clicking on said button
//window.alert('You clicked on me. - jQuery');
//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'
//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');
res.send(sent_data);
});
module.exports = router;
https://riptutorial.com/it/home 88
Capitolo 18: Comunicazione Socket.io
Examples
"Ciao mondo!" con i messaggi socket
Node.js server
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>
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.
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.
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 .
project root
| server.js
|____views
| index.html
| page1.html
server.js
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.
https://riptutorial.com/it/home 92
Capitolo 21: Creazione di API con Node.js
Examples
Ottieni API usando Express
L'esempio seguente crea una semplice API GET per elencare tutti gli utenti.
Esempio
// 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');
});
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
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);
app.listen('3000', function(){
console.log('Server listening on port 3000');
});
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';
module.exports = {
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';
// classic callbacks
// 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);
});
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
(async () => {
try {
let x = await math.sum(6, 3);
console.log('Test 7a: ' + x);
} 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
package.json
"dependencies": {
"mongoose": "^4.5.5",
}
server.js (ECMA 6)
mongoose.connect('mongodb://localhost:27017/stackoverflow-example');
const db = mongoose.connection;
db.on('error', console.error.bind(console, 'DB connection error!'));
mongoose.connect('mongodb://localhost:27017/stackoverflow-example');
var db = mongoose.connection;
db.on('error', console.error.bind(console, 'DB connection error!'));
Modello
https://riptutorial.com/it/home 98
app / model / user.js (ECMA 5.1)
module.exports = User
Inserisci dati
ECMA 6:
user.save((err) => {
if (err) throw err;
console.log('User saved!');
});
ECMA5.1:
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');
}
});
https://riptutorial.com/it/home 100
Capitolo 24: Debug dell'applicazione Node.js
Examples
Core node.js debugger e node inspector
'use strict';
2. I punti di interruzione
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()
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.
Puoi eseguire l'ispettore integrato in v8 del nodo! Il plug-in ispettore nodo non è più necessario.
https://riptutorial.com/it/home 102
Installa l'ispettore del nodo:
node-debug filename.js
http://localhost:8080/debug?port=5858
A volte la porta 8080 potrebbe non essere disponibile sul tuo computer. Potresti ricevere il
seguente errore:
In questo caso, avviare l'ispettore del nodo su una porta diversa usando il seguente comando.
$node-inspector --web-port=6500
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> .
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.
Se avvii la tua applicazione su Linux, usa il proxy per il debug via porta, ad esempio:
https://riptutorial.com/it/home 106
Capitolo 26: Design API restful: best practice
Examples
Gestione degli errori: OTTENERE tutte le risorse
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);
}
});
});
https://riptutorial.com/it/home 108
Capitolo 27: Disinstallazione di Node.js
Examples
Disinstallare completamente Node.js su Mac OSX
Per disinstallare Node.js su Windows, utilizzare Aggiungi o Rimuovi programmi come questo:
Windows 10:
Windows 7-8.1:
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
listen_timeout
kill_timeout
server.js
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.
https://riptutorial.com/it/home 111
Capitolo 29: Distribuzione di applicazioni
Node.js in produzione
Examples
Impostazione NODE_ENV = "produzione"
Bandiere di runtime
Qualsiasi codice in esecuzione nella tua applicazione (inclusi i moduli esterni) può controllare il
valore di NODE_ENV :
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 :
Finestre :
set NODE_ENV=production
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 .
Questo imposterà NODE_ENV per l'app corrente. Questo aiuta quando vogliamo testare le nostre app
in diversi ambienti.
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 .
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:
È 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.
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.
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.
pm2 list
Interrompi un'app:
Riavvia un'app:
https://riptutorial.com/it/home 114
pm2 show my-app
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
Esegui l'applicazione:
Riavvia l'applicazione:
$ forever restart 0
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.
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.
• 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;
}
}
});
se usiamo process manager come per sempre che sia semplice come
https://riptutorial.com/it/home 116
forever start app.js env=dev
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.
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');
cluster.on('disconnect', function(worker) {
console.error('disconnect!');
//clearTimeout(timeout);
cluster.fork();
});
} else {
require('./app.js');
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
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))
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 => :
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 .
Esegui in RunKit
destrutturazione
flusso
/* @flow */
const b = 3;
let c = [1,2,3,,{}];
let d = 3;
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...');
}
}
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:
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:
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
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)
});
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.
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);
myDog.once('chew', pet);
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!!");
});
Esegui in RunKit
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
console.log(emitter.listenerCount("data")) // => 2
console.log(emitter.listenerCount("message"))// => 1
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 .
https://riptutorial.com/it/home 125
});
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:
console.log(`stdout: ${stdout}`);
console.log(`stderr: ${stderr}`);
});
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:
console.log(stdout);
});
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
# send log tot syslog here (it doesn't compete with other log config in the app itself)
StandardOutput=syslog
StandardError=syslog
[Install]
https://riptutorial.com/it/home 128
# start node at multi user system level (= sysVinit runlevel 3)
WantedBy=multi-user.target
Per dire a systemd di avviare automaticamente il nodo all'avvio, basta digitare: systemctl enable
node .
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:
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:
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:
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:
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);
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:
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);
};
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');
// 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!"
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');
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.
Per utilizzare uno di questi, basta richiedere il modulo come faresti normalmente:
req.user = user
next()
https://riptutorial.com/it/home 133
})
}
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
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.
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:
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".
https://riptutorial.com/it/home 136
Capitolo 35: Esportazione e importazione del
modulo in node.js
Examples
Utilizzando un modulo semplice in node.js
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";
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";
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
... 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
Importa la funzione say() perché è contrassegnata come l'esportazione predefinita nel file
sorgente ( export default … )
https://riptutorial.com/it/home 138
Importazione in bundle
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
verrà cercato nelle cartelle node_modules locali e globali e genererà un errore se non viene trovato
alcun modulo corrispondente.
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.
while true:
wait for something to happen
react to whatever happened
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.
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:
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.
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:
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:
Esempio:
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.
https://riptutorial.com/it/home 143
$ bower installa async
var fs = require('fs');
var async = require('async');
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!');
});
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.
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');
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);
}
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:
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:
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 :
https://riptutorial.com/it/home 146
//Rest of Function
}
const fs = require('fs');
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');
return iter.next(data);
});
iter.next();
}
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);
});
const fs = require('fs');
Se viene specificata un'opzione di encoding , verrà restituita una stringa, altrimenti verrà restituito
un Buffer .
var fs = require('fs');
fs.unlink('/path/to/file.txt', function(err) {
if (err) throw err;
console.log('file deleted');
});
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.
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');
// Of course, you can do anything else you need to here, like emit an event!
});
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';
sincrono
fs.accessha anche una versione sincrona fs.accessSync . Quando si utilizza fs.accessSync è
necessario racchiuderlo all'interno di un blocco try / catch.
A causa della natura asincrona del nodo, creando o utilizzando una directory prima:
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.
var fs = require('fs');
if (err)
return console.error(err.code);
});
mkdirSync('./existing-dir');
// Do something with `./existing-dir` now
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');
}
}
Questo programma illustra come è possibile copiare un file utilizzando flussi leggibili e scrivibili
utilizzando le createReadStream() e createWriteStream() fornite dal modulo del file system.
/*
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 });
Questo programma copia un file utilizzando un flusso leggibile e scrivibile con la funzione pipe()
fornita dalla classe stream
/*
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 });
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');
app.js
const readline = require('readline');
const fs = require('fs');
Uso:
nodo app
https://riptutorial.com/it/home 153
app.js
const readline = require('readline');
const fs = require('fs');
Uso:
nodo app
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
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.
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à.
https://riptutorial.com/it/home 155
var err = new Error("Some error occurred");
throw err;
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 ... 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
}
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.
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 .
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';
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}`);
});
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
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
Installa il filo
Installa il filo
Arco
Installa il filo tramite AUR.
yaourt -S yarn
Solus
https://riptutorial.com/it/home 161
Tutte le distribuzioni
Aggiungi quanto segue al tuo profilo di shell preferito ( .profile , .bashrc , .zshrc etc)
tarball
cd /opt
wget https://yarnpkg.com/latest.tar.gz
tar zvxf latest.tar.gz
npm
Se hai già installato npm, esegui semplicemente
Post installazione
Controlla la versione installata di Yarn eseguendo
yarn --version
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
{
"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]
"dependencies": {
"express": "^4.15.2"
}
Il filato usa lo stesso registro usato da npm. Ciò significa che ogni pacchetto disponibile su npm è
lo stesso su Yarn.
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 .
https://riptutorial.com/it/home 163
Capitolo 42: grugnito
Osservazioni
Ulteriori letture:
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.
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'
}
}
});
// 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.
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 .
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
grunt.registerTask('default', ['jshint']);
L'attività predefinita viene eseguita con il comando grunt nel terminale senza alcuna opzione.
https://riptutorial.com/it/home 166
Capitolo 43: Guida per principianti NodeJS
Examples
Ciao mondo !
console.log("Hello World");
node helloworld.js
https://riptutorial.com/it/home 167
Capitolo 44: Hack
Examples
Aggiungi nuove estensioni da richiedere ()
require('./hello')((err, xml) {
if (err)
throw err;
console.log(err);
})
https://riptutorial.com/it/home 168
Capitolo 45: http
Examples
server http
http.createServer(handler).listen(httpPort, start_callback);
function start_callback(){
console.log('Start HTTP on port ' + httpPort)
}
node http_server.js
ora devi testare il tuo server, devi aprire il tuo browser internet e navigare verso questo URL:
http://127.0.0.1:80
curl 127.0.0.1:80
https://riptutorial.com/it/home 169
ok
client http
var options = {
hostname: '127.0.0.1',
port: 80,
path: '/',
method: 'GET'
};
req.on('error', function(e) {
console.log('problem with request: ' + e.message);
});
req.end();
node http_client.js
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
Disaccoppiamento
I moduli diventano meno coppia, quindi è facile da mantenere.
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.
Examples
Creazione di profili di una semplice applicazione di nodo
Passo 1 : Installa il pacchetto node-inspector utilizzando npm globalmente sul tuo computer
$ node-inspector
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.
https://riptutorial.com/it/home 175
Capitolo 48: Installare Node.js
Examples
Installa Node.js su Ubuntu
# 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)
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 standard
Tutti i binari, gli installatori e i file sorgente di Node.js possono essere scaricati qui .
https://riptutorial.com/it/home 176
È inoltre possibile installare dal gestore pacchetti Chocolatey (Software Management Automation).
Maggiori informazioni sulla versione attuale, puoi trovare nel repository choco qui .
Node Version Manager , altrimenti noto come nvm, è uno script di bash che semplifica la gestione
di più versioni di Node.js.
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.
Puoi anche installare una versione specifica del nodo, passando le versioni major, minor e / o
patch:
$ nvm install 6
$ nvm install 4.2
$ 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:
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.
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.
Prerequisiti
[optional]
sudo apt-get install git
cd ~
git clone https://github.com/nodejs/node.git
cd ~
wget https://nodejs.org/dist/v6.3.0/node-v6.10.2.tar.gz
tar -xzvf node-v6.10.2.tar.gz
./configure
make
sudo make install
homebrew
https://riptutorial.com/it/home 178
Puoi installare Node.js utilizzando il gestore di pacchetti Homebrew .
brew update
brew doctor
node -v
macports
Puoi anche installare node.js tramite Macports .
Innanzitutto aggiornalo per assicurarti che i pacchetti più recenti siano referenziati:
È ora possibile eseguire il nodo tramite CLI direttamente richiamando il node . Inoltre, puoi
controllare la versione corrente del tuo nodo con
node -v
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.
$ 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.
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
Installa Oh My Fish
https://riptutorial.com/it/home 180
(Nota: a questo punto ti verrà richiesto di riavviare il tuo terminale. Vai avanti e fallo ora.)
Installeremo plugin-nvm tramite Oh My Fish per esporre nvm funzionalità di nvm all'interno di Fish
Shell:
Ora sei pronto per usare nvm . Puoi installare e utilizzare la versione di Node.js di tuo gradimento.
Qualche esempio:
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.
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 v7.x
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
Innanzitutto, c'è un involucro davvero bello per l'installazione di n sul tuo sistema. Corri:
più recente
n latest
stabile
n stable
n lts
n <version>
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.
https://riptutorial.com/it/home 182
Capitolo 49: Instradare richieste ajax con
Express.JS
Examples
Una semplice implementazione di AJAX
Ora nel tuo file index.js (o nella sua rispettiva corrispondenza), aggiungi:
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>
$(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);
});
});
});
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
https://riptutorial.com/it/home 185
Parametro Dettagli
Examples
Connetti a MongoDB
Inserisci un documento
https://riptutorial.com/it/home 186
const url = 'mongodb://localhost:27017/test';
https://riptutorial.com/it/home 187
db.close(); // Don't forget to close the connection when you are done
}
});
});
Aggiorna un documento
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
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
});
});
Semplice connessione
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);
});
```
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
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
});
}
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.
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: -
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);
});
});
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"});
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:
Ora devi creare una connessione mysql, che puoi in seguito interrogare.
connection.connect();
connection.end();
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.
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 :
conn.release();
callback();
});
});
});
Per ulteriori informazioni sul pooling delle connessioni MySQL, consultare i documenti MySQL .
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);
}
});
// db.js
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');
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
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);
});
// Initializing passport
app.use(passport.initialize());
app.use(passport.session());
Autenticazione locale
https://riptutorial.com/it/home 196
Il modulo passport-local viene utilizzato per implementare un'autenticazione locale.
Registrazione dell'utente:
newUser.save(function() {
// Pass the user to the callback
return next(null, newUser);
});
}
});
});
Accesso dell'utente:
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'
});
app.listen(3000);
Autenticazione Facebook
Strategia di attuazione:
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'
}));
//...
app.listen(3000);
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);
});
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
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();
};
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.
https://riptutorial.com/it/home 201
Capitolo 53: Integrazione di Cassandra
Examples
Ciao mondo
console.log(results.rows);
});
https://riptutorial.com/it/home 202
Capitolo 54: Integrazione di PostgreSQL
Examples
Connetti a PostgreSQL
Ora devi creare una connessione PostgreSQL, che puoi in seguito interrogare.
var pg = require("pg")
var connectionString = "pg://postgres:postgres@localhost:5432/students";
var client = new pg.Client(connectionString);
client.connect();
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
https://riptutorial.com/it/home 204
}
});
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.
Una semplice richiesta GET. Supponiamo che il Modello dell'esempio precedente sia nel file
./db/models/Article.js .
app.use('/api', routes);
};
Ora possiamo ottenere i dati dal nostro database inviando una richiesta HTTP a questo endpoint.
Alcune cose chiave, però:
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:
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.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
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
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
'use strict';
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"
}
PS: il file Manifest.json deve essere nella directory principale o non funzionerà.
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.
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.
if (!range) {
return res.sendStatus(416);
res.writeHead(206, {
'Transfer-Encoding': 'chunked',
"Accept-Ranges": "bytes",
"Content-Length": chunksize,
"Content-Type": mime.lookup(req.params.filename)
});
.on('end', function () {
console.log('Stream Done');
})
res.end(err);
https://riptutorial.com/it/home 212
})
});
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.
Puoi anche usare flent-ffmpeg per convertire i file .mp4 in file .flv o altri tipi:
res.contentType ( 'flv');
.preset('flashvideo')
.on('end', function () {
console.log('Stream Done');
})
res.send(err.message);
})
https://riptutorial.com/it/home 213
Capitolo 59: Koa Framework v2
Examples
Ciao esempio del mondo
app.listen(8080)
https://riptutorial.com/it/home 214
Capitolo 60: La gestione delle eccezioni
Examples
Gestione dell'eccezione in Node.Js
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;
}
// ** 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
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.
// runs asynchronously
setTimeout(function(){
myEvent.emit('error', new Error('User Name cannot be empty'));
}, 1000);
return myEvent;
}
event.on('error', function(err) {
console.log(err);
});
event.on('done', function(result) {
console.log(result); // true
});
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.
• 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.
• Installazione per sempre (o altro strumento CLI per assicurarsi che quel server nodo funzioni
continuamente)
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.
https://riptutorial.com/it/home 217
// ....
In una nota a margine c'era anche un modo per gestire le eccezioni con Cluster e Domini .
Errori e promesse
Le promesse gestiscono gli errori in modo diverso rispetto al codice sincrono o callback.
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.
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
Examples
Notifica Web
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:
server.listen(80);
});
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 :
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');
});
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
https://riptutorial.com/it/home 222
console.log(`Hello ${name}!`);
rl.close();
});
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.
// 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'],
app.configure(function () {
// you will need to use cookieParser to expose cookies to req.cookies
app.use(express.cookieParser());
});
// 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
}
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.
var countries = [
{"key": "DE", "name": "Deutschland", "active": false},
{"key": "ZA", "name": "South Africa", "active": true}
];
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
https://riptutorial.com/it/home 227
"L'ho fatto}"
}
},
"funzioni": {
"findById": [
"Id"
]
}
}
]
}
}
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.
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 list
https://riptutorial.com/it/home 229
pm2 delete <instance name>
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
8. Visualizza i log
https://riptutorial.com/it/home 230
$ forever list
info: Forever processes running
$ forever stop 0
Installazione
usi
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:
Creare un file chiamato build.js nella build.js principale della cartella del progetto, contenente
quanto segue:
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:
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.
Examples
Ciao mondo
if (cluster.isMaster) {
// Fork workers.
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
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
if (cluster.isMaster) {
// Fork workers.
for (var i = 0; i < numCPUs; i++) {
cluster.fork(); //creating child process
}
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);
}
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.
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.
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
}
}
});
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
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.
Osservazioni
Capire il Loop degli Eventi è importante per capire come e perchè usare più thread.
Examples
Grappolo
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.
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!');
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.
Parent (../parent.js)
Bambino (../child.js)
})
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>
printf("Hello world\n");
return retval;
}
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)
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:
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
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/');
// 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);
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.
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
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();
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}
Questo installerà Pug come dipendenza del nostro progetto e lo salverà su package.json . Per
usarlo abbiamo bisogno di modificare il file app.js :
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 .
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')
$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.
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.
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.
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
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')
mkdir my-es6-app
cd my-es6-app
npm init
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')
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.
Creare un file .babelrc nella directory principale della directory e aggiungere le seguenti
impostazioni
{
"presets": ["es2015", "stage-2"],
"plugins": []
}
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
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
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.
'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 !
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!
new Program().print();
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 :)
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:
Ora devi creare una connessione ORACLE, che puoi in seguito interrogare.
oracledb.getConnection(
{
user : "oli",
password : "password",
connectString : "ORACLE_DEV_DB_TNS_NAME"
},
connExecute
);
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.
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.
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);
}
});
}
Per semplificare le tue query da ORACLE-DB, puoi chiamare la tua query in questo modo:
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');
https://riptutorial.com/it/home 256
conn.release(function (err) {
if (err)
console.log(err.message);
});
};
process.nextTick(function() {
oracleDbRelease(connection);
});
});
})
.catch(function(err) {
reject(err);
});
});
}
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.
https://riptutorial.com/it/home 257
Capitolo 78: Node.js Design Fundamental
Examples
La filosofia Node.js
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."
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.
eventEmitter.emit('doorOpen');
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 ??
Examples
Connessione a un database
https://riptutorial.com/it/home 259
console.log('Connected to the database');
}
});
Con Mongoose, tutto è derivato da uno schema. Consente di creare uno schema.
// 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');
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.
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
});
Lettura
Leggere i dati dalla collezione è molto semplice. Ottenere tutti i dati della collezione.
È inoltre possibile specificare il secondo parametro come oggetto di ciò che tutti i campi necessari
In aggiornamento
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:
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:
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:
ReplaceOne
Sostituisce il primo documento di corrispondenza (documento sostitutivo)
db.countries.replaceOne(
{ country: "Spain" },
{ country: "Finland" }
)
E ritorna:
Eliminazione
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.
});
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;
}
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
// Arrow Function
let sum = (a, b)=> a+b;
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.
https://riptutorial.com/it/home 266
}
var service = {
constructorFn : function(){
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();
}
}
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.
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.
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
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');
});
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.
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:
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:
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');
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:
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:
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.
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:
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.
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:
A volte è necessario cancellare alcune chiavi e reinizializzarle. Per cancellare i tasti, puoi usare il
comando del comando come mostrato di seguito:
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:
https://riptutorial.com/it/home 272
Capitolo 82: NodeJS Frameworks
Examples
Framework di server Web
Esprimere
app.listen(3000, function () {
console.log('Example app listening on port 3000!');
});
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);
Commander.js
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();
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
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:
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
# 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:
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:
# 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:
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 list
npm list <name>
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
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.
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
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.
https://riptutorial.com/it/home 281
@myscope:registry=http://registry.corporation.com
//registry.corporation.com/:_authToken=xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxx
Il comando di disinstallazione per npm ha cinque alias che possono essere utilizzati anche:
Se si desidera rimuovere il pacchetto dal file package.json come parte della disinstallazione,
utilizzare il flag --save (abbreviazione: -S ):
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:
https://riptutorial.com/it/home 282
3. major release: npm version major => 2.0.0
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:
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:
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 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 :
https://riptutorial.com/it/home 283
Per installare un pacchetto e salvarlo automaticamente nel pacchetto package.json , utilizzare:
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 .
[...]
"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.
npm login
npm adduser
npm config ls
npm publish
E hai finito.
https://riptutorial.com/it/home 284
name: "package-name",
version: "1.0.4"
}
Esecuzione di script
{
"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"
}
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
Altro su di esso
Per generare una lista (vista ad albero) dei pacchetti attualmente installati, usare
npm list
Opzioni
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 outdated
https://riptutorial.com/it/home 286
Per aggiornare un pacchetto specifico:
Questo aggiornerà il pacchetto alla versione più recente in base alle restrizioni in
package.json
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
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:
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 .
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
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
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
command -v nvm
nvm ls-remote
Per esempio
https://riptutorial.com/it/home 290
Per elencare le versioni locali disponibili del nodo tramite NVM:
nvm ls
$ nvm ls
v4.3.0
v5.5.0
PROCESSO DI INSTALLAZIONE
È possibile installare Node Version Manager utilizzando git, curl o wget. Esegui questi comandi in
Terminale su Mac OSX .
esempio di arricciatura:
esempio di wget:
• 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”
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:
Se si desidera impostare un nome alias nella versione del nodo installato, eseguire:
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:
Quindi ogni volta che inizia console / terminale 5.0.1 sarebbe presente per impostazione
predefinita.
Nota:
nvm ls
v4.5.0
v6.7.0
https://riptutorial.com/it/home 292
v4.5.0
usando alias
Cambio di versione
https://riptutorial.com/it/home 293
Capitolo 85: OAuth 2.0
Examples
OAuth 2 con implementazione Redis - grant_type: password
Ora dobbiamo impostare il nostro server node.js per utilizzare il database redis.
app.use(bodyParser.json());
app.oauth = oauthserver({
model: require('./routes/Oauth2/model'),
grants: ['password', 'refresh_token'],
debug: true
});
// Error handling
app.use(app.oauth.errorHandler());
app.listen(3000);
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'
};
callback(null, {
accessToken: token.accessToken,
clientId: token.clientId,
expires: token.expires ? new Date(token.expires) : null,
userId: token.userId
});
});
};
callback(null, {
clientId: client.clientId,
clientSecret: client.clientSecret
});
});
};
callback(null, {
refreshToken: token.accessToken,
clientId: token.clientId,
expires: token.expires ? new Date(token.expires) : null,
userId: token.userId
});
});
};
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);
};
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);
}
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
https://riptutorial.com/it/home 297
Intestazione:
1. autorizzazione: base seguita dalla password impostata al primo avvio del ripristino:
2. Modulo dati
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:
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
parole
una serie di stringhe, questo aiuterà le persone a trovare il tuo pacchetto
chiave
dipendenze
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"
}
}
Script predefiniti
https://riptutorial.com/it/home 303
Nome script Descrizione
preversione, versione Esegui prima di eseguire il bump della versione del pacchetto.
prerestart, restart,
Esegui dal comando di npm restart
postrestart
{
"scripts": {
"preci": "scripts/preci.js",
"ci": "scripts/ci.js",
"postci": "scripts/postci.js"
}
}
$ npm run-script ci
$ npm run ci
Gli script definiti dall'utente supportano anche gli script pre e post , come mostrato nell'esempio
sopra.
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.
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.
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.
{
"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
]
}
name
Il nome univoco del tuo pacchetto e dovrebbe essere in minuscolo. Questa proprietà è richiesta e
il pacchetto non verrà installato senza di esso.
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:
description
author
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).
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
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');
Ora puoi usare l'array come qualsiasi altro per lavorare su di esso.
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
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);
});
});
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());
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.
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: -
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);
});
});
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"});
https://riptutorial.com/it/home 314
Capitolo 90: Prestazioni Node.js
Examples
Loop degli eventi
// 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 .
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.
Nozioni di base
require('http').globalAgent.maxSockets = 25
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:
options.agent = false
insidie
• Dovresti fare la stessa cosa per l'API https se vuoi gli stessi effetti
Abilita gzip
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)
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
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.
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.
• 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);
}
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 .
const fs = require("fs");
È 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.
// 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
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.
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
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.
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.
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`;
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.
timeout(1000).then(function (dataFromPromise) {
// logs "It was resolved!"
console.log(dataFromPromise);
})
console.log("waiting...");
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.
https://riptutorial.com/it/home 326
Capitolo 92: Programmazione sincrona
contro asincrona in nodejs
Examples
Uso asincrono
Utilizzando la funzione automatica è possibile definire relazioni asincrone tra due o più funzioni:
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.
https://riptutorial.com/it/home 327
Capitolo 93: Promesse Bluebird
Examples
Conversione della libreria del nodoback in Promises
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:
Esempio di filtro:
Esempio di riduzione:
Coroutine (generatori)
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()
})
}
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)
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.
Esempio
// parse cookies
app.use(cookieParser())
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 .
https://riptutorial.com/it/home 330
<button type="submit">Submit</button>
</form>
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")
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 options = {
key: fs.readFileSync('privatekey.pem'),
cert: fs.readFileSync('certificate.pem'),
ca: [fs.readFileSync('1_ca.crt'), fs.readFileSync('2_ca.crt')]
};
https://riptutorial.com/it/home 331
Utilizzando HTTPS
L'installazione minima per un server HTTPS in Node.js sarebbe qualcosa del genere:
const httpsOptions = {
key: fs.readFileSync('path/to/server-key.pem'),
cert: fs.readFileSync('path/to/server-crt.pem')
};
https.createServer(httpsOptions, app).listen(4433);
Se vuoi anche supportare le richieste http, devi fare solo questa piccola modifica:
const httpsOptions = {
key: fs.readFileSync('path/to/server-key.pem'),
cert: fs.readFileSync('path/to/server-crt.pem')
};
http.createServer(app).listen(8888);
https.createServer(httpsOptions, app).listen(4433);
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!
mkdir conf
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
openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem
wget https://raw.githubusercontent.com/anders94/https-authorized-
clients/master/keys/server.cnf
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
sudo update-ca-certificates
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');
https://riptutorial.com/it/home 333
var credentials = {key: privateKey, cert: certificate};
var express = require('express');
var app = express();
httpServer.listen(8080);
httpsServer.listen(8443);
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).
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
app.js
// 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.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 %}
https://riptutorial.com/it/home 336
Capitolo 96: Quadri di test unitari
Examples
Mocha sincrono
https://riptutorial.com/it/home 337
})
https://riptutorial.com/it/home 338
Capitolo 97: Richiamata per promettere
Examples
Promuovere una richiamata
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:
Se solo i metodi specifici devono essere promessi, basta usare la sua promessa:
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.
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:
var fs = require('fs');
setTimeout promesso
function wait(ms) {
return new Promise(function (resolve, reject) {
setTimeout(resolve, ms)
})
}
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...
}
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,
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.
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,
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 .
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.
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.
Questo codificatore finirà per scrivere più codici. Ma alla fine i codici saranno molto più
manutenibili e separati.
user.model.js
var mongoose = require('mongoose')
module.exports = User;
https://riptutorial.com/it/home 344
user.routes.js
var express = require('express');
var router = express.Router();
router.get('/', UserController.getUsers)
module.exports = router;
user.controllers.js
var UserService = require('../services/user.service')
user.services.js
var User = require('../models/user.model')
try {
var users = await User.find(query)
return users;
} catch (e) {
// Log Errors
throw Error('Error while Paginating Users')
}
}
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
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
router.get("/",function(req,res){
res.json({"message" : "Hello World"});
});
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].
nodo server.js
L'output sarà
https://riptutorial.com/it/home 347
.
router.use(function(req,res,next) {
console.log("/" + req.method);
next();
});
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
});
http://localhost:3000/api/
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
.
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
Sarà inoltre necessario installare i moduli Node.js del database supportati. Devi solo installare
quello che stai utilizzando
Per PostgreSQL
Per SQLite
Per MSSQL
Una volta installato, puoi includere e creare una nuova istanza di Sequalize in questo modo.
Sintassi ES5
Ora hai un'istanza di sequelize disponibile. Potresti se ti senti così incline chiamarlo con un nome
diverso come
https://riptutorial.com/it/home 351
o
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/
/* 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
}
});
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:
Per ulteriori informazioni su come utilizzare l' import , controlla l' esempio esplicito di sequelize su
GitHub .
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.
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:
https://riptutorial.com/it/home 354
app.use(express.static(__dirname + '/../'));
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');
taskProcessor.send(params);
response.status(200).json(task);
});
});
mongoose.connect('mongodb://localhost/test');
http.listen('1234');
task.js:
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!' });
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('');
https://riptutorial.com/it/home 356
$("#log").val( $("#log").val() + '\n' + task.status);
if(response.status != 'Done!'){
checkTaskTimeout = setTimeout(updateStatus, 500);
}
});
}
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.
https://riptutorial.com/it/home 357
Capitolo 103: Socket TCP
Examples
Un semplice server TCP
// 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');
});
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');
});
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
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
|-- 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.
• 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
|-- 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
https://riptutorial.com/it/home 365
Capitolo 106: Upload di file
Examples
Caricamento file singolo con multer
Ricordati di
server.js :
app.get('/',function(req,res){
res.sendFile(__dirname + "/index.html");
});
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
e cambia:
Ad esempio solo le estensioni delle immagini. Basta aggiungere a var upload = multer({ storage :
storage}).single('userFile'); condizione file filtro
Ora puoi caricare solo file immagine con estensioni png , jpg , gif o jpeg
https://riptutorial.com/it/home 367
npm i formidable@latest
http.createServer(function(req, res) {
if (req.url == '/upload' && req.method.toLowerCase() == 'post') {
// parse a file upload
var form = new formidable.IncomingForm();
return;
}
https://riptutorial.com/it/home 368
Capitolo 107: Usa casi di Node.js
Examples
Server HTTP
console.log('Starting server...');
var config = {
port: 80,
contentType: 'application/json; charset=utf-8'
};
// JSON-API server on port 80
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();
https://riptutorial.com/it/home 370
Capitolo 108: Usando i flussi
Parametri
Parametro Definizione
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:
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 ():
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')
Quando i flussi scrivibili sono anche flussi leggibili, vale a dire quando sono flussi duplex , è
possibile continuare a collegarli ad altri flussi scrivibili.
fs.createReadStream('style.css')
.pipe(zlib.createGzip()) // The returned object, zlib.Gzip, is a duplex stream.
.pipe(fs.createWriteStream('style.css.gz')
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:
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);
}
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
Perché i flussi?
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:
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);
})
Vale la pena ricordare che entrambi gli esempi fanno esattamente la stessa cosa . Qual è la
differenza allora?
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.
https://riptutorial.com/it/home 374
if (err) console.error(err)
// 1339 milliseconds
// 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)
https://riptutorial.com/it/home 375
Capitolo 109: Usare Browserfiy per risolvere
l'errore 'richiesto' con i browser
Examples
Esempio: file.js
Per fare questo, tutto ciò che devi fare è inserire la seguente dichiarazione nel tuo file:
Quindi, analizziamo un URL usando il metodo .parse (). Analizza una stringa di query URL (str) in
un insieme di coppie chiave e valore.
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.
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 analizza l'Abstract Syntax Tree per le chiamate require () per attraversare l'intero
grafico delle dipendenze del tuo
<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:
"dependencies": {
"ws": "*"
},
var ws = require('ws');
https://riptutorial.com/it/home 378
ws.send('something');
});
https://riptutorial.com/it/home 379
Capitolo 111: Utilizzo di IISNode per ospitare
le app Web Node.js in IIS
Osservazioni
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.
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.
- /app_root
- package.json
- server.js
- Web.config
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>
<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.
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.
<appSettings>
<add key="virtualDirPath" value="/foo" />
</appSettings>
All'interno della nostra app Node.js possiamo accedere alle impostazioni virtualDirPath
Ora che possiamo usare l'elemento <appSettings> per la configurazione, sfruttiamo questo e lo
usiamo nel nostro codice server.
// Public Directory
server.use(express.static(path.join(virtualDirPath, 'public')));
// Bower
server.use('/bower_components', express.static(path.join(virtualDirPath,
'bower_components')));
https://riptutorial.com/it/home 383
const express = require('express');
const server = express();
// Public Directory
server.use(express.static(path.join(virtualDirPath, 'public')));
// Bower
server.use('/bower_components', express.static(path.join(virtualDirPath,
'bower_components')));
server.listen(port, () => {
console.log(`Listening on ${port}`);
});
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.
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
Analizzare gli
3 argomenti della riga yrtimiD
di comando
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
13 CLI Ze Rubeus
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
Consegna HTML o
20 qualsiasi altro tipo di Himani Agrawal, RamenChef, user2314737
file
Creazione di una
libreria Node.js che
22 supporti entrambe le Dave
promesse e le
callback first-error
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
Disinstallazione di
27 John Vincent Jardin, RamenChef, snuggles08, Trevor Clarke
Node.js
Distribuzione
dell'applicazione
28 gentlejo
Node.js senza tempi
di inattività.
ECMAScript 2015
30 David Xu, Florian Hämmerle, Osama Bari
(ES6) con Node.js
Esecuzione di file o
32 comandi con Child guleria, hexacyanide, iSkore
Processes
Esecuzione di
33 node.js come Buzut
servizio
Esportazione e
AndrewLeonardi, Bharat, commonSenseCode, James
35 importazione del
Billingham, Oliver, sharif.io, Shog9
modulo in node.js
https://riptutorial.com/it/home 388
Evita l'inferno del
37 tyehia
callback
Gestire la richiesta
40 Manas Jayanth
POST in Node.js
Gestore pacchetti
41 Andrew Brooke, skiilaa
filati
Guida per
43 Niroshan Ranapathi
principianti NodeJS
44 Hack signal
Iniezione di
46 Niroshan Ranapathi
dipendenza
Iniziare con la
47 damitj07
profilatura dei nodi
Instradare richieste
49 RamenChef, SynapseTech
ajax con Express.JS
Integrazione con
50 cyanbeam, FabianCook, midnightsyntax
Mongodb
https://riptutorial.com/it/home 389
Skiba, Rafael Gadotti Bachovas, RamenChef, Simplans,
Sorangwala Abbasali, surjikal
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
Invio di un flusso di
58 Beshoy Hanna
file al client
La gestione delle
60 KlwntSingh, Nivesh, riyadhalnur, sBanda, sjmarshy, topheman
eccezioni
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
https://riptutorial.com/it/home 390
Sharma, riyadhalnur, Vsevolod Goloviznin
70 multithreading arcs
Node.js (express.js)
73 con il codice di sigfried
esempio angular.js
Node.js Architecture
74 Ivan Hristov
& Inner Workings
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
https://riptutorial.com/it/home 391
Palma
nvm - Node Version cyanbeam, guleria, John Vincent Jardin, Luis González,
84
Manager pranspach, Shog9, Tushar Gupta
88 passport.js Red
Pool di connessione
89 KlwntSingh
Mysql
Programmazione
92 sincrona contro Craig Ayre, Veger
asincrona in nodejs
Richiamata per
97 Clement JACOB, Michael Buen, Sanketh Katta
promettere
Route-Controller-
99 Struttura del servizio nomanbinhussein
per ExpressJS
https://riptutorial.com/it/home 392
100 Routing NodeJs parlad neupane
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