Introduktion till NodeJs

Introduktion

När du försöker lära dig om webben

utveckling, finner vi vanligtvis att front-end är betydligt mer tillgängligt än back-end. Det finns många anledningar till detta, särskilt känslan av omedelbar feedback som kommer från att ändra en viss del av en sida i koden, och märka att förändringen tillämpas på webbplatsen. Denna feedback är ofta användbar för nybörjare, eftersom den gör det möjligt för dem att justera sin kod och lära sig av sina misstag. Tyvärr är det inte fallet med backend: ofta ägnas en betydande mängd arbete åt att ställa in miljön i förväg och installera de beroenden som behövs för att få ett enkelt "Hello World"-meddelande att visas på terminalen., görs ständigt många framsteg i open source-gemenskapen för att underlätta utvecklingsprocessen av ramverk, och att förbättra utvecklarens upplevelse är ett bra exempel på detta kod i Javascript bekvämt, och erbjuder en mängd inbyggda verktyg och funktioner som skiljer den från sina konkurrenter. I den här artikeln kommer vi att utforska NodeJs och dess ekosystem, med ett praktiskt tillvägagångssätt, och bygga ett fullt fungerande projekt.

Vad ska vi bygga?

Att göra-applikationer är ett go-to-projekt för nybörjare som lär sig frontend-utveckling. Det är därför vi bestämde oss för att bygga ett Todo list API. Detta kommer att göra det möjligt för oss att lägga till databeständighet till vårt gränssnitt och ge oss möjligheten att manipulera dessa data (genom att lägga till, uppdatera, ta bort uppgifter, etc...).

Den slutliga koden kan hittas här.

Våra verktyg

Vi kommer att använda en förenklad teknikstack för detta projekt. Det kan betraktas som en minimal version av många verktyg du hittar i verkliga projekt, anledningen är att idéerna på högre nivå är desamma. Detaljerna för implementering och val av ett specifikt verktyg framför ett annat är inte viktiga för att komma igång.

NodeJs, som vi nämnde, är ett av de mest populära Javascript-ramverken för att bygga applikationer på serversidan.
ExpressJs är ett minimalt Javascript-ramverk som används ovanpå NodeJS. Det påskyndar utvecklingsprocessen genom att använda många inbyggda funktioner. Det används också som ett sätt att standardisera utvecklingsmetoderna i NodeJS-projekt för att underlätta användningen för ingenjörer.
LowDB är en enkel databas i minnet. Dess enkelhet tillåter oss att visa upp hur man interagerar med en databas i ett NodeJs-projekt, utan att ta itu med mer avancerade ämnen som distributioner och konfigurationer.

Nu när vi har identifierat alla verktyg som vi kommer att använda, låt oss gå till våra tangentbord och börja koda!

Installation

Node är tillgänglig på alla plattformar. Alla installationsguider finns på den officiella webbplatsen. Windows-användare bör se till att lägga till nod sökväg till miljövariabler så att den kan användas på kommandoraden.

Vi kommer också att behöva npm installerat. Npm är standardpakethanteraren för NodeJs. Det kommer att göra det möjligt för oss att hantera våra projektberoenden. Installationsguiden finns här.

Projektinitiering

Gå över till länken och klona startprojektet:

Detta är ett enkelt startförråd för vårt projekt. Den innehåller alla beroenden vi kommer att använda tillsammans med projektfilstrukturen. Vi kommer att förklara varje element när det har nåtts. Öppna din terminal, navigera till projektets sökväg och kör kommandot:

npm install

Detta kommer att installera alla beroenden för projektet som anges i filen package.json. package.json är filen som finns i roten av alla Javascript/NodeJs-projekt, den innehåller metadata om det senare och används för att hantera alla projektberoenden, skript och versioner.

När alla beroenden är installerade kan vi starta vår applikation:

npm run start

"start" är ett skript som vi angav i paketet. json filen. Den specificerar inmatningsfilen till vår applikation, som i vårt fall är app.js.

Följande meddelande bör nu visas i din terminal:

Det betyder att vår server startade framgångsrikt och lyssnar efter alla förfrågningar som skickas till port 3000. Låt oss titta på app.js och förklara vad som händer här:

App.js är vår projektpostfil (och den enda vid det här laget). Vi instansierar en expressapplikation med namnet app, anger att alla förfrågningar som har http-metoden "GET" och undersökvägen "/" kommer att hanteras av denna rutt, passerar in en funktion som kallas mellanprogram, som tar in förfrågnings- och svarsobjektet som parametrar. Detta är avgörande, eftersom förfrågan innehåller all information som behövs för att den ska kunna hanteras (parametrar, förfrågningskropp, förfrågningsrubriker, etc..), och svarsobjektet är det som kommer att returneras till klienten. Vi börjar med att bara skicka meddelandet "Hej världen". Efter det låter vi vår applikation lyssna på alla inkommande förfrågningar till den angivna porten (i vårt fall 3000), och loggar meddelandet "Lyssnar på port 3000" för att indikera att vår applikation är igång och redo att ta emot förfrågningar.

