Nybörjarguide för att komma igång med Node.js

Nyborjarguide For Att Komma Igang Med Node Js



Node.js har visat sig vara ett potent verktyg inom webbutveckling och har blivit populärt bland utvecklare på grund av dess effektivitet, tillförlitlighet och skalbarhet. Att få en grundläggande förståelse innan du dyker in i någonting och veta allt på en enda plats är en känsla. Du måste komma till rätt plats om du vill utveckla en djupgående förståelse för Node.js. Efter att ha läst den här artikeln kan användare börja på sin resa för att skriva kodskript i Node.js.

Det här inlägget kommer att täcka:

Vad är Node.js?

Den vanligaste sökfrågan på Googles sökmotor är Vad är Node.js? De mest populära frågorna är Är Node.js ett programmeringsspråk? Är det ett ramverk? Är det ett bibliotek? För att förenkla kan Node.js definieras som en runtime-miljö som stöds av ett JS-bibliotek.







En välkänd Javascript-runtimemiljö med öppen källkod för flera plattformar är Node.js. På grund av dess anpassningsförmåga kan den användas i alla projekt eller applikationer. Det som skiljer den åt är användningen av V8-motorn, samma motor som driver Google Chrome. Detta gör Node.js till ett optimalt val för skriptning på serversidan och exekvering av kodskript utanför utvecklingsmiljön.



Node.js skiljer sig ganska mycket från andra programmeringsspråk på serversidan. Det bör noteras att det inte är en backend-server eller en webbserver. Ensam kan det inte göra något annat än en samling moduler hjälper till att göra ett skalbart projekt. Den körs på en enda server och genererar inte ytterligare trådar för varje enskild begäran. Dessutom används icke-blockerande paradigm för att skriva majoriteten av NodeJS-bibliotek, så blockerande beteende är undantaget istället för regeln. Asynkrona I/O-primitiver är en funktion i standardbiblioteket för Node.js som hindrar JavaScript-kod från att blockeras.



När Node.js utför en I/O-operation, som att utföra crud-operationer över nätverket, kommer den inte att blockera tråden och slösa CPU-cykler som väntar på att svara; i stället kommer den att återuppta driften efter att svaret har mottagits.





Node.js enkelt exempel

Ett enkelt exempel för att förstå konceptet med Node.js är att skapa en webbserver och skriva lite text. Eftersom det är en introduktion till Node.js, så låt oss lägga till introraden till en webbport:

konst http = behöva ( 'http' ) ;

konst server Port = 3000 ;

konst server = http. skapaServer ( ( req, res ) => {

res. statuskod = 200 ;

res. setHeader ( 'Innehållstyp' , 'text/vanlig' ) ;

res. slutet ( 'Nybörjarguide för att komma igång med Node.js! \n ' ) ;

} ) ;

server. lyssna ( server Port, ( ) => {

trösta. logga ( `Server körs på http : //localhost:${serverPort}/`);

} ) ;

I denna kod:



  • 'const http = require('http')' importerar http-modulen som hjälper till att skapa HTTP-servrar och hantera de funktioner som är associerade med den.
  • 'const serverPort = 3000' definierar porten som servern kommer att arbeta på.
  • 'const server = http.createServer((req, res) => {})' använder skapa servermetoden för http-modulen för att skapa en server med en callback-funktion som tar två argument, det ena är begäran och det andra är svaret som kommer att genereras för begäran.
  • Inuti callback-funktionen är HTTPS-statuskoden inställd på 200, och svarsinnehållstypen är inställd på vanlig text. Dessutom visar webbservern ett meddelande med titeln 'Nybörjarguide för att komma igång med Node.js'.
  • 'server.listen(serverPort, () =>{})' anropas för att starta servern och lyssna på alla inkommande förfrågningar på servern. Återuppringningsfunktionen anropas efter start av servern och visar ett meddelande i terminalen för att visa porten på vilken servern startas.

