# Node.js 24 w 2026: URLPattern, model uprawnień i pytania rekrutacyjne

> Node.js 24 LTS wprowadza stabilny model uprawnień, globalny URLPattern, jawne zarządzanie zasobami z using/await using oraz V8 13.6. Szczegółowy przegląd funkcji istotnych dla produkcji i rozmów kwalifikacyjnych.

- Published: 2026-05-31
- Updated: 2026-05-31
- Author: SharpSkill
- Tags: node.js, node.js 24, urlpattern, permissions, interview, v8, javascript
- Reading time: 10 min

---

Node.js 24, noszący kryptonim Krypton, uzyskał status LTS w październiku 2025 roku i pozostaje zalecaną wersją produkcyjną w 2026. To wydanie stabilizuje model uprawnień (Permission Model), promuje URLPattern do globalnego API, wprowadza jawne zarządzanie zasobami przez V8 13.6 oraz aktualizuje npm do wersji 11. Te zmiany bezpośrednio wpływają na sposób, w jaki aplikacje backendowe obsługują bezpieczeństwo, routing i cykl życia zasobów.

> **Node.js 24 LTS w skrócie**
>
> V8 13.6 z `using`/`await using`, stabilna flaga `--permission` zastępująca `--experimental-permission`, globalny `URLPattern` do routingu bez frameworków, npm 11 oraz Undici 7 jako domyślny klient HTTP. Najnowsza wersja to 24.16.0 (maj 2026).

## Model uprawnień: od eksperymentalnego do gotowego na produkcję

Node.js 20 wprowadził model uprawnień za flagą `--experimental-permission`. Node.js 24 usuwa prefiks `experimental`. Flaga to teraz po prostu `--permission`, a środowisko uruchomieniowe ogranicza dostęp do systemu plików, sieci, procesów potomnych, natywnych dodatków i zmiennych środowiskowych, chyba że zostanie to jawnie dozwolone.

Ma to kluczowe znaczenie dla bezpieczeństwa łańcucha dostaw. Skompromitowana zależność nie może eksfiltrować danych przez sieć ani odczytywać dowolnych plików, jeśli proces działa pod `--permission` z wąsko określonymi uprawnieniami.

```bash
# launch-secure.sh
# Run an API server with minimal permissions
node --permission \
  --allow-fs-read=/app/src,/app/config \
  --allow-fs-write=/app/uploads \
  --allow-net=0.0.0.0:3000 \
  server.js
```

Powyższy proces może jedynie odczytywać katalogi źródłowe i konfiguracyjne, zapisywać do folderu uploads i nasłuchiwać na porcie 3000. Każda próba uruchomienia procesu potomnego, załadowania natywnego dodatku lub dostępu do zmiennych środowiskowych poza dozwolonym zakresem powoduje błąd `ERR_ACCESS_DENIED`.

### Sprawdzanie uprawnień w czasie działania za pomocą process.permission

Metoda `process.permission.has()` umożliwia introspekcję w czasie działania. Kod aplikacji może weryfikować własne uprawnienia przed próbą wykonania operacji o ograniczonym dostępie.

```javascript
// permission-check.js
// Verify permissions before performing restricted operations
function ensureWriteAccess(directory) {
  if (!process.permission.has('fs.write', directory)) {
    throw new Error(`No write permission for ${directory}`);
  }
}

function canSpawnProcesses() {
  return process.permission.has('child');
}

// Gracefully degrade when network access is restricted
function fetchWithFallback(url, cachedData) {
  if (!process.permission.has('net')) {
    console.warn('Network access denied, using cached data');
    return cachedData;
  }
  return fetch(url);
}
```

Ten wzorzec jest szczególnie przydatny dla bibliotek, które muszą działać zarówno w środowiskach izolowanych, jak i nieograniczonych. Marcowa poprawka bezpieczeństwa 2026 dla Node.js 24.14.1 naprawiła również obejście w `FileHandle.chmod()` i `FileHandle.chown()`, które pomijało sprawdzanie uprawnień, co podkreśla znaczenie aktualizowania środowiska uruchomieniowego.

## Globalny URLPattern: natywne dopasowywanie tras bez zależności

