KnowHub

オブジェクト拡張子

オブジェクトは JavaScript で最も重要なデータ構造です。 ES6 では大幅なアップグレードが行われ、この章ではデータ構造自体の変更が紹介され、次の章では Object オブジェクトの新しいメソッドが紹介されます。

属性の簡潔な表現

ES6 では、変数や関数をオブジェクトのプロパティやメソッドとして中括弧内に直接記述することができます。この種の書き方はより簡潔です。

const foo = 'バー';
const baz = {foo};
baz // {foo: "バー"}

// と同等
const baz = {foo: foo};

上記のコードでは、変数 foo が中括弧内に直接書き込まれています。このとき、属性名が変数名、属性値が変数の値となります。別の例を示します。

関数 f(x, y) {
  {x, y} を返します。
}

// と同等

関数 f(x, y) {
  {x: x, y: y} を返します。
}

f(1, 2) // オブジェクト {x: 1, y: 2}

属性の省略形に加えて、メソッドも省略形にすることができます。

定数 = {
  方法（） {
    「こんにちは！」を返します。
  }
};

// と同等

定数 = {
  メソッド: function() {
    「こんにちは！」を返します。
  }
};

ここでは実際的な例を示します。

誕生 = '2000/01/01';

const 人 = {

  名前：「チャン・サン」、

  //誕生に相当: 誕生
  誕生、

  // hello: function ()... と同等
  hello() { console.log('私の名前は', this.name) }

};

この書き方は関数の戻り値に非常に便利です。

関数 getPoint() {
  定数 x = 1;
  定数y = 10;
  {x, y} を返します。
}

getPoint()
// {x:1, y:10}

CommonJS モジュールは一連の変数を出力します。これは簡潔な記述に非常に適しています。

ms = {}; とします。

関数 getItem (キー) {
  ms でキーを返しますか? : null;
}

関数 setItem (キー、値) {
  ms[キー] = 値;
}

関数クリア() {
  ミリ秒 = {};
}

module.exports = { getItem、setItem、clear };
// と同等
module.exports = {
  getItem: getItem、
  setItem: setItem、
  クリア：クリア
};

属性設定器(setter)と値取得器(getter)は実際にはこのように書きます。

const カート = {
  _車輪: 4、

  車輪を取得 () {
    これを返します。_wheels;
  }、

  ホイールのセット (値) {
    if (値 < this._wheels) {
      throw new Error('値が小さすぎます!');
    }
    this._wheels = 値;
  }
}

簡潔な表記は、オブジェクトを印刷するときにも役立ちます。

ユーザー = { にします
  名前：「テスト」
};

let foo = {
  バー：「バズ」
};

console.log(ユーザー、foo)
// {名前: "テスト"} {バー: "バズ"}
console.log({user, foo})
// {ユーザー: {名前: "テスト"}、foo: {バー: "バズ"}}

上記のコードで、「console.log」が 2 つのオブジェクト「user」と「foo」を直接出力すると、これらは 2 セットのキーと値のペアになるため、混乱する可能性があります。これらを中括弧で囲んで出力すると、オブジェクトの簡潔な表現となり、キーと値のペアの各セットの前にオブジェクト名が出力され、わかりやすくなります。

短縮されたオブジェクト メソッドはコンストラクターとして使用できず、エラーが報告されることに注意してください。

const obj = {
  f() {
    this.foo = 'バー';
  }
};

new obj.f() // エラーを報告する

上記のコードでは、f は省略表現のオブジェクト メソッドであるため、obj.f をコンストラクターとして使用することはできません。

属性名の式

JavaScript でオブジェクトのプロパティを定義するには 2 つの方法があります。

//方法1
obj.foo = true;

//方法2
obj['a' + 'bc'] = 123;

上記のコードの 1 つ目の方法は、識別子を属性名として直接使用する方法であり、2 つ目の方法は、式を属性名として使用することです。この場合、式は角かっこで囲む必要があります。

ただし、リテラル (中括弧を使用) を使用してオブジェクトを定義する場合、ES5 ではメソッド 1 (識別子) のみを使用してプロパティを定義できます。

var obj = {
  ふー：本当、
  ABC: 123
};

ES6 では、リテラルを使用してオブジェクトを定義するときに、メソッド 2 (式) をオブジェクトのプロパティ名として使用できます。つまり、式を角かっこで囲むことができます。

propKey = 'foo' にします。

obj = { にします
  [propKey]: true、
  ['a' + 'bc']: 123
};