Produktion

Använd raden nedan för utförandet:

nod App. js

Var App.js är programmets namn.

Utgången i terminalen är:

Detta indikerar att servern har startat och lyssnar på inkommande förfrågningar. För att kontrollera svaret på servern använd följande länk ' http://localhost:3000/ ”.

Utdata på serversidan skulle visa sig som:

Hur fungerar Node.js?

Node.js är en plattform som hjälper servrar att hantera många förfrågningar samtidigt. Även om den bara använder en tråd för att hantera förfrågningar, hanterar den effektivt in- och utdataoperationer genom att använda trådar. Trådar är en grupp instruktioner som utför uppgifter samtidigt. Node.js fungerar med en händelseslinga som kontrollerar uppgifter utan att stoppa tills en är klar innan nästa start.

Node.js händelseloop är en kontinuerlig och semi-oändlig loop. Denna loop hanterar de synkrona och icke-synkrona händelserna i Node.js. Så fort Node.js-projektet startar utlöses exekveringen, vilket sömlöst överför de svåra uppgifterna till systemet. Detta gör att andra uppgifter på huvudtråden kan löpa smidigt.

För att förstå och förstå det detaljerade konceptet med Event-loopar i Node.js har vi skrivit en särskild artikel om detta ämne.

Node.js Meriter

Några viktiga fördelar med Node.js är:

  • Skalbarhet : Förenklar tillväxten av appar i två riktningar: horisontellt och vertikalt.
  • Webbappar i realtid : bäst för uppgifter som kräver snabb synkronisering och förhindrar för mycket belastning på HTTP.
  • Fart : Utför uppgifter snabbt, som att lägga in data i eller ta ut från databaser, länka till nätverk eller hantera filer.
  • Lätt att lära : Node.js är lätt att lära sig för nybörjare eftersom det använder Javascript.
  • Cachingfördel : Lagrar endast en del, så det finns ingen anledning att köra kod igen när du tillfrågas, cachen är ett snabbt minne och sparar ytterligare laddningstid.
  • Dataströmning : Hanterar HTTP-förfrågningar och svar som olika händelser vilket förbättrar prestandan.
  • Värdskap : Lätt att lägga på webbplatser som PaaS och Heroku.
  • Företagssupport : Används av stora företag som Netflix, SpaceX, Walmart, etc.

Hur installerar jag Node.js på Windows?

Eftersom vi börjar utveckla Node.js-applikationer, om vi har en Windows-miljö, måste Node.js-miljön ställas in. Följ de stegvisa riktlinjerna nedan för att ställa in Node.js-miljön i ett Windows-operativsystem.

Steg 1: Ladda ner installationspaketet för Node.js

Gå till den officiella webbplatsen för Node.js Node.js officiella webbplats och se till att du laddar ner den senaste versionen av Node.js. Kontrollera också om npm-pakethanteraren är installerad med den eftersom den spelar en avgörande roll för att skala Node.js-applikationer.

Klicka bara på Windows Installer så startar nedladdningen. Den nedladdade versionen kommer att vara 64-bitars och LTS-versionen (Long Term Support) rekommenderas. Kör installationspaketet för att installera Node.js.

Steg 2: Installera Node.js och NPM-modulen på din dator

Följande skärm visas så klicka på knappen Nästa:

Efter att ha klickat på Nästa kommer ett nytt fönster upp där användaren kommer att bli ombedd att ange sökvägen där det är tänkt att ladda ner Node.js msi-biblioteken.

Välj nu önskad sökväg i fönstret nedan och klicka på nästa knapp:

Efter att ha klickat på nästa knapp kommer du att få ett fönster med anpassad installation där du blir ombedd att välja det paket du vill installera. Från det här fönstret väljer du npm-pakethanteraren som standard. Node.js körtid är vald. I pakethanteraren för npm är både Node.js och paketet npm installerade.

