Visualizzazione post con etichetta npm. Mostra tutti i post
Visualizzazione post con etichetta npm. Mostra tutti i post

martedì, dicembre 02, 2014

Impariamo a definire i nostri ravioli .. ehm ... moduli in node.js

Node.js è stato disegnato all'insegno della modularità.
Abbiamo già notato come esista una pletora di moduli utilizzabili da un programma node.js:
basta utilizzare l'istruzione require('nomemodulo') per utilizzare le funzionalità esportate dal modulo.

La piattaforma provvede una serie di moduli inclusi nella distribuzione di base, abbiamo visto ad esempio l'utilizzo del modulo fs o del modulo path

In questo post impariamo a definire i nostri moduli da utilizzare nei nostri programmi, per cercare di programmare utilizzando ravioli e non spaghetti

Una volta definito un modulo, è anche possibile pubblicarlo sul repository ufficiale dei moduli gestiti da npm.

Date un'occhiata alla lista ufficiale di moduli per node disponibili attualmente.

Se vi piace un modulo, basterà eseguire in una shell il comando npm  <nomemodulo> nella cartella radice del progetto che state sviluppando, per poterlo utilizzare con una istruzione di require('nomemodulo') dal vostro codice.

Ad esempio, supponete di aver bisogno della funzionalità di trasformazione dei vostri oggetti json in formato xml: basterà utilizzare il modulo di terze parti che si chiama xml registrato sul repository ufficiale.

Vi posizionate nella cartella del vostro progetto e digitate npm install xml: verrà creata una directory node_modules, all'interno del vostro progettoche contiene i sorgenti del modulo, se un modulo dipende da altri moduli, questi verranno a loro volta scaricati in locale, tutto in maniera semplice e trasparente.

Ogni modulo ufficiale ha una pagina di documentazione come questa in cui ci sono le informazioni su come utilizzarlo.

In questo caso basta scrivere del codice di questo tipo
 var xml = require('xml');  
   
 var xmlString = xml({libri :   
      [  
           {  
                libro: [  
                     {titolo : 'Il signore degli anelli'},   
                     {autore : 'Tolkien'}  
                ],  
           },  
           {  
                libro: [  
                     {titolo: 'Guerra e pace'},  
                     {autore: 'Tolstoj'}  
                ]  
           }  
      ]  
 }, true);  
   
 console.log(xmlString);  
Per ottenere sulla console
 <libri>  
   <libro>  
     <titolo>Il signore degli anelli</titolo>  
     <autore>Tolkien</autore>  
   </libro>  
   <libro>  
     <titolo>Guerra e pace</titolo>  
     <autore>Tolstoj</autore>  
   </libro>  
 </libri>  
I singoli moduli devono essere definiti in un file, il cui nome sarà il nome del modulo, all'interno del file si deve utilizzare una istruzione del tipo module.exports = {}: assegniamo alla proprietà export dell'oggetto globale module un qualsiasi oggetto che definiremo noi, magari una iife per incapsulare dettagli implementativi mediante il meccanismo delle closure.

Facciamo un esempio.
Immaginiamo di implementare un modulo biblioteca che ci permetta di salvare in memoria dei libri e di ottenere la lista attuale dei libri.

Il programma principale utilizza il modulo biblioteca
 var biblioteca = require('./biblioteca');  
   
 biblioteca.inserisciLibro({  
      titolo : "Il signore degli anelli",  
      autore : "Tolkien"  
 });  
   
 biblioteca.inserisciLibro({  
      titolo : "Guerra e pace",  
      autore : "Tolstoj"  
 });  
   
 biblioteca.elaboraLibri(function(error, libri) {  
      if (error)  
           console.log(error.messaggio);  
      else {  
           libri.forEach(function(libro) {  
                console.log("Titolo: " +   
                          libro.titolo +   
                          "- Autore: " +   
                          libro.autore);  
           });  
      }  
 });  
Il modulo biblioteca dovrà essere implementato in un file dal nome biblioteca.js presente nella stessa cartella del file programma.js che rappresenta il programma principale.
 module.exports = (function() {  
      var libri = [],  
          inserisciLibro = function(libro) {  
             libri.push(libro);  
          },  
          elaboraLibri = function(callback) {  
             if (libri.length === 0)  
                callback({messaggio: 'biblioteca vuota'}, null);  
             else  
                callback(null, libri);       
          };  
          
          return {  
             inserisciLibro : inserisciLibro,  
             elaboraLibri : elaboraLibri  
          };  
 })();  
