W tym krótkim wstępie pragnę zaprosić do lektury, która wprowadzi Cię w podstawy Node.js i pozwoli przełamać barierę lub obawy, które sporo osób miewa przed wejściem do świata backendu. Jest to artykuł rekomendowany dla osób bardzo początkujących, które stawiają pierwsze kroki w tym obszarze. Node.js to nie tylko narzędzie do pracy z backendem, ale także ogromne możliwości, które pozwalają tworzyć skrypty, aplikacje w czasie rzeczywistym czy narzędzia CLI (jedno z nich dziś stworzymy).

Wiele osób może zastanawiać się, czy warto uczyć się Node.js, szczególnie jeśli nie mają jeszcze dużego doświadczenia z programowaniem. To pytanie jest zasadne, ponieważ na rynku dostępnych jest wiele technologii umożliwiających tworzenie aplikacji serwerowych i obsługę backendu. Wyróżnia się jednak na tle innych rozwiązań kilkoma kluczowymi cechami, które sprawiają, że warto poświęcić czas na jego naukę.

Node.js to środowisko uruchomieniowe JavaScript, które pozwala na korzystanie z tego języka poza przeglądarką internetową, na przykład na serwerze. Jest ono oparte na silniku V8, czyli tym samym silniku, który napędza przeglądarkę Google Chrome.

Znajduje zastosowanie w wielu obszarach:

• tworzenie API – szybko budujesz backend dla aplikacji webowych i mobilnych.

• aplikacje w czasie rzeczywistym – idealne do chatów, gier online i innych systemów wymagających WebSocketów.

• streaming danych – obsługuje strumieniowanie wideo, muzyki czy plików.

• automatyzacja procesów – ułatwia tworzenie narzędzi do automatyzacji, jak skrypty CLI.

• integracje z systemami – łączy się z bazami danych i innymi serwisami.

Uczenie się Node.js to inwestycja, która przyniesie korzyści zarówno początkującym, jak i zaawansowanym programistom. Dzięki swojej wszechstronności, wydajności i bogatemu ekosystemowi, pozwala tworzyć nowoczesne aplikacje, które spełniają wymagania współczesnych użytkowników. Bez względu na to, czy chcesz budować aplikacje serwerowe, rozwijać API, czy automatyzować procesy – Node.js dostarczy Ci odpowiednich narzędzi i możliwości.

Od czego zatem zacząć? Potrzebujemy oczywiście Node.js, który możesz pobrać z oficjalnej strony. Ważne, aby wybrać odpowiednią wersję: dla większości zalecana jest wersja LTS (Long Term Support), która jest stabilna i wspierana przez dłuższy czas. Na stronie znajdziesz również informację o wersji Current, która oferuje najnowsze funkcje, ale może być mniej stabilna i skierowana głównie do zaawansowanych użytkowników. Po krótkiej i intuicyjnej instalacji możesz sprawdzić, czy wszystko przebiegło pomyślnie. Otwórz wiersz poleceń, korzystając ze skrótu klawiszowego Win + R, wpisując cmd i klikając Enter lub wybierając OK.

Uruchamianie wiersza poleceń

Skorzystaj z pola "🔍Wyszukaj", wpisując cmd i wybierz Wiersz polecenia

Uruchamianie wiersza poleceń

W nowo otwartym oknie wpisz komendę node -v, powinna wyświetlić się aktualna wersja Node.js. Jeśli tak się nie stało, spróbuj zrestartować komputer i ewentualnie ponowić instalację Node.js.

Swój pierwszy działający serwer utworzysz za pomocą kilku linijek kodu.

Na początku, za pomocą destrukturyzacji z modułu http, importujemy metodę createServer, dzięki której utworzymy serwer. Ustawiamy port, w naszym przykładzie będzie to 5000. Metoda ta przyjmuje jeden, opcjonalny argument - funkcję, która wykona się za każdym razem, gdy nasz serwer otrzyma żądanie. Nazywa się ją requestListener i obsługuje ona zarówno żądanie użytkownika, jak i odpowiedź do niego.

Jak widzisz na przedstawionym wyżej kawałku kodu, requestListener przyjmuje dwa argumenty: req oraz res, jako obiekty do obsługi przed chwilą wspomnianych żądań i odpowiedzi użytkownika. Nazwy tych argumentów są konwencyjne.

req - obiekt żądania (ang. request), który zawiera informacje o żądaniu HTTP, np. adres URL, nagłówki, metodę (GET, POST, itp.)

res - obiekt odpowiedzi (ang. response), który umożliwia wysłanie odpowiedzi do klienta (użytkownika).

