NodeJS: Serwer HTTP
w Praktyce
10 godz. 44 min · Node.js · Full-stack i Programowanie
Piotr PalarzWeb DeveloperCzego się nauczysz
- Omówienie platformy Node.js od podstaw
- Techniki tworzenia aplikacji typu CLI
- Rózne metody tworzenia serwerów sieciowych
- Omówienie wewnetrznej budowy platformy Node.js
- Prace z zewnetrznymi modulami i npm
- Framework express.js i wspólprace z baza danych MongoDB
- Przyklady praktycznych aplikacji
- Mase cennych porad i wskazówek
Co znajdziesz w Kursie?
W kursie tym poznasz platformę Node.js od podstaw, aż po bardziej zaawansowane koncepcje. Zaczniemy od omówienia czym jest Node, a także jakie może być zastosowanie tej technologii. Następnie przejdziemy przez proces instalacji i napisanie swojego pierwszego skryptu. Już na samym początku dokładnie omówimy tworzenie własnych modułów, gdyż jest to wiedza niezbędna, by dobrze zrozumieć funkcjonowanie Node. Następnie dowiesz się czym są zdarzenia, jak działa model “publish / subscribe”, a także czym jest “event-driven development”. Chwilę później omówimy pracę z buforami, stream’ami, a także ze standardowym wejściem i wyjściem. Ta wiedza pozwoli Ci zrozumieć jak tworzone aplikacje mogą otrzymywać od użytkownika dane oraz jak je wyświetlają.
Praca z Systemem Plików
Niezwykle ważnym rozdziałem będzie ten, poświęcony pracy z systemem plików. Szczególnie dla dewelopera, pracującego dotychczas z językiem JavaScript wyłącznie w środowisku przeglądarki internetowej. Node pozwala bowiem tworzyć nowe pliki, zapisywać w nich dane oraz odczytywać i usuwać pliki i katalogi. Przy wszystkich tych operacjach, niezwykle ważna jest jednak asynchroniczna natura Node. Dowiesz się jak działa, a także jakie są jej zalety. Na tym etapie nie zabraknie oczywiście praktycznego projektu, którym będzie aplikacja typu CLI (Command Line Interface). Pozwoli nam ona grupowo zmienić nazwy wielu plików, według podanego wzorca.
Tworzenie Serwerów Siecowych
W kolejnym rozdziale poruszymy fundamentalną dla Node kwestię, mianowicie tworzenie serwerów sieciowych. Zaczniemy od najniższego poziomu, tworząc prosty serwer bazujący na protokole TCP/IP. Wiedza w jaki sposób Node radzi sobie z takim zadaniem, pozwoli później lepiej zrozumieć wyższe warstwy, takie jak np. HTTP czy WebSockets. Chwilę później stworzymy swój pierwszy serwer HTTP, do którego będzie można wysyłać zapytania wprost z przeglądarki internetowej. Omówimy również jak w Node wykorzystać bezpieczne szyfrowanie HTTPS.Na tym etapie będziesz już miał solidną wiedzę jak pracować z Node, jednak zanim przejdziemy dalej, zatrzymamy się, by omówić jak dokładnie działa Node.js, a także jak ta platforma została zbudowana. Dwie dość obszerne lekcje, będą być może jednymi z najważniejszych w tym kursie. Dowiesz się w nich czym jest, a także jak działa jednowątkowa pętla zdarzeń, czym jest proces i wątek, a także zobaczysz kod źródłowy Node.js i wszystkie bloki budulcowe, z jakich Node się składa. To naszym zdaniem niezwykle ważny temat, często jednak pomijany w wielu materiałach. Dzięki dogłębnemu zrozumieniu jednowątkowej natury języka JavaScript i asynchroniczności Node, będziesz mógł tworzyć dużo lepsze aplikacje.
Node.js + Express.js + MongoDB
Node.js posiada kilkanaście wbudowanych modułów, z których w dowolnej chwili można skorzystać. Wszystkie jednak dają nam dużą, niskopoziomową kontrolę, ale czasami sporo kodu należy napisać, by zrealizować jakieś zadanie. Jest to jednak świadomy wybór twórców Node, gdyż całą resztę świetnych rozwiązań, dopisuje nieustannie ogólnoświatowa społeczność deweloperów. Zdecydowana większość z modułów ląduje w rejestrze npm. Jest to genialny package manager, który pozwoli nam wyszukiwać, pobierać i aktualizować niezliczoną ilość modułów. Dowiesz się zatem jak korzystać z npm, a chwilę później zaczniemy wykorzystywać zgromadzone tam moduły w dalszej pracy.Jednym z najpopularniejszych modułów jest express.js, który pozwala w bardzo prosty sposób tworzyć serwery HTTP. Grzechem byłoby zatem z niego nie skorzystać. Dowiesz się wszystkiego co niezbędne, by zacząć tworzyć własne aplikacje bazujące na protokole HTTP z użyciem express.js, a także kilku dodatków do tego systemu. Zobaczysz jak routować zapytania, jak korzystać z middleware czy serwować statyczne pliki. Następnie omówimy współpracę z bazą danych MongoDB i z jej wykorzystaniem stworzymy API typu REST. Stworzona aplikacja pozwoli odczytywać dane z bazy i przesyłać je do klienta w formacie JSON, a także dodawać nowe dane, aktualizować i usuwać je. Wszystko to zgodnie z dobrymi praktykami pracy z REST.
Praktyczny Projekt i ES6
Chwilę później czeka Cię kolejny praktyczny projekt - skracacz linków. Stworzymy wspólnie aplikację, która pozwoli skrócić dowolny adres URL do krótkiej formy. Oczywiście będzie działać również w drugą stronę! Kiedy przejdziemy pod skrócony adres, przekieruje nas do odpowiedniej witryny. Node.js to platforma wręcz stworzona do tworzenia aplikacji typu real-time, dlatego w kolejnym rodziale podejmiemy temat technologii WebSockets. Dowiesz się jakie są jej zalety, a także jak pracować z nią po stronie serwera i klienta. Tutaj czeka nas kolejny praktyczny, niezwykle ciekawy projekt. Wykonamy bowiem czat grupowy. Aplikacja ta pozwoli dowolnej ilości użytkowników podłączyć się do czatu podając swój nick, a następnie wysyłać widoczne dla wszystkich wiadomości. Zaimplementujemy nawet takie rozwiązania jak wyświetlanie statusów o dołączeniu kogoś do czatu, a także o jego opuszczeniu.W przedostatnim rodziale tego kursu podejmiemy tematykę dobrych praktyk pracy z Node.js. Na początku omówimy najważniejsze konstrukcje nowej specyfikacji EcmaScript 2015, które są znakomicie wspierane w Node. Chwilę później omówimy jak korzystanie z Promises uprości, a także ulepszy nasz kod. Wśród dobrych praktyk nie zabraknie również informacji o debugowaniu aplikacji. Zobaczysz sprawdzone sposoby, by znaleźć błędy lub lepiej, krok po kroku, zrozumieć jak działa napisany wcześniej kod. Dowiesz się również jak pracować z błędami, by Twoje aplikacje działały w sposób przewidywalny.
Praktyczny projekt z Git i Heroku
Ostatni rozdział w całości został poświęcony temu, co zwykle jest pomijane w innych materiałach, mianowicie wdrażaniu aplikacji do produkcji. Przez cały ten kurs pracować będziemy lokalnie, lecz kiedy aplikacje są już gotowe, wypadałoby udostępnić je światu. Wdrażanie aplikacji napisanych z użyciem Node.js nie jest jednak tak oczywiste, jak np. wgrywanie WordPress’a u wybranego hostingodawcy. Ty będziesz miał jednak możliwość zobaczyć, jak wdrożyć napisany przez nas grupowy czat na platformie Heroku. Jest to bardzo popularny serwis działający jako PaaS (Platform as a Service). Za darmo będziesz mógł w ciągu kilku chwil uruchomić swoją aplikację.Zobaczysz o co należy zadbać, by wszystko poszło gładko. Serwisy typu PaaS dbają o bardzo wiele aspektów wdrażania i serwowania naszych aplikacji, takich jak bezpieczeństwo oraz nieustanną dostępność. Mają jednak pewne ograniczenia. Z tego powodu, dowiesz się również jak wdrożyć swoją aplikację na serwerze wirtualnym VPS z systemem Ubuntu Server. Takie rozwiązanie daje nam całkowitą kontrolę, ale także obarczone jest większą odpowiedzialnością. Zaczniemy od instalacji na serwerze platformy Node.js, systemu kontroli wersji GIT, a także innych niezbędnych modułów
Konfiguracja środowiska i porady
Następnie zobaczysz jak skonfigurować swoje lokalne środowisko tak, by za pomocą GIT’a wysyłać kod do zdalnego serwera, a potem jednym poleceniem wdrażać go do produkcji. Dowiesz się również jak jednocześnie serwować wersję produkcyjną oraz developmencką. W rodziale tym poruszymy również inne kwestie, takie jak procesy potomne czy tworzenie klastrów. Dzięki tej wiedzy, będziesz mógł maksymalnie wykorzystać dostępne zasoby serwera. Na sam koniec tego kursu rzucimy okiem również na inne, nie przedstawione wcześniej zastosowania Node, a także nakreślimy dalszą drogę nauki w tym zakresie.
Dla kogo jest ten kurs?
Kurs ten jest dla wszystkich osób, które dobrze czują się w technologiach frontendowych, tj. HTML, CSS i JavaScript, a teraz chcą rozpocząć swoją przygodę z back-endem. Im zatem lepiej znasz język JavaScript, tym więcej wyciśniesz z Node, natomiast nie jest wymagana bardzo zaawansowana wiedza z zakresu tego języka.
Po tych kilkudziesięciu już lekcjach doszliśmy wreszcie do tego, co w Node.js będzie nas interesowało
najbardziej, czyli do modułu HTTP, który pozwoli nam tworzyć serwery takie, do których można się podłączyć
z przeglądarki internetowej.
Ja już sobie ten moduł tutaj zaimportowałem w pliku index.js z katalogu 20.
Natomiast na stronie dokumentacji wygląda to w następujący sposób.
Bardzo ważne jest to, że ten moduł korzysta pod spodem z modułu net, który pokazałem ci przed momentem
w poprzedniej lekcji.
Nie pozostaje nam nic innego, jak utworzyć sobie serwer. I znowu stworzymy metodą czy w zasadzie stałą
const server i metodą http.createServer, czyli zauważ, że bardzo podobnie jak w poprzedniej lekcji
możemy utworzyć serwer i tutaj podać funkcję, która będzie wywoływana dla każdego nowego połączenia.
Ale tym razem nie musimy się z żadnego Telnetu podłączać, bo mamy świetny klient, który potrafi się komunikować
po protokole HTTP, jakim jest przeglądarka internetowa.
Dlatego będziemy chcieli to zrobić w ten sposób, że podamy w funkcji, czyli tutaj, dwa parametry.
One są niezbędne.
Pierwszy jest to request, a drugi jest to response.
Możesz je dowolnie nazwać, ale zawsze mamy taką parę. Czyli w momencie kiedy przeglądarka internetowa
podłącza się do strony, to wysyła zapytanie - jest to request - a w momencie, kiedy dostaje odpowiedź, to jest
to response.
I tutaj na response będziemy mogli różne rzeczy odsyłać.
Mam nadzieję, że taką podstawową wiedzę z zakresu protokołu HTTP masz. Tłumaczyłem, jak to działa, w kursie
JavaScript w praktyce, gdzie omawialiśmy AJAX.
Ale jeżeli nie, to tak czy siak powinieneś większość tych rzeczy bardzo dobrze zrozumieć.
Teraz jeszcze bardzo ważne jest to, że zarówno request, jak i response, są to po raz kolejny streamy.
Gdybyś chciał się dokładnie dowiedzieć, który obiekt jest pod tym request, czyli req, i response w dokumentacji,
aby poczytać trochę o tym więcej, to jeżeli chodzi o request, to tutaj znajdziesz coś takiego jak
IncomingMessage.
Dokładnie to jest w tym miejscu, czyli wszystko, co jest poniżej,
będzie się odwoływało do właśnie tego obiektu, który jest tutaj.
A z kolei response będzie znajdował się pod http.ServerResponse - to znajduje się w tym miejscu.
Czyli wszystko, co jest poniżej, będzie dotyczyło tego obiektu, który jest tutaj.
Skoro powiedziałem, że oba te obiekty są to streamy, to pokażę ci teraz, jak możemy odesłać do klienta cokolwiek
po podłączeniu się do takiego serwera. Poprzez response będziemy to robić. Skoro jest to stream, to
ma pewnie metodę write. Napiszmy sobie Hello World!
W ten sposób. Ale aby nam połączenie w nieskończoność nie wisiało, tutaj w przeglądarce abyśmy nie mieli
takiego kółeczka przez długi czas, aż timeout się nie wykona, to będziemy chcieli jeszcze napisać
res.end albo to Hello world!
mogliśmy przekazać od razu tutaj. Teraz musimy taki serwer sobie uruchomić
bardzo podobnie jak lekcji poprzedniej. A więc server.listen. Podamy tutaj port, może 8000. W ten sposób.
I następnie znowu funkcję, która nam zrobi console.log.
W ten sposób. Czyli serwer został uruchomiony pod adresem HTTP, bo jest to serwer HTTP localhost 8000.
Tak się do tego będziemy podłączać, więc uruchommy sobie ten serwer. Widzimy console.log i proces znowu wisi,
czyli wszystko jest ok. I teraz otworzę nową kartę i z przeglądarki, która rozumie ten protokół HTTP, podłączymy
się tutaj i otrzymaliśmy Hello World!
Czyli wszystko działa jak należy.
Dzięki temu, że skorzystaliśmy tutaj z response end, to całe to połączenie zostało zakończone, bo za pomocą
write moglibyśmy wielokrotnie przesyłać informacje, tak jak to się dzieje w przypadku streamów. Bo właśnie
response jest streamem. Przejdźmy teraz do przeglądarki i kliknę tutaj prawym przyciskiem. I wybiorę Zbadaj,
bo chcę ci pokazać bardzo ważną rzecz. Otóż w panelu Network możemy sobie podejrzeć wszystko, co
tutaj się dzieje, ale musimy odświeżyć, aby raz jeszcze się podłączyć do tego serwera. I teraz będziemy
mogli doskonale zobaczyć, co tutaj się dzieje.
Zignorujmy na razie favicon, dlatego że Chrome automatycznie wysłał zapytanie po taki zasób.
Ale przejdźmy w to miejsce.
I tutaj będziesz mógł bardzo dobrze zobaczyć, co się działo.
Mianowicie mówiłem ci, że przeglądarka wysyła zapytanie do serwera, a więc jest to request i wraz z takim
zapytaniem protokół HTTP działa tak, że możemy wysłać najróżniejsze nagłówki. I część z tych nagłówków
serwer może rozumieć i coś z nimi robić, a część to mogą być dowolne nagłówki, z których my możemy w aplikacji
skorzystać. I przeglądarka domyślnie do tego serwera wysłała takie oto nagłówki. Tutaj różne rzeczy powiedziała
serwerowi i serwer z części z nich,
tak jak wspomniałem, korzysta, np. z connection: keep-alive itd.
Tak to jest zaimplementowane w Node i w każdym serwerze, który rozumie protokół HTTP.
Natomiast później za pomocą response, czyli w tym miejscu, odesłaliśmy coś do przeglądarki i również
odpowiednie nagłówki były tam wstawione.
Zerknijmy sobie, co mieliśmy w response headers.
Otóż jak widzisz, serwer Node automatycznie dodał takie oto nagłówki do odpowiedzi i przeglądarka również
mogła je w odpowiedni sposób zrozumieć i zinterpretować. To, co jest jednak najważniejsze w tym wszystkim,
jest to zawsze status, czyli Status Code.
Jest to 200 OK,
a to oznacza, że poprawnie się podłączyliśmy i otrzymaliśmy informację. My możemy zarządzać oczywiście tymi
statusami i wpisać sobie dowolny status, np. 404. Niemniej jednak to, co jest istotne, to przeglądarka
przecież powinna wyświetlać kod HTML, ale czy potrafi to zrobić, jeżeli nie wie, co zostało przesłane?
Otóż nie.
W tym przypadku odesłaliśmy wyłącznie Hello World!, ale było to odesłane jako czysty tekst.
Natomiast aby przeglądarka potrafiła to zinterpretować jako kod HTML, czyli utworzyć całe drzewo DOM
i tak dalej, wyrenderować tę stronę, to musimy dobrać odpowiedni nagłówek.
I teraz będę chciał ci pokazać, jak możemy to zrobić.
Mianowicie na response mamy coś takiego jak writeHead.
Ta metoda jako pierwszy parametr przyjmuje status code, jaki chcemy odesłać. W naszym przypadku będzie
to 200.
Domyślnie też byłoby to 200, ale jako drugi przyjmuje taki obiekt, w którym możemy wpisać dowolne nagłówki.
Więc mogę sobie tutaj wpisać nagłówek content type. Jest to jeden z nagłówków, który rozumie przeglądarka.
I podam jego wartość jako text/html.
Jest to tzw. mime type.
No i być może wiesz, że różne zasoby mają różne mime type. Np. obrazki to mielibyśmy tutaj powiedzmy
image/jpg.
Listę takich mime type możesz znaleźć pod takim adresem.
Tutaj, w Wikipedii, zobaczysz najpopularniejsze typy mime
właśnie dla różnych zasobów. Warto wiedzieć, że tak to działa i przeglądarka wtedy wie, z jakim
contentem ma do czynienia.
Jeżeli teraz tak zrobimy i coś odeślemy, np. response write albo od razu zrobimy end, aby to zakończyć.
I napiszemy i podamy jakiś kod HTML,
to przeglądarka już to odpowiednio zinterpretuje, ale serwer znowu musimy zatrzymać i musimy go uruchomić
od nowa,
aby te zmiany były zaaplikowane. I teraz mogę odświeżyć. Widzimy od razu, że strona została wyrenderowana.
Natomiast jeżeli przejdziemy tutaj do response headers, to zauważ, że ten nagłówek, który wpisałem content type
text/HTML został tutaj dodany. Dzięki temu przeglądarka wiedziała, że ma do czynienia z kodem HTML.
Wróćmy jednak do edytora Sublime Text i pokażę ci jeszcze jedną metodę. Mianowicie metoda writeHead pozwala
nam wpisać status i obiekt z różnymi nagłówkami.
Natomiast później nie możemy już dodać żadnego nagłówka, bo nagłówki muszą być na początku odpowiedzi,
a dopiero później jakby body, czyli treść takiej odpowiedzi.
Tak to działa na protokole HTTP, więc przeglądarka najpierw musi otrzymać te nagłówki. I kiedy skorzystamy
z writeHead, to nie możemy już zmieniać nagłówków. Natomiast mamy jeszcze inną metodę, która nazywa się
setHeader i również na response możemy z niej skorzystać.
Ona pozwoli nam ustawić nagłówek. i tutaj możemy napisać content type.
W ten sposób.
I znowu text/HTML.
I teraz możemy znowu skorzystać z setHeader i znowu z setHeader, aby dodać więcej takich nagłówków.
I one zostaną do przeglądarki przesłane dopiero później, kiedy zaczniemy przesyłać jakąś treść. Czyli
za pomocą write albo end przesyłany treść.
I wtedy Node wyśle najpierw wszystkie zakolejkowane za pomocą setHeader nagłówki. Sprawdzmy, czy to zadziała dokładnie tak
samo.
Ok. Odświeżę.
No i wygląda na to, że wszystko jest dokładnie w ten sam sposób. Mamy tutaj taki oto nagłówek
content type.
Jak zatem widzisz, pracujemy na dość niskim poziomie.
Trudno będzie stworzyć na bazie tego, co tutaj mamy, dobrze działający serwer, który będzie potrafił serwować
do przeglądarki wszystkie pliki. Ale tym się nie martw. Rozwiążemy ten problem później. Natomiast chcę
ci pokazać, jak to na tym najniższym poziomie działa, abyś miał lepsze zrozumienie tego wszystkiego w Node.
Głównym celem tego kursu z mojego punktu widzenia jest to, abyś jak najlepiej zrozumiał, jak to wszystko
działa.
Gdybyś chciał ustawić Status Code, tak jak to zrobiłem tutaj - 200. Ale nie korzystać z metody writeHead,
to możesz to zrobić za pomocą res.statusCode.
Jest to taka właściwość i tutaj napisać 200. Wybór należy do ciebie. Zależy, z których metod będziesz chciał
korzystać.
Na razie zajęliśmy się obiektem response, ale chcę ci pokazać, że bardzo wiele ważnych informacji znajduje się
jeszcze w obiekcie request.
Przede wszystkim adres, do jakiego się podłączamy. Bo zauważ, że tutaj odesłało nam Hello World!, ale jeżeli
przejdę sobie do strony O nas, to domyślasz się, że na stronie internetowej, na której nie ma takiego adresu, będzie
błąd 404.
Czyżby? Jednak nie. W Node.js tak nie jest, bo nie ma znaczenia, czy taki zasób istnieje czy nie.
Nigdzie tego nie sprawdziliśmy. Dlatego możemy to zrobić tutaj, w tym obiekcie request i wtedy zdecydować
dopiero -
dlatego właśnie, że pracujemy na bardzo niskim poziomie z tym protokołem HTTP -
czy chcemy wyświetlić jakiś błąd czy nie.
Możemy to zrobić i tak naprawdę będę chciał te informacje wszystkie odesłać do klienta, aby w przeglądarce
się wyświetliły.
Będzie nam łatwiej na tym pracować.
Dlatego zamiast tutaj robić Hello World!, to będziemy chcieli napisać res.write.
I tutaj skorzystamy z template stringu - ja go wkleję od razu. W ten sposób. Czyli chcę utworzyć h3, gdzie wpiszę
HTTP i odwołam się do request httpVersion. To wszystko w dokumentacji znajdziesz. Tutaj będzie wersja
http, a następnie request metod. Domyślna metoda, kiedy wchodzimy na stronę internetową, jest to get. To
widać również tutaj. Ale być może wiesz, że mamy również inne metody typu post, delete czy np. put. To sobie będziemy
chcieli wyświetlić.
I jeszcze jedną linijkę tutaj dodam.
A w zasadzie nawet dwie linijki.
Pierwsza z nich to będzie właśnie req.url. Ten URL to będzie właśnie np. O nas albo slash, jeżeli będziemy
tutaj bezpośrednio na serwerze. A jako trzecią chciałbym dodać taki tag pre w HTML-u i wyświetlić wszystkie
nagłówki, które zostały przysłane przez przeglądarkę, czyli request headers.
Mówiłem ci, że można je znaleźć w tym miejscu - request headers. One będą do serwera przesłane i są dla nas
dostępne pod request.headers.
Ale aby je poprawnie wyświetlić, bo będzie to obiekt JavaScript, aby je wyświetlić jako json możemy
skorzystać w JavaScrypt z JSON.stringify.
I tutaj byłoby to wszystko brzydko w jednej linijce wyświetlone, dlatego możemy jako trzeci parametr
podać tutaj ilość spacji,
jeżeli chodzi o wcięcia przy formowaniu json. Dzięki temu będzie to ładnie sformatowane. I teraz jeżeli
zatrzymam ten serwer, uruchomię go od nowa
i tutaj odświeżę, to te wszystkie dane zostały dla nas odesłane. I tak jak ci wspomniałem, tutaj za pomocą
JSON.stringify i czterech spacjach przy cięciach
mamy wszystkie te nagłówki odpowiednio wyświetlone. Będą one dokładnie takie same, jak możesz zobaczyć
tutaj, w request headers.
Tak to wygląda. Natomiast wersja protokołu HTTP jest to 1.1, metoda to get, a adres URL.
jest to po prostu slash.
I teraz jeżeli sobie przejdziemy np. do O nas, to zauważ, że URL zmieni się na O nas, ale cały czas tak naprawdę
serwujemy dokładnie to samo i obsługujemy to za pomocą tej samej funkcji.
Przy okazji zauważ jeszcze, że ciągle nam się to tutaj kręci, a więc połączenie się nie zakończyło, bo zapomniałem
tutaj na końcu dopisać response end. To jest to, o czym mówiłem. Jest to bardzo ważne, dlatego zatrzymam serwer,
uruchomię go raz jeszcze i teraz gdybyśmy odświeżyli, to od razu to połączenie jest skończone.
Wróćmy jednak tutaj, bo na koniec chcę ci pokazać jeszcze, jak możemy sobie routować różne zapytania. Skoro
wiesz, że za pomocą request URL możemy odczytać, o jaki zasób chodzi, np. O nas,
to będziemy mogli tym samym routować sobie zapytania.
Zrobimy to w taki sposób, ja wkleję gotowy kod.
To, co mieliśmy wcześniej, sobie wykomentowałem. Natomiast teraz utworzyłem zmienną body, która ma wartość null i status
będzie to 200.
I zauważ, że sprawdzam sobie w if, czy URL był to slash.
Jeżeli tak, to do body przypiszemy Strona główna.
Jeżeli O nas, to O nas.
A jeżeli jakiś inny, to Nie znaleziono.
I status zmienię sobie na 404. I teraz poniżej metodą, którą już ci pokazywałem writeHead ustawimy ten status
i następnie content type text/html.
No i to wszystko, co mieliśmy wcześniej. Zatrzymam jeszcze raz ten serwer, uruchomię i tutaj przejdziemy sobie
do strony głównej.
Zauważ, że wszystko działa poprawnie. Ale np. dla favicon mamy już 404, czyli nasz serwer zaczyna działać
poprawnie. Chrome sobie bez naszej wiedzy wysłał zapytanie do serwera pod favicon.ico.
Aby to zobaczyć w tym miejscu, to mógłbyś sobie za każdym takim połączeniem robić tutaj console.log.
I ten console.log dokładnie tu byłby wyświetlany, czyli Chrome
wysłał sobie zapytanie po favicon w tym miejscu, gdzie req.url.
Byłoby to po prostu favicon.ico - i w ten sposób. Jak widzisz, w tym momencie nie pasuje to do żadnego if,
czyli jesteśmy w tym miejscu. A więc ustawimy status na 404 i dokładnie to pokazała nam tutaj przeglądarka,
czyli taki zasób nie istnieje.
Przejdźmy sobie do O nas.
Zauważ, że mamy tutaj O nas.
Nie ma żadnego problemu, wszystko się wyświetla.
Zapomniałem jednak o tym, że chcemy jeszcze wyświetlić body.
Więc zróbmy to tutaj. Res.write(body) - szybko raz jeszcze zatrzymamy ten serwer. Wykonam go od nowa. Przejdziemy
do przeglądarki na stronę główną.
Ok.
I widzimy teraz - strona główna, przejdźmy do O nas.
Mamy tutaj O nas - nie ma problemu. Ale teraz przejdźmy do czegokolwiek.
Może to być style.css, chcemy pobrać sobie taki plik.
No i mamy Nie znaleziono, a tutaj mamy 404.
Jak zatem widzisz, tak wygląda podstawa tworzenia serwera HTTP na bardzo niskim poziomie w Node.js.
Oznacza to tylko tyle, że mamy ogromną kontrolę nad tym, co chcemy zrobić.
Ale jak widzisz, już widzimy dużo problemów, np. takich jak routowanie zapytań, takich jak np. obsługa
ciasteczek. Co gdybyś chciał z nich korzystać?
Nie ma problemu, bo ciasteczka są przesyłane jako nagłówki, ale trzeba je odpowiednio sparsować.
Co gdybyś chciał te ciasteczka ustawiać itd?
Tym wszystkim możemy się oczywiście zająć, ale jest to bardzo żmudne i wymaga dużej wiedzy. Abyśmy nie
musieli tego robić, to będziemy jeszcze w tym kursie wielokrotnie korzystać z genialnych modułów napisanych
przez społeczność dla Node.js, które nam to umożliwią.
Natomiast zapamiętaj jedno - każdy z tych modułów korzysta pod spodem z tego, co my napisaliśmy tutaj, czyli
właśnie z http.createServer i z tego wszystkiego, co widzimy w tym miejscu.
Dlatego chciałbym ci pokazać, w jaki sposób taki serwer można stworzyć.
Jeżeli bardzo prosty serwer będziesz tworzył, możesz go napisać sam.
Natomiast każdy bardziej zaawansowany serwer będzie wymagał już tego, abyśmy skorzystali z jakiegoś frameworka.
I pokażę ci później w tym kursie bardzo popularny framework Express, który znakomicie nam to wszystko
ułatwi i zadba o wiele rzeczy, o których nawet nie mielibyśmy pojęcia, takich właśnie jak ustawienie odpowiednich
typów mime type, takich jak ustawienie odpowiednich statusów, jak zarządzanie plikami cookies itd.