10 concetti JavaScript che ogni sviluppatore Node.js deve padroneggiare

Rahul Mhatre è un responsabile del team di sviluppatori presso Software AG.

Con JavaScript e il motore V8 al centro, un'architettura basata sugli eventi e una scalabilità immediata, Node.js è diventato rapidamente lo standard de facto per la creazione di applicazioni Web e prodotti SaaS. I framework Node.js come Express, Sails e Socket.IO consentono agli utenti di avviare rapidamente le applicazioni e concentrarsi solo sulla logica aziendale.

Node.js deve molto a JavaScript per la sua enorme popolarità. JavaScript è un linguaggio multiparadigma che supporta molti diversi stili di programmazione, inclusa la programmazione funzionale, la programmazione procedurale e la programmazione orientata agli oggetti. Consente allo sviluppatore di essere flessibile e di sfruttare i vari stili di programmazione.

Ma JavaScript può essere un'arma a doppio taglio. La natura multiparadigma di JavaScript significa che quasi tutto è mutabile. Pertanto, non è possibile ignorare la probabilità di mutazione dell'oggetto e dell'ambito durante la scrittura del codice Node.js. Poiché JavaScript manca dell'ottimizzazione delle chiamate tail (che consente alle funzioni ricorsive di riutilizzare gli stack frame per le chiamate ricorsive), è pericoloso usare la ricorsione per iterazioni di grandi dimensioni. Oltre a insidie ​​come queste, Node.js è a thread singolo, quindi è imperativo per gli sviluppatori scrivere codice asincrono.

JavaScript può essere un vantaggio se usato con cautela o una rovina se sei sconsiderato. Seguire regole strutturate, modelli di progettazione, concetti chiave e regole pratiche di base ti aiuterà a scegliere l'approccio ottimale a un problema. Quali concetti chiave dovrebbero comprendere i programmatori di Node.js? Di seguito condividerò i 10 concetti JavaScript che ritengo siano essenziali per scrivere codice Node.js. efficiente e scalabile.

Video correlato: suggerimenti e trucchi per Node.js.

In questo video esplicativo, impara diverse tecniche che possono migliorare la tua esperienza di sviluppo di Node.

JavaScript IIFE: espressioni di funzione richiamate immediatamente

Un'espressione di funzione invocata immediatamente (IIFE) è una funzione che viene eseguita non appena viene creata. Non ha alcuna connessione con alcun evento o esecuzione asincrona. È possibile definire un IIFE come mostrato di seguito:

(funzione() {

// tutto il tuo codice qui

// ...

}) ();

La prima coppia di parentesi function(){...}converte il codice racchiuso tra parentesi in un'espressione, mentre la seconda chiama la funzione risultante dall'espressione. Un IIFE può anche essere descritto come una funzione anonima autoinvocante. Il suo utilizzo più comune è limitare l'ambito di una variabile creata tramite varo incapsulare il contesto per evitare conflitti di nome.

Chiusure JavaScript

Una chiusura in JavaScript è una funzione interna che ha accesso all'ambito della sua funzione esterna, anche dopo che la funzione esterna ha restituito il controllo. Una chiusura rende private le variabili della funzione interna. Di seguito è riportato un semplice esempio di chiusura:

var count = (function () {

    var _counter = 0;

    funzione di ritorno () {return _counter + = 1;}

}) ();

contare();

contare();

contare();

> // il contatore ora è 3

Alla variabile countviene assegnata una funzione esterna. La funzione esterna viene eseguita una sola volta, il che imposta il contatore su zero e restituisce una funzione interna. La _countervariabile è accessibile solo dalla funzione interna, che la fa comportare come una variabile privata.

Prototipi JavaScript

Ogni funzione JavaScript ha una proprietà prototipo che viene utilizzata per allegare proprietà e metodi. Questa proprietà non è enumerabile. Consente allo sviluppatore di collegare metodi o funzioni membro ai propri oggetti. JavaScript supporta l'ereditarietà solo tramite la proprietà prototype. In caso di un oggetto ereditato, la proprietà prototype punta al genitore dell'oggetto. Un approccio comune per associare metodi a una funzione consiste nell'utilizzare prototipi come mostrato di seguito:

function Rectangle (x, y) {

    this._length = x;

    this._breadth = y;

}

Rectangle.prototype.getDimensions = function () {

    return {length: this._length, breadth: this._breadth};

};

Rectangle.prototype.setDimensions = function (len, bred) {

    this._length = len;

    this._breadth = allevato;

};

Proprietà private JavaScript, utilizzando chiusure

JavaScript consente di definire proprietà private utilizzando il prefisso di sottolineatura come mostrato nell'esempio precedente. Tuttavia, ciò non impedisce a un utente di accedere o modificare direttamente una proprietà che dovrebbe essere privata.