Żądanie zostało obsłużone poprzez ustawienie kodu statusu HTTP na 200, co oznacza, że wszystko poszło zgodnie z planem – serwer zrozumiał żądanie i prawidłowo na nie odpowiedział. Kody statusu są jak uniwersalny język, w którym serwer informuje klienta (np. przeglądarkę) o tym, co się dzieje. Kod 200 mówi: "Wszystko OK, tutaj masz to, o co prosiłeś". Jest to przydatne nie tylko dla przeglądarek, które na tej podstawie mogą np. poprawnie wyświetlić stronę, ale też dla programistów, którzy mogą łatwiej diagnozować ewentualne problemy, jeśli coś pójdzie nie tak (np. zamiast kodu 200 serwer zwróci błąd 404 – "Nie znaleziono"). Następnie ustawienie nagłówka, gdzie "Content-Type", "text/html") informuje klienta, że odpowiedź zawiera dane w formacie HTML. Na zakończenie metoda res.end, która kończy odpowiedź, wysyła przekazane do niej dane (w tym przypadku, klasyczne "Hello World") do klienta. Od tego momentu serwer nie może już dodawać kolejnych danych do tej odpowiedzi.

server.listen uruchamia serwer i ustawia go tak, aby nasłuchiwał na określonym porcie (w naszym przypadku 5000). Funkcja callback, którą przekazujemy do metody listen zostanie wywołana, gdy serwer zacznie działać. Tutaj informacyjnie wyświetlamy, że serwer zaczął swoją pracę. Metoda listen przyjmuje do czterech argumentów i wszystkie są opcjonalne. Te argumenty to port, host, backlog oraz callback. Pierwszy i drugi argument określają kolejno port i adres ip, który chcemy nasłuchiwać. backlog pozwala nam określić maksymalną liczbę oczekujących połączeń (domyślnie 511), które serwer może umieścić w kolejce, zanim zacznie te połączenia odrzucać. Działa to w ten sposób, że gdy serwer odbiera więcej żądań niż jest w stanie obsłużyć w danej chwili (np. z powodu przeciążenia), kolejne połączenia trafiają właśnie do tej kolejki. backlog definiuje nam jej długość i jeśli kolejka się zapełni, nowe żądania będą automatycznie odrzucane. Ostatnim argumentem jest użyty przez nas wcześniej callback, który wykona się po uruchomieniu serwera.

Istotna jest kolejność argumentów, których użyjemy, lecz callback będzie zawsze ostatni i nic nie stoi na przeszkodzie, abyśmy użyli port, następnie pominęli host oraz backlog i wstawili callback. To zadziała 👍.

Aby uruchomić nasz serwer, musimy w pliku np. index.js (nazwa jest dowolna) umieścić kod odpowiedzialny za utworzenie serwera i przechodząc do folderu projektu, w którym znajduje się nasz plik (możesz przejść do folderu korzystając z komendy cd ścieżka/do/katalogu), w terminalu wpisz node nazwa_pliku.js. Ta komenda uruchomi kod znajdujący się w pliku.

Jak sprawdzić czy nasz serwer działa? Otwórz okno przeglądarki i przejdź na port, który określiłeś lub określiłaś podczas nasłuchiwania. W naszym przypadku, poprawnym adresem będzie localhost:5000 i na ekranie powinieneś lub powinnaś zobaczyć tekst Hello World.

Właściwie to nadal dla niektórych może nie być dowodem na to, że serwer działa. Aby udowodnić, że faktycznie tak jest, wyłącz działanie obecnego serwera (Ctrl + C w terminalu) i dodaj linijkę kodu w callbacku funkcji createServer dotyczącą logowania.

Gdy teraz spróbujesz przejść na adres serwera w przeglądarce, to w terminalu będzie logować się tekst, że otrzymaliśmy żądanie, jaką metodą (w tym przypadku będzie to GET) oraz z jakiego url przyszło żądanie, czyli u nas będzie to /. Jeśli w przeglądarce wpiszesz np. localhost:5000/test, to informacja skąd przyszło żądanie odpowiednio się zmieni.

Czym są moduły? To niezależne fragmenty kodu, które mogą być wielokrotnie wykorzystywane w różnych miejscach aplikacji. Node.js oferuje trzy rodzaje modułów: moduły wbudowane (ang. core modules), moduły zewnętrzne - instalowane za pomocą npm oraz moduły własne, czyli tworzone przez programistę. Przyjrzyjmy się bliżej każdemu z nich.

Node.js oferuje szereg modułów wbudowanych, takich jak fs (praca z systemem plików), którego możemy użyć np. w celu zapisania danych do pliku.

