Node.js tutorial: Kom godt i gang med Node.js

Node.js, et JavaScript-runtime-miljø på tværs af platforme til servere og applikationer, tilbyder mange fordele. Lavt hukommelsesforbrug, god ydeevne og et stort økosystem med pakker, som i øjeblikket tæller ca. 475.000, har gjort Node.js til et populært valg til opbygning af webservere, REST API'er, netværksapplikationer i realtid (f.eks. Chat, spil) og endda platform-apps på tværs af platforme.

Hvis du ikke allerede er kommet i gang med Node.js, er det måske tid. Tjek min Node.js-forklarer for at lære, hvordan Node.js fungerer som sin magi. I denne artikel gennemgår vi installation af Node.js og NPM-pakkehåndteringen, spinding af en simpel webserver og brug af Node.js-klyngemodulet til at drage fordel af flere CPU-kerner.

Vi vil også se på installation af yderligere Node.js-moduler og andre JavaScript-pakker ved hjælp af NPM-pakkehåndtering. Og vi dypper en tå i at bruge en Node.js-ramme, i dette tilfælde Koa, for at skabe mere funktionsrige og fleksible Node.js-servere.

Lad os komme igang.

Sådan installeres Node.js og NPM

Start med at gennemse //nodejs.org:

Node.js Foundation

Klik på knappen for download af LTS (langvarig support), medmindre du ved, at du har brug for nogle nye funktioner i den aktuelle udgivelse. Præcis hvordan det downloadede installationsprogram ser ud, kan variere mellem operativsystemer, men på en Mac ser det sådan ud i starten:

Når installationen er færdig, ser det sådan ud:

Nu skal du sørge for, at både Node.js og NPM er installeret korrekt. Åbn en kommandolinjeskal (Terminal på en Mac; Kommandoprompt på Windows) og kontroller de installerede versioner af begge:

$ node —version
v6.11.3
$ npm —version
3.10.10

Hvis du får fejl, der siger, at Node.js eller NPM ikke blev fundet, skal du prøve at genstarte din shell-applikation eller genstarte din computer. Hvis det ikke virker, skal du muligvis redigere din $ PATH (Mac og Linux) eller PATH (Windows) og genstarte igen.

Både Node.js og NPM matcher de tilsigtede versioner i Terminal-skærmbilledet ovenfor, så jeg er klar til at komme videre og faktisk udvikle noget med Node.js. Lad os starte med noget, der er let at bygge med ren Node.

Du skal bruge en kodeditor eller IDE, helst en, der understøtter JavaScript og Node.js, såsom Sublime Text, Visual Studio Code, Brackets, Atom eller WebStorm.

Node.js-eksempel: En simpel webserver

For at starte virkelig enkelt, lad os stjæle et simpelt eksempel fra Node.js-webstedet. Kopier koden og indsæt den i din kodeeditor (jeg bruger Visual Studio Code, men enhver editor, der gemmer almindelig tekst, er tilstrækkelig), og gem den som eksempel.js.

const http = kræve (‘http’);
const hostname = ‘127.0.0.1’;
const port = 3000;
const server = http.createServer ((req, res) => {
   res.statusCode = 200;
   res.setHeader ('Content-Type', 'text / plain');
   res.end ('Hello World \ n');
});
server.listen (port, hostname, () => {
   console.log (`Server, der kører på // $ {hostname}: $ {port} /`);
});

Åbn en skal i det bibliotek, hvor du gemte filen, og kør filen fra din kommandolinje:

$ node eksempel.js
Server kører på //127.0.0.1:3000/

I mit tilfælde brugte jeg terminalvinduet i Visual Studio-kode. Jeg kunne næsten lige så godt have skiftet til et uafhængigt skalvindue.

Gennemse nu den URL, der er angivet af serveren:

Tryk på Control-C i terminalen for at stoppe Node-serveren.

Lad os rive koden fra hinanden, inden vi fortsætter.

const http = kræve (‘http’);

Linie 1 bruger kræve, hvordan du indlæser moduler i Node.js. Erklæringen indlæser Node.js http-modulet, som leverer createServer metode kaldet i linje 6 til 10 og Lyt metode kaldet i linie 12 til 14. Operatoren "fedtpil" => i linje 6 og 12 er en stenografi for at oprette anonyme Lambda-funktioner, som ofte bruges i Node.js-apps.

const server = http.createServer ((req, res) => {
  res.statusCode = 200;
  res.setHeader ('Content-Type', 'text / plain');
  res.end ('Hello World \ n');
});

Det res argument til createServer () i linje 6 bruges til at opbygge svaret; det rek argumentet indeholder den indkommende HTTP-anmodning, som ignoreres i denne kode. Det res.end metode indstiller svardataene til 'Hello World \ n' og fortæller serveren, at det hele er færdigt med at oprette svaret.

server.listen (port, hostname, () => {
  console.log (`Server kører på // $ {hostname}: $ {port} /`);
});

