Uvod u Node.js | codeBlog

Uvod

Da bismo mogli čitaocima predočiti pravi smisao radnog okruženja kao što je Node.Js, bilo bi potrebno da se u mislima vratimo petnaestak godina unazad, u vreme kada je JavaScript još uvek bio samo front-end jezik, a Node.js nije ni postojao.

Ako bismo, pod navedenim uslovima, proveli neko vreme pišući JS skripte, primetili bismo da je JavaScript prilično elegantan i funkcionalan jezik (pod uslovom da smo u stanju da pravilno odmerimo kako sa njim treba postupati i da se zadržimo u okvirima pravila dobrog programiranja), i spontano bi nam palo na pamet kako bi bilo zanimljivo kada bi lepa i pregledna JS sintaksa mogla da se koristi za pisanje desktop programa i/ili kao jezik za razvoj mrežnih servera ....

Mnogi programeri razmišljali su na navedeni način, a neki su i radili na rešenju.

Pre malo više od deset godina (2009), mladi američki programer Rajan Dal (Ryan Dahl), kreirao je Node.js - radno okruženje koje koristi program V8 (JavaScript interpretator otvorenog koda iz Google Chrome-a), i povezuje ga sa ulazno-izlaznim mogućnostima operativnog sistema na kome je instaliran, čime opisani sistem poprima odlike navedene u drugom pasusu: JavaScript sintaksa koja se može koristiti za pisanje desktop programa i - što je programerima posebno "golicalo maštu" (dok takva mogućnost nije postojala) - kreiranje back-end komponenti web aplikacija.

U godinama koje su došle, Node.js je postao izuzetno popularan, pre svega kao serverska tehnologija, ali i kao osnova svojevrsnog ekosistema za kreiranje najraznovrsnijih web aplikacija, desktop programa, biblioteka, modula i drugih softverskih dodataka ....

Pre nego što počnemo (za prave) ....

Kao što smo već pisali, postoje tehnike koje je neophodno poznavati, pre nego što se neko upusti u upoznavanje sa okruženjem Node.js. Pored samih osnova JavaScript-a i funkcija za rad sa nizovima, potrebno je pre svega biti upoznat sa šablonskim niskama, sa funkcijama povratnog poziva i lambda notacijom, kao i sa ostalim tehnikama o kojima smo već pisali u članku o ES6 sintaksi (koji smo linkovali na početku).

Striktno govoreći, poznavanje PHP-a nije neophodan preduslov za upoznavanje sa Node.js-om, ali, smatraćemo (u nastavku), da ste bar okvirno upoznati i sa PHP-om (pri čemu je, više nego poželjno, da ste sa PHP-om upoznati i 'više nego okvirno' :)), i takođe ćemo smatrati da ste upoznati sa osnovnom internet terminologijom, kao i sa HTTP statusima.

Ukoliko su prethodno navedeni uslovi ispunjeni, nastavljamo dalje ....

Što se tiče samog Node.js-a, članak pred vama, kao i drugi članci koje spremamo (koji će za temu imati Node.js i srodne tehnologije), odnosiće se prevashodno (ali ne isključivo), na primenu Node.js-a kao back-end tehnologije, pa je u takvim okolnostima sasvim primereno (i uobičajeno), na početku razmotriti razlike između Node.Js-a i PHP-a (u ovom trenutku, dve najpopularnije tehnologije za razvoj web aplikacija manjeg i srednjeg obima).

Razlike između Node.js-a i PHP-a

Šta je to što Node.js čini veoma zanimljivim radnim okruženjem koje je u pojedinim situacijama bolji izbor od PHP-a i zašto je Node stekao veliku popularnost?

Za razliku od PHP-a, u kome se naredbe izvršavaju sinhrono (što praktično znači da je izvršavanje sledeće naredbe "blokirano" sve dok se prethodna naredba u potpunosti ne završi), u Node.js-u se naredbe izvršavaju asinhrono, što znači da određene naredbe mogu biti pokrenute pre završetka izvršavanja prethodne naredbe.