Możesz (do czego bardzo zachęcam) w ramach nauki utworzyć plik (nazwa dowolna) o rozszerzeniu .js, w którym umieścisz powyższy kod. Korzystając z wbudowanego modułu fs, wstrzykujemy dane do pliku log.txt. Jeśli plik ten jeszcze nie istnieje to zostanie utworzony, w przeciwnym wypadku zostanie do niego dopisana nowa linia tekstu. Pierwszym argumentem, jaki przekazujemy, jest ścieżka do pliku, do którego chcemy zapisać dane, drugim są dane, które chcemy w nim zapisać, trzecim (opcjonalnym) są opcje, w których możemy określić np. kodowanie (domyślnie jest to utf8). Ostatnim argumentem jest callback, który wykona się po zakończeniu operacji i przechwyci błąd, gdyby takowy wystąpił. Warto też dodać, że metoda appendFile jest asynchroniczna - oznacza to, że operacja zapisu do pliku jest wykonywana w tle, a program nie czeka na jej zakończenie przed przejściem do kolejnych linii kodu.

Możesz sprawdzić i samodzielnie potestować działanie tego kodu, uruchamiając go komendą node nazwa_pliku.js, np. node index.js.

Zewnętrzne moduły można zainstalować za pomocą node package managera, na przykład - npm. To domyślny menedżer pakietów w Node.js. Pozwala na instalowanie, zarządzanie i udostępnianie bibliotek oraz modułów zewnętrznych. Te ostatnie są udostępniane przez społeczność lub firmy w rejestrze npm. Dzięki niemu możesz łatwo dodać gotowe rozwiązania do swojej aplikacji, zamiast pisać wszystko od zera.

Załóżmy, że chcemy zainstalować moduł axios, który umożliwia wykonywanie zapytań HTTP w prosty sposób. Uruchom terminal w folderze projektu i zainstaluj moduł za pomocą npm, wpisując polecenie npm install axios.

Polecenie to pobierze moduł axios z rejestru npm, utworzy folder node_modules (jeśli wcześniej nie istniał), gdzie przechowywane są wszystkie zależności projektu, utworzy także plik package.json (jeśli wcześniej nie istniał) i doda w nim moduł axios jako zależność.

Po instalacji modułu możesz go zaimportować i używać w swoim kodzie przykładowo w ten sposób:

Moduły własne to fragmenty kodu, które tworzymy w celu enkapsulacji funkcjonalności, co pozwala unikać zaśmiecania globalnej przestrzeni nazw oraz ułatwia ich ponowne wykorzystanie w projekcie.

Przykładem modułu własnego może być prosty kalkulator, który umożliwia wykonywanie podstawowych operacji matematycznych. Taki moduł jest praktyczny, ponieważ funkcje dodawania, odejmowania czy mnożenia mogą być wielokrotnie wykorzystywane w różnych częściach aplikacji.

Utwórz plik o nazwie calculator.js w folderze projektu i dodaj w nim następujący kod:

Następnie w pliku, gdzie masz zamiar z tego modułu skorzystać np. index.js, zaimportuj go i użyj jego funkcji:

Po uruchomieniu pliku index.js w terminalu (node index.js) zobaczysz wykonane działania.

Aby jednak pokazać przykład bardziej pasujący do dzisiejszego tematu, wykorzystamy zdobytą wcześniej wiedzę o zapisywaniu danych do pliku. Zrobimy prosty menedżer notatek, który pozwala dodawać, usuwać i odczytywać notatki zapisane w pliku JSON. Taki przykład jest bardziej praktyczny i pokazuje realne zastosowanie Node.js.

Utwórz pliki notesData.js oraz notes.js i umieść w nich następujący kod:

Poniższy kod (plik notesData.js) odpowiada za obsługę pliku notes.json, który przechowuje nasze notatki. Dzięki oddzieleniu logiki zarządzania plikiem JSON od reszty aplikacji, kod staje się bardziej modularny i łatwiejszy do utrzymania.

• loadNotes – funkcja wczytuje notatki z pliku notes.json. Jeśli plik nie istnieje, zwraca pustą tablicę. Umożliwia bezpieczne czytanie danych.

• saveNotes – funkcja zapisuje notatki do pliku notes.json w formacie JSON. Zapewnia trwałość danych.

Na końcu eksportujemy obie funkcje, aby mogły być używane w innych modułach.

W tym kodzie (plik notes.js) umieszczamy logikę operacji na notatkach, takich jak dodawanie, usuwanie czy wyświetlanie. Korzystamy z funkcji zaimportowanych z notesData.js.

