MENU
  1. ホーム
  2. JavaScript
  3. JavaScriptのクラスを使ったモジュールの作成方法

JavaScriptのクラスを使ったモジュールの作成方法

JavaScript

JavaScriptのクラスを使ったモジュールの作成は、現代のWeb開発において非常に重要なスキルです。クラスを利用することで、コードの再利用性が高まり、モジュール化によって複雑なプログラムも効率的に管理することができます。本記事では、クラスとモジュールの基本概念から始め、具体的な作成手順や実践例、トラブルシューティング方法までを詳しく解説します。これにより、JavaScriptでクラスを使ったモジュールを自信を持って作成できるようになります。

目次

クラスとは何か

クラスとは、オブジェクト指向プログラミングにおける基本概念の一つであり、オブジェクトの設計図として機能します。クラスは、共通の属性（データ）とメソッド（機能）を持つオブジェクトを定義するためのテンプレートです。これにより、同じ構造を持つ複数のオブジェクトを効率的に生成し、管理することができます。

クラスの基本構成

クラスは通常、次のような構成要素を持ちます：

  • プロパティ：クラスのインスタンスが持つデータ。
  • メソッド：クラスのインスタンスが持つ機能や動作。

クラスの重要性

クラスの利用は、以下の理由で重要です：

  • 再利用性：同じコードを繰り返し使用できるため、コードの重複を避けることができます。
  • 可読性：コードの構造が明確になり、読みやすくなります。
  • 保守性：変更が必要な場合でも、クラスの定義を修正するだけで済むため、メンテナンスが容易です。

クラスは、複雑なプログラムをシンプルで管理しやすい形にするための強力なツールです。次に、JavaScriptにおけるクラスの具体的な定義方法について見ていきましょう。

JavaScriptでのクラスの定義

JavaScriptでは、ES6（ECMAScript 2015）以降、クラスを定義するための専用の構文が導入されました。これにより、オブジェクト指向プログラミングのパターンをより簡単に実装できるようになりました。

クラスの基本的な定義方法

JavaScriptでクラスを定義するには、classキーワードを使用します。以下は、基本的なクラス定義の例です。

class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

// クラスのインスタンス化
const person1 = new Person('John', 30);
person1.greet(); // "Hello, my name is John and I am 30 years old."

クラスの構成要素

  • constructor: クラスのインスタンスを初期化するためのメソッドです。インスタンスが生成される際に自動的に呼び出されます。
  • プロパティ: インスタンスが持つデータを定義します。上記の例では、nameとageがプロパティです。
  • メソッド: クラスに関連する機能や動作を定義します。上記の例では、greetがメソッドです。

クラスの継承

JavaScriptでは、クラスを継承して新しいクラスを作成することもできます。これにより、既存のクラスの機能を再利用しながら、新しい機能を追加することができます。

class Employee extends Person {
  constructor(name, age, jobTitle) {
    super(name, age); // 親クラスのconstructorを呼び出します
    this.jobTitle = jobTitle;
  }

  work() {
    console.log(`${this.name} is working as a ${this.jobTitle}.`);
  }
}

const employee1 = new Employee('Jane', 28, 'Software Engineer');
employee1.greet(); // "Hello, my name is Jane and I am 28 years old."
employee1.work(); // "Jane is working as a Software Engineer."

クラスの定義と継承を利用することで、JavaScriptのオブジェクト指向プログラミングを効果的に活用できます。次に、モジュールの基本について説明します。

モジュールの基礎

モジュールとは、コードを論理的に分割し、再利用性や管理性を向上させるための単位です。モジュールを使用することで、複雑なプログラムを小さな部品に分けて開発することができます。

モジュールの利点

モジュールを利用する主な利点は次の通りです：

  • コードの再利用：一度作成したモジュールは、他のプロジェクトや他の部分でも再利用できます。
  • 可読性の向上：コードが小さな単位に分割されるため、各部分の役割が明確になり、コードの理解が容易になります。
  • 保守性の向上：モジュール化されたコードは、個別にテストおよびデバッグができるため、メンテナンスが簡単になります。

JavaScriptでのモジュールの使用

JavaScriptでは、ES6以降、標準的なモジュールシステムが導入されました。これにより、importおよびexportキーワードを使用してモジュールを定義および利用できます。