別の例を示します。

lastWord = '最後の単語'; とします。

定数 a = {
  「最初の単語」: 「こんにちは」、
  [最後の単語]: '世界'
};

a['最初の単語'] // 「こんにちは」
a[lastWord] // "世界"
a['最後の言葉'] // "世界"

式を使用してメソッド名を定義することもできます。

obj = { にします
  ['h' + 'ello']() {
    「こんにちは」を返します。
  }
};

obj.hello() // こんにちは

属性名の表現と簡潔な表記は同時に使用できず、エラーが報告されることに注意してください。

// エラーを報告する
const foo = 'バー';
const bar = 'abc';
const baz = { [foo] };

// 正しい
const foo = 'バー';
const baz = { [foo]: 'abc'};

プロパティ名の式がオブジェクトの場合、そのオブジェクトはデフォルトで文字列 [object Object] に自動的に変換されることに注意してください。

const keyA = {a: 1};
const keyB = {b: 2};

const myObject = {
  [キーA]: '値A',
  [キーB]: '値B'
};

myObject // オブジェクト {[object オブジェクト]: "valueB"}

上記のコードでは、[keyA] と [keyB] は両方とも [object Object] を取得するため、[keyB] は [keyA] を上書きし、myObject には 1 つのみが含まれます。 [オブジェクト オブジェクト]`プロパティ。

メソッドの name 属性

関数の name 属性は関数名を返します。オブジェクト メソッドも関数であるため、「name」属性も持ちます。

const 人 = {
  SayName() {
 console.log('こんにちは!');
  }、
};

person.sayName.name // "言う名前"

上記のコードでは、メソッドの name 属性は関数名 (つまり、メソッド名) を返します。

オブジェクトのメソッドが値関数 (getter) と値関数 (setter) を使用する場合、name 属性はメソッドにはなく、オブジェクトを記述する属性の get と にあります。 set 属性の上では、戻り値はメソッド名の前に get と set が付いています。

const obj = {
  foo() {} を取得し、
  set foo(x) {}
};

obj.foo.name
// TypeError: 未定義のプロパティ 'name' を読み取れません

const 記述子 = Object.getOwnPropertyDescriptor(obj, 'foo');

descriptor.get.name // "foo を取得"
descriptor.set.name // "set foo"

2 つの特殊なケースがあります。bind メソッドによって作成された関数の場合、name 属性は bound と元の関数の名前を返します。Function コンストラクターによって作成された関数の場合、name 属性は ` を返します。匿名さん。

(new Function()).name // "匿名"

var doSomething = function() {
  // ...
};
doSomething.bind().name // "バインドされた doSomething"

オブジェクトのメソッドが Symbol 値の場合、「name」属性は Symbol 値の説明を返します。

const key1 = シンボル('説明');
const key2 = シンボル();
obj = { にします
  [key1]() {},
  [キー2]() {},
};
obj[key1].name // "[説明]"
obj[key2].name // ""

上記のコードでは、「key1」に対応する Symbol 値には説明がありますが、「key2」には説明がありません。

プロパティの列挙可能性と走査

列挙可能性

オブジェクトの各プロパティには、プロパティの動作を制御する記述子があります。 Object.getOwnPropertyDescriptor メソッドは、このプロパティの説明オブジェクトを取得できます。

obj = { foo: 123 };
Object.getOwnPropertyDescriptor(obj, 'foo')
// {
// 値: 123,
// 書き込み可能: true,
// 列挙可能: true,
// 設定可能: true
// }

「列挙可能性」と呼ばれる、オブジェクトの enumerable プロパティを記述します。このプロパティが false の場合、一部の操作が現在のプロパティを無視することを意味します。

現在、4 つの操作は、enumerable が false である属性を無視します。

  • for...in ループ: オブジェクト自身および継承された列挙可能なプロパティのみを走査します。
  • Object.keys(): オブジェクト自体の列挙可能なすべてのプロパティのキー名を返します。
  • JSON.stringify(): オブジェクト自体の列挙可能なプロパティのみをシリアル化します。
  • Object.assign(): enumerable が false であるプロパティを無視し、オブジェクト自体の列挙可能なプロパティのみをコピーします。

