MENU
  1. ホーム
  2. JavaScript
  3. JavaScriptの条件分岐とリファクタリングのベストプラクティス

JavaScriptの条件分岐とリファクタリングのベストプラクティス

JavaScript

JavaScriptの条件分岐とリファクタリングは、コードの可読性と保守性を向上させるための重要な技術です。条件分岐はプログラムが異なる状況に応じて異なる処理を実行するための基本的な構造であり、適切に設計されていないと、コードが複雑になり、バグが発生しやすくなります。本記事では、JavaScriptの条件分岐の基本から、複雑な条件分岐をシンプルで理解しやすいコードに変換するためのリファクタリングテクニックまでを詳しく解説します。具体例やベストプラクティスを交えながら、効果的なコードの書き方を学び、実践的なスキルを身につけましょう。

目次

条件分岐とは

条件分岐とは、プログラムが特定の条件に基づいて異なる処理を実行するための構造です。これにより、プログラムはさまざまな状況に適応し、適切なアクションを取ることができます。条件分岐は、ユーザー入力の検証、異常処理、ロジックの選択など、さまざまな場面で使用されます。

基本的な概念

条件分岐は「もし〜ならば〜を行う」といった形式で記述されます。最も基本的な形はif文であり、特定の条件が真である場合に特定のコードブロックを実行します。

条件分岐の役割

条件分岐は以下のような役割を果たします。

  • 入力の検証：ユーザーが入力したデータが正しいかどうかを確認する。
  • 異常処理：エラーや例外が発生した場合の対処方法を決定する。
  • ロジックの選択：異なる条件に基づいて異なる処理を実行する。

条件分岐を正しく理解し、効果的に利用することが、堅牢でメンテナンスしやすいコードを書くための第一歩です。

if文の基本と応用

if文は、条件分岐の中で最も基本的かつ広く使用される構造です。条件が真である場合に特定のコードブロックを実行し、偽である場合には他のコードブロックを実行します。

if文の基本的な使い方

if文の基本構文は次の通りです：

if (条件) {
    // 条件が真の場合に実行されるコード
} else {
    // 条件が偽の場合に実行されるコード
}

例として、数値が正の数かどうかを判定するコードを示します：

let number = 10;

if (number > 0) {
    console.log("正の数です");
} else {
    console.log("正の数ではありません");
}

else ifの使用例

複数の条件を評価する場合、else ifを使用します：

let score = 85;

if (score >= 90) {
    console.log("優秀");
} else if (score >= 75) {
    console.log("良好");
} else if (score >= 50) {
    console.log("合格");
} else {
    console.log("不合格");
}

この例では、スコアに応じて異なるメッセージが出力されます。

ネストされたif文

if文はネスト（入れ子）にすることもできますが、深くネストするとコードの可読性が低下するため注意が必要です：

let number = 15;

if (number > 0) {
    if (number % 2 === 0) {
        console.log("正の偶数です");
    } else {
        console.log("正の奇数です");
    }
} else {
    console.log("正の数ではありません");
}

高度な使用例

複数の条件を一度に評価する場合、論理演算子（AND, OR）を使用します：

let age = 20;
let hasPermission = true;

if (age >= 18 && hasPermission) {
    console.log("アクセス許可があります");
} else {
    console.log("アクセス許可がありません");
}

この例では、年齢が18歳以上でかつ許可がある場合にのみアクセスが許可されます。

if文の基本と応用を理解することで、複雑なロジックを効率的に実装できるようになります。次に、switch文について詳しく見ていきましょう。

switch文の使い方

switch文は、複数の条件を簡潔に評価するための条件分岐構造です。複数のif-else文を使用するよりもコードが読みやすく、保守しやすくなります。

switch文の基本構文

switch文の基本構文は次の通りです：

switch (評価する値) {
    case 値1:
        // 評価する値が値1に等しい場合に実行されるコード
        break;
    case 値2:
        // 評価する値が値2に等しい場合に実行されるコード
        break;
    // 他のケース
    default:
        // 評価する値がどのケースにも一致しない場合に実行されるコード
}