モジュールのエクスポート

モジュールをエクスポートするには、exportキーワードを使用します。以下は、クラスをエクスポートする例です。

// person.js
export class Person {
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }

  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  }
}

モジュールのインポート

エクスポートされたモジュールを他のファイルで使用するには、importキーワードを使用します。

// main.js
import { Person } from './person.js';

const person1 = new Person('John', 30);
person1.greet(); // "Hello, my name is John and I am 30 years old."

デフォルトエクスポート

モジュールには、デフォルトエクスポートを使用してエクスポートできるものもあります。この場合、インポートする際に任意の名前を使用できます。

// mathUtils.js
export default class MathUtils {
  static add(a, b) {
    return a + b;
  }
}

// main.js
import MathUtils from './mathUtils.js';

console.log(MathUtils.add(2, 3)); // 5

モジュールの基礎を理解することで、コードをより効果的に構造化し、再利用性と保守性を向上させることができます。次に、クラスを用いたモジュールの作成手順について詳しく見ていきましょう。

クラスを用いたモジュールの作成手順

クラスを利用してモジュールを作成することで、コードの再利用性と管理性を高めることができます。以下に、クラスを用いたモジュールの作成手順をステップバイステップで説明します。

ステップ1：クラスの定義

まず、モジュールとして利用するクラスを定義します。例えば、簡単な計算機能を持つクラスを定義します。

// calculator.js
export class Calculator {
  constructor() {
    this.value = 0;
  }

  add(number) {
    this.value += number;
    return this.value;
  }

  subtract(number) {
    this.value -= number;
    return this.value;
  }

  multiply(number) {
    this.value *= number;
    return this.value;
  }

  divide(number) {
    if (number !== 0) {
      this.value /= number;
      return this.value;
    } else {
      throw new Error('Division by zero');
    }
  }

  reset() {
    this.value = 0;
    return this.value;
  }
}

ステップ2：クラスのエクスポート

定義したクラスをモジュールとしてエクスポートします。上記のコード例では、すでにexportキーワードを使用してクラスをエクスポートしています。

ステップ3：モジュールのインポート

次に、他のファイルでエクスポートしたクラスをインポートします。以下は、calculator.jsモジュールをインポートして利用する例です。

// main.js
import { Calculator } from './calculator.js';

const calc = new Calculator();

console.log(calc.add(10));       // 10
console.log(calc.subtract(4));   // 6
console.log(calc.multiply(3));   // 18
console.log(calc.divide(2));     // 9
console.log(calc.reset());       // 0

ステップ4：モジュールの使用

インポートしたクラスを利用して、実際に計算機能を実行します。main.jsの例では、Calculatorクラスのメソッドを呼び出して計算を行っています。

ステップ5：エラーハンドリングの追加

必要に応じて、エラーハンドリングを追加して、より堅牢なモジュールを作成します。例えば、除算メソッドでゼロ除算のエラーを処理しています。

try {
  console.log(calc.divide(0));  // Error: Division by zero
} catch (error) {
  console.error(error.message); // エラーメッセージを出力
}

これで、クラスを用いたモジュールの基本的な作成手順が完了しました。次に、クラスとモジュールの連携方法について詳しく見ていきましょう。

クラスとモジュールの連携方法

クラスとモジュールを連携させることで、コードの再利用性や可読性をさらに向上させることができます。ここでは、クラスとモジュールの連携方法を具体例を交えて説明します。

複数のクラスをモジュールとしてエクスポート

一つのモジュールに複数のクラスをエクスポートすることができます。これにより、関連するクラスを一つのファイルにまとめて管理することができます。

// shapes.js
export class Circle {
  constructor(radius) {
    this.radius = radius;
  }

  getArea() {
    return Math.PI * this.radius * this.radius;
  }
}

export class Rectangle {
  constructor(width, height) {
    this.width = width;
    this.height = height;
  }

  getArea() {
    return this.width * this.height;
  }
}

モジュールのインポートと使用

エクスポートされた複数のクラスをインポートして使用する方法を示します。

// main.js
import { Circle, Rectangle } from './shapes.js';

const circle = new Circle(5);
console.log(`Circle Area: ${circle.getArea()}`);  // Circle Area: 78.53981633974483

