Javaでプログラムを作成する際、if-else文は非常に一般的な構造です。条件に応じて異なる処理を行うために多用されるこの文法は、プログラムの流れを制御する強力な手段ですが、コードの再利用性という観点から見ると、改善の余地があります。if-else文が複雑になると、コードが冗長になり、メンテナンスが難しくなります。特に、大規模なプロジェクトでは、同じようなif-else文が至るところに散在し、プログラム全体の可読性や保守性に悪影響を及ぼします。本記事では、Javaにおけるif-else文の再利用性を高め、コードの品質を向上させる方法について詳しく解説します。
if-else文の基本構造とその限界
Javaにおけるif-else文は、条件に応じて異なる処理を実行するための基本的な構文です。典型的な構造としては、以下のように書かれます。
if (条件1) {
// 条件1が真の場合の処理
} else if (条件2) {
// 条件2が真の場合の処理
} else {
// どの条件も真でない場合の処理
}このような構造は非常に分かりやすく、プログラムの流れを直感的に把握できるメリットがあります。しかし、if-else文は、そのまま使うと次のような限界があります。
再利用性の低さ
if-else文は特定の条件に基づいて処理を分岐させるため、同様のロジックを再度使いたい場合でも、新たに同じようなif-else文を繰り返し記述しなければなりません。このようなコードの重複は、バグの発生率を高め、修正やメンテナンスが困難になる要因となります。
スケーラビリティの問題
if-else文が複雑化すると、条件分岐が多岐にわたるため、コードが肥大化し、読みやすさが低下します。これにより、プログラム全体のスケーラビリティに悪影響を及ぼし、新しい条件を追加する際にもエラーが発生しやすくなります。
このような限界を理解し、次のステップとして、より再利用性の高いコードを書くための手法について考えていく必要があります。
コード再利用性の重要性
プログラム開発において、コードの再利用性は非常に重要な概念です。再利用性が高いコードとは、一度作成したコードを、他のプロジェクトや異なるコンテキストでも繰り返し使用できるコードのことを指します。このようなコードを作成することで、開発効率が向上し、メンテナンスコストが削減されます。
開発効率の向上
再利用可能なコードを作成することで、同じ機能を新たに作成する必要がなくなり、開発時間を大幅に短縮できます。特に、大規模なプロジェクトでは、再利用可能なコンポーネントを組み合わせてシステムを構築することができるため、プロジェクト全体の効率が向上します。
メンテナンスコストの削減
再利用性の高いコードは、変更やバグ修正が必要な場合にも、その修正が一箇所で済むため、メンテナンスコストが大幅に削減されます。例えば、同じ処理を行うif-else文が複数の箇所に存在する場合、修正が必要なときにすべての箇所を変更する必要がありますが、再利用可能なコードであれば、一箇所の修正で済みます。
品質と信頼性の向上
再利用可能なコードは、通常、よくテストされ、信頼性が高いです。繰り返し使用されることで、その品質が確認されているため、新たなバグを生む可能性が低く、システム全体の信頼性が向上します。
Javaのif-else文においても、この再利用性を意識することで、コードの品質を高め、保守性を向上させることができます。次に、具体的な手法を通じて、if-else文の再利用性を向上させる方法を見ていきます。
関数に分割して再利用性を向上させる
if-else文の再利用性を高めるための最も基本的な手法は、コードを関数に分割することです。関数に分割することで、同じ処理を何度も記述する必要がなくなり、コードの重複を避けることができます。さらに、関数は明確な入力と出力を持つため、テストが容易になり、メンテナンス性も向上します。
if-else文の関数化の例
例えば、以下のようなif-else文を考えてみます。
if (age >= 18) {
System.out.println("成人です");
} else {
System.out.println("未成年です");
}このコードは単純ですが、複数の場所で同様のロジックが必要になると、コードの再利用性が低くなります。これを関数化すると、次のように書き直すことができます。
public class AgeChecker {
public static void checkAge(int age) {
if (age >= 18) {
System.out.println("成人です");
} else {
System.out.println("未成年です");
}
}
public static void main(String[] args) {
checkAge(20); // 出力: 成人です
checkAge(16); // 出力: 未成年です
}
}関数化によるメリット
このように関数に分割することで、次のようなメリットが得られます。
コードの再利用
一度作成した関数を、複数の場所で繰り返し使用することができるため、コードの再利用性が向上します。新しい条件を追加したり、既存のロジックを修正する場合も、関数を修正するだけで済みます。
テストの容易さ
関数に分割することで、その関数を個別にテストできるようになります。テストケースを作成して、関数が期待通りに動作するか確認することができ、バグの早期発見にもつながります。
コードの可読性向上
関数名に処理内容を適切に反映させることで、コードの可読性が向上します。if-else文が複雑化する場合でも、関数にまとめることでコードが整理され、理解しやすくなります。
このように、if-else文を関数に分割することは、コードの再利用性を高め、品質を向上させるための基本的かつ効果的な手法です。次に、さらに高度な手法を用いて、再利用性を向上させる方法を探っていきます。
ストラテジーパターンを活用した再利用性の向上
if-else文が複雑になると、コードの再利用性や可読性が低下しがちです。こうした問題を解決するために、デザインパターンの一つであるストラテジーパターンを活用することが効果的です。ストラテジーパターンは、アルゴリズムをクラスとして定義し、それを動的に切り替えることで、柔軟なコード設計を可能にします。
ストラテジーパターンの基本概念
ストラテジーパターンでは、共通のインターフェースを持つ複数のアルゴリズムクラスを作成し、それらをクライアントコードで動的に選択して使用します。これにより、if-else文による条件分岐を避けつつ、必要に応じて異なるアルゴリズムを簡単に切り替えることができます。
具体例：支払い方法の選択
例えば、支払い方法に応じた処理を行う場合を考えてみましょう。以下のように、if-else文で支払い方法を選択するコードがあったとします。
if (paymentType.equals("credit")) {
processCreditCardPayment();
} else if (paymentType.equals("paypal")) {
processPaypalPayment();
} else if (paymentType.equals("bank")) {
processBankTransfer();
}このコードは、支払い方法が増えるたびにif-else文が増え、保守性が低下します。これをストラテジーパターンを使ってリファクタリングすると、次のようになります。
1. インターフェースの定義
public interface PaymentStrategy {
void pay();
}2. 具体的なアルゴリズムクラスの実装
public class CreditCardPayment implements PaymentStrategy {
public void pay() {
System.out.println("クレジットカードで支払いました。");
}
}
public class PaypalPayment implements PaymentStrategy {
public void pay() {
System.out.println("Paypalで支払いました。");
}
}
public class BankTransferPayment implements PaymentStrategy {
public void pay() {
System.out.println("銀行振込で支払いました。");
}
}3. クライアントコードでの使用
public class PaymentProcessor {
private PaymentStrategy paymentStrategy;
public PaymentProcessor(PaymentStrategy paymentStrategy) {
this.paymentStrategy = paymentStrategy;
}
public void processPayment() {
paymentStrategy.pay();
}
public static void main(String[] args) {
PaymentProcessor processor = new PaymentProcessor(new CreditCardPayment());
processor.processPayment(); // クレジットカードで支払いました。
processor = new PaymentProcessor(new PaypalPayment());
processor.processPayment(); // Paypalで支払いました。
}
}ストラテジーパターンのメリット
if-else文の削減
ストラテジーパターンを使用することで、if-else文を削減し、アルゴリズムの選択を柔軟に行えるようになります。これにより、コードがよりクリーンで保守しやすくなります。
アルゴリズムの追加が容易
新しい支払い方法を追加する場合、対応するアルゴリズムクラスを実装するだけで、クライアントコードに手を加える必要がありません。これにより、システムの拡張性が向上します。
コードのテストが容易
各アルゴリズムが独立したクラスとして定義されているため、それぞれを個別にテストすることができます。これにより、バグの検出と修正が容易になり、コードの信頼性が向上します。
ストラテジーパターンを活用することで、if-else文に頼らず、再利用性と拡張性に優れた柔軟なコード設計が可能となります。次に、さらに具体的な技術を使って、再利用性を高める方法を見ていきます。
Enumとメソッド参照の活用
if-else文を改善し、コードの再利用性と可読性を向上させるもう一つの効果的な手法として、Enum（列挙型）とメソッド参照を活用する方法があります。Enumを用いることで、条件をシンプルに管理でき、メソッド参照を組み合わせることで、コードがさらに洗練されます。
Enumを用いた条件管理
JavaのEnumは、一連の定数を定義できる非常に便利な機能です。if-else文で使用される条件をEnumにまとめることで、条件の管理が簡潔になり、コードの可読性が向上します。
例えば、支払い方法に関する条件分岐をEnumで管理すると、以下のようになります。
1. Enumの定義
public enum PaymentType {
CREDIT, PAYPAL, BANK
}2. Enumを使用した条件分岐
以前のif-else文は、Enumを使うことで以下のように書き換えることができます。
public void processPayment(PaymentType paymentType) {
switch (paymentType) {
case CREDIT:
processCreditCardPayment();
break;
case PAYPAL:
processPaypalPayment();
break;
case BANK:
processBankTransfer();
break;
default:
throw new IllegalArgumentException("不正な支払い方法です。");
}
}この方法により、条件分岐がEnumの形で管理され、支払い方法が追加される場合もEnumに新しい定数を追加するだけで済みます。
メソッド参照を用いたリファクタリング
さらに、Java 8以降で導入されたメソッド参照を組み合わせることで、コードをよりシンプルにできます。メソッド参照を用いると、関数を直接参照し、可読性が高くなると同時に、if-else文をほぼ完全に排除することが可能です。
1. Enumにメソッド参照を関連付ける
Enumに処理を関連付けるために、関数型インターフェースを使用してメソッド参照を管理します。
public enum PaymentType {
CREDIT(PaymentProcessor::processCreditCardPayment),
PAYPAL(PaymentProcessor::processPaypalPayment),
BANK(PaymentProcessor::processBankTransfer);
private final Runnable paymentAction;
PaymentType(Runnable paymentAction) {
this.paymentAction = paymentAction;
}
public void executePayment() {
paymentAction.run();
}
}2. メソッド参照による支払い処理
これにより、支払い処理を行うコードは次のようにシンプルになります。
public class PaymentProcessor {
public static void processCreditCardPayment() {
System.out.println("クレジットカードで支払いました。");
}
public static void processPaypalPayment() {
System.out.println("Paypalで支払いました。");
}
public static void processBankTransfer() {
System.out.println("銀行振込で支払いました。");
}
public static void main(String[] args) {
PaymentType paymentType = PaymentType.CREDIT;
paymentType.executePayment(); // クレジットカードで支払いました。
}
}Enumとメソッド参照のメリット
コードの簡潔化
Enumとメソッド参照を組み合わせることで、if-else文やswitch文を排除し、コードをより簡潔かつ明確に記述することができます。
拡張性の向上
新しい条件や処理が追加される場合も、Enumに新しい定数とメソッド参照を追加するだけで済みます。これにより、コード全体の拡張性が向上します。
管理の一元化
Enumに関連する処理をまとめることで、条件の追加や変更が一元管理され、メンテナンスが容易になります。
このように、Enumとメソッド参照を活用することで、Javaのif-else文の再利用性を大幅に向上させ、保守性と可読性が高いコードを書くことが可能になります。次は、Java 8のラムダ式を使ったリファクタリングについて詳しく説明します。
Java 8のラムダ式でif-else文をリファクタリング
Java 8以降、ラムダ式が導入され、関数型プログラミングの要素が強化されました。これにより、if-else文をより簡潔かつ柔軟にリファクタリングすることが可能になり、再利用性やメンテナンス性をさらに向上させることができます。
ラムダ式の基本概念
ラムダ式は、匿名関数とも呼ばれ、コードを簡潔に記述できる構文です。関数型インターフェースを使用して、メソッドを一行で定義することができるため、従来の冗長なif-else文を簡略化できます。
// 基本的なラムダ式の例
(int x, int y) -> x + yこの例では、(int x, int y)が引数、x + yがラムダ式の本体です。この簡潔さが、if-else文をリファクタリングする際に大いに役立ちます。
ラムダ式を使用した条件分岐のリファクタリング
if-else文での条件分岐をラムダ式でリファクタリングする場合、関数型インターフェースであるPredicate<T>やFunction<T, R>、Consumer<T>などを使用します。これにより、条件ごとに異なる処理をラムダ式として定義し、柔軟に呼び出すことができます。
1. 条件に応じたラムダ式の定義
例えば、年齢に基づく処理をラムダ式で定義すると以下のようになります。
import java.util.function.Consumer;
public class AgeProcessor {
private static final Consumer<Integer> adultAction = age -> System.out.println("成人です: " + age);
private static final Consumer<Integer> minorAction = age -> System.out.println("未成年です: " + age);
public static void processAge(int age) {
if (age >= 18) {
adultAction.accept(age);
} else {
minorAction.accept(age);
}
}
public static void main(String[] args) {
processAge(20); // 出力: 成人です: 20
processAge(16); // 出力: 未成年です: 16
}
}2. 条件分岐をラムダ式でカプセル化
さらに、条件そのものをラムダ式としてカプセル化することも可能です。
import java.util.function.Predicate;
public class AgeProcessor {
private static final Predicate<Integer> isAdult = age -> age >= 18;
public static void processAge(int age) {
if (isAdult.test(age)) {
System.out.println("成人です: " + age);
} else {
System.out.println("未成年です: " + age);
}
}
public static void main(String[] args) {
processAge(20); // 出力: 成人です: 20
processAge(16); // 出力: 未成年です: 16
}
}ラムダ式の活用によるメリット
コードの簡潔化と可読性の向上
ラムダ式を使用することで、冗長なif-else文をより簡潔に書けるようになります。特に、複数の条件が絡む場合でも、ラムダ式を使うことでコードの可読性が大幅に向上します。
条件ロジックの再利用性
条件をラムダ式として定義することで、条件ロジックそのものが再利用可能になります。異なる文脈で同じ条件を使用する場合も、ラムダ式を再利用するだけで済みます。
柔軟な拡張性
ラムダ式を使用すると、新しい条件や処理を簡単に追加できます。これは、if-else文のようにコード全体を見直す必要がなく、メソッドやラムダ式を追加するだけで済むため、柔軟性が高まります。
このように、Java 8のラムダ式を使用してif-else文をリファクタリングすることで、コードの再利用性や可読性を劇的に向上させることができます。次は、実際のサンプルコードを使って、これまで紹介した手法の具体的な適用例を示します。
サンプルコードによる具体例
ここまで紹介してきたif-else文の再利用性向上の手法を実践するために、具体的なサンプルコードを通じて、その効果を確認していきます。このセクションでは、さまざまな方法を組み合わせて、実際のJavaプログラムをどのようにリファクタリングできるかを示します。
ケーススタディ：注文処理システム
例として、異なる種類の注文に応じた処理を行うシステムを考えます。このシステムでは、通常注文、優先注文、緊急注文の3種類の注文に対して異なる処理を行います。
初めに、従来のif-else文を用いたコードを示します。
public class OrderProcessor {
public void processOrder(String orderType) {
if (orderType.equals("regular")) {
processRegularOrder();
} else if (orderType.equals("priority")) {
processPriorityOrder();
} else if (orderType.equals("emergency")) {
processEmergencyOrder();
} else {
throw new IllegalArgumentException("Unknown order type: " + orderType);
}
}
private void processRegularOrder() {
System.out.println("通常注文を処理しています。");
}
private void processPriorityOrder() {
System.out.println("優先注文を処理しています。");
}
private void processEmergencyOrder() {
System.out.println("緊急注文を処理しています。");
}
public static void main(String[] args) {
OrderProcessor processor = new OrderProcessor();
processor.processOrder("priority");
}
}このコードは、if-else文を用いて注文の種類に応じた処理を行っています。しかし、このアプローチには冗長さがあり、拡張性にも限界があります。
リファクタリング：Enumとメソッド参照の活用
ここでは、if-else文をEnumとメソッド参照を用いてリファクタリングし、コードの再利用性と可読性を向上させます。
1. Enumの定義とメソッド参照の関連付け
まず、注文の種類をEnumで管理し、各注文タイプに対応する処理をメソッド参照で関連付けます。
public enum OrderType {
REGULAR(OrderProcessor::processRegularOrder),
PRIORITY(OrderProcessor::processPriorityOrder),
EMERGENCY(OrderProcessor::processEmergencyOrder);
private final Runnable processAction;
OrderType(Runnable processAction) {
this.processAction = processAction;
}
public void process() {
processAction.run();
}
}2. クライアントコードでの使用
次に、クライアントコードでEnumを使用して注文を処理します。
public class OrderProcessor {
public static void processRegularOrder() {
System.out.println("通常注文を処理しています。");
}
public static void processPriorityOrder() {
System.out.println("優先注文を処理しています。");
}
public static void processEmergencyOrder() {
System.out.println("緊急注文を処理しています。");
}
public void processOrder(OrderType orderType) {
orderType.process();
}
public static void main(String[] args) {
OrderProcessor processor = new OrderProcessor();
processor.processOrder(OrderType.PRIORITY); // 優先注文を処理しています。
}
}リファクタリングの効果
コードの簡潔化と柔軟性
このリファクタリングにより、if-else文が完全に排除され、コードが簡潔になりました。また、Enumを使用することで、新しい注文タイプを追加する際にもEnumに新しい定数を追加し、その定数に対応する処理を関連付けるだけで済むため、柔軟性が向上しました。
再利用性の向上
各注文タイプの処理は、Enumにカプセル化されたため、他の部分で同じ処理を行いたい場合にも、同じEnumとメソッド参照を再利用することができます。これにより、コードの重複が減り、再利用性が向上しました。
エラー防止と管理の一元化
注文タイプをEnumで管理することで、未定義の注文タイプを扱おうとした際にコンパイル時にエラーが発生しやすくなり、バグの予防にもつながります。また、注文タイプに対応する処理が一元管理されるため、メンテナンスが容易になりました。
このように、if-else文をリファクタリングし、Enumやメソッド参照、ラムダ式を活用することで、Javaプログラムの再利用性と可読性を劇的に向上させることができます。次に、典型的なアンチパターンとその回避方法について解説します。
典型的なアンチパターンとその回避方法
if-else文を含む条件分岐コードを書く際には、知らず知らずのうちにアンチパターンに陥ってしまうことがあります。アンチパターンとは、問題解決のために一般的に使われるが、実際には悪影響を及ぼす可能性のある非推奨な方法を指します。このセクションでは、典型的なアンチパターンと、それを回避するための方法を解説します。
アンチパターン1: 複雑なネストされたif-else文
最も一般的なアンチパターンの一つは、ネストされたif-else文が深くなることです。ネストが深くなると、コードが複雑になり、理解しにくくなります。このようなコードは、デバッグやメンテナンスも困難になりがちです。
回避方法
ネストを減らすためには、早期リターンを利用する方法が有効です。また、条件ごとに処理を関数化し、各関数を個別にテストできるようにすることも有効です。さらに、前述のように、ストラテジーパターンやEnumを活用することで、ネストを完全に排除することも可能です。
アンチパターン2: 過剰なフラグ変数の使用
もう一つのアンチパターンは、if-else文でフラグ変数を多用することです。フラグ変数が増えると、コードの状態管理が複雑になり、バグの原因となることがあります。
回避方法
フラグ変数の使用は最小限に抑え、代わりに条件をより明確に表現できる構造を使用しましょう。例えば、フラグの代わりにEnumを使用して状態を管理したり、ラムダ式やメソッド参照を活用して条件処理を直接管理することができます。
アンチパターン3: 魔法の数字や文字列のハードコーディング
if-else文内で特定の数値や文字列を直接使用することもアンチパターンです。これらの「魔法の数字」や「魔法の文字列」は、コードの意図を不明瞭にし、変更時にバグを引き起こす可能性があります。
回避方法
このアンチパターンを回避するためには、定数やEnumを使用して意味のある名前を与えることが重要です。これにより、コードの可読性が向上し、変更が必要な際にも一箇所を修正するだけで済むようになります。
アンチパターン4: 長すぎるif-else文
条件が多岐にわたる場合、if-else文が長くなりすぎることがあります。このようなコードは、理解しにくく、他の開発者がメンテナンスする際に困難を伴うことがあります。
回避方法
長いif-else文を回避するためには、条件をグループ化してメソッドに分割する、またはデザインパターンを導入して条件分岐を整理することが効果的です。特に、ファクトリーパターンやストラテジーパターンを活用することで、条件ごとにクラスを分けることができ、コードがスッキリと整理されます。
アンチパターン5: 無意味なデフォルトケース
switch文やif-else文でデフォルトケースを無意味に定義することもアンチパターンです。例えば、”デフォルトケースには到達しないはず”という前提でコードを書くと、後々のバグの原因となることがあります。
回避方法
デフォルトケースをしっかりと定義し、異常系を明確に処理するようにしましょう。また、Enumを使用する場合には、すべてのケースを明示的に扱うようにして、デフォルトケースを省略することが推奨されます。
まとめ
これらのアンチパターンを意識して回避することで、if-else文を使った条件分岐のコードがよりメンテナンスしやすく、理解しやすいものになります。コードの再利用性や可読性を向上させるためには、適切な手法やデザインパターンを活用することが重要です。次のセクションでは、これまでの内容を元に、実際のリファクタリングを体験できる演習問題を提供します。
演習問題：if-else文のリファクタリング
ここまで学んだ内容を実践するために、いくつかの演習問題を用意しました。これらの問題を通じて、if-else文をより再利用性の高いコードにリファクタリングするスキルを身に付けましょう。各問題には、リファクタリングのヒントも含まれていますので、参考にしてください。
演習1: 支払い処理のリファクタリング
次のコードは、異なる支払い方法に応じて処理を行うif-else文です。このコードをEnumとメソッド参照を用いてリファクタリングしてください。
public void processPayment(String paymentMethod) {
if (paymentMethod.equals("credit")) {
processCreditCardPayment();
} else if (paymentMethod.equals("paypal")) {
processPaypalPayment();
} else if (paymentMethod.equals("bank")) {
processBankTransfer();
} else {
throw new IllegalArgumentException("Unknown payment method: " + paymentMethod);
}
}
private void processCreditCardPayment() {
System.out.println("クレジットカードで支払いました。");
}
private void processPaypalPayment() {
System.out.println("Paypalで支払いました。");
}
private void processBankTransfer() {
System.out.println("銀行振込で支払いました。");
}ヒント:
- 支払い方法をEnumとして定義し、それぞれの処理をメソッド参照で関連付けましょう。
- それぞれの処理をEnumのメソッド内で実行するようにリファクタリングします。
演習2: 年齢判定処理のリファクタリング
次のコードは、年齢に応じて異なるメッセージを表示するif-else文です。このコードをラムダ式とPredicateを用いてリファクタリングしてください。
public void checkAge(int age) {
if (age >= 18) {
System.out.println("成人です");
} else {
System.out.println("未成年です");
}
}ヒント:
- ラムダ式を使用して、成人か未成年かを判断するPredicateを定義しましょう。
- 条件に応じたメッセージ表示の処理をラムダ式で行いましょう。
演習3: 商品の価格判定処理のリファクタリング
次のコードは、商品の価格に基づいて異なる処理を行うif-else文です。このコードをストラテジーパターンを用いてリファクタリングしてください。
public void applyDiscount(double price) {
if (price > 100) {
applyHighPriceDiscount();
} else if (price > 50) {
applyMediumPriceDiscount();
} else {
applyLowPriceDiscount();
}
}
private void applyHighPriceDiscount() {
System.out.println("高価格帯の割引が適用されました。");
}
private void applyMediumPriceDiscount() {
System.out.println("中価格帯の割引が適用されました。");
}
private void applyLowPriceDiscount() {
System.out.println("低価格帯の割引が適用されました。");
}ヒント:
- 割引の処理を行うインターフェースを定義し、それぞれの価格帯に応じたクラスを実装しましょう。
- ストラテジーパターンを適用して、価格に応じた割引処理を動的に選択できるようにリファクタリングします。
演習の解答と解説
演習を終えたら、自分の解答を元に、正しくリファクタリングできているかを確認しましょう。解答例を見ながら、自分のコードを見直すことも重要です。
これらの演習問題を通じて、if-else文のリファクタリングを練習し、より洗練されたコードを書くスキルを磨いてください。次のセクションでは、この記事全体のまとめを行います。
まとめ
本記事では、Javaにおけるif-else文の再利用性を高める方法について、さまざまな手法を紹介しました。if-else文の基本的な限界を理解し、関数化やストラテジーパターン、Enum、メソッド参照、そしてラムダ式を活用することで、コードの再利用性、可読性、拡張性を向上させることができます。
また、典型的なアンチパターンを避けるための方法についても触れ、演習問題を通じて実践的なリファクタリングのスキルを磨く機会を提供しました。これらのテクニックを日々のプログラミングに取り入れることで、より堅牢でメンテナンスしやすいコードを書けるようになるでしょう。
if-else文のリファクタリングを習慣化し、質の高いコードを目指して、今後のプロジェクトに役立ててください。
コメント