例として、曜日に基づいてメッセージを出力するコードを示します：

let day = "Monday";

switch (day) {
    case "Monday":
        console.log("週の始まりです");
        break;
    case "Wednesday":
        console.log("週の真ん中です");
        break;
    case "Friday":
        console.log("週の終わりが近いです");
        break;
    default:
        console.log("通常の一日です");
}

この例では、変数dayの値に応じて異なるメッセージが出力されます。

switch文の利点

switch文の主な利点は、以下の通りです：

  • 可読性：複数の条件を明確に分けて記述できるため、コードの可読性が向上します。
  • 保守性：追加のケースを簡単に追加できるため、保守が容易です。

break文の重要性

各ケースの最後にbreak文を使用しないと、次のケースが実行されてしまう「フォールスルー」が発生します：

let fruit = "Apple";

switch (fruit) {
    case "Apple":
        console.log("リンゴです");
    case "Banana":
        console.log("バナナです");
    default:
        console.log("不明な果物です");
}

この例では、「リンゴです」と「バナナです」が両方出力されてしまいます。break文を正しく配置することで、この問題を防ぎます：

let fruit = "Apple";

switch (fruit) {
    case "Apple":
        console.log("リンゴです");
        break;
    case "Banana":
        console.log("バナナです");
        break;
    default:
        console.log("不明な果物です");
}

複数のケースをまとめる

同じ処理を複数のケースで実行する場合、ケースをまとめることができます：

let day = "Saturday";

switch (day) {
    case "Saturday":
    case "Sunday":
        console.log("週末です");
        break;
    default:
        console.log("平日です");
}

この例では、dayが「Saturday」または「Sunday」の場合に「週末です」と出力されます。

switch文を使うことで、コードの可読性と保守性を高めることができます。次に、三項演算子の活用について詳しく見ていきましょう。

三項演算子の活用

三項演算子（条件演算子）は、簡潔な条件分岐を1行で記述できる便利なツールです。主に簡単な条件評価や代入に使用され、コードの可読性を向上させます。

三項演算子の基本構文

三項演算子の基本構文は次の通りです：

条件 ? 条件が真の場合の値 : 条件が偽の場合の値

例として、変数ageが18歳以上かどうかを評価するコードを示します：

let age = 20;
let message = age >= 18 ? "成人です" : "未成年です";
console.log(message); // "成人です"

この例では、ageが18以上であればmessageに「成人です」を代入し、そうでなければ「未成年です」を代入します。

ネストされた三項演算子

三項演算子をネストして使用することもできますが、過度にネストすると可読性が低下するため注意が必要です：

let score = 85;
let grade = score >= 90 ? "A" : score >= 75 ? "B" : score >= 50 ? "C" : "F";
console.log(grade); // "B"

この例では、scoreに基づいてgradeに適切な評価を代入します。

三項演算子の活用例

簡単な条件評価や代入以外にも、三項演算子はさまざまな場面で活用できます。以下にいくつかの例を示します。

UIの状態に基づくクラス名の設定

let isActive = true;
let className = isActive ? "active" : "inactive";
console.log(className); // "active"

この例では、isActiveの値に基づいてクラス名を設定します。

デフォルト値の設定

let userInput = "";
let defaultValue = "デフォルト値";
let displayValue = userInput ? userInput : defaultValue;
console.log(displayValue); // "デフォルト値"

この例では、userInputが空の場合にdefaultValueを使用します。

関数内での簡潔な返り値設定

function getStatus(isMember) {
    return isMember ? "メンバーです" : "非メンバーです";
}
console.log(getStatus(true)); // "メンバーです"
console.log(getStatus(false)); // "非メンバーです"

この例では、isMemberの値に基づいて関数の返り値を決定します。

三項演算子を適切に活用することで、コードを簡潔かつ読みやすく保つことができます。次に、複雑な条件分岐が引き起こす問題点について詳しく見ていきましょう。

複雑な条件分岐の問題点