Node.js 24 udostępnia [URLPattern](https://developer.mozilla.org/en-US/docs/Web/API/URLPattern) w zasięgu globalnym. Ten standard WHATWG zapewnia dopasowywanie wzorców podobne do wyrażeń regularnych, zaprojektowane specjalnie dla adresów URL, z nazwanymi grupami, opcjonalnymi segmentami i ograniczeniami walidacyjnymi.

Nie jest potrzebny żaden `import` ani `require`. API działa identycznie w przeglądarkach, Cloudflare Workers i Deno, co czyni je naprawdę przenośnym prymitywem routingu.

```javascript
// router.js
// Framework-free HTTP router using global URLPattern
const routes = [
  {
    pattern: new URLPattern({ pathname: '/api/users/:userId' }),
    handler: handleGetUser
  },
  {
    pattern: new URLPattern({ pathname: '/api/users/:userId/posts/:postId' }),
    handler: handleGetPost
  },
  {
    // Optional segment: matches /api/products and /api/products/:category
    pattern: new URLPattern({ pathname: '/api/products{/:category}?' }),
    handler: handleProducts
  }
];

function matchRoute(url) {
  for (const route of routes) {
    const result = route.pattern.exec(url);
    if (result) {
      return { handler: route.handler, params: result.pathname.groups };
    }
  }
  return null;
}

// Usage with Node.js HTTP server
import { createServer } from 'node:http';

const server = createServer((req, res) => {
  const url = new URL(req.url, `http://${req.headers.host}`);
  const match = matchRoute(url.href);

  if (match) {
    match.handler(req, res, match.params);
  } else {
    res.writeHead(404).end('Not Found');
  }
});

server.listen(3000);
```

### Walidacja wzorców i zaawansowane dopasowywanie

URLPattern obsługuje ograniczenia wyrażeń regularnych inline w nazwanych grupach, dopasowywanie protokołów i filtrowanie nazw hostów. Metoda `test()` zwraca wartość logiczną do szybkich sprawdzeń bez alokacji obiektu wynikowego.

```javascript
// url-validation.js
// Validate URL segments with inline regex constraints
const numericUser = new URLPattern({ pathname: '/users/:id([0-9]+)' });
numericUser.test('https://app.com/users/42');    // true
numericUser.test('https://app.com/users/alice'); // false

// Match by protocol and hostname
const secureApi = new URLPattern({
  protocol: 'https',
  hostname: 'api.example.com',
  pathname: '/v2/*'
});

// Service worker-style routing for static assets vs API calls
const staticAssets = new URLPattern({ pathname: '/static/*' });
const apiCalls = new URLPattern({ pathname: '/api/*' });
```

Pod względem wydajności URLPattern nie jest zaprojektowany, aby konkurować z zoptymalizowanymi routerami takimi jak [find-my-way](https://github.com/delvedor/find-my-way) pod względem surowej przepustowości. Jego wartość polega na przenośności między środowiskami uruchomieniowymi i ustandaryzowanym API, które eliminuje błędy parsowania ścieżek.

## Jawne zarządzanie zasobami: using i await using

V8 13.6 w Node.js 24 dostarcza propozycję TC39 [Explicit Resource Management](https://github.com/tc39/proposal-explicit-resource-management). Deklaracje `using` i `await using` zastępują bloki `try/finally` dla deterministycznego czyszczenia uchwytów plików, połączeń z bazami danych, blokad i dowolnych obiektów implementujących `Symbol.dispose` lub `Symbol.asyncDispose`.

Od Node.js 24.2.0 `Symbol.dispose` i `Symbol.asyncDispose` nie mają już statusu eksperymentalnego.

```javascript
// resource-management.js
// Automatic cleanup with using and await using
import { open } from 'node:fs/promises';

async function processCSV(path) {
  // File handle is automatically closed when scope exits
  await using file = await open(path, 'r');
  const content = await file.readFile({ encoding: 'utf8' });
  return content.split('\n').length;
  // file[Symbol.asyncDispose]() called here automatically
}

// Custom disposable resource
function createDatabasePool(connectionString) {
  const pool = new Pool(connectionString);
  return {
    pool,
    query: (sql, params) => pool.query(sql, params),
    [Symbol.asyncDispose]: async () => {
      await pool.end();
      console.log('Pool connections released');
    }
  };
}