U praksi to ne znači da se preko Node.js-a 'tek tako' mogu pisati aplikacije u kojima je više procesa pokrenuto istovremeno (Node.js nije multi-threaded okruženje), i ne znači da je "Node.js brži od PHP-a" (pogotovo ne obavezno i uvek), ali, pod određenim okolnostima - može biti brži.

Da pojasnimo, preko tipičnog primera ....

U Node.js-u, pozivi funkcija za pristup bazama podataka neće blokirati dolazeće naredbe (budući da se obrada podataka u bazama obavlja na udaljenom računaru), ali bi zato pokretanje bilo kakve procesorski zahtevne procedure (recimo, while petlje koja računa decimale broja PI preko iterativne formule) - i te kako "ukočilo" aplikaciju.

Jednostavno rečeno, u situacijama kada je potrebno brzo obraditi veliki broj zahteva koji nisu previše zahtevni (po pitanju vremena koje je potrebno za pojedinačnu obradu), Node.js može biti vrlo zanimljivo rešenje (koje najčešće pokazuje bolje performanse od PHP-a).

Pored prethodno navedenih objektivnih okolnosti, prilično smo sigurni da mnogi web developeri poslednjih godina daju prednost Node.js-u iz subjektivnih (i estetskih) razloga - za većinu programera, JS je jednostavno "lepši" i prijemčiviji od PHP-a (to već ostavljamo svakome da samostalno proceni i izabere), a u obzir treba uzeti i praktičnu stranu pristupa u kome se jedan jezik koristi: i za frontend, i za backend (u slučaju Node.js-a).

Instalacija okruženja i pokretanje Node aplikacija

U uvodnom članku, želimo pre svega da pokažemo kako se može pokrenuti jednostavan web server preko Node.js-a (pretpostavljamo da je to, ono što čitaoce najviše zanima), ali, prvo ćemo se ipak upoznati sa osnovnim operacijama sa direktorijumima i datotekama, kao i sa opcijama za pristup bazama podataka, međutim - pre svega navedenog - potrebno je (naravno), da se upoznamo sa još osnovnijim tehnikalijama ....

Instalacija radnog okruženja

Sa adrese nodejs.org, možete preuzeti instalacionu verziju okruženja Node.js koje odgovara operativnom sistemu koji koristite (i potom možete instalirati okruženje Node.js, to jest, Node.js aplikaciju, na vaš računar).

Instalacioni program je mali * i, po završenoj instalaciji, putanja do Node aplikacije biće prijavljena operativnom sistemu.

Kao i u članku koji smo posvetili Python-u, i ovoga puta će komande za pokretanje odgovarati Windows okruženju (u slučaju Linux-a i MacOS-a, putanje prema direktorijumima i samoj izvršnoj datoteci Node.js aplikacije se razlikuju, ali su ostale komande gotovo istovetne).

Pokretanje korisničkih aplikacija

Pre nego što počnemo da pokrećemo Node aplikacije koje smo samostalno kreirali, potrebno je prvo da otvorimo sistemsku konzolu, * i da potom unesemo sledeću naredbu (ista naredba važi i za Linux i MacOS okruženja):

		
node -v

Slika 1. - Provera verzije Node.js aplikacije.

Ako je sve u redu, biće prikazan sledeći odgovor (s tim da će verzija u vašem slučaju najverovatnije biti drugačija, to jest novija):

		
v13.14.0

Slika 2. - Primer konzolnog ispisa koji se dobija pri pokretanju naredbe sa slike 1.

Uspešnim izvršavanjem komande node -v, ustanovili smo dve stvari:

pre svega to da je Node.js uredno instaliran i da je putanja do izvršne datoteke Node.js aplikacije, uredno prijavljena operativnom sistemu (pa se stoga komanda node može pokretati iz bilo kog direktorijuma)
konkretnu verziju paketa Node.js