const rectangle = new Rectangle(10, 5);
console.log(`Rectangle Area: ${rectangle.getArea()}`);  // Rectangle Area: 50

デフォルトエクスポートと名前付きエクスポートの併用

モジュールはデフォルトエクスポートと名前付きエクスポートを併用することもできます。

// utils.js
export default class MathUtils {
  static add(a, b) {
    return a + b;
  }
}

export class Converter {
  static toCelsius(fahrenheit) {
    return (fahrenheit - 32) * 5 / 9;
  }

  static toFahrenheit(celsius) {
    return (celsius * 9 / 5) + 32;
  }
}

インポートする際には、デフォルトエクスポートと名前付きエクスポートをそれぞれ使用できます。

// main.js
import MathUtils, { Converter } from './utils.js';

console.log(MathUtils.add(10, 5));  // 15
console.log(Converter.toCelsius(100));  // 37.77777777777778
console.log(Converter.toFahrenheit(37.77777777777778));  // 100

モジュール間の依存関係管理

モジュール間の依存関係を適切に管理することで、複雑なプロジェクトでもコードの一貫性と保守性を維持できます。たとえば、ユーティリティクラスを別のモジュールで使用する場合、必要なモジュールを適切にインポートします。

// shapesWithUtils.js
import MathUtils from './utils.js';

export class Circle {
  constructor(radius) {
    this.radius = radius;
  }

  getArea() {
    return Math.PI * MathUtils.square(this.radius);
  }
}

このように、クラスとモジュールを連携させることで、コードのモジュール化を進め、管理しやすい形にすることができます。次に、実際のコードを使った簡単なモジュールの作成例を紹介します。

実践例：簡単なモジュールの作成

ここでは、具体的なコード例を使って簡単なモジュールを作成し、実際に使用する方法を説明します。今回は、数値を操作する簡単なユーティリティモジュールを作成します。

ステップ1：ユーティリティクラスの定義とエクスポート

まず、数値操作用のユーティリティクラスを定義し、それをモジュールとしてエクスポートします。

// numberUtils.js
export class NumberUtils {
  static isEven(number) {
    return number % 2 === 0;
  }

  static isOdd(number) {
    return number % 2 !== 0;
  }

  static factorial(number) {
    if (number < 0) {
      throw new Error('Number must be non-negative');
    }
    return number === 0 ? 1 : number * NumberUtils.factorial(number - 1);
  }

  static fibonacci(n) {
    if (n < 0) {
      throw new Error('Index must be non-negative');
    }
    return n < 2 ? n : NumberUtils.fibonacci(n - 1) + NumberUtils.fibonacci(n - 2);
  }
}

ステップ2：モジュールのインポートと使用

次に、エクスポートしたNumberUtilsクラスを他のファイルでインポートし、実際に使用します。

// main.js
import { NumberUtils } from './numberUtils.js';

const number = 5;

console.log(`${number} is even: ${NumberUtils.isEven(number)}`);  // 5 is even: false
console.log(`${number} is odd: ${NumberUtils.isOdd(number)}`);    // 5 is odd: true
console.log(`Factorial of ${number}: ${NumberUtils.factorial(number)}`);  // Factorial of 5: 120
console.log(`Fibonacci of ${number}: ${NumberUtils.fibonacci(number)}`);  // Fibonacci of 5: 5

ステップ3：エラーハンドリングの実装

モジュールを使用する際には、エラーハンドリングを実装することで、予期しない入力に対する対処が可能になります。

try {
  console.log(NumberUtils.factorial(-1));  // Error: Number must be non-negative
} catch (error) {
  console.error(error.message);  // エラーメッセージを出力
}

try {
  console.log(NumberUtils.fibonacci(-1));  // Error: Index must be non-negative
} catch (error) {
  console.error(error.message);  // エラーメッセージを出力
}

ステップ4：テストの実行

作成したモジュールの動作を確認するために、実際にテストを行います。上記のコード例を実行して、期待通りの結果が得られることを確認します。

これで、簡単なユーティリティモジュールの作成が完了しました。この方法を応用して、複雑なモジュールも作成することができます。次に、より複雑なモジュールの作成例を紹介します。

応用例：複雑なモジュールの作成

ここでは、より複雑なモジュールを作成する方法を紹介します。今回は、簡単なタスク管理システムを実装します。このシステムでは、タスクの追加、削除、完了状態の更新、およびタスクのリスト表示を行います。