複雑な条件分岐は、コードの可読性と保守性を著しく低下させる可能性があります。これにより、バグが発生しやすくなり、新しい開発者がコードを理解するのが難しくなります。

可読性の低下

複雑な条件分岐は、理解するのが難しいコードを生み出します。多くのネストされたif文や長い論理条件は、コードを読み解くのに時間がかかり、エラーの原因となります。

if (user.isActive && (user.role === "admin" || user.role === "moderator") && user.age >= 18) {
    // 複雑な条件分岐による処理
}

この例では、複数の条件が組み合わさっており、一目で理解するのは困難です。

メンテナンスの困難さ

条件分岐が複雑になると、コードの変更やバグの修正が困難になります。新しい条件を追加する際に既存のロジックが壊れるリスクが高まります。

if (user.isActive) {
    if (user.role === "admin") {
        // 管理者向けの処理
    } else if (user.role === "moderator") {
        // モデレーター向けの処理
    } else {
        // 一般ユーザー向けの処理
    }
} else {
    // 非アクティブユーザー向けの処理
}

このようなネストされた条件分岐は、各条件を追跡するのが難しく、変更が必要な場合にエラーを引き起こしやすくなります。

テストの困難さ

複雑な条件分岐は、すべてのパスをテストするのが困難です。特に、条件が多くの変数に依存している場合、それらの組み合わせを網羅するテストケースを作成するのは容易ではありません。

function getUserStatus(user) {
    if (user.isActive && user.isVerified && user.role === "admin") {
        return "active_verified_admin";
    } else if (user.isActive && user.isVerified) {
        return "active_verified";
    } else if (user.isActive) {
        return "active";
    } else {
        return "inactive";
    }
}

この例では、すべての条件をテストするためには、多数のテストケースが必要となります。

デバッグの難しさ

複雑な条件分岐は、デバッグが難しくなります。条件の一部が予期せず評価されない場合や、意図しない結果が生じる場合、原因を特定するのが困難です。

let user = {
    isActive: true,
    isVerified: false,
    role: "admin"
};

if (user.isActive && user.isVerified && user.role === "admin") {
    console.log("active_verified_admin");
} else {
    console.log("not active_verified_admin");
}

この例では、user.isVerifiedがfalseであるため、条件が意図した通りに評価されません。この問題を特定するのに時間がかかる可能性があります。

複雑な条件分岐を避けるためには、コードのシンプルさと明瞭さを保つことが重要です。次に、リファクタリングの基本について詳しく見ていきましょう。

リファクタリングの基本

リファクタリングとは、既存のコードの動作を変更せずに、コードの内部構造を改善するプロセスです。これにより、コードの可読性、保守性、効率性が向上します。リファクタリングの基本を理解することで、複雑な条件分岐をシンプルで管理しやすいコードに変換することができます。

リファクタリングの目的

リファクタリングの主な目的は以下の通りです：

  • 可読性の向上：コードを理解しやすくすることで、他の開発者がコードを読みやすくなります。
  • 保守性の向上：コードを変更しやすくし、バグを修正しやすくします。
  • 再利用性の向上：共通のロジックを抽出して再利用できるようにします。
  • 効率性の向上：不要なコードや冗長なロジックを削除し、パフォーマンスを向上させます。

リファクタリングの基本的な手法

リファクタリングには多くの手法がありますが、ここでは代表的なものをいくつか紹介します。

関数の抽出

複雑なロジックを小さな関数に分割することで、コードを理解しやすくします。

リファクタリング前：

function processUser(user) {
    if (user.isActive) {
        if (user.role === "admin") {
            // 管理者向けの処理
        } else if (user.role === "moderator") {
            // モデレーター向けの処理
        } else {
            // 一般ユーザー向けの処理
        }
    } else {
        // 非アクティブユーザー向けの処理
    }
}

リファクタリング後：

