【JavaScript】assert関数でコードの正確性を確認する｜console.assert・Node.js assert・テストフレームワークまで徹底解説

この記事で学べること

• console.assert() の基本構文と動作
• 自作 assert 関数の実装方法
• Node.js assert モジュールの主要メソッド
• assert と console.assert の決定的な違い
• Jest / Mocha でのアサーション
• TypeScript の asserts 型述語
• 本番環境での assert の扱いと落とし穴

// 構文
console.assert(条件式, メッセージ);

// 条件がfalsy → コンソールにエラー出力
// 条件がtruthy → 何も起きない

const age = 25;

// 条件が true → 何も出力されない
console.assert(age >= 0, '年齢は0以上でなければなりません');

// 条件が false → エラーメッセージが出力される
console.assert(age >= 30, '年齢は30以上でなければなりません');
// Assertion failed: 年齢は30以上でなければなりません

// オブジェクトも出力可能
console.assert(false, 'エラー情報:', { code: 404, url: '/api/user' });
// Assertion failed: エラー情報: {code: 404, url: '/api/user'}

注意：console.assert() は条件が失敗してもプログラムの実行を停止しません。エラーメッセージを出力するだけで、後続の処理はそのまま続行されます。

// すべて Assertion failed になる
console.assert(false,     'false');
console.assert(0,         '0');
console.assert('',        '空文字列');
console.assert(null,      'null');
console.assert(undefined, 'undefined');
console.assert(NaN,       'NaN');

function assert(condition, message) {
  if (!condition) {
    throw new Error(message || 'Assertion failed');
  }
}

// 使用例
const value = 10;
assert(value > 0, '値は正の数でなければなりません');  // OK
assert(value > 100, '値は100より大きくなければなりません');
// Error: 値は100より大きくなければなりません

class AssertionError extends Error {
  constructor(message) {
    super(message);
    this.name = 'AssertionError';
  }
}

function assert(condition, message) {
  if (!condition) {
    throw new AssertionError(message || 'Assertion failed');
  }
}

// try-catch でアサーションエラーだけを捕捉
try {
  assert(false, '想定外の状態です');
} catch (e) {
  if (e instanceof AssertionError) {
    console.error('アサーション違反:', e.message);
  } else {
    throw e; // その他のエラーは再スロー
  }
}

function assertType(value, expectedType, name = 'value') {
  const actualType = typeof value;
  assert(
    actualType === expectedType,
    `${name} の型は ${expectedType} を期待しましたが ${actualType} でした`
  );
}

function assertNotNull(value, name = 'value') {
  assert(
    value !== null && value !== undefined,
    `${name} は null または undefined であってはなりません`
  );
}

// 使用例
assertType('hello', 'string', 'username');  // OK
assertType(42, 'string', 'username');
// Error: username の型は string を期待しましたが number でした

const assert = require('assert');

// assert(value) — truthy チェック
assert(true);           // OK
assert(1);              // OK
assert('hello');        // OK
assert(0);              // AssertionError!

const assert = require('assert');

// === strictEqual: プリミティブ値の比較 ===
assert.strictEqual(1 + 1, 2);          // OK
assert.strictEqual('hello', 'hello');  // OK
assert.strictEqual(1, '1');            // AssertionError!（型が違う）

// === deepStrictEqual: オブジェクト・配列の比較 ===
assert.deepStrictEqual(
  { name: '太郎', age: 25 },
  { name: '太郎', age: 25 }
);  // OK（プロパティの値が一致）

assert.deepStrictEqual(
  [1, 2, 3],
  [1, 2, 3]
);  // OK

// strictEqual ではオブジェクトの比較は参照が異なるので失敗
assert.strictEqual(
  { name: '太郎' },
  { name: '太郎' }
);  // AssertionError!（参照が異なる）

const assert = require('assert');

// 同期関数がエラーをスローするか検証
assert.throws(
  () => { throw new TypeError('型エラー'); },
  TypeError  // エラーの型を検証
);  // OK

// エラーメッセージも検証可能
assert.throws(
  () => { throw new Error('invalid input'); },
  { message: 'invalid input' }
);  // OK

