JavaScript
PR

JavaScriptのクラス構文入門|class・constructor・extendsとthisの落とし穴

JavaScriptのクラス構文入門|class・constructor・extendsとthisの落とし穴
hr
記事内に商品プロモーションを含む場合があります

JavaScript で「名前と年齢を持つユーザー」「残高を持つ口座」のように、データと処理をひとまとめにするのがクラス構文(class)です。書き方は短いのですが、new や super() の書き忘れ、クリックに渡したメソッドで this が外れる、といったつまずきどころがあります。

この記事では、基本の書き方から継承、# の private フィールド、クラスの正体である prototype、this の落とし穴までを、実際に動かした結果とエラーの文言つきで説明します。出力は Windows 11 の Microsoft Edge 156(156.0.4314.50)で実行したものです。クラスの考え方(設計図とインスタンス)は Python で説明した「Pythonのクラスの基本|__init__・self・メソッド・継承を実例で解説」と共通なので、ここでは JavaScript ならではの書き方と落とし穴に絞ります。

この記事のコードの試し方

  1. インストールは不要です。Edge または Chrome で、どのページでもよいので開いた状態で F12 キーを押します。
  2. 開いた画面の上部にある「Console(コンソール)」タブを選びます。
  3. 記事のコードをコピーして貼り付け、Enter キーを押します。

初めて貼り付けるときは、詐欺を防ぐための警告が出て、確認の文字の入力を求められることがあります。知らない人から教えられたコードはコンソールに貼り付けないでください。コンソールでは、前に貼ったコードと同じ名前の const や class を宣言し直せるので、記事のコードは続けて貼り付けても動きます(ふつうの JS ファイルでは SyntaxError: Identifier 'User' has already been declared になります)。配列はコンソールでは (2) ['items', 'discount'] のように表示されますが、記事では ["items", "discount"] と書いています。

class・constructor・this の基本

クラスは「同じ形のオブジェクトを作るための設計図」です。new クラス名(...) で設計図から作った 1 つ 1 つのオブジェクトをインスタンスと呼びます。

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

  greet() {
    return `こんにちは、${this.name}です(${this.age}歳)`;
  }

  birthday() {
    this.age += 1;
  }
}

const tanaka = new User("田中", 28);
const sato = new User("佐藤", 35);
tanaka.birthday();
console.log(tanaka.greet());
console.log(sato.greet());
console.log(tanaka instanceof User);
こんにちは、田中です(29歳)
こんにちは、佐藤です(35歳)
true

constructor は new したときに 1 回だけ自動で呼ばれる初期化用のメソッドで、Python の __init__ にあたります。this は「いま作っている(またはメソッドを呼んだ)インスタンス自身」で、Python の self にあたりますが、引数には書きません。メソッドは function を付けずに greet() { ... } と書き、メソッドの間に , は書きません。tanaka.birthday() は田中さんの age だけを増やし、佐藤さんには影響しません。instanceof は、そのクラスから作ったインスタンスかを調べます。

new を付け忘れると TypeError

class User {
  constructor(name) {
    this.name = name;
  }
}
const user = User("田中");
Uncaught TypeError: Class constructor User cannot be invoked without 'new'

「クラスのコンストラクター User は new なしでは呼び出せません」という意味です。クラスは必ず new User(...) で使います。昔ながらの function OldUser(name) { this.name = name; } は、new を忘れてもエラーにならず、戻り値は undefined、代わりに window.name が「田中」に書き換わっていました。クラスはこの気づきにくいバグをエラーで防ぎます。

クラスフィールド:初期値をクラスの先頭に書く

引数に関係なく決まった初期値を持たせる項目は、constructor の外に 名前 = 初期値; と書けます。これをクラスフィールドといいます。const や let は付けません。

class Cart {
  items = [];
  discount = 0;

  add(name, price) {
    this.items.push({ name, price });
  }
}

const a = new Cart();
const b = new Cart();
a.add("ノート", 300);
console.log(a.items.length, b.items.length);
console.log(Object.keys(a));
1 0
["items", "discount"]