Öppna din terminal och skriv "localhost:3000/" i länkfältet och tryck på Enter. Detta är den angivna sökvägen som vi kan använda för att nå vår server lokalt. Du kommer att få följande meddelande:

Databaskonfiguration

Lowdb är en öppen källkodsdatabas som är enkel att använda och kräver ingen specifik installation. Den allmänna tanken bakom det är att lagra all data i en lokal json-fil. Efter att LowDB har installerats (vilket har gjorts när vi installerade alla beroenden), kan vi lägga till följande kod till db.js:

Denna kod är ganska lik den som finns i LowDB:s officiella dokumentation. Vi finjusterade det lite för vårt eget bruk. Låt oss förklara det rad för rad:

De första raderna är för att importera nödvändiga beroenden. "join" är en hjälpfunktion tillgänglig i "path"-modulen. Det är en av kärnmodulerna i NodeJs som erbjuder många metoder för att hantera och hantera sökvägar. "Low" och "JSONFile'' är de två klasserna som exponeras av LowDB. Den första skapar json-filinstansen som kommer att innehålla våra data. Den andra skapar den faktiska databasinstansen som kommer att agera på den. Slutligen är "lodash" ett av de mest använda javascript-biblioteken som erbjuder ett brett utbud av verktygsfunktioner för vanliga programmeringsuppgifter. Vi lägger till den i vår databasinstans för att vi ska kunna använda dess avancerade metoder för att hantera vår data.

Först anger vi sökvägen för filen db.json. Det är filen som kommer att innehålla vår data och skickas till LowDB. Om filen inte hittas på den angivna sökvägen kommer LowDB att skapa en.

Vi skickar sedan filsökvägen till LowDB-adaptern och skickar den till vår nya LowDB-databasinstans. Variabeln “db” kan sedan användas för att kommunicera med vår databas. När databasinstansen väl har skapats läser vi från json-filen med hjälp av db.read(). Detta kommer att ställa in "data"-fältet i vår databasinstans så att vi kan komma åt databasinnehållet. Lägg märke till att vi föregick denna rad med "vänta". Detta för att specificera att den här instruktionen kan ta en okänd tid att lösa, och att NodeJs-processen måste vänta på att den körs innan den fortsätter med resten av koden. Vi gör detta eftersom läsoperationen kräver minnesåtkomst till den angivna filen, och tiden för att utföra denna typ av operation beror på dina maskinspecifikationer.

Nu när vi har tillgång till datafältet ställer vi in det som ett objekt som innehåller en tom array av inlägg, eller snarare kontrollerar vi om filen innehåller några tidigare data och ställer in den tomma arrayen om så inte är fallet.

Slutligen kör vi db.write() för att tillämpa ändringarna vi gjorde på data, och exporterar databasinstansen så att den kan användas i andra filer i vårt projekt.

Arbetsflöde för allmän begäran/svar

Tänk på följande diagram:

Den visar den allmänna arkitekturen som tillämpas i en uppsjö av backend-applikationer byggda med NodeJs/Express. Genom att förstå det allmänna arbetsflödet bakom hanteringen av en förfrågan kan du inte bara bygga och strukturera NodeJs applikationer, utan även att du kan överföra dessa koncept till praktiskt taget vilken teknisk stack du vill. Vi kommer att utforska de olika skikten som stör denna process och förklara deras roller:

## HTTP-begäranslager

Detta är det första lagret i vår applikation, föreställ dig det som en gateway som tar emot ett brett utbud av olika förfrågningar som kommer från olika kunder, varje begäran analyseras sedan och vidarebefordras till den dedikerade delen av applikationen för att den ska hanteras.

Routrar: här syftar vi på Express-routrar, men detta koncept kan hittas i många backend-ramverk. Routrar är ett sätt att tillämpa den logiska fördelningen i vår affärslogik på vår kod, vilket innebär att varje uppsättning element som delar liknande funktioner hanteras av samma post och kan separeras från resten av uppsättningarna. Detta har fördelen av att göra varje komponent i koden oberoende av de andra, och lättare att underhålla och utöka. Mer specifikt, och som ett exempel, kommer alla förfrågningar som uppfyller villkoren för den delade url-sökvägen "/posts" att hanteras av samma router. Beroende på deras http-metod (GET, POST, etc..) kommer en annan styrenhet att användas.
Styrenheter: en styrenhet tar emot filtrerade förfrågningar från routrar, tillämpar ytterligare bearbetning och anropar lämpliga servicemetoder.

Affärslogikskikt

Detta lager är unikt beroende på applikationens specifika användningsfall och affärslogiken bakom det.

Tjänster: Tjänster är en uppsättning metoder som innehåller applikationens kärnlogik. De interagerar också med databasen genom att använda ORMs/ODMs.).
Tredjepartstjänster: många moderna applikationer väljer att delegera en del av applikationens logik till dedikerade tjänster som är tillgängliga via ett API. Tjänster av detta slag kan vara betalningshanteringstjänster, lagring av statiska filer, aviseringar och annat.
ODM/ORM: ORM och ODM fungerar som mellanhänder mellan tjänsterna och databasen. Deras roll är att tillhandahålla en abstraktion på hög nivå på en databas som gör det möjligt för en utvecklare att skriva kod på det programmeringsspråk de väljer istället för dedikerade databasspråk, som SQL.

