Express framework – co to jest i jak zacząć z Express.js

1. Co to jest Express.js?

Express.js (Express) to:

Tu przeczytasz

1. Co to jest Express.js?
2. Dlaczego Express.js jest tak popularny?
3. Wymagane podstawy, zanim zaczniesz
4. Instalacja – przygotowanie środowiska
5. Pierwsza aplikacja w Express.js – „Hello World”
6. Podstawy Express.js krok po kroku
7. Tworzenie prostego REST API w Express.js
8. Szablony HTML i klasyczne aplikacje webowe
9. Szybki start z generatorem Express
10. Bezpieczeństwo w Express.js – podstawy
11. Dobra struktura projektu i praktyki
12. Ścieżka nauki Express.js – jak rozwijać umiejętności?
13. Express.js w praktyce – dla jakich projektów?

minimalistyczny framework webowy dla platformy Node.js,
zaprojektowany do tworzenia aplikacji webowych i API (w tym REST API),
lekki, elastyczny i nieopinionowany – daje tylko niezbędny „szkielet”, a architekturę dobierasz sam,
projekt open source, utrzymywany przez szeroką społeczność.

Jego główne zadanie to:

uproszczenie obsługi żądań HTTP,
zarządzanie trasami (routing),
wykorzystanie łańcuchów middleware,
wygodne generowanie odpowiedzi (HTML, JSON, pliki itd.).

Express jest często nazywany „de facto standardowym frameworkiem serwerowym dla Node.js”.

2. Dlaczego Express.js jest tak popularny?

2.1. Minimalizm i elastyczność

Express dostarcza cienką warstwę nad modułem HTTP w Node.js – nie zasłania jego możliwości, tylko je upraszcza.

Zamiast pisać samodzielnie dużo „klejowego” kodu do:

parsowania URL,
obsługi różnych metod HTTP (GET, POST, PUT, DELETE),
zarządzania nagłówkami i kodami statusu,

dostajesz proste API, np. app.get(...) czy res.json(...).

2.2. Routing

Express zawiera rozbudowany system routingu, który mapuje URL-e i metody HTTP na konkretne funkcje (kontrolery). To podstawa do budowy:

klasycznych aplikacji webowych (HTML),
backendów dla SPA (React, Vue, Angular),
mobilnych API (Android, iOS),
mikroserwisów.

2.3. Middleware – „klocki” logiki

Struktura Express opiera się na middleware – funkcjach pośredniczących, które „wpinasz” w łańcuch obsługi żądania.

Za pomocą middleware możesz m.in.:

logować zapytania,
uwierzytelniać użytkowników,
parsować JSON i formularze,
obsługiwać błędy,
dodawać nagłówki bezpieczeństwa.

Takie podejście ułatwia modularny podział kodu i skalowanie nawet złożonych systemów backendowych.

2.4. Skalowalność i ekosystem

Express:

jest bazą wielu innych frameworków (np. Nest.js, Sails.js),
nadaje się do aplikacji od prostych po bardzo duże, o wysokim ruchu i z integracjami z usługami zewnętrznymi,
korzysta z ogromnego ekosystemu NPM – łatwo dołączyć ORM-y, logowanie, cache, kolejki itp.

3. Wymagane podstawy, zanim zaczniesz

Zanim wejdziesz w Express.js, dobrze jest znać:

JavaScript przynajmniej na poziomie podstawowym (zmienne, funkcje, obiekty, moduły, async/await),
Node.js – czym jest, jak uruchamiać pliki JS w środowisku serwerowym, jak działa npm,
podstawy HTTP – metody (GET, POST, PUT, DELETE), kody statusu, nagłówki, JSON.

Oficjalna dokumentacja Express (expressjs.com) jest zwięzła, ale bardzo praktyczna – warto ją przeglądać równolegle z nauką.

4. Instalacja – przygotowanie środowiska

4.1. Krok 1 – zainstaluj Node.js

Aby pracować z Express.js, musisz mieć zainstalowanego Node.js.

Po instalacji sprawdź wersje w terminalu:

node -v npm -v

4.2. Krok 2 – utwórz nowy projekt

W terminalu przejdź do wybranego katalogu i utwórz folder projektu:

mkdir moj-express-projekt cd moj-express-projekt

Zainicjalizuj projekt npm:

npm init -y

Przełącznik -y akceptuje domyślne ustawienia i tworzy plik package.json.

4.3. Krok 3 – instalacja Express.js

Zainstaluj Express jako zależność projektu:

npm install express

To najprostszy i najczęściej stosowany sposób dodania Express do aplikacji Node.js.

5. Pierwsza aplikacja w Express.js – „Hello World”

Teraz stworzysz swój pierwszy serwer Express:

5.1. Tworzymy plik aplikacji

Utwórz plik app.js i wklej poniższy kod:

const express = require('express'); const app = express(); const port = 3000;

// Prosta trasa (routing) dla adresu głównego
app.get('/', (req, res) => {
res.send('Hello World z Express.js!');
});

// Uruchomienie serwera
app.listen(port, () => {
console.log(`Aplikacja Express nasłuchuje na porcie ${port}`);
});

To minimalny szkielet aplikacji Express prezentowany w dokumentacji i materiałach edukacyjnych.

5.2. Uruchomienie serwera

Uruchom aplikację poleceniem:

node app.js

Następnie otwórz w przeglądarce adres:

http://localhost:3000

Powinien pojawić się komunikat „Hello World z Express.js!”.

6. Podstawy Express.js krok po kroku

6.1. Routing – obsługa różnych adresów

Routing w Express definiuje, jak aplikacja reaguje na konkretne metody HTTP i ścieżki URL. Oto proste przykłady:

// GET /about app.get('/about', (req, res) => { res.send('Strona o nas'); });

// POST /contact
app.post('/contact', (req, res) => {
res.send('Dane z formularza kontaktowego zostały odebrane');
});

// Dowolna metoda HTTP (GET, POST, itd.) na /test
app.all('/test', (req, res) => {
res.send('Obsługuję każdą metodę HTTP na /test');
});

Możesz korzystać z parametrów w ścieżce, na przykład:

// Przykład: GET /users/123 app.get('/users/:id', (req, res) => { const userId = req.params.id; res.send(`Użytkownik o ID: ${userId}`); });

6.2. Middleware – serce Express.js

Middleware to funkcje z dostępem do obiektu żądania (req), odpowiedzi (res) oraz funkcji next, która przekazuje sterowanie dalej.

Schemat działania wygląda tak:

function mojeMiddleware(req, res, next) { console.log(`Metoda: ${req.method}, URL: ${req.url}`); next(); // przejście do kolejnego middleware lub trasy }

app.use(mojeMiddleware);

Typowe zastosowania middleware:

logowanie żądań,
parsowanie treści (JSON, formularze),
uwierzytelnianie,
obsługa statycznych plików,
obsługa błędów.

Przykład prostego loggera:

app.use((req, res, next) => { console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`); next(); });

6.3. Wysyłanie odpowiedzi – HTML, JSON, pliki

Najczęściej używane metody pracy z odpowiedzią to:

// Zwykły tekst res.send('Tekst');

// Obiekt JSON
res.json({ status: 'ok', data: [1, 2, 3] });

// Ręczna zmiana statusu
res.status(201).json({ message: 'Utworzono zasób' });

Warto też znać „helpery” HTTP, jak res.redirect czy res.sendFile, a także ETag i cache.

7. Tworzenie prostego REST API w Express.js

REST API to jedno z głównych zastosowań Express. Poniżej przykład prostego API dla listy „zadań” (todo):

const express = require('express'); const app = express(); const port = 3000;

// Middleware do parsowania JSON z body żądania
app.use(express.json());

// „Baza danych” w pamięci
let todos = [
{ id: 1, title: 'Nauczyć się Express.js', done: false },
];

// Pobierz wszystkie zadania
app.get('/api/todos', (req, res) => {
res.json(todos);
});

// Pobierz pojedyncze zadanie
app.get('/api/todos/:id', (req, res) => {
const id = Number(req.params.id);
const todo = todos.find(t => t.id === id);
if (!todo) {
return res.status(404).json({ error: 'Nie znaleziono zadania' });
}
res.json(todo);
});

// Dodaj nowe zadanie
app.post('/api/todos', (req, res) => {
const { title } = req.body;
if (!title) {
return res.status(400).json({ error: 'Brak pola title' });
}
const newTodo = {
id: todos.length + 1,
title,
done: false,
};
todos.push(newTodo);
res.status(201).json(newTodo);
});

// Usuń zadanie
app.delete('/api/todos/:id', (req, res) => {
const id = Number(req.params.id);
const index = todos.findIndex(t => t.id === id);
if (index === -1) {
return res.status(404).json({ error: 'Nie znaleziono zadania' });
}
todos.splice(index, 1);
res.status(204).send();
});

// Uruchomienie
app.listen(port, () => {
console.log(`API działa na http://localhost:${port}`);
});

To niewielki, ale pełnoprawny backend REST z endpointami CRUD.

8. Szablony HTML i klasyczne aplikacje webowe

Express wspiera silniki szablonów (np. Pug, EJS) do generowania dynamicznego HTML po stronie serwera. Oto przykład z EJS krok po kroku:

Instalacja EJS – zainstaluj paczkę:
npm install ejs
Konfiguracja widoków – ustaw silnik i trasę renderującą:
const express = require('express'); const app = express(); const port = 3000; app.set('view engine', 'ejs'); // ustawienie silnika widoków app.set('views', './views'); // katalog z szablonami app.get('/', (req, res) => { res.render('index', { title: 'Strona główna', message: 'Witaj w Express!' }); }); app.listen(port, () => { console.log(`Aplikacja działa na porcie ${port}`); });
Utwórz plik widoku – zapisz szablon w views/index.ejs:
<!DOCTYPE html> <html lang="pl"> <head> <meta charset="UTF-8"> <title><%= title %></title> </head> <body> <h1><%= message %></h1> </body> </html>

Po wejściu na http://localhost:3000 zobaczysz wygenerowaną stronę HTML.

9. Szybki start z generatorem Express

Express udostępnia generator aplikacji, który tworzy gotowy szkielet projektu. Wykonaj te kroki:

Instalacja generatora – zainstaluj globalnie:
npm install -g express-generator
Utwórz nową aplikację – wygeneruj projekt z widokami Pug:
express --view=pug myapp
Instalacja zależności – przejdź do folderu i zainstaluj paczki:
cd myapp npm install
Uruchom projekt – uruchom serwer deweloperski:
npm start

Powstanie kompletna struktura: app.js, foldery routes, views, public, wraz z gotowym routingiem i middleware.

10. Bezpieczeństwo w Express.js – podstawy

Budując aplikację internetową, zadbaj o kluczowe aspekty bezpieczeństwa:

użycie helmet – dodaje bezpieczne nagłówki HTTP,
ograniczenie CORS do zaufanych domen (np. biblioteka cors),
walidacja danych wejściowych (np. express-validator) – chroni przed SQL Injection i XSS,
rate limiting (express-rate-limit) – ogranicza liczbę żądań z jednego IP,
przechowywanie sekretów w zmiennych środowiskowych, nie w kodzie,
stosowanie HTTPS i regularne aktualizowanie zależności (npm audit).

Instalacja i włączenie Helmet wygląda tak:

npm install helmet
const helmet = require('helmet'); app.use(helmet());

Przykładowy prosty limiter żądań:

npm install express-rate-limit
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
windowMs: 15 * 60 * 1000, // 15 minut
max: 100, // max 100 żądań z IP
});