async function runMigrations() {
  await using db = createDatabasePool(process.env.DB_URL);
  await db.query('CREATE TABLE IF NOT EXISTS migrations ...');
  // Pool automatically closed, no try/finally needed
}
```

### DisposableStack dla wielu zasobów

`DisposableStack` i `AsyncDisposableStack` agregują wiele zasobów jednorazowych. Gdy stos jest zwalniany, zasoby są zwalniane w odwrotnej kolejności, prawidłowo obsługując łańcuchy zależności.

```javascript
// disposable-stack.js
// Manage multiple resources with AsyncDisposableStack
async function processTransaction() {
  await using stack = new AsyncDisposableStack();

  const connection = stack.use(await getConnection());
  const transaction = stack.use(await connection.beginTransaction());
  const tempFile = stack.use(await createTempFile());

  await transaction.execute('INSERT INTO orders ...');
  await tempFile.write('backup data');

  // On scope exit: tempFile closed, transaction committed/rolled back,
  // connection returned to pool (reverse order)
}
```

Ten wzorzec eliminuje całą klasę błędów związanych z wyciekami zasobów. Typ `SuppressedError` obsługuje przypadek brzegowy, gdy samo zwalnianie powoduje wyjątek, zachowując zarówno oryginalny błąd, jak i błąd zwalniania.

## V8 13.6: funkcje silnika JavaScript warte poznania

Poza jawnym zarządzaniem zasobami, V8 13.6 wprowadza kilka funkcji, które pojawiają się w [technicznych rozmowach kwalifikacyjnych z Node.js](/technologies/node-nestjs).

**RegExp.escape** sanityzuje ciągi znaków do bezpiecznego osadzania w wyrażeniach regularnych:

```javascript
// regexp-escape.js
// Safely embed user input in regular expressions
const userInput = 'price: $9.99 (USD)';
const escaped = RegExp.escape(userInput);
// escaped: 'price\:\ \$9\.99\ \(USD\)'
const pattern = new RegExp(escaped);
```

**Float16Array** dodaje tablicę typowaną zmiennoprzecinkową 16-bitową, zmniejszając o połowę zużycie pamięci w porównaniu z `Float32Array` dla obciążeń takich jak wnioskowanie ML czy przygotowywanie buforów WebGL:

```javascript
// float16.js
// Half-precision floating point for memory-sensitive workloads
const weights = new Float16Array([0.5, -1.25, 3.14]);
console.log(weights.byteLength); // 6 bytes instead of 12 with Float32Array
```

**Error.isError** zapewnia niezawodne sprawdzanie typów działające między kontekstami (iframes, vm, wątki robocze):

```javascript
// error-check.js
// Cross-realm error detection
const err = new TypeError('invalid input');
Error.isError(err);           // true
Error.isError({ message: 'fake' }); // false
```

## Poprawa wydajności AsyncLocalStorage

Node.js 24 domyślnie przełącza `AsyncLocalStorage` na implementację `AsyncContextFrame`. Poprzednie wersje używały podejścia opartego na hookach, które dodawało narzut do każdej operacji asynchronicznej. Nowa implementacja integruje się bezpośrednio z kolejką mikrozadań V8, redukując koszt propagacji kontekstu w aplikacjach o dużej współbieżności.

Ta zmiana jest transparentna dla istniejącego kodu. Biblioteki takie jak [OpenTelemetry](https://opentelemetry.io/) oraz frameworki logowania, które polegają na `AsyncLocalStorage` do kontekstu zakresu żądania, zyskują mierzalną poprawę przepustowości bez zmian w kodzie.

```javascript
// async-context.js
// Request-scoped context with improved AsyncLocalStorage
import { AsyncLocalStorage } from 'node:async_hooks';

const requestContext = new AsyncLocalStorage();

