Jokaisen Node.js-kehittäjän on hallittava 10 JavaScript-konseptia

Rahul Mhatre on Software AG: n kehitystiimin johtaja.

Node.js: stä on tullut nopeasti tosiasiallinen standardi verkkosovellusten ja SaaS-tuotteiden luomisessa, kun ytimessä on JavaScript ja V8-moottori, tapahtumapohjainen arkkitehtuuri ja skaalautuvuus. Node.js-kehykset, kuten Express, Sails ja Socket.IO, antavat käyttäjille mahdollisuuden käynnistää sovellukset nopeasti ja keskittyä vain liiketoimintalogiikkaan.

Node.js on paljon velkaa JavaScriptille sen valtavan suosion vuoksi. JavaScript on moniulotteinen kieli, joka tukee monia erilaisia ohjelmointityylejä, mukaan lukien toiminnallinen ohjelmointi, menettelytapojen ohjelmointi ja olio-ohjelmointi. Sen avulla kehittäjä voi olla joustava ja hyödyntää erilaisia ohjelmointityylejä.

Mutta JavaScript voi olla kaksiteräinen miekka. JavaScriptin moninaisuus tarkoittaa, että melkein kaikki on muutettavissa. Siksi et voi sivuuttaa objekti- ja laajuusmutaation todennäköisyyttä kirjoittaessasi Node.js-koodia. Koska JavaScriptiltä puuttuu hännän puhelun optimointi (mikä sallii rekursiivisten toimintojen käyttää pinokehyksiä uudelleen rekursiivisiin puheluihin), on vaarallista käyttää rekursiota suurissa iteraatioissa. Tällaisten ongelmien lisäksi Node.js on yksisäikeinen, joten kehittäjien on välttämätöntä kirjoittaa asynkroninen koodi.

JavaScripti voi olla siunaus, jos sitä käytetään varoen, tai bana, jos olet holtiton. Jäsenneltyjen sääntöjen, suunnittelumallien, avainkäsitteiden ja perussääntöjen noudattaminen auttaa valitsemaan ongelman optimaalisen lähestymistavan. Mitkä keskeiset käsitteet Node.js-ohjelmoijien tulisi ymmärtää? Alla jaan 10 JavaScript-käsitettä, jotka ovat mielestäni välttämättömiä tehokkaan ja skaalautuvan Node.js-koodin kirjoittamiseen.

Liittyvä video: Node.js-vinkkejä ja vihjeitä

Opi tässä selitysvideossa useita tekniikoita, jotka voivat parantaa Node-kehityskokemustasi.

JavaScript IIFE: t: Käynnistetyt funktiolausekkeet välittömästi

Välittömästi kutsuttu funktiolauseke (IIFE) on toiminto, joka suoritetaan heti, kun se on luotu. Sillä ei ole yhteyttä mihinkään tapahtumaan tai asynkroniseen suoritukseen. Voit määrittää IIFE: n alla olevan kuvan mukaisesti:

(funktio () {
// kaikki koodisi täällä
// ...
})();

Ensimmäinen sulkeiden pari toiminto () {...} muuntaa suluissa olevan koodin lausekkeeksi. Toinen suluepari kutsuu lausekkeesta johtuvaa funktiota. IIFE: tä voidaan kuvata myös itseään kutsuvaksi nimettömäksi toiminnoksi. Sen yleisin käyttö on rajoittaa kautta tehdyn muuttujan soveltamisalaa var tai kapseloida konteksti nimien törmäysten välttämiseksi.

JavaScript-sulkemiset

JavaScriptin sulkeminen on sisäinen toiminto, jolla on pääsy sen ulkoisen toiminnon piiriin, vaikka uloin toiminto olisi palauttanut hallinnan. Sulkeminen tekee sisäisen funktion muuttujista yksityiset. Alla on yksinkertainen esimerkki sulkemisesta:

var count = (funktio () {
    var _laskuri = 0;
    return-funktio () {return _counter + = 1;}
})();
Kreivi();
Kreivi();
Kreivi();
> // laskuri on nyt 3