app.use('/api/', limiter);

11. Dobra struktura projektu i praktyki

Przy większych aplikacjach Express warto stosować te praktyki:

podziel projekt na moduły (np. /routes, /controllers, /models),
użyj zmiennych środowiskowych (np. dotenv) do konfiguracji,
wdroż centralną obsługę błędów (globalne middleware error-handling),
korzystaj z loggera (np. morgan, winston) do logów żądań i błędów,
pisz testy (Jest, Mocha) – szczególnie przy API,
na produkcji stosuj reverse proxy (np. Nginx) do terminacji HTTPS, cache i load balancingu.

12. Ścieżka nauki Express.js – jak rozwijać umiejętności?

Poniższa ścieżka pomoże Ci systematycznie opanować Express.js:

Node.js i JavaScript
- moduły i system pakietów NPM (require / import),
- asynchroniczność: Promise i async/await,
- podstawy HTTP i JSON.
Podstawy Express
- routing (app.get, app.post, parametry),
- middleware (app.use, logowanie, parsowanie),
- odpowiedzi (res.send, res.json, res.status).
REST API
- zbuduj proste API z CRUD,
- obsługa błędów i kodów statusu,
- testowanie API (np. Postman).
Bazy danych
- integracja z MongoDB (Mongoose),
- integracja z SQL (Sequelize, Prisma),
- migracje, seedy i modelowanie danych.
Bezpieczeństwo i autoryzacja
- JWT, sesje, logowanie użytkowników,
- Helmet, CORS, walidacja danych, rate limiting,
- przechowywanie sekretów i polityka haseł.
Zaawansowane tematy
- rozbijanie kodu na moduły i warstwy,
- architektura mikroserwisów i komunikacja między serwisami,
- Nest.js jako „cięższy” framework bazujący na Express (TypeScript, DI, moduły).

13. Express.js w praktyce – dla jakich projektów?

Express sprawdzi się w szczególności w:

backendach dla klasycznych stron WWW,
REST API dla aplikacji SPA (React, Vue, Angular),
backendach dla aplikacji mobilnych,
prostych usługach integracyjnych (mikroserwisy, webhooki),
prototypach, MVP i później skalowanych systemach.

Dzięki prostocie, elastyczności i wsparciu community Express jest bezpiecznym wyborem dla początkujących i średniozaawansowanych programistów webowych.