function processUser(user) {
    if (!user.isActive) {
        handleInactiveUser(user);
        return;
    }

    switch (user.role) {
        case "admin":
            handleAdminUser(user);
            break;
        case "moderator":
            handleModeratorUser(user);
            break;
        default:
            handleRegularUser(user);
    }
}

function handleInactiveUser(user) {
    // 非アクティブユーザー向けの処理
}

function handleAdminUser(user) {
    // 管理者向けの処理
}

function handleModeratorUser(user) {
    // モデレーター向けの処理
}

function handleRegularUser(user) {
    // 一般ユーザー向けの処理
}

条件の簡略化

複雑な条件をシンプルな条件に変換します。

リファクタリング前：

if (user.isActive && user.age >= 18 && user.role !== "guest") {
    // アクティブで18歳以上の非ゲストユーザー向けの処理
}

リファクタリング後：

let isEligibleUser = user.isActive && user.age >= 18 && user.role !== "guest";
if (isEligibleUser) {
    // アクティブで18歳以上の非ゲストユーザー向けの処理
}

冗長なコードの削除

重複したコードや不要なコードを削除します。

リファクタリング前：

if (user.role === "admin") {
    sendWelcomeMessage(user);
} else if (user.role === "moderator") {
    sendWelcomeMessage(user);
} else {
    sendWelcomeMessage(user);
}

リファクタリング後：

sendWelcomeMessage(user);

リファクタリングのメリット

リファクタリングを行うことで、以下のメリットがあります：

  • コードの品質向上：読みやすく理解しやすいコードを保つことで、コードの品質が向上します。
  • バグの減少：コードがシンプルになることで、バグの発生リスクが減少します。
  • 開発速度の向上：理解しやすいコードは、新しい機能の追加やバグの修正を迅速に行うことができます。

リファクタリングの基本を理解したところで、次に具体的な条件分岐のリファクタリングテクニックについて見ていきましょう。

条件分岐のリファクタリングテクニック

複雑な条件分岐をシンプルで理解しやすいコードにリファクタリングするための具体的なテクニックを紹介します。これにより、コードの可読性と保守性を大幅に向上させることができます。

ガード節の使用

ガード節（Guard Clause）は、早期リターンを用いてネストを浅くする手法です。これにより、条件が満たされない場合の処理を先に記述し、主要なロジックをより簡潔に保つことができます。

リファクタリング前：

function processOrder(order) {
    if (order.isPaid) {
        if (order.isShipped) {
            if (!order.isDelivered) {
                // 配達処理
            }
        }
    }
}

リファクタリング後：

function processOrder(order) {
    if (!order.isPaid) return;
    if (!order.isShipped) return;
    if (order.isDelivered) return;

    // 配達処理
}

ポリモーフィズムの活用

オブジェクト指向のポリモーフィズムを利用して、条件分岐を減らす方法です。異なるタイプのオブジェクトが同じインターフェースを共有し、それぞれのタイプに固有の実装を持つことで、条件分岐を置き換えます。

リファクタリング前：

function getDiscount(product) {
    if (product.type === "electronics") {
        return product.price * 0.9;
    } else if (product.type === "clothing") {
        return product.price * 0.8;
    } else {
        return product.price;
    }
}

リファクタリング後：

class Product {
    constructor(price) {
        this.price = price;
    }

    getDiscountedPrice() {
        return this.price;
    }
}

class Electronics extends Product {
    getDiscountedPrice() {
        return this.price * 0.9;
    }
}

class Clothing extends Product {
    getDiscountedPrice() {
        return this.price * 0.8;
    }
}

let product = new Electronics(100);
console.log(product.getDiscountedPrice()); // 90

オブジェクトマップの利用

オブジェクトマップを使用して、条件分岐をキーと値のペアに置き換える方法です。これにより、コードの簡潔さと可読性が向上します。

リファクタリング前：

function getRoleName(role) {
    if (role === "admin") {
        return "Administrator";
    } else if (role === "moderator") {
        return "Moderator";
    } else if (role === "user") {
        return "User";
    } else {
        return "Guest";
    }
}

リファクタリング後：