Muuttuja Kreivi on määritetty ulompi toiminto. Ulompi toiminto toimii vain kerran, mikä asettaa laskurin nollaksi ja palauttaa sisäisen funktion. _laskuri muuttujaan pääsee vain sisäisen toiminnon avulla, mikä saa sen käyttäytymään kuin yksityinen muuttuja.

JavaScript-prototyypit

Jokaisella JavaScript-toiminnolla on prototyypin ominaisuus, jota käytetään ominaisuuksien ja menetelmien liittämiseen. Tätä ominaisuutta ei ole lueteltu. Sen avulla kehittäjä voi liittää menetelmiä tai jäsentoimintoja kohteisiinsa. JavaScript tukee perimistä vain prototyypin kautta. Perityn objektin tapauksessa prototyyppiominaisuus osoittaa objektin vanhemmalle. Yleinen tapa liittää menetelmiä toimintoon on käyttää prototyyppejä alla esitetyllä tavalla:

funktio Suorakulmio (x, y) {
    tämä.pituus = x;
    tämä.leveys = y;
}
Suorakulmio.prototype.getDimensions = funktio () {
    return {pituus: tämä.pituus, leveys: tämä.leveys};
};
Suorakulmio.prototype.setDimensions = funktio (len, kasvatettu) {
    tämä.pituus = len;
    tämä.leveys = kasvatettu;
};

JavaScript-yksityiset kiinteistöt, sulkemiset

JavaScript antaa sinun määrittää yksityiset ominaisuudet käyttämällä alaviivan etuliitettä yllä olevan esimerkin mukaisesti. Tämä ei kuitenkaan estä käyttäjää käyttämästä suoraan tai muuttamasta omaisuutta, jonka oletetaan olevan yksityinen.

Yksityisten kiinteistöjen määrittely sulkemisten avulla auttaa sinua ratkaisemaan tämän ongelman. Jäsentoiminnot, jotka tarvitsevat pääsyn yksityisiin kiinteistöihin, tulisi määritellä itse objektissa. Voit tehdä yksityisiä kiinteistöjä sulkemalla alla olevan kuvan mukaisesti:

funktio Suorakulmio (_pituus, _leveys) {
     this.getDimensions = funktio () {
     return {pituus: _pituus, leveys: _leveys};
     };
 this.setDimension = funktio (len, kasvatettu) {
     _pituus = len;
    _leveys = kasvatettu
    };
}

JavaScript-moduulin malli

Moduulikuvio on JavaScriptissä yleisimmin käytetty mallikuvio löyhästi yhdistetyn, hyvin jäsennetyn koodin saavuttamiseksi. Sen avulla voit luoda julkisen ja yksityisen käyttöoikeustason. Yksi tapa saavuttaa moduulimalli on esitetty alla:

var Suunta = (funktio () {
  var _direction = 'eteenpäin'
  var changeDirection = funktio (d) {
          _suunta = d;
  }
  return {setDirection: funktio (d) {
          muutossuunta (d);
          console.log (_direction);
          }
  };
})();
Direction.setDirection ('taaksepäin'); // Lähdöt: 'taaksepäin'
console.log (Direction._direction);

Paljastava moduulikuvio on samanlainen kuin moduulikuvio, jossa paljastettavat muuttujat ja menetelmät palautetaan objektikirjaimessa. Yllä oleva esimerkki voidaan kirjoittaa käyttämällä paljastavan moduulin mallia seuraavasti:

var Suunta = (funktio () {
  var _direction = 'eteenpäin';
  var _privateChangeDirection = funktio (d) {
_suunta = d;
  }
  paluu {
          setDirection: _privateChangeDirection
  };
})();

JavaScriptin nostaminen

JavaScript siirtää muuttujat ja funktiodeklaraatiot toimialueensa yläpuolelle ennen koodin suorittamista. Tätä kutsutaan nostoksi. Riippumatta siitä, mihin asetat funktioiden ja muuttujien ilmoituksen koodiin, tulkki siirtää ne soveltamisalansa yläosaan. Tämä voi olla tai ei olla missä haluat. Jos ei, niin ohjelmassasi on virheitä.