Notate la prima istruzione che assegna a module.exports il risultato di una funzione che viene eseguita immediatamente, tale risultato è un oggetto che espone solo i metodi inserisciLibro ed elaboraLibri.

Notate anche l'utilizzo di una funzione di callback definita in programma.js e passata come argomento a eleboraLibri, tale funzione di callback verrà eseguita solo se non ci sono condizioni di errore (in questo caso rappresentate da una biblioteca vuota).

Ho aggiornato su github il progetto, effettuate un git pull per aggiornare i sorgenti che avete in locale, come mostrato questo post.
Ricordatevi, per il progetto esempio-xml, di posizionarvi nella cartella radice ed eseguire npm install xml per includere il modulo xml nel progetto.

Se avete dubbi e/o domande, commentate!

Alla prox.
Ivan


lunedì, dicembre 01, 2014

Ambiente di sviluppo per node.js

Per anni, sviluppando in java, ho utilizzato ambienti di sviluppo (IDE) come eclipse o netbeans: col tempo sono diventati sempre più pesanti e lenti: ma non se ne puo' fare a meno per lo sviluppo con una tecnologia che prevede la fase di compilazione e tutta una serie di regole su come impachettare gli eseguibili prodotti.

Per sviluppare in node.js, linguaggio interpretato, ho finalmente trovato un ambiente di sviluppo snello, veloce e altamente configurabile: un semplice ma potente editor di testi: Sublime Text 3

Installatelo, non ve ne pentirete, ha una licenza temporanea illimitata, se poi vi piace e lo utilizzerete come faccio io, potrete comprare la licenza e far felice il suo ideatore.

Sublime Text ha una serie di funzionalità veramente comode ed è estendibile tramite dei pacchetti esterni: in questo post vi mostrerò come configurarlo al meglio per sviluppare efficacemente in node.is.

La prima caratteristica che noterete utilizzandolo è la sua velocità, mai più tempi di attesa biblici per aprire o cercare un file.

Sublime text vi farà scordare l'ulizzo del mouse: con semplici scorciatoie da tastiera potrete fare tutto ciò che vi serve, aumentando notevolmente la vostra velocità di programmazione.

Al primo avvio del programma, l'interfaccia utente si presenta così


Tipicamente organizzeremo i singoli progetti node.js in cartelle, la prima cosa da fare è aprire la cartella root del nostro progetto con il comando File -> Open Folder e selezionando la cartella di progetto


Ho aperto la cartella primoesempio contentente i file leggiFile.js e readme.txt: notate come l'editor sia capace di applicare la sintassi colorata a seconda del tipo di estensionde del file che andremo ad aprire.

La prima caratteristica che vi voglio mostrare è la possibilità di utilizzare cursori multipli: supponete di voler cambiare tutte le occorrenze della parola console presente nel file leggiFile.js
  • digitate ctrl + i (ricerca incrementale), poi la parola console e poi <enter>: verrà selezionata la prima occorrenza di console all'interno del file
  • digitate alt + F3 per selezionare tutte le occorrenze di console nel file
  • ora avete 3 cursori attivi in corrispondenza delle tre parole, provate a digitare e tutte le parole verranno modificate allo stesso tempo

Eccellente la ricerca dei file, per nome, all'interno di un progetto. Supponete di avere un progetto con centinaia di files, vi basterra digitare ctrl + p e inserire parte del nome file, otterrete una lista di potenziali file: vi spostate con i tasti cursore e avrete, immediatamente, il file aperto nell'editor.


Altro comando utilissimo ctrl + shift + p, per eseguire qualsiasi comando attivabile dai menu, ad esempio inserite nella combo di ricerca il termine syntax o parte di esso, e comparirà la lista dei comandi per segliere una colorazione per html,css,javascript e così via.

Vediamo ora come configurare il build system per node.js, in modo da attivare l'interprete node.js direttamente dall'editor: scegliete Tools -> Build System -> New Build System ... 



L'editor aprirà un nuovo file di configurazione dal nome untitled.sublime-build, copiate ed incollateci il seguente frammento di configurazione

 {  
   "cmd": ["node", "$file", "$file_base_name"],  
   "working_dir": "${file_path}",  
   "selector": "*.js"  
 }  

Digitate ctrl + s per salvare il file, si aprirà una finestra di dialogo per sceglire un nome: per convenzione, chiamate il file Node.sublime-build e lasciatelo nella posizione scelta dall'editor.

Se ora provate a selezionare nuovamente Tools -> Build System comparirà il nuovo build system associato a Node, selezionatelo e potrete eseguire qualunque programma node.js presente in un file, digitando ctrl + b.