// 非同期関数の reject を検証
async function testAsync() {
  await assert.rejects(
    async () => {
      throw new Error('API Error');
    },
    { message: 'API Error' }
  );  // OK
}

// --- console.assert: 実行が止まらない ---
console.assert(false, '失敗しました');
console.log('この行は実行される');  // 出力される

// --- Node.js assert: 実行が停止する ---
const assert = require('assert');
assert(false, '失敗しました');          // AssertionError!
console.log('この行は実行されない');  // 到達しない

// sum.test.js
const sum = require('./sum');

test('1 + 2 は 3 になる', () => {
  // 等値チェック
  expect(sum(1, 2)).toBe(3);
});

test('オブジェクトの一致', () => {
  const user = { name: '太郎', age: 25 };
  // オブジェクトの深い比較
  expect(user).toEqual({ name: '太郎', age: 25 });
});

test('エラーがスローされる', () => {
  expect(() => {
    throw new Error('invalid');
  }).toThrow('invalid');
});

test('真偽値のチェック', () => {
  expect(true).toBeTruthy();
  expect(null).toBeNull();
  expect(undefined).toBeUndefined();
});

const assert = require('assert');

describe('Array', () => {
  describe('#indexOf()', () => {
    it('値が存在しない場合は -1 を返す', () => {
      assert.strictEqual(
        [1, 2, 3].indexOf(4),
        -1
      );
    });

    it('値が存在する場合はインデックスを返す', () => {
      assert.strictEqual(
        [1, 2, 3].indexOf(2),
        1
      );
    });
  });
});

function divide(a, b) {
  // 前提条件: 0で割ることはできない
  console.assert(b !== 0, '0で割ることはできません');
  return a / b;
}

function processItems(items) {
  // 前提条件: 配列であること
  console.assert(Array.isArray(items), 'items は配列でなければなりません');
  // 前提条件: 空でないこと
  console.assert(items.length > 0, 'items は空であってはなりません');
  return items.map(item => item * 2);
}

function createUser(name, email, age) {
  // 引数の型と値をチェック
  assert(typeof name === 'string' && name.length > 0,
    'name は空でない文字列でなければなりません');
  assert(email.includes('@'),
    'email は有効なメールアドレスでなければなりません');
  assert(typeof age === 'number' && age >= 0,
    'age は0以上の数値でなければなりません');

  return { name, email, age };
}

class Order {
  constructor() {
    this.status = 'created';
  }

  pay() {
    // 支払いは created 状態でのみ可能
    assert(
      this.status === 'created',
      `支払いは created 状態でのみ可能です（現在: ${this.status}）`
    );
    this.status = 'paid';
  }

  ship() {
    // 出荷は paid 状態でのみ可能
    assert(
      this.status === 'paid',
      `出荷は paid 状態でのみ可能です（現在: ${this.status}）`
    );
    this.status = 'shipped';
  }
}

console.log('1: 処理開始');
console.assert(false, 'アサーション失敗');
console.log('2: 処理続行');  // 実行される！
console.log('3: 処理完了');  // 実行される！

実行結果

1: 処理開始
Assertion failed: アサーション失敗
2: 処理続行
3: 処理完了

const assert = require('assert');

console.log('1: 処理開始');
assert.ok(false, 'アサーション失敗');
console.log('2: ここには到達しない');

実行結果

1: 処理開始
AssertionError [ERR_ASSERTION]: アサーション失敗
    at Object.<anonymous> (test.js:4:8)
    at Module._compile (...)

// asserts condition — 条件が true であることを保証
function assert(
  condition: unknown,
  message?: string
): asserts condition {
  if (!condition) {
    throw new Error(message ?? 'Assertion failed');
  }
}

// 使用例
function processValue(value: string | null) {
  assert(value !== null, 'value は null であってはなりません');
  // ここで value は string 型に絞り込まれる
  console.log(value.toUpperCase());  // OK: string 型として扱える
}

interface User {
  name: string;
  email: string;
}

// value が User 型であることを保証する assert 関数
function assertIsUser(value: unknown): asserts value is User {
  if (
    typeof value !== 'object' ||
    value === null ||
    !('name' in value) ||
    !('email' in value)
  ) {
    throw new Error('User型ではありません');
  }
}

