Programmering

10 JavaScript-koncepter, som hver Node.js-udvikler skal mestre

Rahul Mhatre er udviklerholdsleder hos Software AG.

Med JavaScript og V8-motoren i centrum, en hændelsesdrevet arkitektur og skalerbarhed ude af kassen, er Node.js hurtigt blevet de facto-standarden til oprettelse af webapplikationer og SaaS-produkter. Node.js-rammer som Express, Sails og Socket.IO giver brugerne mulighed for hurtigt at bootstrap applikationer og kun fokusere på forretningslogikken.

Node.js skylder JavaScript meget for sin enorme popularitet. JavaScript er et multiparadigm-sprog, der understøtter mange forskellige programmeringsstile, herunder funktionel programmering, procedureprogrammering og objektorienteret programmering. Det giver udvikleren mulighed for at være fleksibel og drage fordel af de forskellige programmeringsstile.

Men JavaScript kan være et dobbeltkantet sværd. JavaScript af multiparadigm karakter betyder, at næsten alt er mutabelt. Således kan du ikke børste væk sandsynligheden for objekt- og omfangsmutation, når du skriver Node.js-kode. Da JavaScript mangler optimering af haleopkald (som gør det muligt for rekursive funktioner at genbruge stakrammer til rekursive opkald), er det farligt at bruge rekursion til store iterationer. Ud over faldgruber som disse er Node.js enkeltgevindet, så det er bydende nødvendigt for udviklere at skrive asynkron kode.

JavaScript kan være en velsignelse, hvis den bruges med forsigtighed - eller en bane, hvis du er hensynsløs. At følge strukturerede regler, designmønstre, nøglekoncepter og grundlæggende tommelfingerregler hjælper dig med at vælge den optimale tilgang til et problem. Hvilke nøglebegreber skal Node.js-programmører forstå? Nedenfor deler jeg de 10 JavaScript-koncepter, som jeg mener er mest vigtige for at skrive effektiv og skalerbar Node.js-kode.

Relateret video: Node.js tip og tricks

I denne forklaringsvideo lærer du flere teknikker, der kan forbedre din Node-udviklingsoplevelse.

JavaScript IIFE'er: Straks påkaldte funktionsudtryk

Et straks påkaldt funktionsudtryk (IIFE) er en funktion, der udføres, så snart det oprettes. Det har ingen forbindelse med nogen begivenheder eller asynkron udførelse. Du kan definere en IIFE som vist nedenfor:

(funktion () {

// al din kode her

// ...

})();

Det første par parentes fungere(){...} konverterer koden inden for parenteserne til et udtryk. Det andet par parentes kalder den funktion, der er resultatet af udtrykket. En IIFE kan også beskrives som en selvopkaldende anonym funktion. Dens mest almindelige anvendelse er at begrænse omfanget af en variabel lavet via var eller at indkapsle kontekst for at undgå navnekollisioner.

JavaScript-lukninger

En lukning i JavaScript er en indre funktion, der har adgang til dens ydre funktions rækkevidde, selv efter at den ydre funktion har returneret kontrol. En lukning gør variablerne i den indre funktion private. Et simpelt eksempel på en lukning er vist nedenfor:

var count = (funktion () {

var _tæller = 0;

returfunktion () {return _counter + = 1;}

})();

tælle();

tælle();

tælle();

> // tælleren er nu 3

Variablen tælle er tildelt en ydre funktion. Den ydre funktion kører kun én gang, hvilket sætter tælleren til nul og returnerer en indre funktion. Det _tæller variabel kan kun fås med den indre funktion, hvilket får den til at opføre sig som en privat variabel.

JavaScript-prototyper

Hver JavaScript-funktion har en prototype-egenskab, der bruges til at vedhæfte egenskaber og metoder. Denne egenskab kan ikke tælles. Det giver udvikleren mulighed for at vedhæfte metoder eller medlemsfunktioner til sine objekter. JavaScript understøtter kun arv gennem prototype-egenskaben. I tilfælde af et nedarvet objekt peger prototypeegenskaben på objektets forælder. En almindelig tilgang til at knytte metoder til en funktion er at bruge prototyper som vist nedenfor:

funktion rektangel (x, y) {

denne._længde = x;

denne._bredde = y;

}

Rectangle.prototype.getDimensions = funktion () {

returner {længde: denne._længde, bredde: denne._bredde};

};

Rectangle.prototype.setDimensions = funktion (len, opdrættet) {

this._length = len;

denne._bredde = opdrættet;

};