Per far funzionare il nuovo build system, occorre preventivamente installare node.js e mettere nel path di sistema la cartella degli eseguibili di node.js, ma credo e spero che, a questo punto, lo abbiate già fatto.

La parte in cui eccelle Sublime Text è la possibilità di aggiungere funzionalità aggiuntive direttamente da un repository centralizzato accessibile in rete.

Per poter intallare un package aggiuntivo, bisogna però prima installare il package manager tramite  una provedura una tantum che ci permetterà, in seguito, di installare qualsiasi nuovo package in una manciata di secondi.

Per installare il package manager seguite le istruzioni presenti su questa pagina: si tratta di copiare ed incollare il codice ivi presente (occhio a selezionare il codice per Sublime Text 3) nella console di Sublime Text attivabile con View -> Show Console.

Riavviate l'editor e provate a digitare ctrl + shift + p inserendo la parola package, o parte di essa, nella combo di ricerca: se avete eseguito correttamente la procedura precedente, dovreste avere a disposizione una serie di comandi aggiuntivi per, ad esempio, installare un nuovo package


Vi propongo ora  una serie di package aggiuntivi molto utili.

Il primo, SublimeLinter, permette di avere un controllore sintattico per il linguaggio javascript, in modo da renderci immediatamente conto di errori di sintassi nel programma.

L'utilizzo di questo package, presuppone l'esistenza sul nostro sistema, di un modulo aggiuntivo di node.js, che si chiama, jshint, che deve essere installato a livello globale con npm: aprite una shell e digitate il seguente comando npm install -g jshint.

Ora, tramite Sublime Text, digitate ctrl + shift + p, inserite install nella combo di ricerca fino a trovate e selezionare la voce Package Controll: Install Package, dopo un paio di secondi verrà caricata una lista di package presenti nel repository centralizzato, inserite la parola SublimeLinter fino a trovare e selezionare il pacchetto SublimeLinter; come ultimo passo, ripetete la procedura per installare un secondo pacchetto che si chiama SublimeLinter-jshint.

Se ora provate a scrivere del codice js con degli errori, talli errori verranno evidenziati dal package appena installato: comodo ed efficace, in questo esempio ho definito una variabile a senza inserire il punto e virgoala, sublime linter mi indica l'errore con un pallino giallo in corrispondenza dell'istruzione e con una coppia di parentesi quadre nel punto in cui dovrebbe esserci il punto e virgola


Per cambiare lo stile dei messaggi di SublimeLinter digitate ctrl + shift + p ,cercate e selezionate il comando SublimeLinter: Choose Gunter Themes, selezionate uno qualsiasi dei temi che compariranno nella successiva lista.

Altro modulo molto utile è il modulo di git, che ci permetteràà di eseguire i comandi di git dall'interno dell'ambiente.

Con la stessa procedura, digitate ctrl + shift + p, inserite install nella combo di ricerca fino a trovate e selezionare la voce Package Controll: Install Package, dopo un paio di secondi verrà caricata una lista di package presenti nel repository centralizzato, inserite la parola Git fino a trovare e selezionare il package Git.

Riavviate l'editor e se avete letto e seguito le istruzioni di questo post, dovreste avete da qualche parte sul vostro file system la cartella passionejavascript contenente tutti gli esempi del blog : apritela in Sublime Text con il comando File -> Open Folder.

Se adesso digitate ctrl + shift + p e poi git, avete una lista di comandi git da poter eseguire a livello di cartella di progetto: selezionata git pull per aggiornare in futuro tutti file che metterò sul repository centralizzato.

Per una lista dei migliori package presenti per sublime text, vi rimando a questa pagina: se ve ne piace qualcuno, installatelo così come vi ho mostrato.

Siamo pronti ora a sviluppare seriamente con un ambiente di sviluppo snello e potente.

Alla prox.
Ivan

venerdì, novembre 28, 2014

Signore e signori: node.js

Questo post sarà il primo di una lunga serie per scoprire node.js, una piattaforma di sviluppo basata sul linguaggio javascript.
Tutto ciò che abbiamo imparato fino ad ora è ovviamente propedeutico al suo utilizzo.

Come si recita nella home page di node.js:

Node.js è una piattaforma, costruita sul runtime scripting di Chrome, per costruire applicazioni di rete veloci e scalabili. Node.js usa un modello guidato dagli eventi, non bloccante, che lo rende leggero ed efficiente, perfetto per applicazioni real time che devono essere eseguite attraverso device distibuiti.