ステップ1：タスククラスの定義

まず、タスクを表すクラスを定義します。

// task.js
export class Task {
  constructor(title, description) {
    this.title = title;
    this.description = description;
    this.completed = false;
  }

  complete() {
    this.completed = true;
  }

  uncomplete() {
    this.completed = false;
  }
}

ステップ2：タスク管理クラスの定義

次に、複数のタスクを管理するためのクラスを定義します。このクラスでは、タスクの追加、削除、完了状態の更新、およびタスクのリスト表示を行います。

// taskManager.js
import { Task } from './task.js';

export class TaskManager {
  constructor() {
    this.tasks = [];
  }

  addTask(title, description) {
    const task = new Task(title, description);
    this.tasks.push(task);
  }

  removeTask(title) {
    this.tasks = this.tasks.filter(task => task.title !== title);
  }

  completeTask(title) {
    const task = this.tasks.find(task => task.title === title);
    if (task) {
      task.complete();
    }
  }

  uncompleteTask(title) {
    const task = this.tasks.find(task => task.title === title);
    if (task) {
      task.uncomplete();
    }
  }

  listTasks() {
    return this.tasks.map(task => ({
      title: task.title,
      description: task.description,
      completed: task.completed
    }));
  }
}

ステップ3：モジュールのインポートと使用

定義したTaskManagerクラスをインポートし、タスク管理システムを実際に使用してみます。

// main.js
import { TaskManager } from './taskManager.js';

const taskManager = new TaskManager();

// タスクの追加
taskManager.addTask('Learn JavaScript', 'Study the basics of JavaScript');
taskManager.addTask('Write a blog post', 'Write about JavaScript modules');

// タスクのリスト表示
console.log(taskManager.listTasks());

// タスクの完了
taskManager.completeTask('Learn JavaScript');
console.log(taskManager.listTasks());

// タスクの削除
taskManager.removeTask('Write a blog post');
console.log(taskManager.listTasks());

ステップ4：エラーハンドリングの実装

タスクの操作に失敗した場合のエラーハンドリングも実装します。

try {
  taskManager.completeTask('Nonexistent Task');
} catch (error) {
  console.error('Error:', error.message);
}

try {
  taskManager.removeTask('Nonexistent Task');
} catch (error) {
  console.error('Error:', error.message);
}

ステップ5：ユニットテストの追加

複雑なモジュールでは、ユニットテストを追加して各機能の動作を確認することが重要です。例えば、jestを使用してテストを実行します。

// taskManager.test.js
import { TaskManager } from './taskManager.js';

test('TaskManager adds and completes tasks', () => {
  const taskManager = new TaskManager();
  taskManager.addTask('Test Task', 'This is a test task');
  expect(taskManager.listTasks().length).toBe(1);
  taskManager.completeTask('Test Task');
  expect(taskManager.listTasks()[0].completed).toBe(true);
});

このように、複雑なモジュールの作成手順を理解することで、実際のプロジェクトにおいても効果的にモジュールを作成し、管理することができます。次に、モジュールのテスト方法について詳しく説明します。

モジュールのテスト方法

モジュールを作成した後、その動作を確認するためにテストを実行することが重要です。ここでは、JavaScriptモジュールのテスト方法について詳しく説明します。

ステップ1：テストフレームワークの選定

JavaScriptにはさまざまなテストフレームワークがありますが、ここでは広く使用されているJestを例に取ります。Jestは、設定が少なく、シンプルなAPIを提供するため、初めてのテストにも適しています。

ステップ2：Jestのインストールと設定

Jestをインストールするには、以下のコマンドを実行します。

npm install --save-dev jest

次に、package.jsonファイルにテストスクリプトを追加します。

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

ステップ3：テストケースの作成

モジュールの各機能をテストするためのテストケースを作成します。例えば、先ほどのTaskManagerクラスに対するテストケースを以下のように作成します。

// taskManager.test.js
import { TaskManager } from './taskManager.js';