JavaScript private ejendomme ved hjælp af lukninger

JavaScript giver dig mulighed for at definere private ejendomme ved hjælp af understregerpræfikset som vist i eksemplet ovenfor. Dette forhindrer dog ikke en bruger i at få direkte adgang til eller ændre en ejendom, der formodes at være privat.

Definition af private ejendomme ved hjælp af lukninger hjælper dig med at løse dette problem. De medlemsfunktioner, der har brug for adgang til private ejendomme, skal defineres på selve objektet. Du kan oprette private ejendomme ved hjælp af lukninger som vist nedenfor:

funktion rektangel (_length, _breadth) {

this.getDimensions = funktion () {

returnere {længde: _længde, bredde: _bredde};

     };

this.setDimension = funktion (len, opdrættet) {

_længde = len;

_bredde = opdrættet

    };

}

JavaScript-modulmønster

Modulmønsteret er det hyppigst anvendte designmønster i JavaScript til opnåelse af løst koblet, velstruktureret kode. Det giver dig mulighed for at oprette offentlige og private adgangsniveauer. En måde at opnå et modulmønster er vist nedenfor:

var Retning = (funktion () {

var _direction = 'fremad'

var changeDirection = funktion (d) {

_direction = d;

  }

returnere {setDirection: funktion (d) {

ændre Retning (d);

console.log (_direction);

          }

  };

})();

Direction.setDirection ('bagud'); // Udgange: 'bagud'

console.log (Direction._direction);

Det afslørende modulmønster svarer til modulmønsteret, hvor variablerne og metoderne, der skal eksponeres, returneres i et bogstaveligt objekt. Ovenstående eksempel kan skrives ved hjælp af det afslørende modulmønster som følger:

var Retning = (funktion () {

var _direction = 'fremad';

var _privateChangeDirection = funktion (d) {

_direction = d;

  }

Vend tilbage {

setDirection: _privateChangeDirection

  };

})();

JavaScript-hejsning

JavaScript flytter variabler og funktionserklæringer til toppen af ​​deres anvendelsesområde inden kodeudførelse. Dette kaldes hejsning. Uanset hvor du placerer erklæringen om funktioner og variabler i din kode, flyttes de til toppen af ​​deres rækkevidde af tolken. Dette kan måske ikke være, hvor du vil have dem. Hvis ikke, vil dit program have fejl.

Variable erklæringer behandles, før en kode udføres. Ironisk nok eksisterer ikke deklarerede variabler, før de tildeles en værdi. Dette får alle sort angivne variabler til at blive globale variabler. Selvom funktionserklæringer hejses, hejses ikke funktionsudtryk. JavaScript har en rækkefølge, mens variabler og funktioner hejses.

Prioriteten gives nedenfor fra højere til lavere:

  • Variabel opgave
  • Funktionserklæring
  • Variable erklæringer

For at undgå fejl skal du erklære dine variabler og funktioner i begyndelsen af ​​ethvert omfang.

JavaScript currying

Currying er en metode til at gøre funktioner mere fleksible. Med en curried-funktion kan du videregive alle de argumenter, som funktionen forventer, og få resultatet, eller du kan kun videregive en undersæt af argumenter og modtage en funktion tilbage, der venter på resten af ​​argumenterne. Et simpelt eksempel på en karry er givet nedenfor:

var myFirstCurry = funktion (ord) {

returfunktion (bruger) {

return [word, ",", user] .join ("");

  };

};

var HelloUser = myFirstCurry ("Hej");

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

Den oprindelige karryfunktion kan kaldes direkte ved at sende hver af parametrene i et separat sæt parentes efter hinanden som vist nedenfor:

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

JavaScript gælder, kald og bind metoder

Det er bydende nødvendigt for enhver JavaScript-udvikler at forstå forskellen mellem opkald, ansøgeog binde metoder. De tre funktioner er ens, idet deres første argument altid er "denne" værdi eller kontekst, som du vil give den funktion, du kalder metoden på.

Af de tre, opkald er den nemmeste. Det er det samme som at påberåbe sig en funktion, mens du specificerer dens kontekst. Her er et eksempel:

var bruger = {

navn: "Rahul Mhatre",

whatIsYourName: funktion () {

console.log (dette.navn);

     }

};

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

var bruger2 = {

navn: "Neha Sampat"

};

user.whatIsYourName.call (bruger2); // Output: "Neha Sampat"