これら 4 つの操作のうち、最初の 3 つは ES5 で使用でき、最後の操作 Object.assign() は ES6 で新しく追加されました。このうち、「for...in」だけが継承されたプロパティを返します。他の 3 つのメソッドは継承されたプロパティを無視し、オブジェクト自体のプロパティのみを処理します。実際、「列挙可能」の概念を導入する本来の目的は、特定のプロパティが「for...in」操作を回避できるようにすることです。そうしないと、すべての内部プロパティとメソッドが走査されてしまいます。たとえば、オブジェクト プロトタイプの toString メソッドと配列の length プロパティは、for...in によるトラバースを避けるために「列挙可能性」を渡します。

Object.getOwnPropertyDescriptor(Object.prototype, 'toString').enumerable
// 間違い

Object.getOwnPropertyDescriptor([], 'length').enumerable
// 間違い

上記のコードでは、toString および length プロパティの enumerable は両方とも false であるため、for...in はプロトタイプから継承されたこれら 2 つのプロパティをトラバースしません。

さらに、ES6 では、すべてのクラスのプロトタイプ メソッドが列挙不可能であると規定されています。

Object.getOwnPropertyDescriptor(class {foo() {}}.prototype, 'foo').enumerable
// 間違い

一般に、操作に継承されたプロパティを導入すると、問題が複雑になります。ほとんどの場合、オブジェクト自体のプロパティのみが考慮されます。したがって、「for...in」ループは使用せず、代わりに「Object.keys()」を使用してください。

属性の走査

ES6 には、オブジェクトのプロパティを走査するためのメソッドが合計 5 つあります。

(1)...で

for...in は、オブジェクト自身および継承された列挙可能なプロパティ (Symbol プロパティを除く) をループします。

(2)オブジェクト.キー(obj)

Object.keys は、オブジェクト自体 (継承されたプロパティを除く) のすべての列挙可能なプロパティ (Symbol プロパティを除く) のキー名を含む配列を返します。

(3)Object.getOwnPropertyNames(obj)

Object.getOwnPropertyNames は、オブジェクト自体のすべてのプロパティ (シンボル プロパティを除く、列挙不可能なプロパティも含む) のキー名を含む配列を返します。

(4)Object.getOwnPropertySymbols(obj)

Object.getOwnPropertySymbols は、オブジェクト自体のすべての Symbol プロパティのキーを含む配列を返します。

(5)Reflect.ownKeys(obj)

Reflect.ownKeys は、キー名がシンボルか文字列か、また列挙可能かどうかに関係なく、オブジェクト自体のすべてのキー名 (継承されたものを除く) を含む配列を返します。

上記の 5 つのメソッドはオブジェクトのキー名を走査し、すべて属性走査の同じ順序規則に従います。

  • 最初にすべての数値キーを調べ、値の昇順に並べます。
  • 次に、すべての文字列キーを走査し、結合時間を昇順に並べます。
  • 最後に、すべてのシンボル キーをスキャンし、結合時刻の昇順で並べ替えます。
Reflect.ownKeys({ [シンボル()]:0, b:0, 10:0, 2:0, a:0 })
// ['2', '10', 'b', 'a', Symbol()]

上記のコードでは、「Reflect.ownKeys」メソッドはパラメータ オブジェクトのすべてのプロパティを含む配列を返します。この配列の属性の順序は次のとおりです。最初は数値属性 '2' と '10'、次に文字列属性 'b' と 'a'、そして最後に Symbol 属性です。

スーパーキーワード

this キーワードは常に、関数が配置されている現在のオブジェクトを指すことがわかっています。ES6 では、現在のオブジェクトのプロトタイプ オブジェクトを指す別の同様のキーワード super が追加されています。

const プロト = {
  フー：「こんにちは」
};

const obj = {
  foo: '世界',
  探す（） {
    super.foo を返します。
  }
};

Object.setPrototypeOf(obj, proto);
obj.find() // 「こんにちは」

上記のコードでは、オブジェクト obj.find() メソッドで、プロトタイプ オブジェクト proto の foo プロパティが super.foo を通じて参照されています。

super キーワードがプロトタイプ オブジェクトを表す場合、そのオブジェクトのメソッド内でのみ使用できます。他の場所で使用すると、エラーが報告されます。

// エラーを報告する
const obj = {
  foo: super.foo
}

// エラーを報告する
const obj = {
  foo: () => super.foo
}

// エラーを報告する
const obj = {
  foo: 関数 () {
    super.foo を返す
  }
}

JavaScript エンジンの場合、ここでの「super」はオブジェクト メソッドで使用されないため、上記の 3 つの「super」の使用はエラーを報告します。 1 つ目の記述方法は、super を属性内で使用する方法です。2 つ目と 3 つ目の記述方法は、super を関数内で使用し、その後 foo 属性に割り当てる方法です。現在、JavaScript エンジンが定義されているのがオブジェクトのメソッドであることを確認できるのは、オブジェクト メソッドの短縮表現のみです。