describe('TaskManager', () => {
  let taskManager;

  beforeEach(() => {
    taskManager = new TaskManager();
  });

  test('should add a task', () => {
    taskManager.addTask('Test Task', 'This is a test task');
    const tasks = taskManager.listTasks();
    expect(tasks.length).toBe(1);
    expect(tasks[0].title).toBe('Test Task');
    expect(tasks[0].description).toBe('This is a test task');
  });

  test('should complete a task', () => {
    taskManager.addTask('Test Task', 'This is a test task');
    taskManager.completeTask('Test Task');
    const tasks = taskManager.listTasks();
    expect(tasks[0].completed).toBe(true);
  });

  test('should remove a task', () => {
    taskManager.addTask('Test Task', 'This is a test task');
    taskManager.removeTask('Test Task');
    const tasks = taskManager.listTasks();
    expect(tasks.length).toBe(0);
  });
});

ステップ4：テストの実行

作成したテストケースを実行します。以下のコマンドを実行することで、Jestがすべてのテストを実行し、結果を出力します。

npm test

テストがすべて成功すれば、以下のような出力が得られます。

PASS  ./taskManager.test.js
 TaskManager
  ✓ should add a task (5ms)
  ✓ should complete a task (3ms)
  ✓ should remove a task (2ms)

ステップ5：エッジケースのテスト

通常の動作だけでなく、エッジケースもテストすることが重要です。例えば、存在しないタスクを完了または削除しようとした場合の動作をテストします。

test('should not complete a non-existent task', () => {
  expect(() => {
    taskManager.completeTask('Non-existent Task');
  }).not.toThrow();
});

test('should not remove a non-existent task', () => {
  expect(() => {
    taskManager.removeTask('Non-existent Task');
  }).not.toThrow();
});

これらのテストにより、モジュールが期待通りに動作することを確認し、バグの早期発見と修正が可能になります。次に、モジュール開発においてよく発生するトラブルとその解決方法について説明します。

トラブルシューティング

モジュール開発においては、様々なトラブルが発生する可能性があります。ここでは、よくある問題とその解決方法について説明します。

依存関係の問題

依存関係が正しく管理されていないと、モジュールが正しく動作しないことがあります。例えば、モジュールが必要とする外部ライブラリが見つからない場合があります。

Error: Cannot find module 'some-module'

このエラーが発生した場合、以下の方法で解決できます：

  • 必要なライブラリがpackage.jsonに正しく記述されているか確認する。
  • npm installを実行して依存関係をインストールする。

循環依存の問題

モジュール間で循環依存が発生すると、予期しない動作を引き起こすことがあります。循環依存とは、モジュールAがモジュールBに依存し、モジュールBが再びモジュールAに依存する状態です。

循環依存を解決するための方法：

  • モジュールの設計を見直し、依存関係を明確にする。
  • 依存関係を分離し、共通のモジュールにまとめる。

クラスの継承に関する問題

クラスの継承を利用する際に、親クラスのメソッドやプロパティが正しく継承されないことがあります。

class Parent {
  constructor() {
    this.name = 'Parent';
  }
}

class Child extends Parent {
  constructor() {
    super();
    this.name = 'Child';
  }
}

const child = new Child();
console.log(child.name);  // Output: 'Child'

継承の問題を解決するために：

  • super()を忘れずに呼び出す。
  • 親クラスのプロパティやメソッドが正しく定義されているか確認する。

非同期処理の問題

非同期処理を扱う際に、意図しないタイミングでコードが実行されることがあります。これにより、データの取得が完了する前に処理が進行してしまうことがあります。

async function fetchData() {
  const response = await fetch('https://api.example.com/data');
  const data = await response.json();
  return data;
}

fetchData().then(data => {
  console.log(data);
}).catch(error => {
  console.error('Error fetching data:', error);
});

非同期処理の問題を解決するために：

  • async/awaitを適切に使用する。
  • 非同期関数の呼び出しが正しく待機されているか確認する。

テストの失敗

テストが失敗する場合、原因を特定し修正する必要があります。テストが失敗する主な原因としては、以下のようなものがあります：

  • モジュールの変更によるテストコードの不整合。
  • 予期しない入力データやエッジケースの見落とし。
FAIL  ./taskManager.test.js
 TaskManager
  ✕ should add a task (5ms)
  ✕ should complete a task (3ms)
  ✕ should remove a task (2ms)

テストの失敗を解決するために：

  • テストコードと実装コードの整合性を確認する。
  • エラーメッセージやスタックトレースを確認し、問題の箇所を特定する。
  • エッジケースを追加してテストカバレッジを向上させる。