Sada možemo pokretati i naše sopstvene skripte.

Kao prvo, prostim unošenjem komande node (bez dodatnih argumenata), dobijamo direktan pristup JS interpretatoru:

		
D:\node_apps> node
Welcome to Node.js v13.14.0.
Type ".help" for more information.
>

Slika 3. - Primer pokretanja Node.js interpretatora (pri čemu se JS komande mogu predavati direktno).

.... kome možemo direktno predavati instrukcije.

Ako interpretatoru predamo sledeće komande (jednu za drugom) ....

		
// 1.
console.log(a)

// 2.
let a = 12
console.log(a)

// 3.
console.log(`а + 10 = ${a + 10}`)

Slika 4. - Primer komandi koje ćemo redom predati Node.js interpretatoru (za probu).

.... dobićemo sledeće povratne poruke:

		
// 1.
undefined

// 2.
12

// 3.
a + 10 = 22

Slika 5. - Poruke koje se ispisuju u konzoli, po pokretanju naredbi sa prethodne slike.

Međutim, nećemo se (gotovo nikada), interpretatoru obraćati direktno (naravno, niko vam ne brani da takav pristup, ako vam se baš sviđa, isprobavate do mile volje ).

Node skripte se gotovo uvek pokreću iz datoteka (s tim da ćemo ozbiljnije projekte smeštati u zasebne direktorijume, i pisati za njih konfiguracione JSON datoteke).

Baš kao što smo i do sada radili, kada smo pisali programe i sajtove u drugim jezicima, i ovoga puta kreirajte zaseban direktorijum/folder za vaše Node.js projekte (osnovna adresa koju ćemo mi koristiti u članku je "D:\node_apps"), i potom sačuvajte, na lokaciji koju ste predvideli za Node aplikacije, datoteku sa nazivom proba.js (poznata ekstenzija na koju ste već navikli) - i unesite u datoteku sledeći sadržaj:

		
console.log("Dobar dan! :)");

Slika 6. - Nezaobilazni program "zdravo svete" (Node.js varijanta), sa kojim uvek počinjemo upoznavanje sa novim jezicima/tehnologijama.

Otvorite konzolu (ako ste je zatvarali) i unesite sledeće komande:

		
D:
cd \node_apps

Slika 7. - Konzolne naredbe za prebacivanje u direktorijum sa Node.js skriptama (koje ćemo kreirati).

Na kraju, pokrenite "hello world" aplikaciju;

		
node proba.js

Slika 8. - Pokretanje prve Node skripte.

U konzoli će biti ispisan sledeći tekst:

		
D:
cd \node_apps
D:\node_apps> node proba.js
Dobar dan! :)

Slika 9. - Konzolni ispis koji se dobija pokretanjem prethodno napisane skripte.

Sve je vrlo slično kao da smo pokrenuli program pisan u C-u (i skoro isto onako kako smo videli da se pokreću Python skripte).

Node Package Manager - npm

Na ovom mestu, upoznaćemo se ukratko i sa programom Node Package Manager (u daljem tekstu - npm), koji olakšava posao instaliranja Node.js modula, biblioteka, ili celokupnih aplikacija.

Neki od modula koje ćemo koristiti, kao što je recimo fs (File System), deo su osnovne instalacije paketa Node.js (fs je jedan od tzv. 'core modula'), međutim, drugi moduli se moraju dodatno instalirati (i u takvim situacijama, "na scenu stupa" npm).

Modul mysql, koji (očekivano), služi za povezivanje Node aplikacija sa MySql bazama podataka, jedan je od modula koji se moraju dodatno instalirati (a kasnije će nam trebati u članku).

Da bismo instalirali navedeni paket, u konzolu je potrebno uneti sledeću naredbu (podrazumevamo da se još uvek nalazimo u folderu sa Node.js projektima):

		
npm install mysql

Slika 10. - Komanda za instaliranje modula mysql, preko menadžera paketa npm (Node Package Manager).