• addNote – dodaje nową notatkę do istniejącej listy.

  • korzysta z loadNotes, by wczytać aktualne notatki.

  • dodaje nową notatkę w formie obiektu { title, body }.

  • zapisuje listę za pomocą saveNotes.

• removeNote – usuwa notatkę o określonym tytule.

  • porównuje notatki z tytułem podanym przez użytkownika i zapisuje zaktualizowaną listę.

• listNotes – wyświetla wszystkie zapisane notatki w terminalu.

  • wczytuje notatki i iteruje po nich, wyświetlając tytuły.

Funkcje te również są eksportowane, by mogły być używane w innych plikach. To dobra metoda na szybkie przetestowanie funkcji. Następnie możesz zaimportować ten moduł w innym pliku i używać do tworzenia, usuwania i wyświetlania notatek:

Uruchom plik notesUsage.js, wpisując w terminalu komendę node notesUsage.js. Dzięki temu możesz zobaczyć, jak działają wszystkie funkcje modułu notes. Ten sposób użycia jest przydatny na etapie testowania, ponieważ umożliwia szybkie sprawdzenie działania operacji takich jak dodawanie, usuwanie czy listowanie notatek. Jednak podejście to wymaga każdorazowego edytowania pliku, co czyni je mało praktycznym w codziennym użytkowaniu.

Aby rozwiązać ten problem i umożliwić dynamiczne zarządzanie notatkami bez edytowania kodu, przygotowałem plik notesCLI.js, który pozwala na interakcję z modułem za pomocą wiersza poleceń. Utwórz plik notesCLI.js i umieść w nim poniższy kod:

Program zaczyna od zaimportowania funkcji (addNote, removeNote, listNotes) z modułu notes, które obsługują logikę zarządzania notatkami.

Znajdując się w folderze projektu, możesz w pełni korzystać z przygotowanego programu. Dodanie nowej notatki jest niezwykle proste – wystarczy wpisać w terminalu:

Program wykorzystuje process.argv, aby odczytać argumenty podane przez użytkownika. process.argv to tablica, która zawiera wszystkie argumenty przekazane do programu w momencie jego uruchamiania. Każdy element tej tablicy to kolejne "słowo", które zostało wpisane w terminalu.

W tym przypadku process.argv wygląda tak:

process.argv[0]: ścieżka do interpretera Node.js, np. /usr/local/bin/node.

process.argv[1]: ścieżka do uruchamianego pliku, np. /ścieżka-do-folderu/notesCLI.js.

process.argv[2]: pierwszy argument podany po nazwie pliku, czyli add.

process.argv[3]: kolejny argument, czyli "Zakupy".

process.argv[4]: następny argument, czyli "Kup masło".

Pierwsze dwa elementy (process.argv[0] i process.argv[1]) są zawsze ścieżkami do Node.js i pliku programu. Są one technicznymi informacjami, których nie potrzebujemy w naszym programie, bo nie są związane z faktycznym działaniem naszej aplikacji. Pomijamy je umieszczając tylko ,.

Interesujące nas argumenty zaczynają się od process.argv[2]. W tym przypadku:

process.argv[2] to komenda, np. add, remove, list.

process.argv[3] i kolejne to parametry dla funkcji, np. tytuł i treść notatki.

Po wykonaniu powyższej komendy notatka o tytule „Zakupy” i treści „Kup masło” zostanie zapisana w pliku notes.json.

Notatka dodana w pliku notes.json

Jeśli później zdecydujesz, że notatka jest już niepotrzebna, możesz ją usunąć, wpisując:

Aby sprawdzić, jakie notatki masz aktualnie zapisane, wystarczy uruchomić komendę:

Po jej wykonaniu program wyświetli listę wszystkich notatek zapisanych w pliku notes.json. Dzięki temu możesz szybko zarządzać swoimi notatkami bez konieczności edytowania kodu. Spróbuj samodzielnie dodać kilka notatek, wyświetlić ich listę i usunąć te, które nie są już potrzebne.

Mam nadzieję, że podczas tej krótkiej podróży z Node.js udało Ci się zrozumieć, czym jest to środowisko, jakie korzyści przynosi jego nauka oraz jak rozpocząć swoją przygodę z backendem. W prosty sposób zainstalowaliśmy Node.js, uruchomiliśmy pierwszy serwer i poznaliśmy moduły – zarówno wbudowane, zewnętrzne, jak i własne. Wystarczy odrobina praktyki i wyobraźni, aby odkryć jego pełen potencjał. Mam nadzieję, że ten artykuł będzie dla Ciebie dobrym punktem wyjścia do dalszej nauki i eksploracji.