Muuttujailmoitukset käsitellään ennen koodin suorittamista. Ironista kyllä, pimeitä muuttujia ei ole olemassa ennen kuin niille on annettu arvo. Tämän vuoksi kaikista pimeistä muuttujista tulee globaaleja muuttujia. Vaikka toimintoilmoitukset nostetaan, funktiolausekkeita ei nosteta. JavaScriptillä on prioriteettijärjestys muuttujien ja toimintojen nostamisen aikana.

Ensisijaisuus annetaan alla ylemmästä alempaan:

Muuttuva tehtävä
Toimintoilmoitus
Muuttuvat ilmoitukset

Virheiden välttämiseksi sinun tulee ilmoittaa muuttujat ja toiminnot jokaisen laajuuden alussa.

JavaScript-curry

Curry on tapa tehdä toiminnoista joustavampia. Curried-funktiolla voit välittää kaikki argumentit, joita funktio odottaa, ja saada tuloksen, tai voit välittää vain osan argumenteista ja saada takaisin funktion, joka odottaa muita argumentteja. Yksinkertainen esimerkki currysta on annettu alla:

var myFirstCurry = funktio (sana) {
  palautustoiminto (käyttäjä) {
            return [sana, ",", käyttäjä] .join ("");
  };
};
var HelloUser = myFirstCurry ("Hei");
HelloUser ("Rahul"); // Output: "Hei, Rahul"

Alkuperäinen curried-toiminto voidaan kutsua suoraan välittämällä kukin parametreista erillisissä suluissa peräkkäin alla olevan kuvan mukaisesti:

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

JavaScript soveltaa, kutsu ja sido menetelmiä

Kaikkien JavaScript-kehittäjien on ehdottomasti ymmärrettävä niiden välinen ero puhelu, Käytäja sitoa menetelmiä. Nämä kolme toimintoa ovat samanlaisia siinä mielessä, että niiden ensimmäinen argumentti on aina "tämä" -arvo tai konteksti, jonka haluat antaa funktiolle, johon kutsut metodia.

Kolmesta puhelu on helpoin. Se on sama kuin funktion kutsuminen samalla määritettäessä sen konteksti. Tässä on esimerkki:

var käyttäjä = {
     nimi: "Rahul Mhatre",
     whatIsYourName: function () {
     console.log (tämä.nimi);
     }
};
user.whatIsYourName (); // Tulos: "Rahul Mhatre",
var user2 = {
     nimi: "Neha Sampat"
};
user.whatIsYourName.call (käyttäjä2); // Tulos: "Neha Sampat"

Ota huomioon, että Käytä on melkein sama kuin puhelu. Ainoa ero on, että välität argumentit matriisina etkä erikseen. Matriiseja on helpompi käsitellä JavaScriptissä, mikä avaa suuremman määrän mahdollisuuksia toimintojen kanssa työskentelyyn. Tässä on esimerkki Käytä ja puhelu:

var käyttäjä = {
     tervehdi: "Hei!",
     greetUser: funktio (käyttäjänimi) {
     console.log (this.greet + "" + käyttäjänimi);
     }
};
var tervehti1 = {
     tervehtiä: "Hola"
};
user.greetUser.call (tervehti1, "Rahul") // Tulos: "Hola Rahul"
user.greetUser.apply (tervehti1, ["Rahul"]) // Tulos: "Hola Rahul"

sitoa menetelmä antaa sinun välittää argumentteja funktiolle käynnistämättä sitä. Uusi funktio palautetaan argumenteilla, jotka on rajattu ennen muita argumentteja. Tässä on esimerkki:

var käyttäjä = {
     tervehdi: "Hei!",
     greetUser: funktio (käyttäjänimi) {
     console.log (this.greet + "" + käyttäjänimi);
}
};
var greetHola = user.greetUser.bind ({tervehdi: "Hola"});
var greetBonjour = user.greetUser.bind ({tervehdi: "Bonjour"});
HelloHola ("Rahul") // Tulos: "Hola Rahul"
greetBonjour ("Rahul") // Output: "Bonjour Rahul"

JavaScript-muistio