これらのトラブルシューティングの方法を理解することで、モジュール開発中に発生する問題に迅速に対応し、プロジェクトの品質を維持することができます。次に、クラスを使ったモジュール作成のベストプラクティスについて説明します。

ベストプラクティス

クラスを使ったモジュール作成では、いくつかのベストプラクティスに従うことで、コードの品質と保守性を向上させることができます。ここでは、クラスを使ったモジュール作成のベストプラクティスを紹介します。

シングルレスポンシビリティの原則

クラスは一つの責任を持つべきです。これにより、クラスが複雑化せず、理解しやすくなります。

// Bad: Multiple responsibilities
class UserManager {
  constructor() {
    this.users = [];
  }

  addUser(user) {
    this.users.push(user);
  }

  authenticateUser(username, password) {
    // Authentication logic
  }

  logUserActivity(user) {
    // Logging logic
  }
}

// Good: Single responsibility
class UserManager {
  constructor() {
    this.users = [];
  }

  addUser(user) {
    this.users.push(user);
  }
}

class Authenticator {
  authenticateUser(username, password) {
    // Authentication logic
  }
}

class Logger {
  logUserActivity(user) {
    // Logging logic
  }
}

コンポジションの利用

継承よりもコンポジションを利用することで、柔軟性が向上し、コードの再利用性が高まります。

// Bad: Inheritance
class Animal {
  eat() {
    console.log('Eating');
  }
}

class Dog extends Animal {
  bark() {
    console.log('Barking');
  }
}

// Good: Composition
class Animal {
  eat() {
    console.log('Eating');
  }
}

class Dog {
  constructor() {
    this.animal = new Animal();
  }

  bark() {
    console.log('Barking');
  }

  eat() {
    this.animal.eat();
  }
}

モジュールのインターフェースを明確にする

モジュールのエクスポートを通じて提供するインターフェースを明確に定義し、内部実装の詳細を隠蔽します。

// Good: Clear interface
class PrivateDetails {
  // Internal logic
}

export class PublicInterface {
  constructor() {
    this.details = new PrivateDetails();
  }

  performAction() {
    // Public method using internal logic
  }
}

テスト可能なコードを書く

モジュールをテストしやすいように設計します。依存関係を注入し、外部リソースへの依存を最小限に抑えます。

// Good: Testable code
class Database {
  query(sql) {
    // Database query logic
  }
}

class UserManager {
  constructor(database) {
    this.database = database;
  }

  getUser(id) {
    return this.database.query(`SELECT * FROM users WHERE id = ${id}`);
  }
}

ドキュメントを充実させる

クラスやメソッドに対して適切なコメントやドキュメントを追加し、使用方法や挙動を明確に伝えます。

/**
 * UserManager class
 * Manages user data and interactions with the database
 */
export class UserManager {
  /**
   * Adds a new user to the system
   * @param {Object} user - The user object
   */
  addUser(user) {
    // Add user logic
  }
}

エラーハンドリングを徹底する

予期しない状況に対して適切にエラーハンドリングを行い、システムの安定性を確保します。

class UserManager {
  getUser(id) {
    if (!id) {
      throw new Error('User ID is required');
    }
    // Fetch user logic
  }
}

これらのベストプラクティスに従うことで、クラスを使ったモジュール作成の品質を高め、保守性の高いコードを書くことができます。次に、この記事のまとめを行います。

まとめ

本記事では、JavaScriptのクラスを使ったモジュールの作成方法について、基本概念から具体的な実装方法、応用例、トラブルシューティング、そしてベストプラクティスまで詳しく解説しました。クラスを利用することで、コードの再利用性と保守性が向上し、モジュール化によって複雑なプログラムも効率的に管理できるようになります。

クラスとモジュールの連携方法を理解し、実践的な例を通じてその応用方法を学ぶことで、JavaScriptでの開発スキルを一段と向上させることができます。また、ベストプラクティスを遵守することで、高品質なコードを書く習慣を身に付けることができます。

今後も学習を続け、さまざまなプロジェクトでこれらの知識を応用し、より効率的で効果的な開発を目指しましょう。

JavaScript
モジュール プログラミング クラス JavaScript

コメント

コメントする

目次