Node.js Tutorial
Iniziare con Node.js

Osservazioni

Versioni

Ciao server World HTTP

Innanzitutto, installa Node.js per la tua piattaforma.

In questo esempio creeremo un server HTTP in ascolto sulla porta 1337, che invia Hello, World! al browser. Si noti che, invece di utilizzare la porta 1337, è possibile utilizzare qualsiasi numero di porta a scelta che al momento non è utilizzato da nessun altro servizio.

Il modulo http è un modulo core Node.js (un modulo incluso nell'origine di Node.js, che non richiede l'installazione di risorse aggiuntive). Il modulo http fornisce la funzionalità per creare un server HTTP utilizzando il metodo http.createServer() . Per creare l'applicazione, creare un file contenente il seguente codice JavaScript.

const http = require('http'); // Loads the http module

http.createServer((request, response) => {

    // 1. Tell the browser everything is OK (Status code 200), and the data is in plain text
    response.writeHead(200, {
        'Content-Type': 'text/plain'
    });

    // 2. Write the announced text to the body of the page
    response.write('Hello, World!\n');

    // 3. Tell the server that all of the response headers and body have been sent
    response.end();

}).listen(1337); // 4. Tells the server what port to be on

Salva il file con qualsiasi nome di file. In questo caso, se lo hello.js possiamo eseguire l'applicazione andando nella directory in cui si trova il file e usando il seguente comando:

node hello.js

È possibile accedere al server creato con l'URL http: // localhost: 1337 o http://127.0.0.1:1337 nel browser.

Una pagina web semplice apparirà con un testo "Hello, World!" In alto, come mostrato nello screenshot qui sotto.

Esempio online modificabile.

Ciao linea di comando mondiale

Node.js può anche essere utilizzato per creare utilità da riga di comando. L'esempio seguente legge il primo argomento dalla riga di comando e stampa un messaggio Hello.

Per eseguire questo codice su un sistema Unix:

1. Crea un nuovo file e incolla il codice qui sotto. Il nome file è irrilevante.
2. Rendi questo file eseguibile con chmod 700 FILE_NAME
3. Esegui l'app con ./APP_NAME David

Su Windows fai il passaggio 1 ed node APP_NAME David con il node APP_NAME David

#!/usr/bin/env node

'use strict';

/*
    The command line arguments are stored in the `process.argv` array, 
    which has the following structure:
    [0] The path of the executable that started the Node.js process
    [1] The path to this application
    [2-n] the command line arguments

    Example: [ '/bin/node', '/path/to/yourscript', 'arg1', 'arg2', ... ]
    src: https://nodejs.org/api/process.html#process_process_argv
 */

// Store the first argument as username.
var username = process.argv[2];

// Check if the username hasn't been provided.
if (!username) {

    // Extract the filename
    var appName = process.argv[1].split(require('path').sep).pop();

    //  Give the user an example on how to use the app.
    console.error('Missing argument! Example: %s YOUR_NAME', appName);

    // Exit the app (success: 0, error: 1). 
    // An error will stop the execution chain. For example:
    //   ./app.js && ls       -> won't execute ls
    //   ./app.js David && ls -> will execute ls
    process.exit(1);
}

// Print the message to the console.
console.log('Hello %s!', username);

Installazione ed esecuzione di Node.js

Per iniziare, installa Node.js sul tuo computer di sviluppo.

Windows: vai alla pagina di download e scarica / esegui il programma di installazione.

Mac: vai alla pagina di download e scarica / esegui il programma di installazione. In alternativa, è possibile installare il nodo tramite Homebrew utilizzando il brew install node . Homebrew è un pacchetto di comandi a riga di comando per Macintosh, e ulteriori informazioni a riguardo sono disponibili sul sito Web di Homebrew .

Linux: seguire le istruzioni per la distro sulla pagina di installazione della riga di comando .

Esecuzione di un programma di nodo

Per eseguire un programma Node.js, esegui semplicemente il node app.js o nodejs app.js , dove app.js è il nome file del tuo codice sorgente dell'app nodo. Non è necessario includere il suffisso .js per il nodo per trovare lo script che desideri eseguire.

