Node.js 24の注目機能：URLPattern、パーミッションモデル、面接対策まで徹底解説（2026年版）

# 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

// 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);
}

// 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);

// 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/*' });

// 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
}

// 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)
}

// 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);

// 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

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

// 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);
  });
}