const roleNames = {
    admin: "Administrator",
    moderator: "Moderator",
    user: "User",
    guest: "Guest"
};

function getRoleName(role) {
    return roleNames[role] || "Guest";
}

関数の委譲

関数にロジックを委譲することで、複雑な条件分岐をシンプルな関数呼び出しに置き換えます。

リファクタリング前：

function calculateShippingCost(order) {
    if (order.weight > 10) {
        return 20;
    } else if (order.weight > 5) {
        return 15;
    } else {
        return 10;
    }
}

リファクタリング後：

function getShippingRate(weight) {
    if (weight > 10) return 20;
    if (weight > 5) return 15;
    return 10;
}

function calculateShippingCost(order) {
    return getShippingRate(order.weight);
}

これらのリファクタリングテクニックを活用することで、条件分岐の複雑さを軽減し、コードの品質を向上させることができます。次に、関数の分割と再利用の利点について詳しく見ていきましょう。

関数の分割と再利用

関数を分割し、再利用可能なコードを作成することで、コードの可読性と保守性が向上します。関数を小さく、単一の責任に絞ることで、コードの理解とテストが容易になります。

関数の分割

関数を分割することで、1つの関数が複数の責任を持たないようにします。これにより、各関数が明確な目的を持ち、変更やバグ修正がしやすくなります。

リファクタリング前：

function processOrder(order) {
    if (!order.isPaid) return "Order not paid";
    if (!order.isShipped) return "Order not shipped";
    if (order.isDelivered) return "Order already delivered";

    // 配達処理
    deliverOrder(order);

    // メール送信処理
    sendConfirmationEmail(order);

    return "Order processed";
}

リファクタリング後：

function validateOrder(order) {
    if (!order.isPaid) return "Order not paid";
    if (!order.isShipped) return "Order not shipped";
    if (order.isDelivered) return "Order already delivered";
    return null;
}

function deliverOrder(order) {
    // 配達処理
}

function sendConfirmationEmail(order) {
    // メール送信処理
}

function processOrder(order) {
    let validationError = validateOrder(order);
    if (validationError) return validationError;

    deliverOrder(order);
    sendConfirmationEmail(order);

    return "Order processed";
}

この例では、processOrder関数が小さな責任に分割され、各関数が明確な目的を持っています。

再利用可能な関数の作成

再利用可能な関数を作成することで、コードの重複を避け、保守性を向上させます。

リファクタリング前：

function applyDiscount(order) {
    if (order.customerType === "regular") {
        order.total *= 0.9;
    } else if (order.customerType === "vip") {
        order.total *= 0.8;
    }
    return order.total;
}

function applyShippingCost(order) {
    if (order.weight > 10) {
        order.shippingCost = 20;
    } else if (order.weight > 5) {
        order.shippingCost = 15;
    } else {
        order.shippingCost = 10;
    }
    return order.shippingCost;
}

リファクタリング後：

function getDiscountRate(customerType) {
    const discountRates = {
        regular: 0.9,
        vip: 0.8,
        default: 1.0
    };
    return discountRates[customerType] || discountRates.default;
}

function getShippingCost(weight) {
    if (weight > 10) return 20;
    if (weight > 5) return 15;
    return 10;
}

function applyDiscount(order) {
    order.total *= getDiscountRate(order.customerType);
    return order.total;
}

function applyShippingCost(order) {
    order.shippingCost = getShippingCost(order.weight);
    return order.shippingCost;
}

この例では、getDiscountRateとgetShippingCost関数を作成することで、重複するロジックを避け、再利用可能なコードを提供しています。

メリット

関数の分割と再利用には以下のメリットがあります：

  • 可読性の向上：小さな関数は、コードの意図を明確にし、読みやすくなります。
  • 保守性の向上：変更やバグ修正が容易になり、新たな機能追加もスムーズに行えます。
  • テストの容易さ：小さな関数はテストしやすく、バグを早期に発見できます。
  • 再利用性の向上：共通のロジックを関数化することで、他の部分でも簡単に再利用できます。