In alternativa, con i sistemi operativi basati su UNIX, un programma Node può essere eseguito come uno script terminale. Per fare ciò, è necessario iniziare con uno shebang che punta all'interprete Node, come #!/usr/bin/env node . Il file deve anche essere impostato come eseguibile, che può essere fatto usando chmod . Ora lo script può essere eseguito direttamente dalla riga di comando.

Distribuzione dell'applicazione online

Quando si distribuisce l'app in un ambiente ospitato (specifico per Node.js), in genere questo ambiente offre una variabile di ambiente PORT che è possibile utilizzare per eseguire il server. La modifica del numero di porta in process.env.PORT consente di accedere all'applicazione.

Per esempio,

http.createServer(function(request, response) {
   // your server code
}).listen(process.env.PORT);

Inoltre, se desideri accedere a questo offline durante il debug, puoi utilizzare questo:

http.createServer(function(request, response) {
  // your server code
}).listen(process.env.PORT || 3000);

dove 3000 è il numero di porta offline.

Debug della tua applicazione NodeJS

È possibile utilizzare il nodo-inspector. Esegui questo comando per installarlo tramite npm:

npm install -g node-inspector

Quindi puoi eseguire il debug dell'applicazione usando

node-debug app.js

Il repository Github può essere trovato qui: https://github.com/node-inspector/node-inspector

Debugging nativamente

Puoi anche eseguire il debug di node.js in modo nativo avviandolo in questo modo:

node debug your-script.js

Per interrompere il debugger esattamente in una riga di codice che desideri, usa questo:

debugger;

Per maggiori informazioni vedi qui .

In node.js 8 usa il seguente comando:

node --inspect-brk your-script.js

Quindi apri about://inspect in una versione recente di Google Chrome e seleziona lo script del nodo per ottenere l'esperienza di debug di Chrome's DevTools.

Ciao mondo con Express

Nell'esempio seguente viene utilizzato Express per creare un server HTTP in ascolto sulla porta 3000, che risponde con "Hello, World!". Express è un framework web comunemente utilizzato che è utile per creare API HTTP.

Innanzitutto, crea una nuova cartella, ad esempio myApp . Vai su myApp e crea un nuovo file JavaScript contenente il seguente codice ( hello.js per esempio). Quindi installare il modulo express usando npm install --save express dalla riga di comando. Fare riferimento a questa documentazione per ulteriori informazioni su come installare i pacchetti .

// Import the top-level function of express
const express = require('express');

// Creates an Express application using the top-level function
const app = express();

// Define port number as 3000
const port = 3000;

// Routes HTTP GET requests to the specified path "/" with the specified callback function
app.get('/', function(request, response) {
  response.send('Hello, World!');
});

// Make the app listen on port 3000
app.listen(port, function() {
  console.log('Server listening on http://localhost:' + port);
});

Dalla riga di comando, eseguire il seguente comando:

node hello.js

Apri il browser e vai a http://localhost:3000 o http://127.0.0.1:3000 per vedere la risposta.

Per ulteriori informazioni sul framework Express, è possibile controllare la sezione Web Apps con Express

Hello World routing di base

Una volta compreso come creare un server HTTP con nodo, è importante capire come farlo "fare" le cose in base al percorso a cui un utente ha navigato. Questo fenomeno è chiamato "routing".

L'esempio più semplice di questo sarebbe verificare if (request.url === 'some/path/here') , e quindi chiamare una funzione che risponde con un nuovo file.

Un esempio di questo può essere visto qui:

const http = require('http');

function index (request, response) {
    response.writeHead(200);
    response.end('Hello, World!');
}

http.createServer(function (request, response) {
    
    if (request.url === '/') {
        return index(request, response);
    }

    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);

}).listen(1337);

Se continui a definire le tue "rotte" come questa, però, finirai con una funzione di callback enorme, e non vogliamo un pasticcio gigante come quello, quindi vediamo se riusciamo a ripulire tutto.

Per prima cosa, memorizziamo tutti i nostri percorsi in un oggetto:

var routes = {
    '/': function index (request, response) {
        response.writeHead(200);
        response.end('Hello, World!');
    },
    '/foo': function foo (request, response) {
        response.writeHead(200);
        response.end('You are now viewing "foo"');
    }
}