Po uspešno završenoj instalaciji, u prilici smo da koristimo modul mysql (sa svim pripadajućim funkcijama).

U prethodnom slučaju, modul mysql postao je dostupan aplikaciji koju pišemo - i ostalim (manjim) aplikacijama koje možete pokretati iz probnog foldera, ali, aplikacije koje su smeštene u druge foldere - ne mogu koristiti modul mysql.

Jednostavno, korisnicima je dat izbor da module instaliraju 'u lokalu' (kao u gornjem primeru), * ili tako da budu dostupni svim Node aplikacijama na računaru, što se postiže preko argumenta -g ('global'):

		
npm install mysql -g

Slika 11. - Instaliranje modula mysql preko npm-a (uz korišćenje argumenta -g).

Menadžer paketa npm, može se iskoristi i za inicijalizaciju projekata, ali je u tom slučaju potrebno da svaki projekat, bude smešten u zaseban direktorijum (folder).

Pokretanjem sledeće komande (na primer, unutar foldera D:\node_proba\projekat_01) ....

		
npm init -y

Slika 12. - inicijalizacija projekta preko programa npm.

.... kreira se "prazna" * konfiguraciona JSON datoteka:

		
{
	"name": "projekat_01",
	"version": "1.0.0",
	"description": "",
	"main": "index.js",
	"directories": {
		"doc": "docs"
	},
	"scripts": {
		"test": "echo \"Error: no test specified\" && exit 1"
	},
	"keywords": [],
	"author": "",
	"license": "ISC"
}

Slika 13. - Primer konfiguracione JSON datoteke (koja nastaje pokretanjem programa npm).

Navedeni pristup (inicijalizacija projekta preko programa npm), svakako pomaže u organizaciji većih i ozbiljnijih projekata, ali, temu inicijalizacije projekata, kao i detaljniji osvrt na modul nodemon (preko koga se aplikacija automatski restartuje pri svakom čuvanju datoteka iz projekta), ostavićemo za sledeći članak, u kome ćemo detaljno opisati postupak kreiranja web servera uz pomoć paketa Express.js (verovatno najpopularnije biblioteke za Node.js).

Što se tiče osnovne funkcionalnosti Node aplikacija, budući da smo se već bavili osnovnim komandama JavaScript-a kao i drugim temama vezanim za ovaj jezik, nećemo "ponavljati priču" o dobro poznatim C-olikim konstrukcijama JS-a (kao što su grananja, petlje, način definisanja i pozivanja funkcija i sl), ali, iznećemo nekoliko primedbi opšteg tipa, koje se tiču razlika između izvršavanja skripti u browser-u i pokretanja Node.js aplikacija.

Razlike između Node.js-a i izvršavanju JS-a u browseru

Sa jedne strane, Node.js jeste "JavaScript koji se izvršava u konzoli" (što ćemo na primerima jasno videti), ali, sa druge strane - u odnosu na pokretanje JavaScript-a u browseru - postoje određene razlike koje su očigledne i neke razlike koje su 'malo manje očigledne':

Node.js ima pristup file sistemu, ali nema pristup DOM strukturi, browser-u (objekti window i document) i pripadajućoj funkcionalnosti (kukiji i localStorage)
JavaScript u browser-u nema pristup file sistemu, ali (naravno/očekivano/dobro poznato), ima pristup DOM strukturi i ostalim navedenim opcijama u browserima

Ono što je verovatno važnije (što, rekli bismo, ponekad "žulja" programere koji su navikli na standardni JS na web sajtovima) - ne postoji globalni opseg promenljivih: promenljiva deklarisana izvan funkcija nije (a pogotovo ne automatski), dostupna svim modulima (datotekama) unutar projekta, već samo onom modulu u kome je deklarisana.

Primer jednostavne Node.js aplikacije

Node.js je (kao što smo već naglasili), popularna serverska tehnologija, a jedan od osnovnih zadataka u back-end programiranju je, kao što već znamo, priprema HTML sadržaja.