次に、長期的なコードメンテナンスを考慮した戦略的リファクタリングについて詳しく見ていきましょう。

戦略的リファクタリング

戦略的リファクタリングとは、長期的なコードメンテナンスを考慮して計画的にコードを改善するプロセスです。これにより、コードベースが成長しても保守しやすく、新しい機能追加がスムーズに行えるようになります。

リファクタリングの計画

リファクタリングは計画的に行うことが重要です。無計画に行うと、プロジェクトの進行が遅れたり、新たなバグが発生したりするリスクがあります。リファクタリングの計画を立てる際には、以下のポイントを考慮します：

  • 目的の明確化：リファクタリングの目的を明確にし、何を達成したいのかをチームで共有します。
  • 範囲の設定：リファクタリングの対象範囲を明確にし、影響を受ける部分を特定します。
  • 優先順位の設定：改善が急務な部分から優先的にリファクタリングを行います。

インクリメンタルなリファクタリング

一度に大規模なリファクタリングを行うのではなく、小さなステップで徐々に改善していく方法です。これにより、変更の影響を最小限に抑えながら、継続的にコードベースを改善できます。

リファクタリング前：

function processOrder(order) {
    if (!order.isPaid) return "Order not paid";
    if (!order.isShipped) return "Order not shipped";
    if (order.isDelivered) return "Order already delivered";

    // 配達処理
    deliverOrder(order);

    // メール送信処理
    sendConfirmationEmail(order);

    return "Order processed";
}

インクリメンタルなリファクタリングのステップ：

  1. バリデーションの分離：バリデーションロジックを別の関数に分離
  2. 配達処理の分離：配達処理を別の関数に分離
  3. メール送信処理の分離：メール送信処理を別の関数に分離

リファクタリング後：

function validateOrder(order) {
    if (!order.isPaid) return "Order not paid";
    if (!order.isShipped) return "Order not shipped";
    if (order.isDelivered) return "Order already delivered";
    return null;
}

function deliverOrder(order) {
    // 配達処理
}

function sendConfirmationEmail(order) {
    // メール送信処理
}

function processOrder(order) {
    let validationError = validateOrder(order);
    if (validationError) return validationError;

    deliverOrder(order);
    sendConfirmationEmail(order);

    return "Order processed";
}

コードレビューの活用

リファクタリングの過程でコードレビューを活用することで、他の開発者からフィードバックを受け取り、コードの品質を高めることができます。コードレビューを通じて、リファクタリングの効果や潜在的な問題を早期に発見することができます。

テスト駆動開発（TDD）との併用

リファクタリングを行う際には、テスト駆動開発（TDD）を併用することで、コードの品質と安全性を確保します。リファクタリング前にテストを作成し、リファクタリング後もテストが成功することを確認することで、コードの動作が変わらないことを保証します。

リファクタリングのタイミング

リファクタリングは、以下のようなタイミングで行うのが効果的です：

  • 新機能の追加前：新機能を追加する前に、関連するコードをリファクタリングしておくと、後の変更が容易になります。
  • バグ修正時：バグ修正を行う際に、そのバグの原因となったコードをリファクタリングすることで、再発を防ぎます。
  • 定期的なメンテナンス：定期的にコードベースを見直し、改善点をリファクタリングする習慣を持つことが重要です。

戦略的リファクタリングを通じて、コードの品質と保守性を高めることができます。次に、リファクタリング後のコードのテスト方法とその重要性について詳しく見ていきましょう。

テストの重要性

リファクタリング後のコードのテストは、コードが正しく機能し続けることを確認するために非常に重要です。テストは、リファクタリングによる変更が予期しないバグを引き起こさないことを保証します。

単体テストの実施

単体テスト（ユニットテスト）は、個々の関数やメソッドが期待通りに動作することを確認するテストです。リファクタリング前に単体テストを作成し、リファクタリング後もこれらのテストが成功することを確認します。

const assert = require('assert');