Ora che abbiamo memorizzato 2 percorsi in un oggetto, ora possiamo controllarli nel nostro callback principale:

http.createServer(function (request, response) {
    
    if (request.url in routes) {
        return routes[request.url](request, response);
    }

    response.writeHead(404);
    response.end(http.STATUS_CODES[404]);

}).listen(1337);

Ora ogni volta che provi a navigare nel tuo sito web, controllerà l'esistenza di quel percorso nei tuoi percorsi e chiamerà la rispettiva funzione. Se non viene trovata alcuna route, il server risponderà con un 404 (non trovato).

Ed ecco fatto: il routing con l'API di HTTP Server è molto semplice.

Socket TLS: server e client

Le uniche differenze principali tra questa e una normale connessione TCP sono la chiave privata e il certificato pubblico che dovrai impostare in un oggetto opzione.

Come creare una chiave e un certificato

Il primo passo in questo processo di sicurezza è la creazione di una chiave privata. E qual è questa chiave privata? Fondamentalmente, è un insieme di rumore casuale che viene utilizzato per crittografare le informazioni. In teoria, potresti creare una chiave e usarla per crittografare quello che vuoi. Ma è una buona pratica avere diverse chiavi per cose specifiche. Perché se qualcuno ruba la tua chiave privata, è come se qualcuno rubasse le chiavi della tua casa. Immagina se hai usato la stessa chiave per bloccare la tua auto, garage, ufficio, ecc.

openssl genrsa -out private-key.pem 1024

Una volta che abbiamo la nostra chiave privata, possiamo creare una CSR (richiesta di firma del certificato), che è la nostra richiesta di far firmare la chiave privata da un'autorità immaginaria. Questo è il motivo per cui devi inserire le informazioni relative alla tua azienda. Queste informazioni verranno visualizzate dall'autorità di firma e utilizzate per verificare l'utente. Nel nostro caso, non importa ciò che scrivi, dal momento che nel prossimo passaggio firmeremo noi stessi il nostro certificato.

openssl req -new -key private-key.pem -out csr.pem

Ora che abbiamo completato il nostro lavoro cartaceo, è tempo di fingere di essere un'autentica autorità firmataria.

openssl x509 -req -in csr.pem -signkey private-key.pem -out public-cert.pem

Ora che hai la chiave privata e il certificato pubblico, puoi stabilire una connessione sicura tra due app NodeJS. E, come puoi vedere nel codice di esempio, è un processo molto semplice.

Importante!

Dal momento che abbiamo creato noi stessi il certificato pubblico, in tutta onestà, il nostro certificato non ha valore, perché siamo nomini. Il server NodeJS non si fiderà di tale certificato per impostazione predefinita, ed è per questo motivo che è necessario dirlo per fidarsi effettivamente del nostro cert con la seguente opzione rejectUnauthorized: false. Molto importante : non impostare mai questa variabile su true in un ambiente di produzione.

TLS Socket Server

'use strict';

var tls = require('tls');
var fs = require('fs');

const PORT = 1337;
const HOST = '127.0.0.1'

var options = {
    key: fs.readFileSync('private-key.pem'),
    cert: fs.readFileSync('public-cert.pem')
};

var server = tls.createServer(options, function(socket) {

    // Send a friendly message
    socket.write("I am the server sending you a message.");

    // Print the data that we received
    socket.on('data', function(data) {

        console.log('Received: %s [it is %d bytes long]',
            data.toString().replace(/(\n)/gm,""),
            data.length);

    });

    // Let us know when the transmission is over
    socket.on('end', function() {

        console.log('EOT (End Of Transmission)');

    });

});

// Start listening on a specific port and address
server.listen(PORT, HOST, function() {

    console.log("I'm listening at %s, on port %s", HOST, PORT);

});

// When an error occurs, show it.
server.on('error', function(error) {

    console.error(error);

    // Close the connection after the error occurred.
    server.destroy();

});

TLS Socket Client

'use strict';

var tls = require('tls');
var fs = require('fs');

const PORT = 1337;
const HOST = '127.0.0.1'

// Pass the certs to the server and let it know to process even unauthorized certs.
var options = {
    key: fs.readFileSync('private-key.pem'),
    cert: fs.readFileSync('public-cert.pem'),
    rejectUnauthorized: false
};