Za sam početak, kreiraćemo vrlo jednostavnu Node.js aplikaciju koja (po pokretanju), čuva HTML dokument na lokaciji po izboru, a budući da smo se već upoznali i sa šablonskim niskama, formatiranje ćemo obaviti upravo preko šablonskih niski.

Prvo ćemo (upravo po obrascu sa kojim smo se upoznali u članku o šablonskim niskama), definisati funkciju koja vraća sadržaj HTML dokumenta:

		
function formatiranjeHTMLDokumenta(title, naslov_h1) {
	let htmlDoc = `
<!DOCTYPE html>
<html>
	<head>
		<title>${title}</title>
	</head>
	<body>
		<h1>${naslov_h1}</h1>
	</body>
</html>
`;

	return htmlDoc;
}

Slika 14. - Funkcija koja vraća formatirani HTML ispis.

Za upis u datoteku, koristićemo (već najavljenu) funkciju writeFile iz modula fs ("File System" - jedan od 'core' modula; sadrži funkcije za čitanje i upis u datoteke, i druge funkcije vezane za operativni sistem).

		
const fs              = require('fs');
const nazivDatoteke   = 'index.html';
const sadrzajDatoteke = formatiranjeHTMLDokumenta("Node aplikacija #1", "Glavni naslov");

function proveraUpisa(err) {
	if (err) {
		console.error(err)
		return;
	}

	console.log(`Datoteka ${nazivDatoteke } je kreirana.`);
	console.log("Sadržaj je upisan.");
}

fs.writeFile(nazivDatoteke, sadrzajDatoteke, 'utf8', proveraUpisa);

Slika 15. - Skripta za formatiranje HTML datoteke koja koristi funkciju sa prethodne slike. Po pozivu metode writeFile, datoteka će biti sačuvana na lokaciju koju smo izabrali.

Opšta šema poziva funkcije writeFile podrazumeva četiri argumenta:

naziv datoteke (koju je potrebno kreirati i/ili popuniti tekstualnim sadržajem)
tekstualni sadržaj koji se upisuje u datoteku
metodu enkodiranja (UTF-8)
funkciju povratnog poziva, koja će se izvršavati posle (pokušaja) upisa

		
fs.writeFile(nazivDatoteke, sadrzajDatoteke, 'utf8', callback);

Slika 16. - Opšta šema poziva metode writeFile iz modula fs.

Četvrti argument je definisan kao funkcija povratnog poziva, koja prima jedan argument (poruku o grešci), a ovoga puta, callback funkciju nismo implementirali preko arrow notacije (već kao standardnu imenovanu funkciju), budući da nije u pitanju "funkcija manjeg obima koja se efikasno može zapisati u jednom ili dva reda".

Takvo rešenje, u ovom slučaju smatramo elegantnijim i praktičnijim, međutim (budući da nije u pitanju ni funkcija prevelikog obima), takođe se može koristiti i lambda notacija:

		
fs.writeFile(nazivDatoteke, sadrzajDatoteke, 'utf8', (err) => {
	if (err) {
		console.error(err)
		return;
	}

	console.log(`Datoteka ${nazivDatoteke } je kreirana.`);
	console.log("Sadržaj je upisan.");
});

Slika 17. - Primer sa prethodne slike, prepravljen tako da koristi funkciju povratnog poziva koja je implementirana preko lambda notacije.

Iako smo već najavili da u uvodnom članku nećemo koristiti baze podataka pri pokretanju servera (što će biti tema poslednjeg poglavlja), svakako smatramo da je potrebno upoznati se, već na početku, sa osnovnim funkcijama za pristup bazama podataka preko Node.js-a.

Povezivanje sa MySql bazom i preuzimanje podataka

Da bismo išta mogli da radimo sa MySql bazama (baš kao i u primerima gde smo za povezivanje sa MySql bazama koristili PHP), potrebno je prvo obezbediti najosnovniju funkcionalnost, to jest - povezati Node aplikaciju sa bazom podataka.