Klicka slutligen på knappen Installera för att komma igång med resan.

Steg 3: Verifiera de installerade versionerna

Att ta reda på vilken version som är installerad är avgörande så för att kontrollera det, gå till sökfältet i Windows och skriv kommandotolken:

När kommandotolksfönstret öppnas, skriv in två kommandon för verifiering.

Version av Node.js

Node.js-versionen kan kontrolleras genom att använda följande kommando i kommandotolken:

nod - i

Den installerade versionen skulle dyka upp

NPM-version

För npm-versionskontrollen, använd följande kommando:

npm - i

Versionen för npm skulle visas i terminalen.

Det är det nu du kan börja utveckla applikationer med installationen av Node.js-miljön.

Alla användare använder inte Windows så det är önskvärt att möta allas behov. Nedan är processen för att installera Node.js på Mac.

Hur installerar jag Node.js på Mac?

För användare som använder Mac är installationen ganska densamma för Windows. Gå till officiella webbplats för Node.js och ladda ner paketet för Mac.

Steg 1: Ladda ner Package Manager för Mac

Besök den officiella webbplatsen för Node och ladda ner MacOSInstaller för NodeJS:

https://nodejs.org/en/download/current

Klicka på den angivna knappen på skärmen ovan för att påbörja nedladdningen.

Användare kan ange var den ska installeras.

Steg 2: Installera filen Node.js .pkg

Kör installationsfilen och följ installationsguiden:

Klicka på 'Installera'-knappen och installationen av Node.js börjar.

Efter slutförandet av NodeJS-installationen kommer den att visa sammanfattningen:

Klicka på 'Stäng'-knappen för att avsluta installationen.

Steg 3: Verifiera Node.js-installationen och versionerna

För att verifiera att Node.js har installerats och för att kontrollera dess version, använd följande kommando:

nod -- version

Steg 4: Uppgradera NPM globalt

Utför kommandot nedan för att uppgradera NPM för alla systemanvändare med flaggan '–global':

sudo apt installera npm -- global

Steg 5: Ställ in nodsökvägen till $PATH-variabel

Kör följande kommando för att ställa in PATH-variabeln för NodeJS:

export PATH =/ usr / lokal / git / bin :/ usr / lokal / bin : $PATH

Notera: I kommandot ovan är '/usr/local/bin' platsen där NodeJS är installerat som standard.

Steg 6: Uppdatera PATH-information i '.bash\_profile'

Lägg till sökvägsdetaljerna till '~/.bash\_profile' med kommandot nedan:

eko 'export PATH=/usr/local/bin:$PATH' >> ~ / . våldsamt slag \_profil

Steg 7: Uppdatera ~/.bashrc

För att göra den tillgänglig för alla användare, kör kommandot nedan:

källa ~ / . bashrc

Det handlar om att installera NodeJS och ställa in PATH-variabeln i MacOS för NodeJS.

Hur installerar jag Node.js på Linux?

För att installera Node.js på valfritt Debian-baserat Linux-operativsystem, följ steg-för-steg-proceduren nedan:

Steg 1: Öppna terminalen

Starta först terminalen med kortkommandot 'CTRL+ALT+T':

Steg 2: Uppdatera och uppgradera systemet

Utför kommandot nedan för att uppdatera och uppgradera systemets arkiv:

sudo apt uppdatering && sudo apt uppgradering - och

Steg 3: Installera Node med hjälp av apt package manager

Efter att ha uppdaterat systemets arkiv installerar du Node.js från den officiella APT-pakethanteraren med kommandot:

sudo apt installera nodejs

Steg 4: Verifiera nodinstallationen

När det är installerat, verifiera installationen genom att kontrollera versionen av Node.js med hjälp av det givna kommandot nedan:

nod - i

Steg 5: Installera NPM

Det är en bra praxis att installera NPM tillsammans med NodeJS eftersom det krävs för det mesta. NPM är också tillgängligt i det officiella APT-förvaret och kan installeras med det givna kommandot:

sudo apt installera npm

Steg 6: Verifiera NPM-installationen

Kontrollera även NPM-versionen för att verifiera installationen av NPM med följande kommando:

npm - i

Så här kan du installera Node och NPM på Debian-baserade Linux-operativsystem.

Hur man skriver första Node.js-programmet? (Hej världen)

Allt har satts för att börja på vår väg att utveckla applikationer i Node.js. Låt oss skapa vårt första program som är ganska vanligt. När någon börjar lära sig ett nytt språk eller ramverk är det första programmet vanligtvis att skriva ut 'Hello World'. Att säga hej till alla på ett annat sätt är en känsla och berätta för dem om starten på vår nya resa. Nedan är koden för att komma igång:

// App.js

trösta. logga ( 'Hej världen!' ) ;

Använd följande kommando för att köra detta kodskript:

nod App. js

Produktion

Uttalandet Hello World kommer att loggas till terminalen:

Hur importerar jag nodkärnmoduler?

Användare måste använda funktionen 'require()' för att använda den önskade modulen att arbeta med i sitt kodskript. Till exempel, om modulen 'fs' (Filsystem) ska användas kommer importkodraden att vara:

konst fs = behöva ( 'fs' )

Detta skulle importera alla funktioner i den modulen och lagra den i fs-variabeln som är en konstant variabel som innebär att dess innehåll inte kan ändras under körningen. Genom att använda variabeln 'fs' kan användaren sedan implementera de önskade funktionerna.

Låt oss nu skapa ett enkelt kodexempel där en modul importeras och dess funktionalitet används i kodskriptet.

Exempel: Använda HTTP-modulen

konst http = behöva ( 'http' ) ;

// Enkel HTTP-server

konst httpServer = http. skapaServer ( ( req, res ) => {

res. skrivhuvud ( 200 , { 'Innehållstyp' : 'text/html' } ) ;

res. skriva ( '' ) ;

res. skriva ( '' ) ;

res. skriva ( '' ) ;

res. skriva ( '' ) ;

res. skriva ( '' ) ;

res. skriva ( 'Hej världen!' ) ;

res. skriva ( '' ) ;

res. skriva ( '' ) ;

res. skriva ( '

Hej världen!

'
) ;

res. skriva ( '' ) ;

res. skriva ( '' ) ;

res. slutet ( ) ;

} ) ;

// Lyssnar på port 3000

httpServer. lyssna ( 3000 , ( ) => {

trösta. logga ( 'Server lyssnar på port 3000' ) ;

} ) ;