Serveren lukning produceret af server.listen () metode fortæller serveren at lytte efter anmodninger på den definerede vært (127.0.0.1, f.eks. localhost) og port (3000). Lukningen produceret af createServer () metoden håndterer anmodningerne, når de kommer ind på den definerede vært og port.

Ideen om, at JavaScript-lukninger er defineret som begivenhedshåndterere, er en af ​​de mest subtile og kraftfulde dele af Node.js og er en nøgle til Nodes asynkrone ikke-blokerende arkitektur. Node.js skjuler sin begivenhedssløjfe, men vender altid tilbage til håndtering af begivenheder, når de ikke ellers er involveret. Derudover bruger JavaScript-lukninger meget mindre hukommelse end alternative måder at håndtere flere klientforbindelser på, såsom gydetråde eller gaffelprocesser.

Node.js eksempel: En webserver med flere processer

Bortset fra kun at udskrive "Hello World" kører eksemplet ovenfor kun i en tråd, hvilket betyder, at det kun kan bruge en kerne i værtscomputeren. Der er tidspunkter, hvor du vil have mange kerner, som du gerne vil afsætte til en server.

Det officielle eksempel på Node-klyngemodulet viser, hvordan du løser det. Som før stjæler vi koden og kører den. Gå til Node.js-klyngedokumentationen, kopier koden, indsæt den i din kodeeditor eller IDE, og gem den som server.js.

const cluster = kræve (‘cluster’);
const http = kræve (‘http’);
const numCPUs = kræve (‘os’). cpus (). længde;
hvis (cluster.isMaster) {
console.log (`Master $ {process.pid} kører`);
// Gaffelarbejdere.
for (leti = 0; i
cluster.fork ();
}
cluster.on ('exit', (arbejdstager, kode, signal) => {
console.log (`arbejdstager $ {worker.process.pid} døde`);
});
} andet {
// Arbejdstagere kan dele enhver TCP-forbindelse
// I dette tilfælde er det en HTTP-server
http.createServer ((req, res) => {
res.writeHead (200);
res.end (`hej verden fra $ {process.pid} \ n`);
}). lyt (8000);
console.log ('Arbejder $ {process.pid} startet');
}

Når du udfører node server.js fra din kommandolinje viser loggen proces-id'erne til master- og arbejdsprocesserne. Der skal være lige så mange arbejdere, som din computer har logiske kerner - otte til min MacBook Pro med sin Core i7-processor, som har fire hardwarekerner og hyper-threading.

Hvis du surfer til localhost: 8000 eller til 127.0.0.1:8000, vises "hej verden". Du kan trykke på Control-C i terminalvinduet for at stoppe Node-serverprocesserne.

const cluster = kræve (‘cluster’);
const http = kræve (‘http’);
const numCPUs = kræve (‘os’). cpus (). længde;

Linje 1 og 2 skal se bekendt ud fra det sidste eksempel. Linje 3 er lidt anderledes. I stedet for blot at kræve os modul, kaldes det også cpus () medlemsfunktion og returnerer længden af ​​det array, der returneres, hvilket er antallet af CPU'er. Selve arrayet og os modullink kan ikke nås og kan blive affald indsamlet af JavaScript-motoren på et senere tidspunkt.

hvis (cluster.isMaster) {
   console.log (`Master $ {process.pid} kører`);
   // Gaffelarbejdere.
   for (lad i = 0; i <num CPU'er; i ++) {
      cluster.fork ();
   }
   cluster.on ('exit', (arbejdstager, kode, signal) => {
      console.log (`arbejdstager $ {worker.process.pid} døde`);
   });
}