// 使用例
function greet(data: unknown) {
  assertIsUser(data);
  // この時点で data は User 型
  console.log(`こんにちは、${data.name}さん！`);
}

ポイント：asserts 型述語は、is 型ガード（value is Type）と異なり、戻り値が void です。関数が正常にリターンした場合に、型が保証されたとコンパイラが判断します。

// 環境変数で assert の有効/無効を切り替え
const isDev = process.env.NODE_ENV !== 'production';

function assert(condition, message) {
  if (isDev && !condition) {
    throw new Error(`[DEV] Assertion failed: ${message}`);
  }
}

// 開発環境: エラーをスロー
// 本番環境: 何もしない（パフォーマンスに影響なし）

const webpack = require('webpack');

module.exports = {
  plugins: [
    new webpack.DefinePlugin({
      'process.env.NODE_ENV': JSON.stringify('production')
    })
  ]
};

注意：assert を本番で例外スローする設計にする場合、ユーザーが直面するエラーとなるため、適切なエラーハンドリング（try-catch やエラーバウンダリ）を必ず実装してください。

function processData(data) {
  // NG: console.assert は実行を止めない！
  console.assert(data !== null, 'data は null です');
  // data が null でも以下が実行されてしまう
  return data.toString();  // TypeError!
}

// OK: 停止が必要なら自作 assert を使う
function processDataSafe(data) {
  assert(data !== null, 'data は null です'); // Error をスロー
  return data.toString();  // null の場合はここに到達しない
}

const assert = require('assert');

// assert.equal() は == で比較（非推奨！）
assert.equal(1, '1');          // OK（型変換されてしまう）

// assert.strictEqual() は === で比較（推奨）
assert.strictEqual(1, '1');    // AssertionError!（正しく検出）

注意：assert.equal() と assert.deepEqual() は非推奨（deprecated）です。常に assert.strictEqual() と assert.deepStrictEqual() を使ってください。

let count = 0;

// NG: assert の中で副作用（count++）を使う
console.assert(++count === 1, 'count が不正です');
// assert を除去すると count のインクリメントも消える！

// OK: 副作用は assert の外で行う
count++;
console.assert(count === 1, 'count が不正です');

const assert = require('assert');

// NG: Promise 内の assert はキャッチされない可能性がある
setTimeout(() => {
  assert.strictEqual(1, 2); // UnhandledPromiseRejection
}, 1000);

// OK: assert.rejects を使う
async function testAsync() {
  const result = await fetchData();
  assert.strictEqual(result.status, 200);
}

async function fetchUser(id) {
  const response = await fetch(`/api/users/${id}`);
  const data = await response.json();

  // レスポンスの構造を検証
  assert(data !== null, 'APIレスポンスがnullです');
  assert(typeof data.id === 'number', 'idが数値ではありません');
  assert(typeof data.name === 'string', 'nameが文字列ではありません');

  return data;
}

function initApp(config) {
  // 必須設定の検証
  assert(config.apiUrl, 'API URLが設定されていません');
  assert(config.apiKey, 'API Keyが設定されていません');
  assert(
    config.timeout > 0 && config.timeout <= 30000,
    `timeout は 1〜30000ms の範囲で指定してください（現在: ${config.timeout}）`
  );

  // アプリ起動
  console.log('アプリを起動しました');
}

function assertNever(value) {
  throw new Error(`未処理のケース: ${JSON.stringify(value)}`);
}

function getStatusMessage(status) {
  switch (status) {
    case 'loading':  return '読み込み中...';
    case 'success':  return '完了';
    case 'error':    return 'エラーが発生しました';
    default:        assertNever(status);
  }
}

// 'pending' が追加された場合、assertNever でエラーになる
// → 開発者が switch 文の修正を忘れることを防止

実務での使い分け指針

• デバッグ目的なら console.assert() で軽くチェック
• 絶対に守るべき前提条件には自作 assert（Error スロー）
• テストコードでは Jest の expect や Node.js の assert モジュールを使用
• TypeScript では asserts 型述語で型安全性とランタイムチェックを両立
• 本番環境では環境変数やビルドツールで assert の動作を制御