var client = tls.connect(PORT, HOST, options, function() {

    // Check if the authorization worked
    if (client.authorized) {
        console.log("Connection authorized by a Certificate Authority.");
    } else {
        console.log("Connection not authorized: " + client.authorizationError)
    }

    // Send a friendly message
    client.write("I am the client sending you a message.");

});

client.on("data", function(data) {

    console.log('Received: %s [it is %d bytes long]',
        data.toString().replace(/(\n)/gm,""),
        data.length);

    // Close the connection after receiving the message
    client.end();

});

client.on('close', function() {

    console.log("Connection closed");

});

// When an error ocoures, show it.
client.on('error', function(error) {

    console.error(error);

    // Close the connection after the error occurred.
    client.destroy();

});

Ciao mondo nella REPL

Quando chiamato senza argomenti, Node.js avvia un REPL (Read-Eval-Print-Loop) noto anche come " Node shell ".

Al prompt dei comandi digitare node .

$ node
>

Al prompt della shell Nodo > tipo "Ciao Mondo!"

$ node
> "Hello World!"
'Hello World!'

Moduli core

Node.js è un motore Javascript (motore V8 di Google per Chrome, scritto in C ++) che consente di eseguire Javascript all'esterno del browser. Mentre numerose librerie sono disponibili per estendere le funzionalità di Node, il motore viene fornito con una serie di moduli principali che implementano funzionalità di base.

Ci sono attualmente 34 moduli principali inclusi nel nodo:

[ 'assert',
  'buffer',
  'c/c++_addons',
  'child_process',
  'cluster',
  'console',
  'crypto',
  'deprecated_apis',
  'dns',
  'domain',
  'Events',
  'fs',
  'http',
  'https',
  'module',
  'net',
  'os',
  'path',
  'punycode',
  'querystring',
  'readline',
  'repl',
  'stream',
  'string_decoder',
  'timers',
  'tls_(ssl)',
  'tracing',
  'tty',
  'dgram',
  'url',
  'util',
  'v8',
  'vm',
  'zlib' ]

Questo elenco è stato ottenuto dall'API di documentazione del nodo https://nodejs.org/api/all.html (file JSON: https://nodejs.org/api/all.json ).

Tutti i moduli di base a colpo d'occhio

affermare

Il modulo assert fornisce una semplice serie di test di asserzione che possono essere utilizzati per testare gli invarianti.

buffer

Prima dell'introduzione di TypedArray in ECMAScript 2015 (ES6), il linguaggio JavaScript non aveva alcun meccanismo per leggere o manipolare flussi di dati binari. La classe Buffer è stata introdotta come parte dell'API Node.js per rendere possibile l'interazione con i flussi di ottetti nel contesto di operazioni come flussi TCP e operazioni del file system.

Ora che TypedArray è stato aggiunto in ES6, la classe Buffer implementa l'API Uin t8Array in un modo più ottimizzato e adatto ai casi d'uso di Node.js.

C / C ++ _ addons

I componenti aggiuntivi di Node.js sono oggetti condivisi collegati dinamicamente, scritti in C o C ++, che possono essere caricati in Node.js usando la funzione require() e usati come se fossero un normale modulo Node.js. Vengono utilizzati principalmente per fornire un'interfaccia tra JavaScript in esecuzione nelle librerie Node.js e C / C ++.

child_process

Il modulo child_process fornisce la possibilità di generare processi figlio in un modo simile, ma non identico, a popen (3).

grappolo

Una singola istanza di Node.js viene eseguita in un singolo thread. Per sfruttare i sistemi multi-core, l'utente a volte desidera avviare un cluster di processi Node.js per gestire il carico. Il modulo cluster consente di creare facilmente processi figlio che condividono tutte le porte del server.

consolle

Il modulo console fornisce una semplice console di debug che è simile al meccanismo della console JavaScript fornito dai browser web.

crypto

Il modulo crypto fornisce funzionalità crittografiche che include un set di wrapper per le funzioni di hash, HMAC, cifratura, decifratura, firma e verifica di OpenSSL.

deprecated_apis

Node.js può deprecare API quando: (a) l'utilizzo dell'API è considerato non sicuro, (b) è stata resa disponibile un'API alternativa migliorata oppure (c) sono previste interruzioni delle modifiche all'API in una futura versione principale .