function validateOrder(order) {
    if (!order.isPaid) return "Order not paid";
    if (!order.isShipped) return "Order not shipped";
    if (order.isDelivered) return "Order already delivered";
    return null;
}

// 単体テスト
assert.strictEqual(validateOrder({ isPaid: false, isShipped: true, isDelivered: false }), "Order not paid");
assert.strictEqual(validateOrder({ isPaid: true, isShipped: false, isDelivered: false }), "Order not shipped");
assert.strictEqual(validateOrder({ isPaid: true, isShipped: true, isDelivered: true }), "Order already delivered");
assert.strictEqual(validateOrder({ isPaid: true, isShipped: true, isDelivered: false }), null);

console.log("All tests passed!");

統合テストの実施

統合テストは、複数のコンポーネントが正しく連携することを確認するテストです。リファクタリング後に、システム全体が正しく動作することを確認します。

function processOrder(order) {
    let validationError = validateOrder(order);
    if (validationError) return validationError;

    deliverOrder(order);
    sendConfirmationEmail(order);

    return "Order processed";
}

// 統合テスト
assert.strictEqual(processOrder({ isPaid: true, isShipped: true, isDelivered: false }), "Order processed");
assert.strictEqual(processOrder({ isPaid: false, isShipped: true, isDelivered: false }), "Order not paid");

console.log("All integration tests passed!");

自動テストの導入

自動テストを導入することで、リファクタリング後に手動でテストを行う手間を省き、効率的にコードの品質を保証します。継続的インテグレーション（CI）ツールを使用して、自動テストを実行し、コードの変更が常にテストされるようにします。

自動テストの設定例

Jestなどのテストフレームワークを使用して自動テストを設定します。

npm install --save-dev jest

package.jsonファイルに以下のスクリプトを追加します：

"scripts": {
    "test": "jest"
}

テストファイルを作成し、Jestを使用してテストを実行します：

test('validateOrder returns correct validation messages', () => {
    expect(validateOrder({ isPaid: false, isShipped: true, isDelivered: false })).toBe("Order not paid");
    expect(validateOrder({ isPaid: true, isShipped: false, isDelivered: false })).toBe("Order not shipped");
    expect(validateOrder({ isPaid: true, isShipped: true, isDelivered: true })).toBe("Order already delivered");
    expect(validateOrder({ isPaid: true, isShipped: true, isDelivered: false })).toBe(null);
});

test('processOrder returns correct processing messages', () => {
    expect(processOrder({ isPaid: true, isShipped: true, isDelivered: false })).toBe("Order processed");
    expect(processOrder({ isPaid: false, isShipped: true, isDelivered: false })).toBe("Order not paid");
});

テストを実行するには、次のコマンドを使用します：

npm test

テストのメリット

  • 信頼性の向上：テストはコードが意図したとおりに動作することを保証します。
  • バグの早期発見：リファクタリング後のバグを早期に発見し、修正することができます。
  • リファクタリングの安全性：テストがあることで、安心してコードをリファクタリングできます。
  • ドキュメントとしての役割：テストコードは、関数やメソッドの使い方を示すドキュメントとしての役割も果たします。

リファクタリング後のテストは、コードの品質を維持し、予期しない問題を防ぐために不可欠です。次に、本記事のまとめを行います。

まとめ

本記事では、JavaScriptにおける条件分岐とリファクタリングの重要性と具体的な手法について解説しました。条件分岐の基本からif文、switch文、三項演算子の使い方、複雑な条件分岐の問題点までをカバーし、それらを改善するためのリファクタリングの基本や具体的なテクニックを紹介しました。また、関数の分割と再利用、戦略的リファクタリング、リファクタリング後のテストの重要性についても詳しく説明しました。

効果的なリファクタリングを行うことで、コードの可読性、保守性、効率性が向上し、プロジェクト全体の品質も向上します。この記事を参考にして、実際のプロジェクトでこれらのテクニックを活用し、より良いコードを書けるようにしていきましょう。

JavaScript
条件分岐 リファクタリング JavaScript

コメント

コメントする

目次