Kreirajte novu datoteku sa prigodnim nazivom i unesite u datoteku sledeći sadržaj:

		
const mysql = require('mysql');

const veza  = mysql.createConnection({
	host:     "localhost",
	user:     "root",
	password: "",
	database: "korisnici"
});

veza.connect(err => {
	
	if (err) {
		 console.log("Greška u povezivanju sa MySql serverom!");
		 throw err;
	}
	
	console.log("Uspešno ste se povezali sa MySql serverom.");

});

Slika 18. - Osnovna verzija Node.js skripte za povezivanje sa bazom podataka.

Primećujemo da je (jedini) argument funkcije connect, callback funkcija (koja se aktivira posle povezivanja sa bazom).

Ovoga puta, smatrali smo da je lambda notacija, dobar izbor za implementaciju osnovnog povratnog poziva, međutim, konkretnu funkciju preko koje ćemo zapravo čitati sadržaj tabele (iz baze podataka), mnogo radije ćemo implementirati kao standardnu imenovanu funkciju (koju ćemo 'spremiti unapred'):

		
/* -------------------------------------------- */
// Funkcija za čitanje podataka iz baze
// U pitanju je imenovana funkcija koja se,
// (kao što smo već navikli), ne poziva na mestu
// na kom je definisana
/* -------------------------------------------- */
function CitanjeTabele(veza, tabela, ime, prezime) {
	let upit = `SELECT * FROM ${tabela} WHERE ime="${ime}" AND prezime="${prezime}" ORDER BY id ASC`;
	
	veza.query(upit, (err, rezultat, polja) => {
		if (err) {
			console.log("Greška pri prosleđivanju upita!");
			throw(err);
		}

		console.log(rezultat);
		console.log(rezultat[0].ime);
		console.log(rezultat[0].prezime);
		console.log(rezultat[0].email);
	});
}
/* -------------------------------------------- */
const mysql = require('mysql');

const veza  = mysql.createConnection({
	host:     "localhost",
	user:     "root",
	password: "",
	database: "korisnici"
});
/* -------------------------------------------- */
// Poziv funkcije za čitanje podataka,
// koju smo ranije pripremili, obavlja se
// unutar funkcije connnect.
/* -------------------------------------------- */
veza.connect(err => {
	if (err) {
		 console.log("Greška u povezivanju sa MySql serverom!");
		 throw err;
	}
	console.log("Uspešno ste se povezali sa MySql serverom.");
	CitanjeTabele(veza, "korisnici", "Petar", "Petrović");
});
/* -------------------------------------------- */
console.log("Proba async ....");
/* -------------------------------------------- */

Slika 19. - Node.js skripta koja pristupa bazi korisnici i čita podatke iz tabele.

U funkciji CitanjeTabele, koristili smo metodu query (objekta veza), preko koje smo bazi (sa kojom se povezujemo) prosledili upit.

Ugnežđavanje funkcija, na ovako jednostavnom primeru, i dalje deluje (bar donekle) pregledno, međutim, lako možemo intuitivno zaključiti da, ukoliko bi "povratni pozivi koristili (dodatne) povratne pozive .... (u mislima dodajte još koji 'nivo rekurzije')" .... kod više ne bi bio (ni iz daleka (!)) pregledan.

Ugnežđavanje povratnih poziva i (što je mnogo bitnije) - sintaksne konstrukcije koje omogućavaju da se (višestruko) ugnežđeni pozivi izbegnu - biće tema članka o asinhronom programiranju u Javascriptu (koji je već u pripremi i biće objavljen uskoro).

Što se tiče podataka koje smo preuzeli iz MySql baze, vidimo da je način pristupa podacima idejno sličan načinu pristupa u PHP-u, ali postoje i razlike:

umesto da se preko funkcije (u PHP-u je to funkcija mysqli_fetch_assoc), sadržaj čita red-po-red, redovima se može direktno pristupiti, preko indeksa
za pristup pojedinačnim podacima, koriste se nazivi polja tabele (koji se pojavljuju kao polja objekta rezultat).

Za sam kraj uvodne priče o Node.js-u ("ono što smo čekali") - pokrenućemo lokalni web server.

Pokretanje jednostavnog web servera

Kada smo koristili PHP za pokretanje web sajtova, nismo previše brinuli o tome šta radi sam PHP interpretator (što je donekle očekivano jer, ako koristimo paket kao što je Apache, PHP interpretator se pokreće automatski, a na internet serverima za koje plaćamo hosting, tipično nećemo biti u mogućnosti da samostalno pokrećemo PHP interpretator).

Sa Node aplikacijama, situacija je sa jedne strane malo drugačija, i moraćemo sami da pokrenemo server (koji je pre toga potrebno konfigurisati), ali, sa druge strane, procedura nije (iole značajno) komplikovanija u odnosu na proceduru u PHP-u (na koju smo navikli).

U osnovnom smislu, web server je program koji obraća pažnju na mrežni saobraćaj koji je usmeren prema računaru na kome je program pokrenut: kada se na odgovarajućem mrežnom portu pojavi zahtev za određenim vidom obrade podataka, server proverava zahtev i - ukoliko je zahtev uredno formatiran - započinje priprema sadržaja koji će biti vraćen korisniku (klijentu), koji je zahtevao sadržaj.

Još prostije, korisnici upućuju serveru URL-ove ("putanje"), server tumači putanje (recimo, putanje /, /blog i /kontakt su dozvoljene; ostale putanje nisu), i ukoliko je korisnik naveo jednu od dozvoljenih putanja, dobiće od servera odgovor u vidu sadržaja (u browseru će se otvoriti naslovna stranica, blog ili kontakt stranica).

Ukoliko zahtev nije uredno poslat, odgovor servera će biti neki od "nepovoljnih" HTTP statusa.

Da se vratimo na primer ....

Aplikaciju ćemo smestiti u datoteku "probni_server.js" (za sada nećemo ipak kreirati i zaseban podfolder), unećemo sledeći sadržaj ....

		
const http = require('http');
const fs   = require('fs');

const hostname = '127.0.0.1';
const port     = process.env.port || 8080;

const server = http.createServer((req, res) => {
	res.statusCode = 200;
	res.setHeader('Content-Type', 'text/html');
	fs.createReadStream('index.html').pipe(res);
});

server.listen(port, hostname, () => {
  console.log(`Server na adresi http://${hostname}:${port}/ je pokrenut ....`);
});

Slika 20. - Node.js skripta za pokretanje web servera.

.... i potom pokrenuti server (kao što bismo pokrenuli bilo koju drugu Node aplikaciju):

		
node probni_server

Slika 21. - Naredba za pokretanje web servera (skripta sa prethodne slike), u konzoli.

Što se tiče parametara koje smo koristili za kreiranje servera, prepoznajemo:

IP adresu (127.0.0.1 - što je praktično localhost)
port (process.env.port || 8080)
statusni kod (200)

Što se tiče tehnikalija koje (možda) "ne prepoznajemo" na samom početku, osvrnimo se za sada na objekte/promenljive req i res: u pitanju su objekti koji sadrže parametre zahteva koji je korisnik uputio (za šta je zadužen objekat req - skraćeno od "request"), kao i detaljan odgovor servera (za šta je zadužen objekat res - skraćenica od "response").

Metoda pipe() (preko koje se direktno predaje odgovor klijentu, to jest, objekat res), posebno je zanimljiva, jer se preko navedene metode sadržaj HTML datoteke index.html preusmerava u objekat res (koji "nosi" sadržaj stranice koja će biti prikazana). *