function handleRequest(req, res) {
  const context = {
    requestId: crypto.randomUUID(),
    startTime: performance.now()
  };

  requestContext.run(context, async () => {
    // Context automatically propagated through all async operations
    const data = await fetchUserData(req.userId);
    const elapsed = performance.now() - requestContext.getStore().startTime;
    logger.info(`Request ${requestContext.getStore().requestId} completed in ${elapsed}ms`);
    res.json(data);
  });
}
```

## Pytania rekrutacyjne: edycja Node.js 24

Poniższe pytania odzwierciedlają funkcje i wzorce, na które rekruterzy zwracają uwagę w 2026 roku. Każda odpowiedź demonstruje zrozumienie na poziomie produkcyjnym, a nie powierzchowną wiedzę.

**P1: Czym model uprawnień Node.js różni się od sandboxingu na poziomie systemu operacyjnego?**

Model uprawnień działa na poziomie środowiska uruchomieniowego Node.js, a nie jądra systemu operacyjnego. Ogranicza dostęp do wbudowanych API Node.js (`fs`, `net`, `child_process`) na podstawie flag CLI. Sandboxing na poziomie systemu operacyjnego (kontenery, seccomp, AppArmor) działa poniżej środowiska uruchomieniowego i ogranicza wywołania systemowe. Model uprawnień uzupełnia sandboxing systemowy, zapewniając granularność na poziomie aplikacji. Kluczowe ograniczenie: nie dotyczy natywnych dodatków omijających API Node.js, a istniejące deskryptory plików otwarte przed sprawdzeniem uprawnień mogą być nadal używane.

**P2: Kiedy URLPattern byłby złym wyborem w porównaniu z dedykowanym routerem?**

URLPattern nie obsługuje middleware, routingu opartego na metodach (GET vs POST) ani gwarancji kolejności tras. Wykonuje liniowe dopasowywanie podczas iteracji po tablicy wzorców, podczas gdy routery takie jak [find-my-way](https://github.com/delvedor/find-my-way) używają drzew radix do wyszukiwania O(log n). URLPattern jest odpowiedni dla współdzielonej logiki walidacji klient-serwer, handlerów fetch w service workerach i prototypów. Produkcyjne API HTTP z setkami tras korzystają z dedykowanego routera.

**P3: Wyjaśnij różnicę między `using` a `await using`. Kiedy stosować każdy z nich?**

`using` wywołuje `[Symbol.dispose]()` synchronicznie po wyjściu z bloku. Działa dla zasobów takich jak muteksy, deskryptory plików zarządzane przez synchroniczne dodatki C++ lub pamięci podręczne w pamięci. `await using` wywołuje `[Symbol.asyncDispose]()` i czeka na wynik, co jest konieczne dla połączeń z bazami danych, sesji HTTP lub dowolnego czyszczenia obejmującego asynchroniczne I/O. Użycie synchronicznego `using` dla zasobu asynchronicznego po cichu pomija czyszczenie.

**P4: Jak `AsyncContextFrame` poprawia wydajność `AsyncLocalStorage`?**

Poprzednie implementacje używały hooków async (`init`, `before`, `after`, `destroy`) do propagacji kontekstu, dodając narzut do każdej rozdzielczości `Promise` i callbacka timera. `AsyncContextFrame` przechowuje kontekst bezpośrednio w wewnętrznym łańcuchu obietnic V8, eliminując narzut hooków. Poprawa jest najbardziej znacząca w obciążeniach o dużej rotacji `Promise`, takich jak serwery HTTP obsługujące tysiące równoległych żądań z śledzeniem per-request.

**P5: Jakie ograniczenia bezpieczeństwa ma model uprawnień?**

Pięć krytycznych ograniczeń: (1) Dowiązania symboliczne mogą wychodzić poza dozwolone ścieżki. (2) Natywne dodatki całkowicie omijają sprawdzanie uprawnień. (3) Deskryptory plików dziedziczone z procesu nadrzędnego lub otwarte przed inicjalizacją `--permission` nie podlegają ograniczeniom. (4) Flagi `--env-file` i `--openssl-config` odczytują pliki przed inicjalizacją modelu uprawnień. (5) Uprawnienia wątków roboczych są niezależne i muszą być konfigurowane osobno. Marcowa poprawka CVE 2026 dla `FileHandle.chmod()`/`FileHandle.chown()` pokazała, że nowe API muszą być stale audytowane pod kątem egzekwowania uprawnień.

## Podsumowanie

- **Ścieżka aktualizacji**: Node.js 24 LTS (Krypton) jest zalecaną wersją produkcyjną do kwietnia 2028. Flaga `--permission` nie wymaga zmian w kodzie, jedynie konfiguracji wdrożenia
- **URLPattern** eliminuje lekkie zależności routingu dla kodu międzyplatformowego. Dedykowane routery należy rezerwować dla wysokoprzepustowych API HTTP ze złożonymi łańcuchami middleware
- **`using`/`await using`** zastępują `try/finally` w zarządzaniu cyklem życia zasobów. Rozpoczynanie warto od dodania `[Symbol.asyncDispose]` do wrapperów puli baz danych i narzędzi obsługi plików
- **Poprawa wydajności AsyncLocalStorage** jest automatyczna. Weryfikacja polega na benchmarkowaniu logowania i śledzenia w zakresie żądania pod obciążeniem
- **Przygotowanie do rozmów kwalifikacyjnych** powinno obejmować ograniczenia modelu uprawnień (dowiązania symboliczne, natywne dodatki, dziedziczone deskryptory plików), kompromisy URLPattern w porównaniu z routerami drzew radix oraz rozróżnienie między synchronicznym a asynchronicznym zwalnianiem zasobów
- Praktyka wdrażania niestandardowych zasobów jednorazowych i sprawdzania uprawnień w czasie działania pozwala wykazać się praktyczną znajomością funkcji Node.js 24 podczas [sesji rozmów kwalifikacyjnych z backendu](/technologies/node-nestjs/interview-questions/authentication-jwt)

---

Source: SharpSkill (https://sharpskill.dev), tech interview preparation for your real stack.
HTML version of this page: https://sharpskill.dev/pl/blog/node-nestjs/nodejs-24-urlpattern-permissions-interview-questions