Data Persistence Layer

Databaser: som vi nämnde tidigare behöver nästan alla applikationer någon form av databeständighet. Denna del hanteras av databaser, och beroende på datas natur, affärslogik och många andra överväganden anses valet av en viss databas framför en annan vara avgörande för applikationens effektivitet och skalbarhet.

Exempel: Lägga till ett inlägg

Nu när vi förstår den allmänna idén bakom arkitekturen, låt oss tillämpa den på vårt enkla exempel. Vi kommer att implementera funktionen att lägga till ett att göra-inlägg i vår applikation. Låt oss anta att alla inlägg har ett unikt id som gör att vi kan identifiera det senare i vår databas, en titel som är en sträng och en ordning som är av typen heltal. Efter vårt diagram börjar vi med att implementera routern. Lägg till följande kod till filen index.js:

Det här är vår routerfil. Vi importerar express och “addPost”-metoden från vår styrenhet (vi kommer att implementera den här inom kort), skapar en instans av expressrouter och binder addPost-metoden till vår router - vilket betyder att för varje begäran som har rotsökvägen och http metoden "POST", kommer metoden "addPost" att anropas för att hantera det.

Innan vi implementerar vår metod i kontrollern refererar vi till den nya routern i vår huvudfil app.js och anger dess sökväg som "/posts": Alla rutter med de angivna sökvägarna kommer att vidarebefordras till denna router, så att den kan hanteras genom de olika styrmetoderna:

Vi importerar routern och namnger den som "inlägg". app.use(“/posts”,..) betyder att alla förfrågningar med undersökvägen “/posts”, oavsett deras http-metod, kommer att dirigeras till den angivna routern.

Andra ändringar av app.js inkluderar att importera databaskonfigurationsfilen för att den ska exekveras, och att använda express.json() som en mellanprogram för att göra det möjligt för oss att komma åt objektet förfrågan body.

Nu när våra rutter är inställda kan vi lägga till metoden "addPost" i filen controller.js:

"addPost" är en middleware-funktion som tar förfrågan, svarsobjekt och nästa funktion som parametrar. När nästa funktion anropas kommer processen att flyttas till nästa mellanprogram i kedjan, eller avsluta begäran. I metodens kod extraherar vi titeln och beställningen från förfrågningskroppen och skickar dessa som parametrar till servicefunktionen "createPost". Den här funktionen tar postattributen, skapar ett nytt inlägg och returnerar det. När det nya inlägget har skapats returnerar vi det till kunden tillsammans med 200-statuskoden, vilket betyder att begäran har lyckats. Du kanske märker att vår kod placeras i ett försök/fånga-block för att fånga upp eventuella oväntade fel och skicka den till nästa mellanprogram. Det anses vara bästa praxis att till alla routrar bifoga en mellanprogramvara för felhantering som extraherar felet och returnerar ett meningsfullt felmeddelande till klienten.

Allt som återstår nu är att implementera funktionen "createPost" i service.js:

Som vi nämnde tidigare när vi förklarade arkitekturens olika lager interagerar servicelagret med datalagringslösningen genom användning av ORM/ODM. Men i vårt exempel behöver vi inte använda en separat ORM, eftersom Lowdb kommer med inbyggt stöd för Javascript. All information om dess syntax finns i dokumentationen.

Metoden "createPost" tar emot titel och ordning som parametrar och använder dem för att skapa postobjektet. För det unika ID:t använder vi ett dedikerat bibliotek som heter "nanoid", som genererar en unik sekvens av tecken. Vi lägger till det nya inlägget i postarrayen i databasen och skriver dessa ändringar; det nya inlägget returneras sedan av funktionen.

Nu när "createPost" är klart är funktionen för att lägga till inlägg nu klar och igång. Vi testar det med Postman, ett populärt verktyg för att testa API:er:

Vi väljer "POST" som http-metoden för begäran tillsammans med den angivna webbadressen "localhost:3000/posts". Vi lägger till titeln och ordningen som json-format i kroppsdelen och skickar förfrågan. Som visas ovan får vi statusen 200 OK tillsammans med det nyskapade inlägget.

Slutsats

Många koncept och idéer har utforskats i det här projektet: Vi täckte hur man installerar och ställer in vår projektmiljö, lärde oss hur man konfigurerar LowDB för lokal databeständighet, utforskade den allmänna arkitekturen för NodeJS/Express backend-applikationer och såg hur man tillämpa det i ett enkelt exempel. Slutligen testade vi vår applikation med Postman.

Avsikten här var att avslöja en förenklad version av allt som ingår i att bygga moderna backend-applikationer. Som vi såg tidigare är NodeJs ett kraftfullt verktyg som gör det möjligt för oss att bygga enkla och komplexa API:er. I kombination med dess rika ekosystem av ramverk, såsom express och en uppsjö av verktyg och bibliotek för nästan alla användningsfall, är det en legitim lösning för modern backend-utveckling - en lösning som vi rekommenderar att lära sig och bemästra.