フィールドの初期値は new のたびに評価されるので、a と b はそれぞれ別の配列を持ちます。Python ではクラス変数にリストを置くと全インスタンスで共有される落とし穴がありますが、JavaScript のクラスフィールドはインスタンスごとの値になるので、この問題は起きません。

getter と setter:プロパティのように読み書きする

get を付けたメソッドは、かっこなしの t.fahrenheit で呼ばれるgetter(ゲッター)、set を付けたメソッドは t.fahrenheit = 値 の代入で呼ばれるsetter(セッター)になります。計算で求める値や、代入のときに値を変換したいときに使います。

class Temperature {
  constructor(celsius) {
    this.celsius = celsius;
  }

  get fahrenheit() {
    return this.celsius * 9 / 5 + 32;
  }

  set fahrenheit(value) {
    this.celsius = (value - 32) * 5 / 9;
  }
}

const t = new Temperature(25);
console.log(t.fahrenheit);
t.fahrenheit = 212;
console.log(t.celsius);
77
100

華氏に 212 を代入すると、setter が摂氏に直して celsius に 100 を入れます。よくある落とし穴が 2 つあります。

書き方結果理由
t.fahrenheit() とかっこを付けて呼ぶTypeError: t.fahrenheit is not a functiongetter は読んだ時点で呼ばれ、77 という数が返る。その数を関数として呼ぼうとした
setter の中で this.name = value.trim(); と同じ名前に代入するRangeError: Maximum call stack size exceeded代入がまた setter を呼び、無限にくり返す。値は別の名前(次に説明する #name など)に入れる

static:インスタンスではなくクラスに付くメソッド

static を付けたメソッドやフィールドは、インスタンスではなくクラスそのものに付きます。User.fromCsv(...) のようにクラス名から呼びます。よく使うのは、別の形のデータからインスタンスを作る「作り方の窓口」や、クラス全体で共通の設定値です。

class User {
  static MAX_NAME_LENGTH = 20;

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

  static fromCsv(line) {
    const [name, age] = line.split(",");
    return new User(name, Number(age));
  }
}

const user = User.fromCsv("田中,28");
console.log(user.name, user.age + 1);
console.log(User.MAX_NAME_LENGTH);
console.log(user.fromCsv);
田中 29
20
undefined

"田中,28" を split すると年齢は文字列の "28" なので、Number() で数に直しています。static メソッドはインスタンスからは見えず、user.fromCsv は undefined です(user.fromCsv("...") と呼ぶと TypeError になります)。標準の Array.isArray() や Date.now() も、Array や Date というクラス(関数)に付いた static メソッドです。

extends と super:クラスを引き継ぐ

class 子 extends 親 と書くと、親クラスのメソッドを受け継いだ子クラスを作れます(継承)。子のほうで同じ名前のメソッドを書くと、親のものを置き換えられます(オーバーライド)。置き換えた中から親の処理を呼びたいときは super.メソッド名() を使います。

class Animal {
  constructor(name) {
    this.name = name;
  }

  speak() {
    return `${this.name}が鳴きました`;
  }

  describe() {
    return `名前:${this.name}`;
  }
}

class Dog extends Animal {
  constructor(name, breed) {
    super(name);
    this.breed = breed;
  }

  speak() {
    return `${this.name}がワンと鳴きました`;
  }

  describe() {
    return `${super.describe()}/犬種:${this.breed}`;
  }
}

const pochi = new Dog("ポチ", "柴犬");
console.log(pochi.speak());
console.log(pochi.describe());
console.log(pochi instanceof Dog, pochi instanceof Animal);
console.log(new Animal("ミケ").speak());
ポチがワンと鳴きました
名前:ポチ/犬種:柴犬
true true
ミケが鳴きました

super(name) で親の constructor を呼び、親が this.name を用意します。speak() は子で書き直したのでポチは「ワン」になり、親のインスタンス(ミケ)は元のままです。super.describe() は親の結果「名前:ポチ」に犬種を書き足しています。Dog のインスタンスは Animal のインスタンスでもあるので、instanceof は両方 true です。

子クラスで constructor を書かなければ、受け取った引数をそのまま super(...) に渡す constructor が自動で用意されます。たとえば class Cat extends Animal { speak() { ... } } だけでも、new Cat("タマ") の name は「タマ」になりました。標準の Error を引き継いで自分のエラーを作る例は「JavaScriptのエラー処理入門|try・catchとErrorの使い方」で説明しています。

super() より前に this を使うと ReferenceError

子クラスの constructor では、this を使う前に必ず super() を呼ぶ決まりです。順番を逆にしてみます。

class Animal {
  constructor(name) {
    this.name = name;
  }
}
class Dog extends Animal {
  constructor(name, breed) {
    this.breed = breed;
    super(name);
  }
}
new Dog("ポチ", "柴犬");
Uncaught ReferenceError: Must call super constructor in derived class before accessing 'this' or returning from derived constructor

「派生クラス(子クラス)では、this に触れる前、または constructor を抜ける前に、親の constructor を呼ばなければならない」という意味です。super() を呼ぶまでは this がまだ用意されていないからです。super() を書き忘れた場合(this を使わない空の constructor でも)も同じエラーになりました。

# で始まる private フィールド:外から本当に触れない

名前を # で始めたフィールドやメソッドは private(非公開)になり、クラスの中からしか読み書きできません。口座の残高のように、決まったメソッド以外で書き換えられては困る値に使います。

class BankAccount {
  #balance = 0;

  deposit(amount) {
    if (amount <= 0) {
      throw new RangeError("入金額は 1 円以上にしてください");
    }
    this.#balance += amount;
  }

  get balance() {
    return this.#balance;
  }
}

const account = new BankAccount();
account.deposit(1000);
console.log(account.balance);
console.log(account["#balance"]);
console.log(Object.keys(account), JSON.stringify(account));
account.balance = 999999;
console.log(account.balance);
1000
undefined
[] {}
1000

残高は getter の balance で読めますが、setter がないので代入しても 1000 のままです。#balance は普通のプロパティではないため、account["#balance"] では読めず、Object.keys にも JSON.stringify にも出てきません。

クラスの外から account.#balance と書いたコードを、HTML ファイルの script で実行するとこうなります。

console.log("1. ここも実行されない");
class BankAccount {
  #balance = 0;
}
const account = new BankAccount();
account.#balance = 999999;
Uncaught SyntaxError: Private field '#balance' must be declared in an enclosing class

「#balance は、それを囲むクラスの中で宣言されていなければならない」という文法のエラー(SyntaxError)です。実行する前の読み込みの段階で見つかるので、1 行目の console.log も実行されません。クラスの中で宣言していない this.#balance に代入したときも同じエラーです。

注意:開発者ツールのコンソールでは、このエラーが出ません。MDN によると、コンソールは調べものをしやすくするために、クラスの外からでも private フィールドを読み書きできるよう特別にゆるめてあります。コンソールと同じ評価のしかた(REPL モード)で試したところ、account.#balance は 1000 を返し、999999 も代入できました。ページの JavaScript では上のとおりエラーになります。

Python の _ との違い

Python には本当の private はなく、_history のように _ を付けて「内部用なので触らないで」と伝える慣習で済ませます(__ の名前の書き換えも、_クラス名__名前 で外から読めます)。JavaScript でも # ができる前は同じように _ を付けていましたが、constructor で this._balance = 0; とした口座は、外から account._balance = 999999; と書くだけで書き換わりました。_ は「お願い」、# は言語が守る「鍵」と考えると違いが分かりやすいでしょう。

クラスの正体は関数と prototype

MDN は「クラスは実は特別な関数」と説明しています。中身を調べてみます。

class User {
  constructor(name) {
    this.name = name;
  }
  greet() {
    return `こんにちは、${this.name}です`;
  }
}

const tanaka = new User("田中");
console.log(typeof User);
console.log(Object.keys(tanaka));
console.log(Object.hasOwn(tanaka, "greet"), Object.hasOwn(User.prototype, "greet"));
console.log(Object.getPrototypeOf(tanaka) === User.prototype);
console.log(Object.getPrototypeOf(User.prototype) === Object.prototype);
console.log(Object.getPrototypeOf(Object.prototype));
console.log(tanaka.greet === new User("佐藤").greet);
console.log(tanaka.toString());
function
["name"]
false true
true
true
null
true
[object Object]

typeof User は "function" で、クラスは関数の一種です(new なしでは呼べない特別な関数です)。インスタンス自身が持つのは name だけで、greet は User.prototype というオブジェクトに 1 つだけ置かれ、田中さんと佐藤さんで同じもの(true)を使っています(Object.hasOwn は「自分自身が持っているか」を調べます)。書いていない toString() が使えるのは、その先の Object.prototype にあるからで、さらに先は null で終わりです。

インスタンスtanaka(name: 田中)、User.prototype(constructorとgreet)、Object.prototype(toStringなど)、nullの順に矢印でつながった図。上のclass Userの箱はtypeofがfunctionで、User.prototypeを参照する。greetは自分になければ右へ順に探され、User.prototypeに1つだけあって全インスタンスで共有される。
図 1:インスタンスから prototype をたどってメソッドを探す

tanaka.greet() と書くと、JavaScript はまず tanaka 自身を探し、なければ User.prototype、それでもなければ Object.prototype と、矢印の向きに探しにいきます。このつながりをプロトタイプチェーンといいます。extends を使うと、Dog.prototype の次に Animal.prototype がつながります(Object.getPrototypeOf(Dog.prototype) === Animal.prototype は true でした)。オーバーライドした speak() が親より優先されるのも、Dog.prototype で先に見つかるからです。class は、このプロトタイプの仕組みを読みやすく書くための書き方だと考えると、次の this の落とし穴も理解しやすくなります。

落とし穴:メソッドを渡すと this が外れる

JavaScript の this は、メソッドを書いた場所ではなく、呼び出したときの形で決まります。counter.increment() と「インスタンス.メソッド()」の形で呼べば this は counter ですが、メソッドだけを取り出して呼ぶと、this はインスタンスを指さなくなります。

class Counter {
  constructor(label) {
    this.label = label;
    this.count = 0;
  }

  increment() {
    this.count += 1;
    console.log(this.label, this.count);
  }
}

const counter = new Counter("保存ボタン");
counter.increment();
const f = counter.increment;
f();
保存ボタン 1
Uncaught TypeError: Cannot read properties of undefined (reading 'count')

f() は何にも付いていない呼び方なので、this は undefined になり、undefined.count を読もうとしてエラーになりました。クラスの中は、何も書かなくても自動で strict mode(厳格モード)になるため、this が undefined になります(MDN の説明どおりです)。

ボタンのクリックや setTimeout に渡したとき

実際によく出会うのは、addEventListener や setTimeout に counter.increment を渡す場面です。上のコードに続けて(再読み込みせずに)貼り付けます。

const button = document.createElement("button");
button.addEventListener("click", counter.increment);
button.click();
setTimeout(counter.increment, 0);
setTimeout(() => console.log(button.count, window.count, counter.count), 10);
undefined NaN
undefined NaN
NaN NaN 1

今度はエラーにならず、おかしな値のまま動きます。button.click() はクリックと同じイベントを起こし、addEventListener に渡した関数の this はボタンの要素になります。setTimeout に渡した普通の関数の this は、MDN によると globalThis(ブラウザでは window)です。どちらも label を持たないので undefined、this.count += 1 は「undefined に 1 を足す」ので NaN(数ではない値)になり、ボタンと window に count が勝手に作られました。肝心の counter.count は 1 のままです。

直し方 1:アロー関数で包む・bind で固定する

const button2 = document.createElement("button");
button2.addEventListener("click", () => counter.increment());
button2.addEventListener("click", counter.increment.bind(counter));
button2.click();
setTimeout(() => counter.increment(), 0);
保存ボタン 2
保存ボタン 3
保存ボタン 4
  • () => counter.increment():アロー関数(=> で書く短い関数)で包み、中で「インスタンス.メソッド()」の形で呼びます。いちばん分かりやすい直し方です。
  • counter.increment.bind(counter):bind は「this を counter に固定した新しい関数」を作ります。

直し方 2:クラスフィールドにアロー関数を書く

アロー関数は自分の this を持たず、書いた場所の this をそのまま使います。クラスフィールドに書くと、その this は作られたインスタンスになるので、そのまま渡しても外れません。

class Counter {
  count = 0;

  constructor(label) {
    this.label = label;
  }

  increment = () => {
    this.count += 1;
    console.log(this.label, this.count);
  };
}

const counter = new Counter("保存ボタン");
const button = document.createElement("button");
button.addEventListener("click", counter.increment);
button.click();
setTimeout(counter.increment, 0);
setTimeout(() => {
  console.log(Object.keys(counter));
  console.log(counter.increment === new Counter("別").increment);
}, 10);
保存ボタン 1
保存ボタン 2
["count", "increment", "label"]
false

ボタンからも setTimeout からも正しく数えられました。ただし最後の 2 行のとおり、この書き方の increment は prototype ではなくインスタンスごとに別々の関数として作られます。メモリーが増えるので、MDN も必要なところだけで使うよう勧めています。イベントの仕組みは「JavaScriptのイベントの伝わり方|バブリングとイベント委譲を実演」で説明しています。

クラスの宣言は巻き上げられない(TDZ)

function で書いた関数は、ファイルの下のほうで宣言しても上から呼べます(巻き上げ)。クラスはそうはいかず、宣言より前で使うとエラーになります。

const member = new Member("田中");
class Member {
  constructor(name) {
    this.name = name;
  }
}
Uncaught ReferenceError: Cannot access 'Member' before initialization

HTML ファイルの script での結果で、「初期化される前の Member にはアクセスできません」という意味です(コンソールでは Member is not defined と出ました)。let や const と同じ動きです。宣言より前の、使えない区間を TDZ(Temporal Dead Zone、一時的なデッドゾーン)と呼びます。function で書いた OldUser なら宣言より前でも動きました。クラスは使う場所より上で宣言すると覚えておきましょう。ファイルの分け方は「JavaScriptのimportとexport入門|モジュールの使い方とよくあるエラー」で説明しています。

よくある間違いとエラーの早見表

Edge 156 で実際に出たメッセージです(文言はブラウザによって違います)。

やったことEdge 156 のメッセージ直し方
new を付けずに User("田中")TypeError: Class constructor User cannot be invoked without ‘new’new User("田中") にする
メソッドの中で this. を付けずに age + 1ReferenceError: age is not definedthis.age + 1 にする
メソッドの間に , を書いた(オブジェクトの書き方と混同)SyntaxError: Unexpected token ‘,’カンマを消す
constructor を 2 つ書いたSyntaxError: A class may only have one constructor1 つにまとめ、引数の有無で分ける
メソッド内で宣言していない変数に代入(nmae = value;)ReferenceError: nmae is not definedつづりを直す。クラスの中は strict mode なので、うっかりグローバル変数が作られずエラーで止まる

よくある質問

bind した関数を removeEventListener で外せません

bind は呼ぶたびに新しい関数を作るので、addEventListener("click", counter.increment.bind(counter)) のあとに同じ式で removeEventListener しても、別の関数とみなされて外れません。試すと、remove のあとのクリックでもメソッドが呼ばれました。外す予定があるときは、const handler = counter.increment.bind(counter); のように変数に入れて、add と remove の両方に同じ handler を渡します。クラスフィールドのアロー関数なら counter.increment がいつも同じ関数なので、そのまま外せます。

まとめ

クラスは new で使い、子の constructor では最初に super() を呼びます。隠したい値は # で本当に隠せます。メソッドは prototype にあり、呼び方で this が決まるので、イベントや setTimeout に渡すときはアロー関数・bind・クラスフィールドのアロー関数で this を固定しましょう。

関連する記事・ツール

ABOUT ME
hr
hr
エンジニアとして働いている hr です。仕事や資格勉強で「こんなツールがあれば」と感じたものを、無料Webツールと解説記事にして発信しています。
記事URLをコピーしました