Node.js 関数の効率的な定義と活用法：モダンな非同期処理からエラーハンドリングまで

// アロー関数の例：簡潔さとスコープの固定
const calculateTax = (price, taxRate = 0.1) => {
  return price * (1 + taxRate);
};

// 従来の関数の例：ホイスティングが可能
function formatCurrency(amount) {
  return `¥${amount.toLocaleString()}`;
}

const total = calculateTax(1000);
console.log(formatCurrency(total));

¥1,100

// オブジェクト分割代入による柔軟な引数設計
function createUser({ name, role = 'guest', status = 'active' } = {}) {
  return {
    id: Date.now(),
    name,
    role,
    status,
    createdAt: new Date()
  };
}

const user = createUser({ name: '田中太郎' });
console.log(user);

{
  id: 1715000000000,
  name: '田中太郎',
  role: 'guest',
  status: 'active',
  createdAt: 2026-05-07T...
}

const fs = require('node:fs/promises');

async function getConfiguration(filePath) {
  try {
    const data = await fs.readFile(filePath, 'utf8');
    return JSON.parse(data);
  } catch (error) {
    console.error('ファイルの読み込みに失敗しました', error.message);
    throw error;
  }
}

async function fetchDashboardData(userId) {
  console.time('fetchData');
  
  // 悪い例：順次実行（トータル時間が各処理の合計になる）
  // const profile = await fetchProfile(userId);
  // const posts = await fetchPosts(userId);

  // 良い例：並行実行（最も長い処理の時間で終わる）
  const [profile, posts] = await Promise.all([
    fetchProfile(userId),
    fetchPosts(userId)
  ]);

  console.timeEnd('fetchData');
  return { profile, posts };
}

// 疑似的なデータ取得関数
async function fetchProfile(id) {
  await new Promise(resolve => setTimeout(resolve, 100));
  return { id, name: 'User ' + id };
}

async function fetchPosts(id) {
  await new Promise(resolve => setTimeout(resolve, 150));
  return [{ id: 1, title: 'Hello Node.js' }];
}

fetchDashboardData(123).then(data => console.log('取得完了'));

fetchData: 155ms (約)
取得完了

function createProcessor() {
  const largeData = new Array(1000000).fill('data'); // 大きなメモリ消費
  
  return {
    process: (input) => {
      // largeDataを参照しているため、この関数が存在する限り解放されない
      return `${input} processed with ${largeData.length} items`;
    },
    clear: () => {
      // 明示的に参照を断つ手法
      // largeData = null; // constだと不可だが、設計として考慮が必要
    }
  };
}

// ログ出力機能を付与する高階関数
function withLogging(fn) {
  return async (...args) => {
    console.log(`[LOG] 実行開始: ${fn.name} 引数:`, args);
    const start = performance.now();
    try {
      const result = await fn(...args);
      const end = performance.now();
      console.log(`[LOG] 実行完了: ${fn.name} (所要時間: ${(end - start).toFixed(2)}ms)`);
      return result;
    } catch (error) {
      console.error(`[LOG] エラー発生: ${fn.name}`, error);
      throw error;
    }
  };
}

const heavyProcess = async (id) => {
  await new Promise(r => setTimeout(r, 50));
  return { success: true, id };
};

const monitoredProcess = withLogging(heavyProcess);
monitoredProcess(500);

class DatabaseError extends Error {
  constructor(message, code) {
    super(message);
    this.name = 'DatabaseError';
    this.code = code;
    this.isOperational = true; // 運用上の予期されたエラーかどうか
  }
}

async function getUserFromDb(id) {
  // 疑似的なエラー発生
  if (!id) {
    throw new DatabaseError('ユーザーIDが指定されていません', 'ERR_INVALID_ID');
  }
  // 処理...
}

const { AsyncLocalStorage } = require('node:async_hooks');
const storage = new AsyncLocalStorage();

function logWithId(message) {
  const id = storage.getStore();
  console.log(`[RequestID: ${id || 'N/A'}] ${message}`);
}

async function serviceA() {
  logWithId('Service A を実行中...');
  await serviceB();
}

async function serviceB() {
  logWithId('Service B を実行中...');
}

// リクエストごとに独立したコンテキストを生成
storage.run('REQ-12345', () => {
  serviceA();
});

[RequestID: REQ-12345] Service A を実行中...
[RequestID: REQ-12345] Service B を実行中...

// バリデーション関数 (純粋関数)
const validateInput = (data) => {
  if (!data.email.includes('@')) return false;
  return true;
};

// メインロジック (非同期関数)
async function registerUser(userData) {
  if (!validateInput(userData)) {
    throw new Error('不正な入力値です');
  }

  return await saveToDatabase(userData);
}

// データベース保存 (抽象化された関数)
async function saveToDatabase(data) {
  // DB保存処理のシミュレーション
  return { ...data, registeredAt: new Date() };
}

const pipe = (...fns) => (x) => fns.reduce((v, f) => f(v), x);

const trim = s => s.trim();
const capitalize = s => s.toUpperCase();
const addExclamation = s => `${s}!`;

const formatMessage = pipe(trim, capitalize, addExclamation);

console.log(formatMessage('  hello nodejs  '));

HELLO NODEJS!