Muistiinpano on optimointitekniikka, joka nopeuttaa toimintojen suorittamista tallentamalla kalliiden toimintojen tulokset ja palauttamalla välimuistissa olevat tulokset, kun sama syötesarja esiintyy uudelleen. JavaScript-objektit käyttäytyvät kuin assosiatiiviset taulukot, mikä helpottaa muistiinpanon toteuttamista JavaScript-ohjelmassa. Esimerkiksi voimme muuntaa rekursiivisen kertoimen funktion muistiin muunnetuksi funktiofunktioksi alla olevan kuvan mukaisesti:

function memoizeFunction (func) {
  var välimuisti = {};
  palautusfunktio () {
          var-avain = argumentit [0];
          if (välimuisti [avain]) {
          return cache [avain];
          }
          muu {
          var val = func.apply (tämä, argumentit);
          välimuisti [avain] = val;
          paluu val;
          }
  };
}
var fibonacci = memoizeFunction (funktio (n) 
  paluu (n === 0);

JavaScript-menetelmän ylikuormitus

Menetelmien ylikuormitus sallii useilla menetelmillä olla sama nimi, mutta erilaiset argumentit. Kääntäjä tai tulkki päättää kutsuttavan toiminnon hyväksyttyjen argumenttien määrän perusteella. Menetelmän ylikuormitusta ei tueta suoraan JavaScriptissä. Mutta voit saavuttaa jotain hyvin samanlaista, kuten alla on esitetty:

function overloadMethod (objekti, nimi, fn) {
   if (! object._overload) {
    object._overload = {};
     }
  if (! object._overload [nimi]) {
    object._overload [nimi] = {};
    }
 jos (! object._overload [nimi] [fn.length]) {
object._overload [nimi] [fn.pituus] = fn;
    }
   objekti [nimi] = funktio () {
         jos (this._overload [nimi] [argumentit.pituus])
         palauta this._overload [nimi] [argumentit.pituus] .apply (tämä, argumentit);
     };
toiminto Opiskelijat () {
  overloadMethod (tämä, "etsi", funktio () {
          // Etsi opiskelija nimen mukaan
  });
overloadMethod (tämä, "etsi", funktio (ensimmäinen, viimeinen) {
          // Etsi opiskelija etu- ja sukunimen mukaan
  });
}
var opiskelijat = uudet opiskelijat ();
opiskelijat. etsi (); // Löytää kaikki
opiskelijat. etsi ("Rahul"); // Etsii opiskelijat nimen mukaan
opiskelijat. etsi ("Rahul", "Mhatre"); // Etsii käyttäjät etu- ja sukunimen mukaan

Kun opit tuntemaan Node.js: n, huomaat, että melkein kaikki ongelmat voidaan ratkaista monella tapaa. Mutta oikea lähestymistapa on kriittinen. Väärä lähestymistapa johtaa moniin haittavaikutuksiin, kuten hajanaiseen tai bugiseen sovellukseen tai regressioon, joka pakottaa sinut kirjoittamaan koko logiikan. Kääntöpuolella oikea lähestymistapa luo perustan vankalle, tehokkaalle ja skaalautuvalle sovellukselle.

Tässä artikkelissa kuvatut 10 JavaScript-käsitettä ovat perusasiat, jotka jokaisen Node.js-kehittäjän tulisi tietää. Mutta ne ovat jäävuoren huippu. JavaScript on tehokas ja monimutkainen. Mitä enemmän käytät sitä, sitä enemmän ymmärrät kuinka laaja JavaScript todella on. Tällaisen kattavan kielen parempi ymmärtäminen auttaa varmasti välttämään virheitä. Sillä välin saat perusasiat oikein ja näet hyviä tuloksia.

Rahul Mhatre on Software AG: n kehitystiimin johtaja. Aikaisemmin hän oli tekninen arkkitehti Built.iossa, jonka hankki Software AG.

—

New Tech Forum tarjoaa mahdollisuuden tutkia ja keskustella kehittyvistä yritysteknologioista ennennäkemättömällä syvyydellä ja laajuudella. Valinta on subjektiivinen, perustuu valitsemiemme tekniikoihin, joiden uskomme olevan tärkeitä ja kiinnostavia lukijoille. ei hyväksy markkinointivakuuksia julkaisua varten ja pidättää oikeuden muokata kaikkea lähetettyä sisältöä. Lähetä kaikki tiedustelut osoitteeseen [email protected].