I denna kod:



  • 'const http = require('http')' importerar innehållet i http-modulen och lagrar det i en konstant variabel 'http'.
  • 'const httpServer = http.createServer((req, res) =>' skapar en enkel HTTP-server och lägger till texten Hello World tillsammans med lite grundläggande HTML. createServer-metoden skapar en server med två argument, ett är begäran på servern och det andra är svaret som genereras för den begäran.
  • “httpsServer.listen(3000, () =>” anger port 3000 på den lokala värden och loggar ett meddelande till terminalen att servern är aktiv och lyssnar på port 3000.

För att köra Node-appen, kör JS-filen med nodkommandot enligt nedan:

nod App. js

Där App.js är filnamnet.







Produktion



Meddelandet i terminalen när den här koden körs skulle vara:







Nu måste vi verifiera utdata på serversidan och kontrollera om meddelandet 'Hello World' är utskrivet där eller inte:



Meddelandet har skrivits ut på servern och teckensnittet har justerats med hjälp av lite grundläggande HTML.

Node.js: Kärnmoduler

Några moduler i Node.js är:

  • http: det gör det möjligt att skapa en HTTP-server i Node.js
  • hävda: en samling av assert-funktioner hjälper främst vid testning
  • fs: det tillåter hantering av filoperationer
  • väg: en uppsättning metoder som hanterar filsökvägar
  • bearbeta: den ger information och kontroller om den aktuella Node.js-processen
  • du: den ger information om operativsystemet
  • frågesträng: ett verktyg som används för att analysera och formatera URL-frågesträngar
  • url: den här modulen tillhandahåller verktyg för URL-upplösning och analys

Hur installerar jag NPM-paket?

NPM (Node Package Manager) hjälper till att hantera och använda tredjepartsbibliotek eller verktyg i Node.js-projektet. Följ stegen nedan för att installera NPM-paket.

Steg 1: Installera det önskade paketet

Låt oss installera expressmodulen som är ganska vanlig för att utveckla webbapplikationer i Node.js. För att installera express använd kommandot:

npm installera express

Denna kommandorad kommer att installera expressmodulen i din projektmapp.

Steg 2: Spara modulen till Package.json

NPM uppdaterar automatiskt filen package.json med det nya beroendet. Om du vill spara det explicit som en utveckling av projektberoende, använd flaggorna –save-dev eller –save.

npm installera express -- spara - dev # Spara som ett utvecklingsberoende

npm installera express -- spara # Spara som ett produktionsberoende

Varför är NPM-paket viktiga?

NPM-paketen är mycket viktiga i utvecklingsmiljön Node.js. Nedan är de möjliga orsakerna:

  • Kodåteranvändbarhet: NPM-paket sparar koden som kan användas igen. De sparar tid för utvecklare genom att erbjuda optimerade färdiga metoder.
  • Beroendehantering: NPM gör det lättare att hantera projektkraven. Listan över projektkrav finns i filen package.json vilket gör det enklare att använda och dela projektkraven.
  • Gemenskapens bidrag: NPM hjälper till att bygga en stor grupp utvecklare som delar med sig av sitt arbete för andra att använda i många gratisprogrampaket. Detta kollektiva bidrag påskyndar applikationsutvecklingsperioden.
  • Versionskontroll: NPM låter dig skriva ner paketversionen för ditt projekt. Detta säkerställer smidigt arbete och hantering av nödvändiga ändringar.
  • Effektivitet och konsekvens: Att använda effektiva paket förbättrar projektets effektivitet och gör det möjligt att upprätthålla kodkonsistens i hela utvecklingsteamet.

Det är allt. Du har inte bara lärt dig hur du installerar de önskade paketen utan har också en förståelse för varför dessa paket krävs i din utvecklingsmiljö för Node.js.

Hur kommer man igång med Express JS?

För att göra effektiva webbapplikationer används Express.js-ramverket. 'Express'-modulen är utmärkt för att bygga webbapplikationer i Node.js. Nedan följer proceduren för hur du kommer igång med detta paket.

Steg 1: Installera Express

För att installera Express använd följande kommando i terminalen:

npm installera express

Expressmodulen kommer att installeras om den redan är installerad, då kommer detta kommando att uppdatera modulen

Steg 2: Testa expressmodulen i en applikation

Ovanstående steg kommer att installera express i paketmappen och användaren kan använda modulen genom att importera den i kodskriptet genom att använda modulen 'require' som

konst uttrycka = behöva ( 'uttrycka' )

Låt oss testa ett enkelt kodskript som använder funktionen hos expressmodulen:

konst uttrycka = behöva ( 'uttrycka' ) ;

konst app = uttrycka ( ) ;

app. skaffa sig ( '/' , ( req, res ) => {

res. skicka ( 'Hej Express!' ) ;

} ) ;

konst hamn = 3000 ;

app. lyssna ( hamn, ( ) => {

trösta. logga ( `Server lyssnar på port $ { hamn } ` ) ;

} ) ;

I ovanstående kod:

  • ' const express = kräver('express') ' importerar expressmodulen och lagrar den i en konstant variabel 'express', med vilken vi kan använda funktionerna som är associerade med detta bibliotek.
  • ' const app = express() ” används för att definiera en uttrycklig applikation.
  • 'app.get('/', (req, res) =>' definierar vägen för expressapplikationen att skicka ett svar 'Hej Express' till den uttryckliga ansökan.
  • Hamnen 3000 anges i konstantvariabeln med namnet 'port' på den lokala värden.
  • 'app.listen(port, () =>' skapar en lyssnare på port 3000 och loggar ett meddelande på terminalen att servern lyssnar på den angivna porten.

Produktion

Använd kommandot nedan för att köra denna applikation:

nod App. js

Utgången i terminalen skulle se ut som

Så servern är aktiv och lyssnar på port 3000 på den lokala värden. Att komma åt den länken i webbläsaren skulle visa utdata som

Det handlar om expressmodulen för hur vi kan installera den, skapa en applikation och starta en serverport.

Hur renderar man statiska filer i Express?

I Express används funktionen express.static() för att rendera statiska filer som HTML, CSS, bilder, etc. Nedan är processen för att rendera statiska filer i Express.

Steg 1: Skapa ett projekt

Innan du startar se till att express är installerat om inte så kan du köra följande kommando:

npm installera express -- spara

Detta kommando kommer att installera expressmodulen lokalt i mappen node_modules och uppdatera den i filen package.json.

Steg 2: Skapa en fil för statiska filer

För det andra, skapa en mapp i arbetskatalogen. Skapa en mapp med namnet public för att lagra de statiska filerna som ska renderas. Placera alla statiska HTML- och CSS-filer i den här katalogen för att rendera dem.

Steg 3: Konfigurera Express för att rendera de statiska filerna

Använd metoden express.static() för att ange katalogen för de statiska filer som användaren vill rendera.

Filrenderingen använder två kodskript, ett för backend som tar HTML-koden som placeras i den offentliga mappen. HTML-koden hålls enkel eftersom vår huvudtyngd ligger på backend.

Node.js-skript

konst uttrycka = behöva ( 'uttrycka' ) ;

konst app = uttrycka ( ) ;

app. använda sig av ( uttrycka. statisk ( 'offentlig' ) ) ;

konst hamn = 3000 ;

app. lyssna ( hamn, ( ) => {

trösta. logga ( `Server lyssnar på port $ { hamn } ` ) ;

} ) ;

I denna kod:

  • 'const express = require('express')' importerar expressmodulen i skriptet för att använda dess funktionalitet.
  • 'const app = express()' startar applikationen
  • 'app.use(express.static('public'))' anger katalogen för att hämta filerna och tillhandahålla dem ett uttryckligt program för att använda dem och rendera dem.
  • Hamnen 3000 anges för den uttryckliga ansökan.
  • ':app.listen(port, () =>' indikerar att servern är aktiv och lyssnar vid den angivna porten genom att logga meddelandet.

HTML-skript

DOCTYPE html >

< endast html = 'i' >

< huvud >

< meta teckenuppsättning = 'UTF-8' >

< metanamn = 'viewport' innehåll = 'width=device-width, initial-scale=1.0' >

< titel > Statisk Exempel på rendering titel >

huvud >

< kropp >

< h1 > Använda Express för att rendera Statisk Filer h1 >

kropp >

html >

I den här koden görs bara en rubrik eftersom fokus ligger på backend inte frontend, men ytterligare funktioner kan läggas till efter behov.

Produktion

Kör nu skriptet Node.js med följande kod:

nod App. js

Följande meddelande kommer att loggas i terminalen som indikerar att servern är redo och lyssnar på port 3000.

Öppna den lokala värdporten 3000 i webbläsaren för att se HTML-kodskriptet som renderas av expressmodulen

Det är allt för att återge statiska filer i expressen. Låt oss nu ta en titt på hur man renderar dynamiska filer.

Hur renderar man dynamiska filer i Express?

Användare kan rendera de dynamiska filerna i Express med hjälp av en mallmotor för att generera HTML dynamiskt baserat på data. Mallen som används nedan är EJS (Embedded Javascript) som är ganska populär för att rendera dynamiska filer.

Steg 1: Installera EJS

Använd följande kommando för att installera EJS i din projektmapp

npm installera ejs -- spara

Steg 2: Konfigurera Express med EJS

Ställ in EJS-mallen som en visningsmotor i din Node.js-fil.

//App.js

konst uttrycka = behöva ( 'uttrycka' ) ;

konst app = uttrycka ( ) ;

konst HAMN = 3000 ;

app. uppsättning ( 'visa motor' , 'Nej' ) ;

app. använda sig av ( uttrycka. statisk ( 'offentlig' ) ) ;

app. skaffa sig ( '/användar ID' , ( req, res ) => {

konst användar ID = req. params . id ;

konst användardata = {

id : användar ID,

Användarnamn : `användare$ { användar ID } `,

e-post : `användare$ { användar ID } @exempel. med `,

} ;

res. framställa ( 'användare' , { användare : användardata } ) ;

} ) ;

app. lyssna ( HAMN, ( ) => {

trösta. logga ( `Server körs på http : //localhost:${PORT}`);

} ) ;

Operationerna som utförs av ovanstående kod är:

  • 'const express = require('express')' importerar expressmodulen från nodmodulerna.
  • 'const app = express()' skapar en instans för expressapplikationen.
  • 'app.set('view engine', 'ejs')' konfigurerar express med ejs-mall för att rendera filerna dynamiskt.
  • 'app.use(express.static('public'))' möjliggör visning av statiska filer lagrade i den publika mappen i Node-projektet.
  • 'app.get('/user/:id', (req, res) => {...})' definierar citattecken som lyssnar efter förfrågningar.
  • 'res.render('user', { user: userData })' återger EJS-mallfilerna.
  • 'app.listen(PORT, () => {...})' startar servern på port 3000 och användaren kan skriva ' http://localhost:3000/user/123 ' i webbläsaren.

Steg 3: EJS-mall

En katalog med namnet 'views' skapas i projektkatalogen och i denna mapp skapas en EJS-mallfil 'user.ejs'. Den här filen kommer att innehålla det dynamiska innehållet som användaren vill rendera. Klistra in följande kod i den här filen

DOCTYPE html >

< endast html = 'i' >

< huvud >

< meta teckenuppsättning = 'UTF-8' >

< metanamn = 'viewport' innehåll = 'width=device-width, initial-scale=1.0' >

< titel > Användarprofil titel >

huvud >

< kropp >

< h1 > Användarprofil h1 >

< sid > användar ID : <%= användare. id %> sid >

< sid > Användarnamn : <%= användare. Användarnamn %> sid >

< sid > E-post : <%= användare. e-post %> sid >

kropp >

html >

Eftersom huvudmålet är att rendera filinnehållet dynamiskt så har endast den nödvändiga frontkoden använts.

Steg 4: Starta servern

Användaren kan nu starta expressapplikationen genom att använda följande kodavsnitt:

nod App. js

Där App.js är namnet på filen i katalogen. Efter att ha kört denna kod kommer terminalen att visa följande meddelande

Nu kan användaren använda länken http://localhost:3000/user/123 i webbläsaren och innehållet renderas dynamiskt som

Det är allt för att rendera filinnehållet dynamiskt med hjälp av expressmodulen i Node.js.

Slutsats

Artikeln förklarar Node.js från början till slut, och visar hur det fungerar med sin non-stop och händelsebaserade JavaScript-tid för många evenemang. Den tittar på Express, ett välkänt verktyg för webbbyggande, och nämner även NPM, och hur man visar statisk eller dynamisk information på en webbplats. Även om artikeln diskuterar allt i detalj, är det en bra nybörjarguide för att lära sig om Node.js.