Pri pozivu Node aplikacije, videli smo da ne moramo koristiti ekstenziju ".js" (nismo morali ni do sada, ali, hteli smo da budemo precizni na samom početku), a gledajući konzolu, možemo steći utisak da aplikacija .... "stoji i ne radi ništa"?!

Međutim, kreirali smo Node aplikaciju koja (osim poruke koja se ispisuje na početku), ne komunicira sa krajnjim korisnicima preko konzole, već - preko internet browsera.

Ako otvorimo browser i unesemo adresu localhost:8080, biće prikazana stranica koju smo kreirali preko funkcije formatiranjeHTMLDokumenta (iz prvog primera).

* Koncept "protočne obrade" (eng. - pipeline/piping), podrazumeva prosleđivanje rezultata obrade jednog programa (ili, u našem slučaju, funkcije), drugom, odnosno - "sledećem" programu.

Navedeni pristup posebno je zastupljen na UNIX-u i operativnim sistemima koji su nastali iz UNIX-a (Linux, BSD), što možemo videti na primeru sledećih naredbi:

ls -l | grep "oktobar" > pretraga_oktobar.txt

Komanda ls prikazuje sadržaj direktorijuma - što bi inače značilo da će (u konzoli) biti prikazane sve datoteke i svi poddirektorijumi - ali, budući da se rezultat ne šalje na standardni izlaz (konzolu), već se šalje komandi grep (pretraga), biće odbačeni svi rezultati koji ne sadrže u imenu nisku "oktobar" i na kraju - umesto da rezultati (izvršavanja komande grep) budu prikazani u konzoli - biće preusmereni (preko komande >) u datoteku "oktobar.txt"

U slučaju Node servera koji smo kreirali, pojam "pajpovanja" podrazumeva da će rezultat čitanja datoteke index.html, biti prosleđen u objekat res.

Šta je REPL?

Sada kada vidimo da server funkcioniše (u osnovnom smislu), osvrnimo se još jednom na tok komunikacije između klijenta i servera.

Program "osluškuje" mrežni saobraćaj preko porta 8080, odnosno, proverava da li postoje zahtevi koji su upućeni serveru i čim se pojavi zahtev, program proverava url * i servira klijentu predviđeni sadržaj (u konkretnom slučaju, statičku HTML stranicu).

Pošto je (jedan) zahtev korisnika rešen, aplikacija se vraća na "osluškivanje" (praktično: "očekivanje budućih zahteva").

Skraćenica REPL iz gornjeg naslova (Read-Evaluate-Print-Loop), označava upravo navedeni princip:

Read ("osluškivanje" konekcije)
Evaluate (provera/obrada zahteva)
Print (prikaz stranice, u slučaju da postoji pravilno primljen i obrađen zahtev)
Loop (povratak na osluškivanje konekcije)

Sledeći koraci ....

Uvodni članak o okruženju Node.js, zamislili smo kao kratak uvod u osnovne tehnikalije, pa ovoga puta nećemo 'širiti diskusiju', međutim, budući da smo priču o "Node serverima" tek načeli, svakako ćemo se u doglednoj budućnosti pozabaviti upravo temom pokretanja servera.

Koristićemo okruženje Express.js, koje predstavlja jednostavnu i funkcionalnu nadogradnju osnovnog okruženja (popularno: "micro framework"), definisaćemo rute i odgovore, predvidećemo mehanizme za obradu korisničkih grešaka, koristićemo šablone za kreiranje HTML-a i naravno - povezaćemo web aplikaciju sa bazom podataka (a bavićemo se i brojnim drugim tehnikalijama).

Pored "Express servera", teme kojima ćemo takođe posvetiti pažnju, biće: razlike između PHP-a, Node.js-a i drugih back-end tehnologija (pri čemu ćemo se detaljno pozabaviti i PHP interpretatorom), asinhrono programiranje u JS-u, AJAX, Fetch API (a "negde usput", napravićemo i kratak osvrt na back-end tehnologije koje se zasnivaju na Python-u).

Tema ima "podosta", ali, tim bolje ....