Al di là di un po' di fuffa da mercante, immaginate di prendere l'ambiente di esecuzione degli script di Chrome,di renderlo indipendente dal browser, di condirlo con un po' di tools di sviluppo a corredo, di renderlo open source: ecco che dopo un pò, la comunità degli smanettoni presente in rete ha cominciato a sviluppare una miriade di moduli per node.js: cioè oggetti javascript che espongono funzionalità tipicamente utili che possiamo utilizzare al volo nei nostri programmi.

Come primo passo, installiamo la piattaforma sul nostro pc, andate alla pagina di download  e scaricate e installate la distribuzione più consona al vostro pc.

Aggiungete al path di sistema la cartella in cui è presente l'interprete node (node.exe per sistemi windows), aprite una nuova shell e digitate node -v per testare l'installazione: se è andato tutto bene dovreste visualizzare un messaggio del tipo: v.0.10.28, che rappresenta la versione della piattaforma installata.

L'eseguibile node è un interprete javascript, è possibile usarlo in maniera interattiva mandandolo in esecuzione senza parametri


Vi basterà, dopo che compare il prompt '>', introdurre le istruzioni terminate con il ';' e battere <Enter> per eseguirle.

Non è ovviamente molto comodo da utilizzare, molto meglio creare un file con estensione .js (ad esempio mioProgramma,js) e darlo in pasto all'interpre con il comando node mioProgramma.js

Node.js è stato implementato seguendo il principio della modularità, un modulo di node.js è un oggetto js che sa fare molto bene uno specifico compito: i nostri programmi tipicamente utilizzano altri moduli per portare a terminie il compito che si prefiggono.

La piattaforma node.js ha una serie di moduli compresi nell'installazione, ad esempio il modulo fs serve ad interagire con il fyle system, per la lista completa degli oggetti globali (disponibili in ogni modulo) e la lista dei moduli basta dare un'occhiata alla pagina ufficiale delle api di node, sono molto ben fatte con esempi di utilizzo per ogni funzionalità a disposizione.

Ma la forza della piattaforma è data dalla possibilità di implementare moduli aggiuntivi che sono facilmente distribuibili e utilizzabili nei nostri programmi.

La piattaforma node.js comprende un applicativo per gestire i moduli installati sulla nostra macchina, l'applicazione si chiama npm che sta per node package manager, che ci permetterà di installare o rimuovere moduli aggiuntivi.

I moduli possono essere installati a livello globale e in tal modo saranno disponibili da qualsiasi programma che andremo a sviluppare, oppure possono essere installati a livello di progetto, e in tal modo saranno disponibili solo per il progetto in questione.

Per avere una lista dei moduli installati a livello globale, eseguite il comando npm -g list, vi comparirà una vista ad albero dei moduli installati con le relative dipendenze.

Per cominciare, vediamo un esempio di programma che utilizza uno dei moduli compresi nella piattaforma

 var fs = require('fs');  
 fs.readFile('readme.txt', {encoding: 'utf8'}, function(err,data) {  
   if (err) {  
    console.log('errore in lettura file');  
   }   
   else {  
     console.log(data);  
   }  
 });  
 console.log('Prima io!');  

Per utilizzare un modulo, bisogna utilizzare la funzione globale require, passando come parametro il nome del modulo che si vuole utilizzare, in questo caso il modulo fs.

Tipicamente la funzione require restituisce un oggetto che andremo a memorizzare in una variabile, in questo caso fs.

L'oggetto fs, tra i tanti metodi, ha il metodo readFile che permette di leggere il contenuto di un file, in questo caso il file readme.txt , codificato in utf8, che deve essere presente nella stessa directory di esecuzione del programma.

Notate la natura asincrona di questo metodo, il terzo parametro è la funzione di callback che verrà eseguita non appena il file è stato caricato completamente in memoria: il metodo non è bloccante.

La piattaforma include anche la versione sincrona, readFileSync, che per motivi di efficienza va chiaramente evitata, specialmente se i file da elaborare sono molto grandi.

Per eseguire questo programma

  • create un file ProgrammaLettutaFile.js e copiateci dentro il codice
  • create nella stessa cartella un file readme.txt, con codifica utf8, e scriveteci dentro ciò che vi pare
  • eseguite il programma con il comando node ProgrammaLettutaFile.js
Il programma stamperà  il contenuto del file a video: secondo voi stamperà prima contenuto del file o 'Prima io!' ?

Abbiamo appena cominciato la nostra avventura in node.js, c'è ancora tanto da imparare, lo faremo un post alla volta :).

Su github ho aggiornato gli esempi. Rimando a questo post i dettagli su come accedere a github per ottenere in locale i sorgenti.

Usate i commenti per eventuali problemi o dubbi!

Alla prox.
Ivan