JavaScriptの基礎 - 継承とプロトタイプ - 版の履歴

Wiki: /* classとプロトタイプの関係 */

2026-02-19T19:44:53Z

classとプロトタイプの関係

← 古い版		2026年2月20日 (金) 04:44時点における版
251行目:		251行目:
	! class構文 !! プロトタイプベースの等価コード !! 説明		! class構文 !! プロトタイプベースの等価コード !! 説明
	\|-		\|-
	\| ~~<u>~~class Animal {}~~</u>~~ \|\| ~~<u>~~function Animal() {}~~</u>~~ \|\| ~~クラス宣言はコンストラクタ関数に対応する~~		\| class Animal {} \|\| function Animal() {} \|\| クラス宣言はコンストラクタ関数に対応する。
	\|-		\|-
	\| ~~<u>~~constructor(name) { this.name = name; }~~</u>~~ \|\| ~~<u>~~function Animal(name) { this.name = name; }~~</u>~~ \|\| ~~コンストラクタ本体はそのまま関数本体になる~~		\| constructor(name) { this.name = name; } \|\| function Animal(name) { this.name = name; } \|\| コンストラクタ本体はそのまま関数本体になる。
	\|-		\|-
	\| ~~<u>~~speak() { ... }~~</u>~~ \|\| ~~<u>~~Animal.prototype.speak = function() { ... };</u> ~~\|\| インスタンスメソッドはprototypeに追加される~~		\| speak() { ... } \|\| Animal.prototype.speak = function() { ... }; \|\| インスタンスメソッドは <u>prototype</u> に追加される。
	\|-		\|-
	\| ~~<u>~~static create() { ... }~~</u>~~ \|\| ~~<u>~~Animal.create = function() { ... };~~</u>~~ \|\| ~~静的メソッドはコンストラクタ関数自体のプロパティになる~~		\| static create() { ... } \|\| Animal.create = function() { ... }; \|\| 静的メソッドはコンストラクタ関数自体のプロパティになる。
	\|-		\|-
	\| ~~<u>~~class Dog extends Animal~~</u>~~ \|\| ~~<u>~~Object.setPrototypeOf(Dog.prototype, Animal.prototype);</u> ~~\|\| extendsはプロトタイプチェーンを設定する~~		\| class Dog extends Animal \|\| Object.setPrototypeOf(Dog.prototype, Animal.prototype); \|\| <u>extends</u> はプロトタイプチェーンを設定する。
	\|-		\|-
	\| ~~<u>~~super(name)~~</u>~~ \|\| ~~<u>~~Animal.call(this, name);</u> \|\| super()~~は親コンストラクタをthisに対して呼び出す~~		\| super(name) \|\| Animal.call(this, name); \|\| <u>super()</u> は親コンストラクタを <u>this</u> に対して呼び出す。
	\|-		\|-
	\| ~~<u>~~super.speak()~~</u>~~ \|\| ~~<u>~~Animal.prototype.speak.call(this);</u> \|\| super.method()~~は親のprototypeのメソッドを呼び出す~~		\| super.speak() \|\| Animal.prototype.speak.call(this); \|\| <u>super.method()</u> は親の <u>prototype</u> のメソッドを呼び出す。
	\|}		\|}
	</center>		</center>

Wiki: /* プロトタイプチェーンの仕組み */

2026-02-19T19:42:50Z

プロトタイプチェーンの仕組み

← 古い版		2026年2月20日 (金) 04:42時点における版
169行目:		169行目:
	<br>		<br>
	# オブジェクト自身のプロパティを探索する。		# オブジェクト自身のプロパティを探索する。
	# 見つからない場合、<code>[[Prototype]]</code> (プロトタイプ) のプロパティを探索する。		# 見つからない場合、<code><nowiki>[[Prototype]]</nowiki></code> (プロトタイプ) のプロパティを探索する。
	# 見つからない場合、プロトタイプのプロトタイプを探索する。		# 見つからない場合、プロトタイプのプロトタイプを探索する。
	# <code>null</code> に到達しても見つからない場合、<u>undefined</u> を返す。		# <code>null</code> に到達しても見つからない場合、<u>undefined</u> を返す。