Linje 5 starter en blok, der kun kører til masterprocessen. Det logger sin PID, forkerer medarbejder pr. Tilgængelig CPU og skaber en lukning til at håndtere og logge cluster exit-begivenheder.

} andet {
   // Arbejdstagere kan dele enhver TCP-forbindelse
   // I dette tilfælde er det en HTTP-server
   http.createServer ((req, res) => {
      res.writeHead (200);
      res.end ('hej verden \ n');
   }). lyt (8000);
   console.log ('Arbejder $ {process.pid} startet');

Blokken, der starter ved linje 16, køres kun af arbejdsprocesser. Denne kode skal se bekendt ud fra det foregående eksempel: Den opretter en webserver, der svarer på enhver anmodning med "hej verden."

Det fremgår tydeligt af det output, vi så ovenfor, at denne kode kørte otte gange på min maskine, hvilket skabte otte webserverarbejdere, der delte den overordnede proces 'TCP-forbindelse på port 8000. Men hvordan deler systemet belastningen blandt dem?

Dokumentationen siger, at Node.js-klyngemodulet bruger en modificeret round-robin-algoritme som standard undtagen i Windows. Algoritmen styres af cluster.schedulingPolicy ejendom.

Hvordan ved vi, at dette fungerer? Lad os teste det. Det tager kun at ændre en linie kode. Rediger linje 21 for at læse:

      res.end (`hej verden fra $ {process.pid} \ n`);

Bemærk, at du ikke kun skal tilføje fra $ {process.pid}, men du er også nødt til at ændre afgrænsningerne fra enkelte anførselstegn til tilbage-flåter, så JavaScript udfører variabel erstatning på strengen.

Gem filen, stop enhver tidligere kørende forekomst, og kør den igen. Du tror måske, at hver gang du opdaterer din browserklient, ændres det returnerede proces-id, men du tager fejl. Browseren er for smart, og vi har ikke markeret websiden som en, der udløber, så browseren cachelagrer svaret første gang, den kører, og fortsætter med at vise det samme nummer. Det gør det, selvom du opretter flere browserfaner eller sider, der peger på den samme URL. Du kan dog se, at rundforsendelsen fra master fungerer ved at køre flere browsere samtidigt, i dette tilfælde Chrome, Safari og Opera:

Hvis du er fortrolig med andre webservere, kan du forvente at se et skema til ruteanmodninger og til at opretholde vedvarende tilstand for at bevare hver brugers login og miljø i Node. Ak, node har ikke den indbyggede. Frygt ikke: Der er adskillige webrammer bygget oven på Node.js, der gør alt, hvad du forventer.

Sådan installeres et Node.js-modul med NPM

For at gøre brug af de fleste Node-moduler installerer du stort set bare modulet fra NPM-registreringsdatabasen, enten globalt eller i et projektkatalog, og derefter kræve() det fra din kode. Ofte afhænger et projekt af flere NPM-moduler og holder denne liste i sin project.json-fil. I stedet for at installere hver afhængighed fra kommandolinjen kan du installere dem alle på én gang, ofte efter at have tjekket projektet ud af dets GitHub-arkiv:

$
$ cd my_project
$ npm installation

Ikke alle NPM-pakker fungerer nøjagtigt på den måde. Nogle, inklusive React, har "fabriks" -apps til skab starter-apps som en af ​​deres installationsmuligheder.

$ npm install -g create-react-app
$ cd ~ / arbejde
$ create-react-app min-app
$ cd min-app /
$ npm start

Det er ikke usædvanligt, at værktøjer installeres globalt. For eksempel installeres det kantede kommandolinjeværktøj Ng globalt. Du kører den derefter lokalt for at oprette en app i en mappe.

$ npm install -g @ vinkel / cli
$ cd ~ / arbejde
$ ng ny my-app

Vinkel har tilfældigvis en anden installationsmetode, der ligner mere som standardmønsteret. Det er til Angular QuickStart-frøet:

$ git klon //github.com/angular/quickstart.git hurtigstart
$ cd hurtigstart
$ npm installation

Package.json-filen i hurtigstartmappen fortæller npm installation for at hente næsten den samme liste over afhængigheder som CLI-installationen.

Node.js-eksempel: En Koa-webserver

Mens både React og Angular er en del af Node.js-økosystemet og har brug for Node.js og NPM til udvikling, er de ikke specifikt Node.js-rammer - de kan køre i en browser. Jeg dækkede snesevis af faktiske Node.js-rammer i "Komplet guide til Node.js-rammer".

Eksempelvis er Express den oprindelige udbyggede Node-webserver, der håndterer webapplikationen, HTTP-anmodninger og svar, routing og middleware. En nyere mulighed, Koa, bruger generatorer i stedet for tilbagekald til middleware.

Du installerer Koa med standardmønsteret i din appmappe:

$ npm installer koa

Nedenfor er koden til Koa “Hello World” -appen, som du kan gemme og køre som i de foregående eksempler.

const Koa = kræve (‘koa’);
const app = ny Koa ();
// x-responstid
app.use (async (ctx, næste) => {
const start = Date.now ();
afvente næste ();
const ms = Date.now () -start;
ctx.set ('X-Response-Time', '$ {ms} ms');
});
// logger
app.use (async (ctx, næste) => {
const start = Date.now ();
afvente næste ();
const ms = Date.now () -start;
console.log (`$ {ctx.method} $ {ctx.url} - $ {ms}`);
});
// respons
app.use (async ctx => {
ctx.body = ‘Hello World’;
});
app.listen (3000);

Der er en forskel mellem middleware-generatorer, som de bruges af Koa, og callbacks, som de bruges af Express og andre Node.js-rammer. Mange tilbagekaldelsesimplementeringer sender simpelthen kontrol gennem en række funktioner, indtil man vender tilbage, mens Koa giver "nedstrøms", hvorefter kontrol strømmer tilbage "opstrøms."

I eksemplet ovenfor "indpakker" x-responstiden responsgeneratoren medafvente næste () erklæring, der markerer opkaldet. Brug af denne asynkrone funktion er mere fleksibel end eksplicit funktionsopkald, da det gør det let at indsætte en anden generator i sekvensen, for eksempel en weblogger mellem timeren og svaret.

Du kan komme på tværs af ældre Koa-kode, der bruger udbytte næste i stedet for afvente næste (). Forskellen er, at Koa nu understøtter ES2015 og async-funktioner. Strømmen af ​​kontrol udgør den samme ting: Den bevæger sig til næste handler i kæden ved udbytte næste opkald, og vender derefter tilbage, når alle håndterere er færdige.