dns

Il modulo dns contiene funzioni appartenenti a due diverse categorie:

1. Funzioni che utilizzano le funzionalità del sistema operativo sottostante per eseguire la risoluzione dei nomi e che non eseguono necessariamente alcuna comunicazione di rete. Questa categoria contiene solo una funzione: dns.lookup() .
2. Funzioni che si connettono a un server DNS effettivo per eseguire la risoluzione dei nomi e che utilizzano sempre la rete per eseguire query DNS. Questa categoria contiene tutte le funzioni nel modulo dns tranne dns.lookup() .

dominio

Questo modulo è in attesa di deprecazione . Una volta completata l'API di sostituzione, questo modulo sarà completamente deprecato. La maggior parte degli utenti non dovrebbe avere motivo di usare questo modulo. Gli utenti che devono assolutamente disporre delle funzionalità fornite dai domini possono affidarsi al momento, ma in futuro dovrebbero aspettarsi di dover eseguire la migrazione a una soluzione diversa.

eventi

Gran parte dell'API core di Node.js è basata su un'architettura asincrona basata sugli eventi asincrona in cui determinati tipi di oggetti (chiamati "emettitori") emettono periodicamente eventi denominati che causano la chiamata di oggetti Function ("listener").

fs

I / O di file sono forniti da semplici wrapper attorno alle funzioni POSIX standard. Per utilizzare questo modulo è require('fs') . Tutti i metodi hanno forme asincrone e sincrone.

http

Le interfacce HTTP in Node.js sono progettate per supportare molte funzionalità del protocollo che sono state tradizionalmente difficili da utilizzare. In particolare, messaggi di grandi dimensioni, possibilmente codificati per il chunk. L'interfaccia fa attenzione a non bufferizzare intere richieste o risposte - l'utente è in grado di trasmettere dati.

https

HTTPS è il protocollo HTTP su TLS / SSL. In Node.js questo è implementato come un modulo separato.

modulo

Node.js ha un semplice sistema di caricamento dei moduli. In Node.js, i file e i moduli sono in corrispondenza uno a uno (ogni file viene trattato come un modulo separato).

netto

Il modulo net fornisce un wrapper di rete asincrono. Contiene funzioni per la creazione di server e client (chiamati flussi). Puoi includere questo modulo con require('net'); .

os

Il modulo os fornisce numerosi metodi di utilità relativi al sistema operativo.

sentiero

Il modulo path fornisce utility per lavorare con i percorsi di file e directory.

Punycode

La versione del modulo punycode in bundle in Node.js è deprecata .

stringa della domanda

Il modulo querystring fornisce utility per l'analisi e la formattazione delle stringhe di query URL.

linea di lettura

Il modulo readline fornisce un'interfaccia per leggere i dati da un flusso leggibile (come process.stdin ) una riga alla volta.

repl

Il modulo repl fornisce un'implementazione Read-Eval-Print-Loop (REPL) che è disponibile sia come programma standalone che includibile in altre applicazioni.

ruscello

Un flusso è un'interfaccia astratta per lavorare con i dati di streaming in Node.js. Il modulo stream fornisce un'API di base che semplifica la creazione di oggetti che implementano l'interfaccia di streaming.

Esistono molti oggetti di flusso forniti da Node.js. Ad esempio, una richiesta a un server HTTP e process.stdout sono entrambe istanze di flusso.

string_decoder

Il modulo string_decoder fornisce un'API per decodificare gli oggetti Buffer in stringhe in modo da preservare i caratteri codificati UTF-8 e UTF-16 codificati.

temporizzatori

Il modulo timer espone un'API globale per le funzioni di pianificazione da richiamare in un determinato periodo di tempo. Poiché le funzioni del timer sono globali, non è necessario chiamare require('timers') per utilizzare l'API.

Le funzioni del timer all'interno di Node.js implementano un'API simile all'API dei timer fornita dai browser Web, ma utilizzano un'implementazione interna diversa costruita attorno al Loop eventi di Node.js.

tls_ (SSL)

Il modulo tls fornisce un'implementazione dei protocolli Transport Layer Security (TLS) e Secure Socket Layer (SSL) costruiti su OpenSSL.