203行目:		203行目:
	</syntaxhighlight>		</syntaxhighlight>
	<br>		<br>

	==== classとプロトタイプの関係 ====		==== classとプロトタイプの関係 ====
	<code>class</code> 構文はシンタックスシュガーであり、内部的にはプロトタイプベースの継承を使用している。<br>		<code>class</code> 構文はシンタックスシュガーであり、内部的にはプロトタイプベースの継承を使用している。<br>

Wiki: /* プロトタイプの基本概念 */

2026-02-19T19:42:37Z

プロトタイプの基本概念

← 古い版		2026年2月20日 (金) 04:42時点における版
137行目:		137行目:
	<br>		<br>
	==== プロトタイプの基本概念 ====		==== プロトタイプの基本概念 ====
	全てのJavaScriptオブジェクトは、内部プロパティ <code>[[Prototype]]</code> を持つ。<br>		全てのJavaScriptオブジェクトは、内部プロパティ <code><nowiki>[[Prototype]]</nowiki></code> を持つ。<br>
	この内部プロパティは、<code>Object.getPrototypeOf()</code> を使用して取得できる。<br>		この内部プロパティは、<code>Object.getPrototypeOf()</code> を使用して取得できる。<br>
	<br>		<br>
164行目:		164行目:
	</syntaxhighlight>		</syntaxhighlight>
	<br>		<br>

	==== プロトタイプチェーンの仕組み ====		==== プロトタイプチェーンの仕組み ====
	オブジェクトのプロパティやメソッドにアクセスすると、JavaScriptエンジンは以下の順序で探索を行う。<br>		オブジェクトのプロパティやメソッドにアクセスすると、JavaScriptエンジンは以下の順序で探索を行う。<br>

Wiki: /* 概要 */

2026-02-19T19:42:23Z

概要

← 古い版		2026年2月20日 (金) 04:42時点における版
4行目:		4行目:
	これはシンタックスシュガーである。(内部では依然としてプロトタイプベースの機構が動作している)<br>		これはシンタックスシュガーである。(内部では依然としてプロトタイプベースの機構が動作している)<br>
	<br>		<br>
	プロトタイプチェーンとは、オブジェクトが持つ内部プロパティ <code>[[Prototype]]</code> を辿ることで、プロパティやメソッドを継承元から順に探索する仕組みである。<br>		プロトタイプチェーンとは、オブジェクトが持つ内部プロパティ <code><nowiki>[[Prototype]]</nowiki></code> を辿ることで、プロパティやメソッドを継承元から順に探索する仕組みである。<br>
	プロパティは、<u>自身のオブジェクト -> プロトタイプ -> プロトタイプのプロトタイプ -> ... -> null</u> の順に探索され、見つからない場合は <u>undefined</u> を返す。<br>		プロパティは、<u>自身のオブジェクト -> プロトタイプ -> プロトタイプのプロトタイプ -> ... -> null</u> の順に探索され、見つからない場合は <u>undefined</u> を返す。<br>
	<br>		<br>