JavaScript エンジンの内部では、super.foo は Object.getPrototypeOf(this).foo (プロパティ) または Object.getPrototypeOf(this).foo.call(this) (メソッド) と同等です。

const プロト = {
  ×：「こんにちは」、
  foo() {
    console.log(this.x);
  }、
};

const obj = {
  x: 「世界」、
  foo() {
    super.foo();
  }
}

Object.setPrototypeOf(obj, proto);

obj.foo() // 「世界」

上記のコードでは、super.foo はプロトタイプ オブジェクト proto の foo メソッドを指しますが、バインドされた this は依然として現在のオブジェクト obj であるため、出力は world になります。

オブジェクトスプレッド演算子

「配列の拡張」の章では、拡張演算子 (...) が導入されました。 ES2018 は、この演算子をオブジェクトに 導入 します。

代入の構造化

オブジェクトの分割代入は、オブジェクトから値を取得するために使用されます。これは、ターゲット オブジェクト自体のすべての走査可能 (列挙可能) ですがまだ読み取られていないプロパティを、指定されたオブジェクトに割り当てることと同じです。すべてのキーとその値が新しいオブジェクトにコピーされます。

let { x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 };
× // 1
y // 2
z // { a: 3、b: 4 }

上記のコードでは、変数 z は、分割代入が配置されるオブジェクトです。等号の右側にあるすべての未読のキー (「a」 と 「b」) を取得し、それらをその値とともにコピーします。

分割代入では等号の右側がオブジェクトである必要があるため、等号の右側が「未定義」または「null」の場合はオブジェクトに変換できないためエラーが報告されます。

let { ...z } = null;
let { ...z } = // 実行時エラー;

構造化代入は最後のパラメータである必要があります。それ以外の場合は、エラーが報告されます。

let { ...x, y, z } = someObject; // 構文エラー;
let { x, ...y, ...z } = someObject; // 構文エラー;

上記のコードでは、構造化代入が最後のパラメータではないため、エラーが報告されます。

構造化代入のコピーは浅いコピーであることに注意してください。つまり、キーの値が複合型値 (配列、オブジェクト、関数) の場合、構造化代入は値のコピーではなく、値への参照をコピーします。値。

let obj = { a: { b: 1 } };
let { ...x } = obj;
obj.a.b = 2;
x.a.b // 2

上記のコードでは、「x」は分割代入が配置されているオブジェクトであり、オブジェクト「obj」の「a」属性がコピーされます。 a 属性はオブジェクトを参照します。このオブジェクトの値を変更すると、そのオブジェクトへの構造化代入の参照が影響を受けます。

さらに、スプレッド演算子の分割代入では、プロトタイプ オブジェクトから継承されたプロパティをコピーできません。

o1 = { a: 1 }; とします。
o2 = { b: 2 }; とします。
o2.__proto__ = o1;
{ ...o3 } = o2; とします。
o3 // { b: 2 }
o3.a // 未定義

上記のコードでは、オブジェクト o3 が o2 をコピーしますが、コピーされるのは o2 自体のプロパティだけであり、そのプロトタイプ オブジェクト o1 のプロパティはコピーされません。

別の例を示します。

const o = Object.create({ x: 1, y: 2 });
オンス = 3;

{ x, ...newObj } = o; とします。
let { y, z } = newObj;
× // 1
y // 未定義
z // 3

上記のコードでは、変数 x は単純な構造化代入であるため、オブジェクト o によって継承された属性を読み取ることができます。変数 y と z は展開演算子の構造化代入であり、オブジェクト o は独自の属性を読み取ることができるため、変数 z には正常に値を割り当てることができますが、変数 y は値を取得できません。 ES6 では、変数宣言文で分割代入を使用する場合、展開演算子の後には分割代入式ではなく変数名を続ける必要があると規定しているため、上記のコードでは中間変数 newObj を導入します。エラーが報告されます。

{ x, ...{ y, z } } = o; とします。
// SyntaxError: ... 宣言コンテキストでは識別子が後に続く必要があります

構造化代入の使用法の 1 つは、関数のパラメーターを拡張して他の演算を導入することです。

関数baseFunction({ a, b }) {
  // ...
}
関数wrapperFunction({ x, y, ...restConfig }) {
  // x と y パラメータを使用して演算します
  //残りのパラメータは元の関数に渡されます
  戻りbaseFunction(restConfig);
}