tracciato

Trace Event fornisce un meccanismo per centralizzare le informazioni di traccia generate da V8, nucleo del nodo e codice dello spazio utente.

La traccia può essere abilitata passando il --trace-events-enabled all'avvio di un'applicazione Node.js.

tty

Il modulo tty fornisce le classi tty.ReadStream e tty.WriteStream . Nella maggior parte dei casi, non sarà necessario o possibile utilizzare direttamente questo modulo.

dgram

Il modulo dgram fornisce un'implementazione di socket UDP Datagram.

url

Il modulo url fornisce utility per la risoluzione e l'analisi dell'URL.

util

Il modulo util è progettato principalmente per supportare le esigenze delle API interne di Node.js. Tuttavia, molte delle utilità sono utili anche per gli sviluppatori di applicazioni e moduli.

v8

Il modulo v8 espone le API specifiche per la versione di V8 integrata nel binario Node.js.

Nota : le API e l'implementazione sono soggette a modifiche in qualsiasi momento.

vm

Il modulo vm fornisce API per la compilazione e l'esecuzione del codice all'interno dei contesti della macchina virtuale V8. Il codice JavaScript può essere compilato ed eseguito immediatamente o compilato, salvato ed eseguito successivamente.

Nota : il modulo vm non è un meccanismo di sicurezza. Non usarlo per eseguire codice non affidabile .

zlib

Il modulo zlib fornisce funzionalità di compressione implementate usando Gzip e Deflate / Inflate.

Come ottenere un server Web HTTPS di base attivo e funzionante!

Una volta che node.js è installato sul tuo sistema, puoi semplicemente seguire la procedura seguente per ottenere un server Web di base in esecuzione con supporto per HTTP e HTTPS!

Passaggio 1: creare un'autorità di certificazione

1. creare la cartella in cui si desidera memorizzare la chiave e il certificato:

   mkdir conf

2. vai a quella directory:

   cd conf

3. prendi questo file ca.cnf da usare come scorciatoia di configurazione:

   wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/ca.cnf

4. creare una nuova autorità di certificazione utilizzando questa configurazione:

   openssl req -new -x509 -days 9999 -config ca.cnf -keyout ca-key.pem -out ca-cert.pem

5. ora che abbiamo la nostra autorità di certificazione in ca-key.pem e ca-cert.pem , ca-key.pem una chiave privata per il server:

   openssl genrsa -out key.pem 4096

6. prendi questo file server.cnf da usare come scorciatoia di configurazione:

   wget https://raw.githubusercontent.com/anders94/https-authorized-clients/master/keys/server.cnf

7. generare la richiesta di firma del certificato utilizzando questa configurazione:

   openssl req -new -config server.cnf -key key.pem -out csr.pem

8. firmare la richiesta:

   openssl x509 -req -extfile server.cnf -days 999 -passin "pass:password" -in csr.pem -CA ca-cert.pem -CAkey ca-key.pem -CAcreateserial -out cert.pem

Passaggio 2: installa il certificato come certificato di origine

1. copia il tuo certificato nella cartella dei certificati di root:

   sudo cp ca-crt.pem /usr/local/share/ca-certificates/ca-crt.pem

2. aggiornare l'archivio di CA:

   sudo update-ca-certificates

Passaggio 3: avvio del server nodo

Innanzitutto, si desidera creare un file server.js che contenga il proprio codice server attuale.

L'installazione minima per un server HTTPS in Node.js sarebbe qualcosa del genere:

var https = require('https');
var fs = require('fs');

var httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

var app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

https.createServer(httpsOptions, app).listen(4433);

Se vuoi anche supportare le richieste http, devi fare solo questa piccola modifica:

var http = require('http');
var https = require('https');
var fs = require('fs');

var httpsOptions = {
    key: fs.readFileSync('path/to/server-key.pem'),
    cert: fs.readFileSync('path/to/server-crt.pem')
};

var app = function (req, res) {
  res.writeHead(200);
  res.end("hello world\n");
}

http.createServer(app).listen(8888);
https.createServer(httpsOptions, app).listen(4433);

1. vai alla directory in cui si trova il tuo server.js :

   cd /path/to

2. eseguire server.js :

   node server.js