La definizione di proprietà private utilizzando le chiusure ti aiuterà a risolvere questo problema. Le funzioni membro che richiedono l'accesso a proprietà private dovrebbero essere definite sull'oggetto stesso. Puoi creare proprietà private utilizzando chiusure come mostrato di seguito:

function Rectangle (_length, _breadth) {

     this.getDimensions = function () {

     return {length: _length, breadth: _breadth};

     };

     this.setDimension = function (len, bred) {

     _length = len;

    _breadth = allevato

    };

}

Pattern del modulo JavaScript

Il pattern Module è il design pattern più frequentemente utilizzato in JavaScript per ottenere un codice ben strutturato e liberamente accoppiato. Ti consente di creare livelli di accesso pubblici e privati. Di seguito è illustrato un modo per ottenere un modello di modulo:

var Direction = (function () {

  var _direction = 'avanti'

  var changeDirection = function (d) {

          _direction = d;

  }

  return {setDirection: function (d) {

          changeDirection (d);

          console.log (_direction);

          }

  };

}) ();

Direction.setDirection ('backward'); // Uscite: "indietro"

console.log (Direction._direction);

Il pattern Revealing Module è simile al pattern Module in cui le variabili ei metodi che devono essere esposti vengono restituiti in un oggetto letterale. L'esempio sopra può essere scritto utilizzando il modello Revealing Module come segue:

var Direction = (function () {

  var _direction = 'forward';

  var _privateChangeDirection = function (d) {

_direction = d;

  }

  ritorno {

          setDirection: _privateChangeDirection

  };

}) ();

Sollevamento JavaScript

JavaScript sposta le variabili e le dichiarazioni di funzione all'inizio del loro ambito prima dell'esecuzione del codice. Questo si chiama sollevamento. Indipendentemente da dove si inserisce la dichiarazione di funzioni e variabili nel codice, vengono spostate all'inizio del loro ambito dall'interprete. Questo può essere o meno dove li vuoi. In caso contrario, il programma presenterà errori.

Le dichiarazioni di variabili vengono elaborate prima dell'esecuzione di qualsiasi codice. Ironia della sorte, le variabili non dichiarate non esistono finché non viene assegnato un valore. Ciò fa sì che tutte le variabili non dichiarate diventino variabili globali. Sebbene le dichiarazioni di funzione siano sollevate, le espressioni di funzione non vengono sollevate. JavaScript ha un ordine di priorità durante il sollevamento di variabili e funzioni.

La priorità è data di seguito da maggiore a minore:

  • Assegnazione variabile
  • Dichiarazione di funzione
  • Dichiarazioni variabili

Per evitare bug, dovresti dichiarare le tue variabili e funzioni all'inizio di ogni scope. 

JavaScript currying

Il curry è un metodo per rendere le funzioni più flessibili. Con una funzione curry, puoi passare tutti gli argomenti che la funzione si aspetta e ottenere il risultato, oppure puoi passare solo un sottoinsieme di argomenti e ricevere indietro una funzione che attende il resto degli argomenti. Di seguito viene fornito un semplice esempio di curry:

var myFirstCurry = function (word) {

  funzione di ritorno (utente) {

            return [parola, ",", utente] .join ("");

  };

};

var HelloUser = myFirstCurry ("Hello");

HelloUser ("Rahul"); // Output: "Hello, Rahul"

La funzione curry originale può essere chiamata direttamente passando ciascuno dei parametri in un insieme separato di parentesi uno dopo l'altro come mostrato di seguito:

myFirstCurry ("Hey, wassup!") ("Rahul"); // Output: "Hey, wassup !, Rahul"

JavaScript applica, chiama e associa metodi

E 'imperativo per qualsiasi sviluppatore JavaScript per capire la differenza tra i call, applye bindmetodi. Le tre funzioni sono simili in quanto il loro primo argomento è sempre il valore "this", o contesto, che si desidera assegnare alla funzione su cui si sta chiamando il metodo.

Dei tre, callè il più semplice. È lo stesso che invocare una funzione specificandone il contesto. Ecco un esempio:

var user = {

     nome: "Rahul Mhatre",

     whatIsYourName: function () {

     console.log (this.name);

     }

};

user.whatIsYourName (); // Risultato: "Rahul Mhatre",

var user2 = {

     nome: "Neha Sampat"

};

user.whatIsYourName.call (user2); // Uscita: "Neha Sampat"

Nota che applyè quasi uguale a call. L'unica differenza è che si passano gli argomenti come un array e non separatamente. Gli array sono più facili da manipolare in JavaScript, aprendo un numero maggiore di possibilità per lavorare con le funzioni. Ecco un esempio che utilizza applye call:

var user = {

     salutare: "Ciao!",

     GreetUser: function (userName) {

     console.log (this.greet + "" + userName);

     }

};

var greet1 = {

     greet: "Hola"

};

user.greetUser.call (greet1, "Rahul") // Output: "Hola Rahul"

user.greetUser.apply (greet1, ["Rahul"]) // Output: "Hola Rahul"

Il bindmetodo consente di passare argomenti a una funzione senza richiamarla. Viene restituita una nuova funzione con argomenti delimitati prima di ogni ulteriore argomento. Ecco un esempio:

var user = {

     salutare: "Ciao!",

     GreetUser: function (userName) {

     console.log (this.greet + "" + userName);

}

};

var GreetHola = user.greetUser.bind ({Greet: "Hola"});

var GreetBonjour = user.greetUser.bind ({Greet: "Bonjour"});

greetHola ("Rahul") // Output: "Hola Rahul"

GreetBonjour ("Rahul") // Output: "Bonjour Rahul"

Memoizzazione JavaScript

La memorizzazione è una tecnica di ottimizzazione che accelera l'esecuzione della funzione memorizzando i risultati di operazioni costose e restituendo i risultati memorizzati nella cache quando si verifica di nuovo lo stesso insieme di input. Gli oggetti JavaScript si comportano come array associativi, semplificando l'implementazione della memoizzazione in JavaScript. Ad esempio, possiamo convertire una funzione fattoriale ricorsiva in una funzione fattoriale memoizzata come mostrato di seguito:

function memoizeFunction (func) {

  var cache = {};

  funzione di ritorno () {

          chiave var = argomenti [0];

          if (cache [key]) {

          restituisci cache [chiave];

          }

          altro {

          var val = func.apply (this, arguments);

          cache [chiave] = val;

          return val;

          }

  };

}

var fibonacci = memoizeFunction (function (n)

  ritorno (n === 0);

Sovraccarico del metodo JavaScript

Il sovraccarico dei metodi consente a più metodi di avere lo stesso nome ma argomenti diversi. Il compilatore o l'interprete determina quale funzione chiamare in base al numero di argomenti passati. Il sovraccarico del metodo non è supportato direttamente in JavaScript. Ma puoi ottenere qualcosa di molto simile come mostrato di seguito:

function overloadMethod (object, name, fn) {

     if (! object._overload) {

    object._overload = {};

     }

     if (! object._overload [nome]) {

    object._overload [nome] = {};

    }

     if (! object._overload [nome] [fn.length]) {

object._overload [nome] [fn.length] = fn;

    }

     oggetto [nome] = funzione () {

         if (this._overload [name] [arguments.length])

         restituisci this._overload [nome] [argomenti.length] .apply (questo, argomenti);

     };

function Students () {

  overloadMethod (this, "find", function () {

          // Trova uno studente per nome

  });

overloadMethod (this, "find", function (first, last) {

          // Trova uno studente per nome e cognome

  });

}

var students = new Students ();

students.find (); // Trova tutto

studenti.find ("Rahul"); // Trova gli studenti per nome

students.find ("Rahul", "Mhatre"); // Trova gli utenti per nome e cognome

Man mano che diventi esperto con Node.js, noterai che ci sono molti modi per risolvere quasi tutti i problemi. Ma adottare il giusto approccio è fondamentale. Un approccio sbagliato si tradurrà in molteplici effetti collaterali come applicazioni irregolari o difettose o regressioni che ti costringono a riscrivere l'intera logica. Il rovescio della medaglia, l'approccio giusto getterà le basi per un'applicazione robusta, efficiente e scalabile.

I 10 concetti JavaScript descritti in questo articolo sono le basi che ogni sviluppatore Node.js dovrebbe conoscere. Ma sono la punta dell'iceberg. JavaScript è potente e complesso. Più lo usi, più capirai quanto sia veramente vasto JavaScript. Una migliore comprensione di un linguaggio così ampio ti aiuterà sicuramente a evitare errori. Nel frattempo, ottieni le basi giuste e vedrai ottimi risultati.

Rahul Mhatre è un responsabile del team di sviluppatori presso Software AG. In precedenza è stato architetto tecnico presso Built.io, che è stata acquisita da Software AG. 

-

Il New Tech Forum offre un luogo per esplorare e discutere la tecnologia aziendale emergente in profondità e ampiezza senza precedenti. La selezione è soggettiva, in base alla nostra scelta delle tecnologie che riteniamo importanti e di maggiore interesse per i lettori. non accetta materiale di marketing per la pubblicazione e si riserva il diritto di modificare tutti i contenuti forniti. Invia tutte le richieste a [email protected]