上記のコードでは、元の関数 baseFunction はパラメータとして a と b を受け入れ、関数 wrapperFunction は冗長なパラメータを受け入れて元の関数の動作を保持するために baseFunction に基づいて拡張されています。

スプレッド演算子

オブジェクトのスプレッド演算子 (...) は、パラメーター オブジェクトのすべての通過可能なプロパティを抽出し、現在のオブジェクトにコピーするために使用されます。

z = { a: 3, b: 4 }; とします。
n = { ...z };
n // { a: 3, b: 4 }

配列は特別なオブジェクトであるため、オブジェクトスプレッド演算子は配列に対しても使用できます。

let foo = { ...['a', 'b', 'c'] };
ふー
// {0: "a"、1: "b"、2: "c"}

スプレッド演算子の後に空のオブジェクトが続いた場合、効果はありません。

{...{}、a: 1}
// { a: 1 }

スプレッド演算子の後にオブジェクトが続かない場合は、自動的にオブジェクトに変換されます。

// {...Object(1)} と同等
{...1} // {}

上記のコードでは、スプレッド演算子の後に整数「1」が続き、これは数値パッケージ化オブジェクト「Number{1}」に自動的に変換されます。オブジェクトには独自のプロパティがないため、空のオブジェクトが返されます。

次の例も同様です。

// {...Object(true)} と同等
{...真実} // {}

// {...Object(unknown)} と同等
{...未定義} // {}

// {...Object(null)} と同等
{...null} // {}

ただし、スプレッド演算子の後に文字列が続く場合、文字列は自動的に配列のようなオブジェクトに変換されるため、返されるオブジェクトは空のオブジェクトではありません。

{...'こんにちは'}
// {0: "h"、1: "e"、2: "l"、3: "l"、4: "o"}

オブジェクトのスプレッド演算子は、パラメータ オブジェクト自体の列挙可能なプロパティのみを返します。特にクラスのインスタンス オブジェクトに使用する場合は、この点に特に注意してください。

クラスC {
  p = 12;
  m() {}
}

c = 新しい C(); とします。
let clone = { ...c };

クローン.p; //OK
clone.m(); // エラー

上記の例では、c はクラス C のインスタンス オブジェクトです。これを拡張すると、c 自身の属性 c.p のみが返されますが、c のメソッド c.m() は返されます。このメソッドは C のプロトタイプ オブジェクトで定義されているため、返されません (詳細についてはクラスの章を参照してください)。

オブジェクトスプレッド演算子は、Object.assign() メソッドを使用するのと同じです。

aClone = { ...a };
// と同等
aClone = Object.assign({}, a); とします。

上記の例では、オブジェクト インスタンスの属性のみをコピーしていますが、オブジェクトを完全に複製し、オブジェクト プロトタイプの属性もコピーしたい場合は、次の記述方法を使用できます。

// 書き方その１
const clone1 = {
  __proto__: Object.getPrototypeOf(obj),
  ...オブジェクト
};

//書き方２
const clone2 = Object.assign(
  Object.create(Object.getPrototypeOf(obj)),
  オブジェクト
);

//書き方３
const clone3 = Object.create(
  Object.getPrototypeOf(obj)、
  Object.getOwnPropertyDescriptors(obj)
)

上記のコードでは、メソッド 1 の proto 属性はブラウザ以外の環境ではデプロイされない可能性があるため、メソッド 2 とメソッド 3 を使用することをお勧めします。

スプレッド演算子を使用して 2 つのオブジェクトを結合できます。

ab = { ...a, ...b };
// と同等
let ab = Object.assign({}, a, b);

ユーザー定義の属性が展開演算子の後に配置される場合、展開演算子内の同じ名前の属性は上書きされます。

aWithOverrides = { ...a, x: 1, y: 2 };
// と同等
let aWithOverrides = { ...a, ...{ x: 1, y: 2 } };
// と同等
x = 1、y = 2、aWithOverrides = { ...a, x, y }; とします。
// と同等
let aWithOverrides = Object.assign({}, a, { x: 1, y: 2 });

上記のコードでは、「a」オブジェクトの「x」属性と「y」属性は、新しいオブジェクトにコピーされた後に上書きされます。

これは、既存のオブジェクトの一部のプロパティを変更する場合に便利です。

newVersion = { にします
  ...前のバージョン、
  name: 'New Name' // name プロパティをオーバーライドします
};

