1. Cloud
2. Programmazione
3. Nodejs

di Andrea Chiarelli

In questo tutorial impareremo a conoscere e a utilizzare Node.js, che è un ambiente di lavoro utile nello sviluppo di applicazioni JavaScript; spiegheremo di cosa si tratta, come possiamo interagire con l'ambiente che ci mette a disposizione, vedremo l'organizzazione di un'applicazione in moduli e faremo un cenno a come utilizzare moduli standard e a come creare dei moduli nostri.
Naturalmente tutto sarà corredato con esempi pratici.

Che cos'è Node.js

Innanzitutto rispondiamo alla domanda che per prima vi starete facendo; ebbene, Node.js non è un linguaggio di programmazione ma potrebbe essere considerato come un framework di programmazione Java Script, sebbene in realtà la definizione di framework non è del tutto appropriata, in quanto Node.js potrebbe essere confuso con un ambiente per creare un particolare tipo di applicazioni. Per l’esattezza, Node.js è un framework/piattaforma per l’esecuzione di applicazioni JavaScript
Diciamo quindi che la definizione più appropriata sarebbe quella di “piattaforma per l'esecuzione di applicazioni JavaScript”, come troviamo scritto nella home page del sito ufficiale; in pratica si tratta si un run-time JavaScript, quindi un motore per l'esecuzione di codice JavaScript.

La definizione di Node.js non fa riferimento all’ambiente cui normalmente è legato JavaScript, cioè normalmente quando si pensa JavaScript si pensa automaticamente al browser; Node.js invece svincola dal browser, offrendo un ambiente per l'esecuzione di codice JavaScript sia sul server che sul desktop. Diciamo che questo runtime può essere seguito in qualunque ambiente.

Un altro aspetto interessante è il fatto che Node.js è multipiattaforma, quindi possiamo eseguirlo su macchine Windows, MacOS, Linux, quindi una volta creata un'applicazione Java Script la possiamo eseguire in una qualsiasi di queste piattaforme.
Naturalmente non è da sottovalutare il fatto che si tratta di un progetto open-source, quindi possiamo utilizzare e vedere i sorgenti, nonché collaborare al progetto.

Un aspetto tecnico che ne ha decretato il successo è che con Node.js viene fornito un modello di programmazione asincrono, cioè basato su un singolo thread, esattamente come è proprio l'esecuzione standard di Java Script; questa caratteristica, anche se potrebbe essere ignorata, in un certo senso e fino a certo punto, dallo sviluppatore, consente di fornire elevate prestazioni soprattutto quando bisogna sviluppare applicazioni interattive.

Setup dell’ambiente

Allora vediamo un po' e vediamo come possiamo muoverci nell'utilizzo innanzitutto dobbiamo scaricare dal sito ufficiale, che è https://nodejs.org, di cui la figura seguente propone la pagina di download, che poi è la landing page.

Come possiamo vedere, è possibile scaricare il pacchetto direttamente dalla home page del sito, che riconosce il sistema operativo da cui stiamo accedendo e quindi ci propone il pacchetto adatto alla piattaforma che stiamo utilizzando. Se vogliamo scaricare altri pacchetti di altre piattaforme, possiamo farlo dal link di download.
Notate che vengono rese disponibili due versioni, che sono l’ultima rilasciata e quella stabile (consigliata), che è la LTS, ossia quella per cui viene garantito il supporto di lungo termine: LTS significa, appunto, Long Time Support.

La versione corrente è la versione in corso di sviluppo, contenente le ultime funzionalità ma non adatta per l'uso in produzione, quindi diciamo a meno che non vogliamo sperimentare le ultime funzionalità sviluppate per il progetto, in una situazione di produzione è opportuno utilizzare la versione LTS.
Una volta scaricato il pacchetto, andrà installato seguendo le istruzioni che vengono fornite a video.
Siamo quindi pronti a lavorare: lanciamo il programma e vediamo che la prima cosa che possiamo utilizzare è il comando:

node –version