Noter det ansøge er næsten det samme som opkald. Den eneste forskel er, at du sender argumenter som en matrix og ikke separat. Arrays er lettere at manipulere i JavaScript, hvilket åbner et større antal muligheder for at arbejde med funktioner. Her er et eksempel på brug af ansøge og opkald:

var bruger = {

hilse: "Hej!",

greetUser: funktion (brugernavn) {

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

     }

};

var hilsen1 = {

hilse: "Hola"

};

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

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

Det binde metode giver dig mulighed for at videregive argumenter til en funktion uden at påberåbe sig den. En ny funktion returneres med argumenter afgrænset forud for yderligere argumenter. Her er et eksempel:

var bruger = {

hilse: "Hej!",

greetUser: funktion (brugernavn) {

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

}

};

var greetHola = user.greetUser.bind ({greet: "Hola"});

var greetBonjour = user.greetUser.bind ({greet: "Bonjour"});

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

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

JavaScript-memoization

Memoization er en optimeringsteknik, der fremskynder eksekvering af funktioner ved at gemme resultater af dyre operationer og returnere de cachelagrede resultater, når det samme sæt input vises igen. JavaScript-objekter opfører sig som associative arrays, hvilket gør det let at implementere memoization i JavaScript. For eksempel kan vi konvertere en rekursiv faktorfunktion til en memo-faktorfunktion som vist nedenfor:

funktion memoizeFunction (func) {

var cache = {};

returfunktion () {

var key = argumenter [0];

hvis (cache [nøgle]) {

returner cache [nøgle];

          }

andet {

var val = func.apply (dette, argumenter);

cache [nøgle] = val;

returval;

          }

  };

}

var retracement = memoizeFunction (funktion (n)

returnere (n === 0);

JavaScript-metode overbelastning

Metodeoverbelastning gør det muligt for flere metoder at have samme navn, men forskellige argumenter. Compileren eller tolken bestemmer, hvilken funktion der skal kaldes på baggrund af antallet af argumenter, der er sendt. Metodeoverbelastning understøttes ikke direkte i JavaScript. Men du kan opnå noget meget ligesom det som vist nedenfor:

funktion overloadMethod (objekt, navn, fn) {

hvis (! object._overload) {

object._overload = {};

     }

hvis (! object._overload [navn]) {

object._overload [navn] = {};

    }

hvis (! object._overload [navn] [fn.længde]) {

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

    }

objekt [navn] = funktion () {

hvis (this._overload [navn] [argumenter.længde])

returner dette._overload [navn] [argumenter.længde] .anvend (dette, argumenter);

     };

funktion Studerende () {

overloadMethod (dette, "find", funktion () {

// Find en studerende ved navn

  });

overloadMethod (dette, "find", funktion (første, sidste) {

// Find en studerende ved for- og efternavn

  });

}

var studerende = nye studerende ();

studerende. find (); // Finder alle

studerende.find ("Rahul"); // Finder studerende ved navn

studerende.find ("Rahul", "Mhatre"); // Finder brugere efter for- og efternavn

Når du bliver fortrolig med Node.js, vil du bemærke, at der er mange måder at løse næsten alle problemer. Men at tage den rigtige tilgang er afgørende. En forkert tilgang vil resultere i flere bivirkninger som ujævn eller buggy applikationer eller regressioner, der tvinger dig til at omskrive hele logikken. På bagsiden vil den rigtige tilgang lægge grundlaget for en robust, effektiv og skalerbar applikation.

De 10 JavaScript-koncepter, der er beskrevet i denne artikel, er grundlæggende, som alle Node.js-udviklere skal kende. Men de er toppen af ​​isbjerget. JavaScript er kraftfuldt og komplekst. Jo mere du bruger det, jo mere vil du forstå, hvor stort JavaScript egentlig er. En bedre forståelse af et så omfattende sprog vil helt sikkert hjælpe dig med at undgå fejl. I mellemtiden får du det grundlæggende rigtigt, så får du gode resultater.

Rahul Mhatre er udviklerholdsleder hos Software AG. Tidligere var han teknisk arkitekt hos Built.io, som blev erhvervet af Software AG.

New Tech Forum giver et sted at udforske og diskutere nye virksomhedsteknologier i hidtil uset dybde og bredde. Valget er subjektivt baseret på vores valg af de teknologier, som vi mener er vigtige og af største interesse for læserne. accepterer ikke markedsføringssikkerhed til offentliggørelse og forbeholder sig retten til at redigere alt bidraget indhold. Send alle forespørgsler til [email protected]