Wiki: ページの作成:「== 概要 == JavaScriptはプロトタイプベースのオブジェクト指向言語であり、全ての継承はプロトタイプチェーンという仕組みによって実現されている。
ES2015で導入された `class` 構文の `extends` と `super` により、他の言語に近い直感的なクラス継承を記述できるが、
これはシンタックスシュガーである。(内部では依然とし…」

2026-02-19T19:42:05Z

ページの作成:「== 概要 == JavaScriptはプロトタイプベースのオブジェクト指向言語であり、全ての継承はプロトタイプチェーンという仕組みによって実現されている。 ES2015で導入された <code>class</code> 構文の <code>extends</code> と <code>super</code> により、他の言語に近い直感的なクラス継承を記述できるが、 これはシンタックスシュガーである。(内部では依然とし…」

新規ページ

== 概要 ==
JavaScriptはプロトタイプベースのオブジェクト指向言語であり、全ての継承はプロトタイプチェーンという仕組みによって実現されている。 
ES2015で導入された <code>class</code> 構文の <code>extends</code> と <code>super</code> により、他の言語に近い直感的なクラス継承を記述できるが、 
これはシンタックスシュガーである。(内部では依然としてプロトタイプベースの機構が動作している) 
 
プロトタイプチェーンとは、オブジェクトが持つ内部プロパティ <code>[[Prototype]]</code> を辿ることで、プロパティやメソッドを継承元から順に探索する仕組みである。 
プロパティは、自身のオブジェクト -> プロトタイプ -> プロトタイプのプロトタイプ -> ... -> null の順に探索され、見つからない場合は undefined を返す。 
 
型チェックには <code>instanceof</code> と <code>typeof</code> の2つの演算子を使い分ける。 
<code>typeof</code> はプリミティブ型の判定に用い、<code>instanceof</code> はプロトタイプチェーンを辿ってオブジェクトの型 (コンストラクタ) を検査する。 
 
なお、<code>typeof null === "object"</code> となる点は言語仕様上の既知の問題であり、注意が必要である。 
 
ReactのErrorBoundaryは、クラス継承が今なお必須とされる代表的な実用例である。 
<code>getDerivedStateFromError</code> と <code>componentDidCatch</code> はクラスコンポーネント専用のライフサイクルメソッドであり、現時点ではHooksに相当する代替手段が存在しない。 
 
クラスの宣言、コンストラクタ、メソッド、フィールド、静的メンバーについては、[[JavaScriptの基礎 - クラス]]のページを参照すること。 
 

== クラスの継承 ==
<code>extends</code> キーワードを使用することにより、既存のクラスを継承した新しいクラスを定義できる。 
子クラスは親クラスのプロパティとメソッドを全て引き継ぎ、独自のメンバーを追加または上書きすることができる。 
 
==== extendsキーワード ====
class Child extends Parent {} と記述することにより、Child は Parent を継承する。 
 
子クラスのインスタンスは、親クラスで定義された全てのプロパティとメソッドを利用できる。 
 
<code>extends</code> を使用した継承の基本例を以下に示す。 
 
<syntaxhighlight lang="javascript">
class Animal {
constructor(name) {
this.name = name;
}

speak() {
console.log(this.name + " が鳴いた");
}
}

// DogはAnimalを継承する
class Dog extends Animal {
constructor(name, breed) {
super(name); // 親クラスのコンストラクタを呼び出す
this.breed = breed; // Dog固有のプロパティを追加する
}

// Dog 固有のメソッドを追加する
fetch() {
console.log(this.name + " がボールを取ってきた");
}
}

const dog = new Dog("ポチ", "柴犬");
dog.speak(); // "ポチが鳴いた" (親クラスのメソッドを使用できる)
dog.fetch(); // "ポチがボールを取ってきた"
console.log(dog.name); // "ポチ"
console.log(dog.breed); // "柴犬"
</syntaxhighlight>
 
==== superキーワード ====
<code>super</code> キーワードには、コンストラクタ内とメソッド内の2つの用途がある。 
 
* コンストラクタ内の <code>super()</code>
*: 親クラスのコンストラクタを呼び出す。
*: <code>this</code> にアクセスするより前に呼び出す必要があり、省略すると ReferenceError が発生する。
*: 
* メソッド内の <code>super.method()</code>
*: 親クラスのメソッドを呼び出す。
*: 子クラスのメソッド内で親の処理を実行してから拡張する場合に使用する。
 
<code>super()</code> と <code>super.method()</code> の両方を示す例を以下に示す。 
 
<syntaxhighlight lang="javascript">
class Vehicle {
constructor(make, speed) {
this.make = make;
this.speed = speed;
}

describe() {
return this.make + " (最高速度: " + this.speed + " km/h)";
}
}

class ElectricCar extends Vehicle {
constructor(make, speed, range) {
super(make, speed); // 親コンストラクタを呼び出してから this にアクセスする
this.range = range; // ElectricCar 固有のプロパティ
}

describe() {
// super.describe() で親のメソッドを呼び出してから拡張する
return super.describe() + " / 航続距離: " + this.range + " km";
}
}

const ev = new ElectricCar("BEV", 200, 500);
console.log(ev.describe());
// "BEV (最高速度: 200 km/h) / 航続距離: 500 km"
</syntaxhighlight>
 
==== メソッドのオーバーライド ====
子クラスで親クラスと同名のメソッドを定義すると、親のメソッドがオーバーライド (上書き) される。 
<code>super.method()</code> を呼び出してから処理を追加することにより、親の実装を再利用しつつ拡張することができる。 
 
オーバーライドの例を以下に示す。 
 
<syntaxhighlight lang="javascript">
class Logger {
log(message) {
console.log(message);
}
}

// Loggerを継承してタイムスタンプ付きのログに拡張する
class TimestampedLogger extends Logger {
log(message) {
// 親のlogを呼び出してから拡張する
const timestamp = new Date().toISOString();
super.log("[" + timestamp + "] " + message);
}
}

const logger = new TimestampedLogger();
logger.log("アプリケーションが起動しました");
// "[2026-02-19T00:00:00.000Z] アプリケーションが起動しました"
</syntaxhighlight>
 

== プロトタイプチェーン ==
プロトタイプチェーンは、JavaScriptのプロトタイプベースの継承の核心となる仕組みである。 
<code>class</code> 構文が導入された後も、継承の内部メカニズムはプロトタイプチェーンによって実現されている。 
 
この仕組みを理解することで、JavaScriptのオブジェクトモデルをより深く把握できる。 
 
==== プロトタイプの基本概念 ====
全てのJavaScriptオブジェクトは、内部プロパティ <code>[[Prototype]]</code> を持つ。 
この内部プロパティは、<code>Object.getPrototypeOf()</code> を使用して取得できる。 
 
非推奨の <code>__proto__</code> プロパティも同様の機能を持つが、コードでは <code>Object.getPrototypeOf()</code> の使用を推奨する。 
 
プロトタイプチェーンの終端は null であり、<code>Object.prototype</code> のプロトタイプが null となる。 
 
<code>Object.getPrototypeOf()</code> でチェーンを辿る例を以下に示す。 
 
<syntaxhighlight lang="javascript">
class Animal {
speak() {
console.log("鳴く");
}
}

class Dog extends Animal {}

const dog = new Dog();

// プロトタイプチェーンを確認する
console.log(Object.getPrototypeOf(dog) === Dog.prototype); // true
console.log(Object.getPrototypeOf(Dog.prototype) === Animal.prototype); // true
console.log(Object.getPrototypeOf(Animal.prototype) === Object.prototype); // true
console.log(Object.getPrototypeOf(Object.prototype)); // null (チェーンの終端)
</syntaxhighlight>
 
==== プロトタイプチェーンの仕組み ====
オブジェクトのプロパティやメソッドにアクセスすると、JavaScriptエンジンは以下の順序で探索を行う。 
 
# オブジェクト自身のプロパティを探索する。
# 見つからない場合、<code>[[Prototype]]</code> (プロトタイプ) のプロパティを探索する。
# 見つからない場合、プロトタイプのプロトタイプを探索する。
# <code>null</code> に到達しても見つからない場合、undefined を返す。
 
子のプロパティが親の同名プロパティを隠す現象をプロパティのシャドウイングと呼ぶ。 
 
多段継承でのプロパティ探索の実演を以下に示す。 
 
<syntaxhighlight lang="javascript">
class A {
hello() { return "Aのhello"; }
common() { return "Aのcommon"; }
}

class B extends A {
hello() { return "Bのhello"; } // Aのhelloをシャドウイングする
}

class C extends B {
// helloもcommonも定義しない
}

const c = new C();

// helloはCにない → Bにある → Bのhelloを使用する
console.log(c.hello()); // "Bのhello"

// commonはCにない → Bにない → Aにある → Aのcommonを使用する
console.log(c.common()); // "Aのcommon"

// unknownは、CにもBにもAにもObject.prototypeにもない
console.log(c.unknown); // undefined
</syntaxhighlight>
 
==== classとプロトタイプの関係 ====
<code>class</code> 構文はシンタックスシュガーであり、内部的にはプロトタイプベースの継承を使用している。 
 
<code>class</code> 構文とプロトタイプベースの等価なコードを以下に示す。 
 
<syntaxhighlight lang="javascript">
// class 構文
class Animal {
constructor(name) {
this.name = name;
}

speak() {
console.log(this.name + " が鳴く");
}
}

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

// 上記と等価なプロトタイプベースのコード
function AnimalFn(name) {
this.name = name;
}
AnimalFn.prototype.speak = function() {
console.log(this.name + " が鳴く");
};

function DogFn(name, breed) {
AnimalFn.call(this, name); // super(name) に相当する
this.breed = breed;
}
// プロトタイプチェーンを設定する (extendsに相当する)
Object.setPrototypeOf(DogFn.prototype, AnimalFn.prototype);
</syntaxhighlight>
 
下表に、<code>class</code> 構文とプロトタイプベースの対応関係を示す。 
 
<center>
{| class="wikitable"
|+ class構文とプロトタイプの対応表
! class構文 !! プロトタイプベースの等価コード !! 説明
|-
| class Animal {} || function Animal() {} || クラス宣言はコンストラクタ関数に対応する
|-
| constructor(name) { this.name = name; } || function Animal(name) { this.name = name; } || コンストラクタ本体はそのまま関数本体になる
|-
| speak() { ... } || Animal.prototype.speak = function() { ... }; || インスタンスメソッドはprototypeに追加される
|-
| static create() { ... } || Animal.create = function() { ... }; || 静的メソッドはコンストラクタ関数自体のプロパティになる
|-
| class Dog extends Animal || Object.setPrototypeOf(Dog.prototype, Animal.prototype); || extendsはプロトタイプチェーンを設定する
|-
| super(name) || Animal.call(this, name); || super()は親コンストラクタをthisに対して呼び出す
|-
| super.speak() || Animal.prototype.speak.call(this); || super.method()は親のprototypeのメソッドを呼び出す
|}
</center>
 

== 型チェック ==
JavaScriptでオブジェクトの型を検査するには、<code>instanceof</code> と <code>typeof</code> の2つの演算子を使い分ける。 
それぞれ用途が異なるため、適切に選択することが重要である。 
 
==== instanceof 演算子 ====
<code>instanceof</code> 演算子は、オブジェクトがあるコンストラクタ (クラス) のインスタンスであるかどうかを、プロトタイプチェーンを辿って検査する。 
子クラスのインスタンスは親クラスの <code>instanceof</code> でも <code>true</code> を返すため、継承チェーン全体を検査できる。 
 
<code>instanceof</code> の挙動を示す例を以下に示す。 
 
<syntaxhighlight lang="javascript">
class Animal {}
class Dog extends Animal {}
class Cat extends Animal {}

const dog = new Dog();

console.log(dog instanceof Dog); // true (Dogのインスタンスである)
console.log(dog instanceof Animal); // true (プロトタイプチェーンを辿ってAnimalも見つかる)
console.log(dog instanceof Cat); // false (Catのインスタンスではない)
console.log(dog instanceof Object); // true (全てのオブジェクトはObjectのインスタンスである)
</syntaxhighlight>
 
==== typeof との違い ====
<code>typeof</code> はプリミティブ型の判定に使用し、<code>instanceof</code> はオブジェクトの型 (コンストラクタ) の判定に使用する。 
typeof null === "object" となる点は言語仕様上の既知の問題 (バグ) であり、nullチェックには <code>=== null</code> を使用する必要がある。 
 
下表に、代表的な値に対する <code>typeof</code> と <code>instanceof Object</code> の結果を示す。 
 
<center>
{| class="wikitable"
|+ typeof vs instanceof 比較表
! 値 !! typeof の結果 !! instanceof Object
|-
| <code>null</code> || <code>"object"</code> (既知の問題) || false
|-
| <code>undefined</code> || <code>"undefined"</code> || false
|-
| <code>"文字列"</code> || <code>"string"</code> || false
|-
| <code>42</code> || <code>"number"</code> || false
|-
| <code>true</code> || <code>"boolean"</code> || false
|-
| <code>{}</code> || <code>"object"</code> || true
|-
| <code>[]</code> || <code>"object"</code> || true
|-
| <code>function() {}</code> || <code>"function"</code> || true
|-
| <code>new Date()</code> || <code>"object"</code> || true
|-
| <code>new Dog()</code> || <code>"object"</code> || true
|}
</center>
 
型チェックの使い分けの例を以下に示す。 
 
<syntaxhighlight lang="javascript">
function processValue(value) {
// null チェック: typeof では "object" になるため === null を使用する
if (value === null) {
console.log("null です");
return;
}

// プリミティブ型の判定には typeof を使用する
if (typeof value === "string") {
console.log("文字列: " + value.toUpperCase());
return;
}

if (typeof value === "number") {
console.log("数値: " + value.toFixed(2));
return;
}

// オブジェクトの型の判定には instanceof を使用する
if (value instanceof Date) {
console.log("日付: " + value.toISOString());
return;
}

if (Array.isArray(value)) {
// 配列チェックには Array.isArray() が確実である
console.log("配列 (要素数: " + value.length + ")");
return;
}

console.log("オブジェクト");
}

processValue(null); // "null です"
processValue("hello"); // "文字列: HELLO"
processValue(3.14159); // "数値: 3.14"
processValue(new Date()); // "日付: 2026-02-19T..."
processValue([1, 2, 3]); // "配列 (要素数: 3)"
processValue({ x: 1 }); // "オブジェクト"
</syntaxhighlight>
 

== ReactのErrorBoundaryとクラス継承 ==
Reactでは関数コンポーネントとHooksが主流となっているが、ErrorBoundaryは現在もクラスコンポーネントで実装しなければならない機能の代表例である。 
 
これは、エラーキャッチに必要なライフサイクルメソッドがHooksで代替できないためであり、クラス継承が実際の開発において今なお不可欠であることを示している。 
 
==== ErrorBoundaryとは ====
ErrorBoundaryは、子コンポーネントツリーのレンダリングエラーをキャッチしてアプリケーション全体のクラッシュを防ぎ、フォールバックUIを表示するコンポーネントである。 
 
* キャッチできるエラー
*: レンダリング中に発生したエラー
*: ライフサイクルメソッド内で発生したエラー
*: コンストラクタ内で発生したエラー
*: 
* キャッチできないエラー
*: イベントハンドラ内で発生したエラー (try / catchで対処する)
*: 非同期コード内で発生したエラー (Promiseのrejection等)
 
==== クラス継承が必要な理由 ====
ErrorBoundaryには以下の2つのライフサイクルメソッドが必要であり、いずれもクラスコンポーネント専用である。 
 
<center>
{| class="wikitable"
|+ 各メソッドの動作
! メソッド !! 動作
|-
| <code>static getDerivedStateFromError(error)</code> || エラー発生時に状態を更新してフォールバックUIをレンダリングするために使用する。 静的メソッドであり、<code>static</code> キーワードを付けて定義する。
|-
| <code>componentDidCatch(error, errorInfo)</code> || エラーの詳細情報をログに記録するために使用する。 エラーのスタックトレース等の情報 (<code>errorInfo.componentStack</code>) を参照できる。
|}
</center>
 
React Hooksには、<code>getDerivedStateFromError</code> と <code>componentDidCatch</code> に相当する機能が存在しない。 
そのため、ErrorBoundaryは現在もクラスコンポーネントで実装する必要がある。 
 
==== ErrorBoundaryの実装例 ====
* ErrorBoundaryの実装例
*: <syntaxhighlight lang="javascript">
import React from "react";

class ErrorBoundary extends React.Component {
constructor(props) {
super(props);
this.state = {
hasError : false,
error : null,
};
}

// エラー発生時にstateを更新してフォールバックUIをレンダリングする
static getDerivedStateFromError(error) {
return {
hasError : true,
error : error,
};
}

// エラーの詳細情報をログに記録する
componentDidCatch(error, errorInfo) {
console.error("ErrorBoundary がエラーをキャッチしました:", error);
console.error("コンポーネントスタック:", errorInfo.componentStack);

// 外部エラートラッキングサービスへの送信例
// reportError(error, errorInfo);
}

// エラー状態をリセットしてコンテンツを再表示する
handleReset = () => {
this.setState({ hasError: false, error: null });
};

render() {
if (this.state.hasError) {
return (
<div>
<h2>予期しないエラーが発生しました</h2>
{this.state.error?.message}
<button onClick={this.handleReset}>再試行</button>
</div>
);
}

// エラーがない場合は子コンポーネントをそのまま表示する
return this.props.children;
}
}

export default ErrorBoundary;
</syntaxhighlight>
*: 
* ErrorBoundaryの使用例
*: <syntaxhighlight lang="javascript">
import React from "react";
import ErrorBoundary from "./ErrorBoundary";
import UserProfile from "./UserProfile";
import DataTable from "./DataTable";

function App() {
return (
<div>
{/* アプリケーション全体をラップする */}
<ErrorBoundary>
<UserProfile userId={1} />
</ErrorBoundary>

{/* 特定のセクションだけをラップすることもできる */}
<ErrorBoundary>
<DataTable dataSource="api/records" />
</ErrorBoundary>
</div>
);
}

export default App;
</syntaxhighlight>
 

== 関連情報 ==
* [[JavaScriptの基礎 - クラス]]
*: クラスの宣言、コンストラクタ、メソッド、フィールド、静的メンバー
* [[JavaScriptの基礎 - thisキーワード]]
*: thisの動作、bind / call / apply、クラスにおけるthis
* [[JavaScriptの基礎 - オブジェクトリテラル]]
*: オブジェクトの作成と操作、プロパティアクセス、メソッド
* [[JavaScriptの基礎 - アロー関数]]
*: アロー関数の構文、レキシカルthis
 

{{#seo:
|title={{PAGENAME}} : Exploring Electronics and SUSE Linux | MochiuWiki
|keywords=MochiuWiki,Mochiu,Wiki,Mochiu Wiki,Electric Circuit,Electric,pcb,Mathematics,AVR,TI,STMicro,AVR,ATmega,MSP430,STM,Arduino,Xilinx,FPGA,Verilog,HDL,PinePhone,Pine Phone,Raspberry,Raspberry Pi,C,C++,C#,Qt,Qml,MFC,Shell,Bash,Zsh,Fish,SUSE,SLE,Suse Enterprise,Suse Linux,openSUSE,open SUSE,Leap,Linux,uCLnux,電気回路,電子回路,基板,プリント基板
|description={{PAGENAME}} - 電子回路とSUSE Linuxに関する情報 | This page is {{PAGENAME}} in our wiki about electronic circuits and SUSE Linux
|image=/resources/assets/MochiuLogo_Single_Blue.png
}}

__FORCETOC__
[[カテゴリ:Web]]