il quale ci consente di verificare la versione correntemente installata. Diciamo che in genere è un approccio empirico utilizzbile per verificare se Node.js è correttamente installato sulla nostra macchina.
Questo comando deve essere impartito da una shell DOS, ossia da prompt dei comandi di Windows.
Notate che se scriviamo semplicemente node e poi diamo Invio, ci viene aperta la shell di Node.js, all'interno della quale possiamo scrivere il codice JavaScript che verrà immediatamente eseguito; tale shell è un po' come la console JavaScript all’interno di un browser e la vedete nella figura seguente.

In essa, per esempio, se scriviamo:

console.log(“Hello world!”)

otteniamo la stringa che abbiamo passato, ovvero il testo “Hello world!”.
Al limite possiamo anche scrivere un’espressione matematica e viene automaticamente calcolata, oppure possiamo mettere una variabile e poi far scrivere il valore della variabile stessa (vedere l’immagine seguente).
Vedete come lanciando semplicemente il comando node, possiamo interagire direttamente con l'ambiente Node.js, scrivendo direttamente il codice codice JavaScript.

Per uscire da questo ambiente scriviamo semplicemente:

Exit

seguito da Invio e così ritorniamo alla shell del sistema operativo su cui stiamo lavorando.

Se creiamo uno script, ad esempio se utilizziamo Notepad, scriviamo una riga di codice JavaScript, ossia quella che avevamo digitato come esempio dimostrativo della shell di Node.js:

console.log(“Hello world!”)

e salviamo il file come script.js, a questo punto se lanciamo node seguito dal nome del file, ossia:

node script.js

il codice JavaScript verrà eseguito.
Questo serve a farvi capire che nell’ambiente, possiamo sia scrivere codice JavaScript interattivamente nella console, sia scrivere un file contenente del codice JavaScript e poi lo possiamo eseguire lanciando il comando node seguito dal nome del file stesso.

Web Server con Node.js

Per farvi avere un’idea di come si può scrivere del codice in Node.js vi proponiamo lo sviluppo di un’applicazione: un semplice Web Server. Il relativo codice è riportato qui di seguito, che vi chiediamo di prendere per buono in questa fase; poi andremo nel dettaglio per descrivere le varie istruzioni, ma per il momento analizziamo la struttura.

var http = require('http');

http.createServer(function (request, response) {
response.writeHead(200,
{'Content-Type': 'text/html'});
response.write('Hello World!');
response.end();
}).listen(8080);

Quello che abbiamo in questo caso è un oggetto http che ci permette di creare un server che cattura una richiesta http e restituisce come risposta una risposta fissa, che è il solito Hello World.
Il server che abbiamo creato con la porzione di codice mostrata nell’immagine ascolta (ovvero rimane in attesa di una richiesta http) sulla porta 8080.
Scriviamo il codice suaccennato in un file che chiameremo simpleWebServer.js e poi mandiamolo in esecuzione con il comando:

node simpleWebServer.js

In realtà il comando non sortirà alcun effetto perché il nostro Web Server rimane in attesa di una richiesta http, quindi fintanto che non gliela inviamo, attende. Quindi se apriamo il browser Internet e andiamo a scrivere:

localhost:8080

otteniamo nella finestra del browser stesso la stringa Hello World! che è ciò che lo script prevede.
Vedete quindi con poche semplici istruzioni abbiamo messo in funzione un server e questo ci dà già un'idea di quello che possiamo fare con questo ambiente di sviluppo, che possiamo considerare modulare.

Node.js e lo sviluppo modulare

Node.js promuove lo sviluppo di codice modulare: un modulo e unità di codice che fornisce funzioni e oggetti da utilizzare in un'applicazione; abbiamo visto nell’esempio appena proposto che in cima al modulo avevamo inserito questo comando:

var http = require('http');