上記のコードでは、「newVersion」オブジェクトは「name」属性をカスタマイズし、他のすべての属性は「previousVersion」オブジェクトからコピーされます。

カスタム プロパティをスプレッド演算子の前に置くと、それが新しいオブジェクトのデフォルトのプロパティ値になります。

aWithDefaults = { x: 1, y: 2, ...a }; とします。
// と同等
let aWithDefaults = Object.assign({}, { x: 1, y: 2 }, a);
// と同等
aWithDefaults = Object.assign({ x: 1, y: 2 }, a); とします。

配列のスプレッド演算子と同様に、オブジェクトのスプレッド演算子の後に式を続けることができます。

const obj = {
  ...(x > 1 ? {a: 1} : {})、
  b：2、
};

スプレッド演算子のパラメータオブジェクトに値関数 get があれば、この関数が実行されます。

a = { にしておきます
  get x() {
    throw new Error('まだスローしていません');
  }
}

let aWithXGetter = { ...a } // エラーを報告する

上記の例では、「a」オブジェクトを拡張するときに値関数「get」が自動的に実行され、エラーが発生します。

AggregateError エラー オブジェクト

ES2021 標準では、新しい Promise.any() メソッド (「Promise オブジェクト」の章を参照) と連携するために、新しいエラー オブジェクト AggregateError も導入されており、これについてもこの章で紹介します。

AggregateError は、複数のエラーをエラー オブジェクトにカプセル化します。 1 つの操作で同時に複数のエラーが発生し、これらのエラーを同時にスローする必要がある場合は、AggregateError エラー オブジェクトをスローして、すべてのエラーをこのオブジェクトに入れることができます。

AggregateError 自体は、AggregateError インスタンス オブジェクトを生成するために使用されるコンストラクターです。

AggregateError(エラー[, メッセージ])

AggregateError() コンストラクターは 2 つのパラメーターを受け入れることができます。

  • エラー: 各メンバーがエラー オブジェクトである配列。このパラメータは必須です。
  • message: AggregateError がスローされたときのプロンプト メッセージを示す文字列。このパラメータはオプションです。
const error = new AggregateError([
  新しいエラー('ERROR_11112')、
  new TypeError('名は文字列である必要があります'),
  new RangeError('トランザクション値は少なくとも 1 でなければなりません'),
  new URIError('ユーザー プロファイル リンクは https である必要があります'),
]、'トランザクションを処理できません')

上の例では、AggregateError() の最初のパラメーター配列に 4 つのエラー インスタンスがあります。 2 番目のパラメーター文字列は、これら 4 つのエラーに対する全体的なプロンプトです。

AggregateError のインスタンス オブジェクトには 3 つのプロパティがあります。

  • name: エラー名、デフォルトは「AggregateError」です。
  • メッセージ: エラーメッセージ。
  • エラー: 配列。各メンバーはエラー オブジェクトです。

ここに例を示します。

試す {
  throw new AggregateError([
    新しいエラー(「何らかのエラー」)、
  ]、 'こんにちは'）;
} キャッチ (e) {
  console.log(e インスタンスオブ AggregateError); // true
  console.log(e.message); // "こんにちは"
  console.log(e.name); // "集計エラー"
  console.log(e.errors); // [エラー: "何らかのエラー" ]
}

Error オブジェクトの Cause 属性

Error オブジェクトは、コードの実行時に例外を表すために使用されますが、このオブジェクトから取得されるコンテキスト情報は解釈が難しく、不十分な場合があります。 ES2022 Error オブジェクトに cause 属性を追加します。これにより、エラー生成時にエラーの理由の説明を追加できます。

その使用法は、new Error() が Error インスタンスを生成するときに、cause 属性を設定できる説明オブジェクトを与えることです。

constactual = new Error('エラー!', { 原因: 'エラーの原因' });
actual.cause; // 'エラーの原因'

上記の例では、Error インスタンスを生成するときに、description オブジェクトを使用して cause 属性を指定し、エラーの理由を記述します。このプロパティはインスタンス オブジェクトから読み取ることができます。

「casue」属性には、必ずしも文字列である必要はなく、任意のコンテンツを含めることができます。

試す {
  たぶんWorks();
} キャッチ (エラー) {
  throw new Error('maybeWorks failed!', { 原因: err });
}

上の例では、「cause」属性がオブジェクトを配置します。

作者: wangdoc

アドレス: https://wangdoc.com/

ライセンス: クリエイティブ・コモンズ 3.0

前の章次の章