utilizzando require(),che è una funzione che permette di includere un modulo. In questo caso stiamo chiedendo all'ambiente di includere il modulo http, ossia quel modulo che ci consente di gestire le chiamate http; nel caso specifico, la relativa funzione restituisce un oggetto e questo oggetto lo possiamo utilizzare all'interno della nostra applicazione richiamando i vari metodi.
Questo è l'approccio standard in Node.js, ossia un approccio che è stato introdotto da Node.js quando ancora mancava un costrutto modulare standard per JavaScript; l’approccio modulare è stato introdotto a partire dal 2015 in JavaScript.
Il comando require() è stato quindi voluto per poter importare moduli all'interno delle applicazioni. Nelle versioni più recenti esiste l'istruzione Import, che però allo stato attuale non è direttamente utilizzabile in un'applicazione Node.js se non a partire la versione 10.
L’utilizzo dell’istruzione Import nell’esempio del Web Server, al posto di require() sarebbe stato questo:

import http from 'http';

Diciamo che attualmente Import è in fase sperimentale, per cui continuiamo, in questa trattazione, a utilizzare require() quando dobbiamo importare moduli.
L’esempio che abbiamo fatto importava il modulo http e forniva funzionalità per gestire il protocollo http; Node.js ci offre diverse moduli predefiniti. Di seguito vedete una tabella che ne riporta l’elenco.

Tra i moduli trovate funzionalità che consentono di gestire la crittografia, di gestire gli eventi, l'accesso al file-system, gestione del parsing in streaming, compressione e decompressione dei file ecc., quindi diciamo che abbiamo insieme di funzionalità che ci consentono di gestire le funzioni tipiche delle attività di gestione web.
Per vedere un esempio di come utilizzare insieme più moduli in un’applicazione andiamo a proporre un ulteriore script: questa volta è un passo in più rispetto a prima perché si tratta di un Server per pagine statiche e quindi non risponde sempre la stessa cosa a qualunque chiamata, ma consente di servire un sito web statico.
Questo è il codice semplificato di tale Web Server:

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

http.createServer(function (request, response) {
…
}).listen(8080);
console.log('Server running at http://127.0.0.1:8080/');

Come vedete, ascoltiamo sempre sulla porta 8080, quindi ora andiamo a vedere come interagire con questo Web Server.
In cima al codice abbiamo l'importazione del modulo http come abbiamo visto nell'esempio precedente, poi abbiamo l'importazione del modulo fs per la gestione del file-system e l'importazione del modulo path, che ci consente di gestire i percorsi di un file-system e quindi di elaborare il percorso in maniera semplice.
Vediamo anche impiegato il metodo createServer dell’oggetto http e all'interno della funzione che passiamo a questo metodo, vediamo che viene analizzato l’URL passato nella richiesta e nel caso di nessun nome di file passato nell’URL sottintendiamo che venga chiamata la pagina index.htm. Altrimenti c'è uno switch che in base all'estensione del file richiamato, prepara il corretto contenuto da inviare al browser in modo che il browser sappia come interpretare il file inviato dal server.
Poi abbiamo, come mostrato nel codice più esteso visibile nell’immagine seguente, la funzione read file, la quale tramite l’oggetto fs che ci consente di accedere al file-system, ci permette di andare a leggere il contenuto di un file, che poi andiamo a restituire direttamente allo stream di cui il browser è in attesa.

Andiamo a vedere come interagire con questo server, il cui file abbiamo salvato come staticWebServer.js, impartendo il comando:

node staticWebServer.js

Aprendo il browser è possibile interagire con il server, impartendo il solito comando:

localhost:8080

che ne apre il sito, il quale stavolta mostra file immagine ed altri contenuti, che sono quelli definiti con le istruzioni contenute nella porzione di codice riportata nell’immagine seguente:

Ogni contentType definisce il file da mostrare, che può essere testo o script Java, immagine (con dopo la slash (/) il formato dell’immagine stessa ecc.

Se dobbiamo esporre un'applicazione all'accesso pubblico su Internet, nulla cambia rispetto all'uso standard di un'applicazione web, cioè come con un qualsiasi altro ambiente come Apache, abbiamo un web server che fa da tramite tra le pagine statiche e l'esterno. Nell’esempio del Web Server che abbiamo creato tramite JavaScript, dobbiamo soltanto avere la disponibilità di un indirizzo IP pubblico che viene mappato sulla porta (potrebbe la porta 80) che mettiamo a disposizione all'interno della nostra macchina, quindi l’esporre a un indirizzo pubblico in un'applicazione web con Node.js non ha nulla di speciale rispetto alle altre applicazioni: l'unica cosa in più che ha è che non necessita di un server, perché il Web Server viene creato direttamente con con JavaScript.

Esiste una differenza tra i Web Server creati con Node.js e quelli sviluppati ad esempio con Apache e Nginx, i quali sono più efficienti perché il loro compito è fare da Web Server, però sono meno efficienti nell’esecuzione di codice, perché in realtà non eseguono codice ma si appoggiano su esecutori esterni.
Il fatto che come esempio abbiamo proposto un Web Server non implica che abbia senso creare un Web Server con Node.js. Il vantaggio che può avere la cosa è il controllo su cosa andrà a fare il Web Server, però dobbiamo avere le competenze per poter gestire il protocollo http, perché il compito non è assolto in automatico dall’ambiente; lo svantaggio è che potremmo avere una minore efficienza rispetto a un Web Server puro come Ngnix o Apache.

Creare un modulo in Node.js

Negli esempi fatti sinora abbiamo utilizzato moduli standard, già pronti e forniti insieme all'ambiente Node.js, ma possiamo crearci il nostro modulo semplicemente creando un file contenente le funzioni che vogliamo utilizzare e inserendo in fondo al file l'espressione module.exports e assegnando a questa proprietà un oggetto con l'elenco delle funzioni che vogliamo esportare.
Un esempio di modulo creato da noi è il seguente:

function somma(a, b) {
return return a + b;
};

module.exports = {
somma
};

Praticamente in questo caso abbiamo definito la funzione somma() e in fondo abbiamo definito che il modulo abbia assegnata, tramite model.exports, una proprietà che è un metodo somma. Naturalmente soltanto quello che assegniamo alla proprietà export dell'oggetto modulo verrà visto al di fuori di questo file, quindi se definiamo una seconda funzione ma non la inseriamo tra gli elementi da esportare, detta funzione rimane privata.
Vediamo un esempio di cosa accade con la funzione somma() modificando il nostro file del Web Server e scrivendovi il codice mostrato nell’immagine seguente:

Eseguiamo il Web Server con aggiunto il modulo somma, andiamo sul browser e apriamo la porta 8080 con il solito localhost: 8080 e in questo caso nella pagina ci appare:

Hello World! La somma di 5 e 7 = 12

Importare un modulo in Node.js

Questo modulo che abbiamo creato, così come qualsiasi altro, possiamo importarlo utilizzando sempre la funzione require() come in questo esempio:

var dt = require('./modulo');

Se confrontate questo esempio con quelli fatti in precedenza, come:

var path = require('path');

notate una piccola differenza, cioè mentre prima avevamo indicato direttamente il nome del modulo (‘path’ oppure ‘fs’ ecc.) in questo caso abbiamo scritto il percorso relativo al modulo da importare, ossia ‘./modulo’.
Fare ciò è importante perché se definiamo un percorso di ricerca, Node.js cerca il file del modulo seguendo quel percorso, mentre se non mettessimo un percorso, andrebbe a cercare tra i moduli di sistema.
Questo significa che se scriviamo tra parentesi il nome del modulo senza il relativo percorso di ricerca, Node.js intende che si tratta di un file da cercare nel percorso predefinito di sistema e quindi non troverebbe il nostro modulo; se tale modulo è necessario a un’applicazione, questa non funzionerebbe.

NODE PACKAGE MANAGER (NPM)

Oltre al supporto ai moduli, Node.js ci fornisce anche supporto per pacchetti, cioè unità di codice che sono riutilizzabili in diverse applicazioni; ad esempio immaginiamo di avere creato una serie di funzionalità che ci serve per la nostra applicazione: ebbene, potrebbe essere utile anche per altre applicazioni.
In questo caso possiamo creare un pacchetto che praticamente è una libreria che ha un particolare formato e lo possiamo condividere tra più applicazioni.
La gestione ufficiale dei pacchetti su Node.js è fatta tramite un’utility a riga di comando che si Chiama NPM, ossia Node Package Manager, la quale consente di installare i pacchetti all'interno un'applicazione, di gestire le dipendenze tra pacchetti e di svolgere attività di questo tipo.
NPM gestisce le versioni e le dipendenze tra pacchetti ed attinge ad un repository online (registry.npmjs.com).

Quindi quando andiamo a sviluppare un'applicazione nell'ambiente Node.js abbiamo tre opzioni:

• utilizzare i moduli di sistema;
• usare nostri moduli;
• utilizzare moduli di terze parti attingendo al repository on-line.

Nello sviluppo dell’applicazione possiamo esercitarle tutte e tre, perché una non esclude le altre.
Per la ricerca di moduli di terze parti NPM attinge automaticamente al proprio repository, ma è anche possibile puntare a repository privati, però in tal caso dobbiamo cambiare la configurazione predefinita.

L’installazione di NPM non prevede un’unica possibilità, ma delle opzioni, ovvero possiamo distinguere tra Installazione in locale e Installazione globale.

NPM: installazione locale

L’installazione locale di un pacchetto è un tipo di installazione che rende disponibile la libreria che scarichiamo dal repository soltanto all'applicazione nella cui cartella ci troviamo.
L’installazione in locale:

• installa un pacchetto e tutte le sue dipendenze nella cartella node_modules;
• permette di utilizzare le librerie installate tramite require();
• è utilizzato per dipendenze dell’applicazione;
• effettua l’impostazione predefinita del sistema.

Quindi se stiamo sviluppando un'applicazione e abbiamo bisogno di un pacchetto perché viene richiesto da una funzione, con l'istallazione locale andiamo a installare questo modulo soltanto per la specifica applicazione; l'effetto che si ottiene quando si installa un pacchetto in modalità locale è che viene creata la cartella “Node Modules” dove vengono inseriti i moduli che costituiscono il pacchetto scaricato, quindi a quel punto col comando require possiamo utilizzarli.
NPM gestisce anche le dipendenze tra i vari pacchetti all'interno dell'applicazione stessa, cioè se abbiamo bisogno di una libreria e questa libreria utilizza a sua volta un’altra libreria, NPM si occupa di scaricare anche le dipendenze indirette, quindi non dobbiamo preoccuparci di capire di cosa abbiamo bisogno per poter utilizzare la libreria stessa, in quanto Node.js avvia un download a catena e alla fine abbiamo tutto quello che ci serve per poter utilizzare le libreria necessarie al nostro sviluppo.
L’installazione in locale si effettua con il comando:

npm install nomeModulo

Se non è stata ancora creata la cartella Node Modules, Node.js provvede a crearla, altrimenti va ad aggiungere i pacchetti scaricati all'interno della cartella esistente.
In generale, il comando npm install permette di installare tutte le dipendenze definite in un file package.json.

NPM: installazione globale

Vediamo adesso l’installazione globale, la quale:

• installa un pacchetto e tutte le sue dipendenze in una cartella di sistema;
• non permette di importare i moduli installati tramite require();
• viene utilizzata per dipendenze dell’ambiente CLI.

Qui l’utilizzo di un pacchetto installato non è legato a una specifica applicazione, ma all'ambiente Node.js; di solito questo tipo di installazione non riguarda librerie da utilizzare in un'applicazione, perché non possiamo importare tramite i moduli tramite require().
Serve invece per aggiungere funzionalità all'ambiente Node.js, quindi per aggiungere funzionalità di riga di comando.
Per eseguire l’installazione globale bisogna impartire il comando:

npm install nomeModulo -g

Ora va detto che sei in un'applicazione abbiamo diverse dipendenze, dobbiamo eseguire npm install per ogni pacchetto, quindi se abbiamo un applicazione che utilizza tre librerie dovremmo fare npm install tre volte. Fino a quando sono poche, questo può essere fatto manualmente, ma se la nostra applicazione richiede decine di pacchetti, la cosa diventa un po' più difficile da gestire; tra l'altro, se immaginiamo di dover fornire la nostra applicazione a un collega perché bisogna lavorarci in più persone, al collega dovremmo anche indicare qual è l'elenco dei pacchetti da installare per poter utilizzare l'applicazione, il che diventa un pochino complesso. Per cui diciamo che l'uso interattivo di npm install non è così pratico.

Per evitare tali problemi NPM ci offre la possibilità di definire un file denominato package.json, in cui vengono descritte le proprietà di un progetto, incluse le dipendenze; quello che vedete qui di seguito è un esempio di package.Json.

{
"name": "Test",
"version": "1.0.0",
"description": "Questo è un esempio di progetto",
"main": "index.js",
"scripts": {
"test": "test.js"
},
"author": "Andrea Chiarelli",
"license": "ISC",
"dependencies": {
"express": "^4.16.3"
}
}

Vedete che riporta informazioni del tipo il nome e la versione dell’applicazione, una descrizione, l’entry-point dell’applicazione (in questo caso index.js), l'autore, la licenza e poi abbiamo una voce che indica le dipendenze: qui avremo uno o più dipendenze che rappresentano le librerie che l’applicazione utilizza.

Una volta che abbiamo un progetto con file package.json, tutto quello che dobbiamo fare per installare tutte le dipendenze è eseguire npm install, quindi Node.js va a leggere il file e installa automaticamente tutte le librerie che trova al suo interno.

Quando dobbiamo creare una nuova applicazione possiamo creare interattivamente il file package.json possiamo farlo manualmente, creando un file di testo e andando a scrivere le varie voci, oppure possiamo utilizzare NPM per chiedere al sistema di aiutarci a creare tale file.

Gestire il file package.json

Vediamo come utilizzare tale strumento: portiamoci in una cartella vuota dove vogliamo creare il progetto e avviamo la creazione con il comando:

npm init

che avvia una sessione interattiva dove Node.js chiede di definire innanzitutto il nome del progetto. Dunque, npm init consente di creare interattivamente un file package.json.
Nello scrivere il nome del file e gli altri parametri che verranno richiesti ricordate che non è consentito l’utilizzo di lettere maiuscole (capital letters).
Definito il nome file, dovete specificare la versione del pacchetto (tra parentesi tonde viene posto un valore predefinito, per cui se non lo modifichiamo verrà assegnato quello, che è 1.0.0), scrivere una descrizione, l’entry-point dell’applicazione, poi il comando per l'esecuzione, ossia il comando che potrebbe servirci per lanciare la nostra applicazione (possiamo lasciare vuoto il campo corrispondente), l’eventuale repository che vogliamo assegnare alla nostra applicazione, eventuali parole chiave (keywords), l'autore e l’eventuale licenza.
Ogni volta che definiamo un campo confermiamo con il tasto OK e passiamo al successivo; dopo l’ultimo OK ci viene mostrato a video un esempio di json (è proposto nella figura seguente, che riporta l’intero processo di creazione di package.json) che verrà inserito all'interno del file.

Se il file proposto ci sta bene, alla domanda “is this OK?” rispondiamo Y (yes) e diamo Invio: vedremo che all'interno della cartella apparirà il file package.json col contenuto che abbiamo appena visto.

A questo punto possiamo vedere cosa fare se per la nostra applicazione abbiamo bisogno di un pacchetto scritto da terze parti; proponiamo un esempio di installazione del pacchetto express, il quale è una libreria che consente di avere funzione avanzate per la realizzazione di applicazioni web rete.
L'istallazione avviene con il comando:

npm install express

che avvia lo scaricamento del pacchetto e mi verrà creata la cartella node_modules e tutto funzionerà correttamente come ci aspettiamo.
Se però desideriamo che venga anche aggiornato il file package.json per aggiungere questa dipendenza, al comando dobbiamo aggiungere il flag -save. In generale, se in ogni momento avessimo bisogno di integrare il set di moduli, dobbiamo farlo con il comando:

npm install nomeModulo -save

che permette di aggiungere dipendenze in un file package.json. Nel caso di express, il comando diverrebbe:

npm install express -save

Impartendolo, Node.js contatta il repository e scarica il pacchetto express, poi va ad aggiornare tutto nella cartella node_modules, aggiungendo le relative cartelle e sottocartelle dove abbiamo, oltre a express, tutte le dipendenze utilizzate.
Ogni volta che facciamo un aggiornamento dell'ambiente, viene scaricata la versione più recente.

Che tipo di applicazione possiamo sviluppare?

Ora che conosciamo abbastanza di Node.js vediamo che applicazioni possono essere sviluppate utilizzandolo; ebbene, Node.js è l’ambiente di riferimento per sviluppare applicazioni con framework moderni come, ad esempio, React, Angular. Quindi consente di automatizzare buona parte delle attività: dalla compilazione del codice JavaScript al deploy, alla nidificazione e così via. In questi casi diciamo che Node.js viene utilizzato come ambiente di sviluppo.
Quando si utilizzano React (o Angular, oppure altri framework abbastanza recenti), il motivo non è tanto legato a React, ma alle versioni più recenti di JavaScript, che introducono una serie di novità tra cui le classi e la creazione del supporto di moduli tramite Import; questo fa sì che si possa incorrere in problemi di compatibilità con i browser più vecchi.
In situazioni del genere abbiamo bisogno di fare una transfilazione, ossia una compilazione da JavaScript più recente a versioni meno recenti e per fare questo abbiamo bisogno di un transpiler che ci trasformi il codice che usa classi in un codice JavaScript alla vecchia maniera; quindi o eseguiamo il transpiler da riga di comando, oppure utilizziamo dei Tool come Webpack o Babel (che sono dei compilatori) quindi un ambiente integrato all'interno del quale possiamo concentrarci soltanto sulla creazione dell'applicazione con React o Angular e l’ambiente lancia automaticamente un comando che ci trasforma il nostro codice in codice compatibile con le vecchie versioni dei browser.
In più possiamo aggiungere funzionalità tipo nidificazione, ottimizzazione cose di questo tipo quindi diciamo che Node.js serve essenzialmente da automazione dell'attività di building.

Altri tipi di applicazioni che possiamo realizzare sono Web API che rispondono in maniera efficiente alle richieste di applicazioni mobile oppure di client Single Page Application; altro utilizzo che possiamo fare di Node.js è creare nuovi tool da riga di comando, come per esempio Generator oppure Gulp, che è un Task Runner (ossia un esecutore di codice) però scritti con JavaScript.

Node.js consente di creare applicazioni desktop multipiattaforma; infatti una nuova generazione di applicazioni che sta emergendo sono quelle applicazioni desktop multipiattaforma basate su Node; ad esempio grazie a framework come Electron possiamo creare applicazioni desktop multipiattaforma, come ad esempio Visual Studio Code, Slack e WhatsApp Desktop sono tutte applicazioni che contengono Node.js, quindi applicazioni scritte con JavaScript HTML e CSS con all'interno Node.js.

Node.js non supporta nativamente i database, ma può utilizzarli previa installazione di appositi pacchetti; in linea di massima si tende a utilizzare all'interno dello stack Node.js dei database non relazionali, come ad esempio Mongo DB, che tra l'altro è un database basato su JavaScript, tanto che usa Java Script anche per eseguire le interrogazioni. Ma esistono anche delle librerie che permettono di interfacciarsi anche con altri database e con mySQL, per esempio.

Perché utilizzare node.js?

La domanda è quasi d’obbligo, ma già buona parte della risposta può essere dedotta da quanto spiegato sinora.
Se non bastasse, ricordiamo che uno dei motivi è che con esso abbiamo lo stesso linguaggio in qualsiasi ambiente e sistema operativo; tra l'altro si tratta dello stesso linguaggio di sviluppo di applicazioni web sia lato browser, sia lato server.
Poi abbiamo gratis il supporto multipiattaforma, un’elevata efficienza per le applicazioni interattive grazie al modello di elaborazione implementato da Node.js.
Ultimo motivo è che utilizzando Node.js abbiamo qualcosa come 650.000 pacchetti pronti all'uso grazie a NPM.
Ricordiamo che con Node.js non si può utilizzare il codice scritto in un altro linguaggio di scripting, perché Node.js interpreta JavaScript, quindi non possiamo utilizzare altri linguaggi; se dobbiamo farlo abbiamo bisogno di un transpiler. Node.js è un runtime Java Script, quindi esegue codice Java.