この記事は技術レビューを必要としています。ぜひご協力ください

この記事は編集レビューを必要としています。ぜひご協力ください

本章では JavaScript の式 (Expression) と、代入、比較、算術、ビット、論理、文字列、そして三項演算子などの各演算子 (Operator) について説明します。

式と演算子を網羅した詳細リストはリファレンスでご覧になれます。

演算子

JavaScript では以下の種類の演算子を使用できます。本章では演算子について説明し、また、演算子の優先順位にも触れます。

JavaScript には二項演算子と単項演算子、さらに唯一の特殊な三項演算子である条件演算子があります。二項演算子は演算子の前後に 1 つずつ、計 2 つの被演算子 (operand) が必要です :

operand1 operator operand2

例えば 3+4x*y です。

単項演算子は、演算子の前か後ろのどちらかに 1 つの被演算子が必要です :

operator operand

または、

operand operator

例えば x++++x です。

代入演算子

代入演算子は右の被演算子の値に基づいて、左の変数に値を代入します。基本的な代入演算子は等号 (=) であり、これは右の被演算子の値を左の被演算子に代入します。すなわち x = y は、y の値を x に代入します。

次表に掲げられている演算向けに短縮表記が使用できる複合代入演算子もあります :

複合代入演算子
名称 短縮表記した演算子 意味
代入 x = y x = y
加算代入 x += y x = x + y
減算代入 x -= y x = x - y
乗算代入 x *= y x = x * y
除算代入 x /= y x = x / y
剰余代入 x %= y x = x % y
べき乗代入 x **= y x = x ** y
左シフト代入 x <<= y x = x << y
右シフト代入 x >>= y x = x >> y
符号なし右シフト代入 x >>>= y x = x >>> y
ビット論理積 (AND) 代入 x &= y x = x & y
ビット排他的論理和 (XOR) 代入 x ^= y x = x ^ y
ビット論理和 (OR) 代入 x |= y x = x | y

分割代入

より複雑な代入方法として、配列やオブジェクトのリテラル構造を反映した構文を使い、配列やオブジェクトからのデータ抽出を可能にする JavaScript の式、分割代入構文があります。

var foo = ["one", "two", "three"];

// 分割を行わない代入
var one   = foo[0];
var two   = foo[1];
var three = foo[2];

// 分割代入
var [one, two, three] = foo;

比較演算子

比較演算子は被演算子を比較して、その結果が真であるかに基づいて論理値を返します。被演算子には数値、文字列、論理値、オブジェクトを使用できます。文字列は Unicode を用い、標準的な辞書順に基づいて比較されます。ほとんどの場合、2 つの被演算子が異なる型ならば JavaScript はその被演算子を比較に適した型に変換しようとします。こうした挙動により、一般的に被演算子は数値的に比較される結果となります。このルールの唯一の例外は === および !== で、これらは「厳密に」等値か否かを判断し、等値性をチェックする前に被演算子を適合する型に変換しません。次の表では、以下のサンプルコードで定義された変数を前提として比較演算子を説明していきます :

var var1 = 3, var2 = 4;
比較演算子
演算子 説明 true を返す例
等しい (==) 被演算子が等しい場合に true を返します。 3 == var1
"3" == var1
3 == '3'
等しくない (!=) 被演算子が等しくない場合に true を返します。 var1 != 4
var2 != "3"
厳密に等しい (===) 被演算子が等しく、かつ同じ型である場合に true を返します。 3 === var1
厳密に等しくない (!==) 被演算子が等しくなく、かつ/または同じ型でない場合に true を返します。 var1 !== "3"
3 !== '3'
より大きい (>) 左の被演算子が右の被演算子よりも大きい場合に true を返します。 var2 > var1
"12" > 2
以上 (>=) 左の被演算子が右の被演算子以上である場合に true を返します。 var2 >= var1
var1 >= 3
より小さい (<) 左の被演算子が右の被演算子よりも小さい場合に true を返します。 var1 < var2
"12" < "2"
以下 (<=) 左の被演算子が右の被演算子以下である場合に true を返します。 var1 <= var2
var2 <= 5

算術演算子

算術演算子は被演算子として数値(リテラルまたは変数)をとり、1 つの数値を返します。標準的な算術演算子は、加算 (+)、減算 (-)、乗算 (*)、除算 (/) です。これらの演算子は、他のほとんどのプログラミング言語で浮動小数点数を用いた場合と同じように機能します(0 で除算した結果は、NaN になることにも注意してください)。例えば :

1 / 2; // 0.5 を表示
1 / 2 == 1.0 / 2.0; // true になります

標準的な算術演算子に加え、さらに JavaScript では、以下の表で示す算術演算子も使用できます。

算術演算子
演算子 説明
剰余
(%)
二項演算子です。2 つの被演算子で除算したときの、整数の余りを返します。 12 % 5 は 2 を返します。
インクリメント
(++)
単項演算子です。被演算子に 1 を加えます。前置演算子 (++x) として用いると、被演算子に 1 を加えた後にその値を返します。後置演算子 (x++) として用いると、被演算子に 1 を加える前にその値を返します。 x が 3 の場合、++xx に 4 を設定して 4 を返します。
一方、x++ は 3 を返したあと x に 4 を設定します。
デクリメント
(--)
単項演算子です。被演算子から 1 を引きます。戻り値はインクリメント演算子のものと同様です。 x が 3 の場合、--xx に 2 を設定して 2 を返します。
一方、x-- は 3 を返したあと x に 2 を設定します。
単項符号反転
(-)
単項演算子です。被演算子の符号を反転して、その値を返します。 x が 3 のとき、-x は -3 を返します。
単項プラス
(+)
単項演算子です。数値でない被演算子の数値への変換を試みます。 +"3"3 を返します。
+true1 を返します。
指数演算子
(**)
baseexponent 乗したものを計算します、つまり、基数部指数部 となります。 2 ** 38 を返します。
10 ** -10.1 を返します。

ビット演算子

ビット演算子はその被演算子を 10 進数や 16 進数や 8 進数ではなく、32 ビットの集合(0 と 1)として扱います。例えば、10 進数の 9 の 2 進表現は 1001 です。ビット演算子はこのように 2 進表現にした上で演算を行いますが、JavaScript において標準的な 10 進数表現の数値を返します。

次の表は JavaScript のビット演算子の要約です。

ビット演算子
演算子 使用法 説明
ビット論理積 (AND) a & b 被演算子の対応するビットがともに 1 である各ビットについて 1 を返します。
ビット論理和 (OR) a | b 被演算子の対応するビットがともに 0 である各ビットについて 0 を返します。
ビット排他的論理和 (XOR) a ^ b 被演算子の対応するビットが同じ各ビットについて 0 を返します。
[被演算子の対応するビットが異なる各ビットについて 1 を返します。]
ビット否定 (NOT) ~ a 被演算子の各ビットを反転します。
左シフト a << b 2 進表現の ab ビット分だけ左にシフトします。右から 0 を詰めます。
符号維持右シフト a >> b 2 進表現の ab ビット分だけ右にシフトします。溢れたビットは破棄します。
ゼロ埋め右シフト a >>> b 2 進表現の ab ビット分だけ右にシフトします。溢れたビットは破棄し、左から 0 を詰めます。

ビット論理演算子

概念上、ビット論理演算子は以下のように機能します :

  • 被演算子は 32 ビット整数に変換され、ビット(0 と 1)の列として表現されます。
  • 第 1 被演算子の各ビットは第 2 被演算子の対応する各ビットと対になります。第 1 ビットと第 1 ビット、 第 2 ビットと第 2 ビット、以下同様に。
  • 演算子は各ビットのペアに適用され、結果はビットごとに構成されます。

例えば 9 の 2 進表現は 1001 で、15 の 2 進表現は 1111 です。したがって、ビット演算子がこれらの値に適用されたときの結果は以下のようになります :

ビット演算子の例
演算式 結果 2 進数での説明
15 & 9 9 1111 & 1001 = 1001
15 | 9 15 1111 | 1001 = 1111
15 ^ 9 6 1111 ^ 1001 = 0110
~15 -16 ~00000000...00001111 = 11111111...11110000
~9 -10 ~00000000...00001001 = 11111111...11110110

ビット否定演算子を使うと 32 ビットすべてが反転し、その値の最上位(最左)ビットは負数を表す 1 に設定される(2の補数表現)ことに注意してください。

ビットシフト演算子

ビットシフト演算子は 2 つの被演算子をとります。第 1 被演算子はシフトされる数を指定し、第 2 被演算子は、第 1 被演算子をシフトさせるビット数を指定します。シフト演算の方向は使用する演算子によって決まります。

シフト演算子はその被演算子を 32 ビット整数に変換し、左の被演算子と同じ型で結果を返します。

シフト演算子の種類は次表のとおりです。

ビットシフト演算子
演算子 説明
左シフト
(<<)
この演算子は、第 1 被演算子を指定したビット数分だけ左にシフトします。左に溢れたビットは破棄されます。0 のビットを右から詰めます。 9<<2 の結果は 36 になります。1001 を 2 ビット左にシフトすると 100100 になり、これは 36 となるからです。
符号維持右シフト
(>>)
この演算子は、第 1 被演算子を指定したビット数分だけ右にシフトします。右に溢れたビットは破棄されます。左端のビットのコピーを左から詰めます。 9>>2 の結果は 2 になります。1001 を 2 ビット右にシフトすると 10 であり、これは 2 となるからです。同様に、-9>>2 の結果は、符号が維持されるため -3 になります。
ゼロ埋め右シフト
(>>>)
この演算子は、第 1 被演算子を指定したビット数分だけ右にシフトします。右に溢れたビットは破棄されます。0 のビットを左から詰めます。 19>>>2 の結果は 4 になります。10011 を 2 ビット右にシフトすると 100 になり、これは 4 となるからです。非負数では、0 埋め右シフトと符号を維持した右シフトは同じ結果になります。

論理演算子

論理演算子では、基本的にブール値 (Boolean value)(論理)値を用います。つまりブール値を取ると、ブール値を返します。しかし && および || 演算子については、実際には指定された被演算子の一方の値を返します。そのため、非ブール値とともに論理演算子が使われた場合、非ブール値を返す可能性があります。次表で論理演算子について説明します。

論理演算子
演算子 使用法 説明
論理積 (AND)
(&&)
expr1 && expr2 expr1 を false と見ることができる場合は、expr1 を返します。そうでない場合は expr2 を返します。したがってブール値を用いた場合、両被演算子が true であれば && は true を返し、そうでなければ false を返します。
論理和 (OR)
(||)
expr1 || expr2 expr1 を true と見ることができる場合は、expr1 を返します。そうでない場合は expr2 を返します。したがってブール値を用いた場合、どちらかの被演算子が true であれば || は true を返し、両方とも false であれば false を返します。
論理否定 (NOT)
(!)
!expr 単一の被演算子を true と見ることができる場合は、false を返します。そうでない場合は true を返します。

false に変換される式の例としては、null、0、空文字列 ("")、または undefined に評価される式が挙げられます。

以下のコードで && (論理 AND) 演算子の例を示します。

var a1 =  true && true;     // t && t は true を返す
var a2 =  true && false;    // t && f は false を返す
var a3 = false && true;     // f && t は false を返す
var a4 = false && (3 == 4); // f && f は false を返す
var a5 = "Cat" && "Dog";    // t && t は Dog を返す
var a6 = false && "Cat";    // f && t は false を返す
var a7 = "Cat" && false;    // t && f は false を返す

以下のコードで || (論理 OR) 演算子の例を示します。

var o1 =  true || true;     // t || t は true を返す
var o2 = false || true;     // f || t は true を返す
var o3 =  true || false;    // t || f は true を返す
var o4 = false || (3 == 4); // f || f は false を返す
var o5 = "Cat" || "Dog";    // t || t は Cat を返す
var o6 = false || "Cat";    // f || t は Cat を返す
var o7 = "Cat" || false;    // t || f は Cat を返す

以下のコードで !(論理 NOT) 演算子の例を示します。

var n1 = !true;  // !t は false を返す
var n2 = !false; // !f は true を返す
var n3 = !"Cat"; // !t は false を返す

短絡評価

論理式は左から右に評価されるため、以下のルールを用いた「短絡 (short-circuit)」評価によるテストが実行できます :

  • false && anything は false へと短絡評価されます。
  • true || anything は true へと短絡評価されます。

論理的なルールにより、これらの評価が常に正確であることが保証されます。上記の式で anything の部分は評価されないため、このようにしても副作用が生じないことに注意してください。

文字列演算子

比較演算子は文字列に使用できますが、これに加えて 2 つの文字列を結合する結合演算子 (+) が使用でき、2 つの被演算子の文字列を結合した文字列を返します。

例えば、

console.log("my " + "string"); // 文字列 "my string" がログに表示される。

短縮表記した代入演算子 += も文字列の結合に使用できます。

例えば、

var mystring = "alpha";
mystring += "bet"; // "alphabet" と評価されて、mystring にその値を代入します。

条件(三項)演算子

条件演算子は JavaScript で唯一 3 つの被演算子を取る演算子です。この演算子は条件に基づいて 2 つの値のうち 1 つを選択します。構文は以下のとおりです :

condition ? val1 : val2

条件 condition が真の場合、演算子は val1 の値を選択します。そうでない場合、 val2 の値を選択します。標準的な演算子を使用できる場所ならどこでも条件演算子を使用できます。

例えば、

var status = (age >= 18) ? "adult" : "minor";

この文では、age が 18 以上の場合、変数 status に "adult" の値が代入されます。そうでない場合 status には "minor" が代入されます。

コンマ演算子

コンマ演算子 (,) は両側の被演算子を単純に評価し、最後の被演算子の値を返します。この演算子は主に for ループ内で使用され、これによりループのたびに複数の変数を更新できます。

例えば、一辺が 10 要素の 2 次元配列 a があるとして、以下のコードでコンマ演算子を用いて 2 変数を同時にインクリメントしています。このコードでは配列の対角成分の値を出力します :

for (var i = 0, j = 9; i <= 9; i++, j--)
  document.writeln("a[" + i + "][" + j + "]= " + a[i][j]);

単項演算子

単項演算は 1 個の被演算子だけを取る演算です。

delete

delete 演算子はオブジェクトやオブジェクトのプロパティ、配列の指定されたインデックスの要素を削除します。構文は以下のとおりです :

delete objectName;
delete objectName.property;
delete objectName[index];
delete property; // with 文内でのみ有効

ここで objectName はオブジェクトの名前を、property は既存のプロパティを、index は配列の要素の位置を示す整数をそれぞれ表しています。

4 番目の形式は with 文内でのみ有効で、これはあるオブジェクトからプロパティを削除します。

delete を用いて暗黙的に宣言された変数を削除できますが、var 文で宣言された変数は削除できません。

delete 演算が成功すると、そのプロパティや要素には undefined がセットされます。また、演算が可能だった場合に delete 演算子は true を返します。演算が不可能である場合は false を返します。

x = 42;
var y = 43;
myobj = new Number();
myobj.h = 4;    // プロパティ h を作成
delete x;       // true を返す (暗黙的に定義された場合は削除可)
delete y;       // false を返す (var つきで宣言された場合は削除不可能)
delete Math.PI; // false を返す (定義済みプロパティは削除不可能)
delete myobj.h; // true を返す (ユーザ定義プロパティは削除可能)
delete myobj;   // true を返す (暗黙的に宣言された場合は削除可能)
配列要素の削除

配列の要素を削除したとき、配列の長さは影響を受けません。例えば a[3] を削除したとき、a[4] は依然 a[4] のままで、a[3] は undefined になります。

delete 演算子で配列要素を除去すると、もうその要素は配列からなくなります。次の例で trees[3]delete によって除去されます。しかし、trees[3] は依然指し示すことが可能であり、undefined を返します。

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
delete trees[3];
if (3 in trees) {
  // この部分は実行されません
}

配列要素は存在させたいが値は未定義にしたい場合は、delete 演算子の代わりに undefined キーワードを使用してください。次の例では trees[3]undefined という値が代入されますが、その配列要素は存在したままになります :

var trees = new Array("redwood", "bay", "cedar", "oak", "maple");
trees[3] = undefined;
if (3 in trees) {
  // この部分は実行されます
}

typeof

typeof 演算子は次の方法のうち、どちらかの方法で使用します :

typeof operand
typeof (operand)

typeof 演算子は、未評価の被演算子の型を指す文字列を返します。被演算子 operand には返される型を調べる対象となる文字列、キーワード、オブジェクトを指定します。括弧はあってもなくてもかまいません。

以下の変数を定義することにしましょう :

var myFun = new Function("5 + 2");
var shape = "round";
var size = 1;
var today = new Date();

typeof 演算子は、変数の型に応じて以下の値を返します :

typeof myFun;     // "function" を返す
typeof shape;     // "string" を返す
typeof size;      // "number" を返す
typeof today;     // "object" を返す
typeof dontExist; // "undefined" を返す

truenull というキーワードに対して、typeof 演算子は以下の結果を返します :

typeof true; // "boolean" を返す
typeof null; // "object" を返す

数値や文字列に対して、typeof 演算子は以下の結果を返します :

typeof 62;            // "number" を返す
typeof 'Hello world'; // "string" を返す

プロパティ値に対して、typeof 演算子はプロパティが持つ値の型を返します :

typeof document.lastModified; // "string" を返す
typeof window.length;         // "number" を返す
typeof Math.LN2;              // "number" を返す

メソッドや関数に対して、typeof 演算子は以下の結果を返します :

typeof blur;        // "function" を返す
typeof eval;        // "function" を返す
typeof parseInt;    // "function" を返す
typeof shape.split; // "function" を返す

定義済みオブジェクトに対して、typeof 演算子は以下の結果を返します :

typeof Date;     // "function" を返す
typeof Function; // "function" を返す
typeof Math;     // "object" を返す
typeof Option;   // "function" を返す
typeof String;   // "function" を返す

void

void 演算子は次の方法のうち、どちらかの方法で使用します :

void (expression)
void expression

void 演算子は、値を返さずに評価する式を指定します。expression は評価する JavaScript の式となります。式の周りの括弧はあってもなくてもかまいませんが、使用する方が見た目がよいです。

void 演算子を使用することで、式をハイパーテキストリンクとして指定できます。式は評価されますが、開いている文書の代わりに読み込まれることはありません。

以下のコードは、ユーザがクリックしても何も起こらないハイパーテキストリンクを作成します。ユーザがリンクをクリックすると void(0) は undefined になり、JavaScript としては影響を及ぼしません。

<a href="javascript:void(0)">Click here to do nothing</a>

以下のコードは、ユーザがクリックするとフォームが送信されるハイパーテキストリンクを作成します。

<a href="javascript:void(document.form.submit())">
Click here to submit</a>

関係演算子

関係演算子は被演算子を比較し、比較結果が真かどうかに基づいてブール値 Boolean を返します。

in

in 演算子は、指定したプロパティが指定のオブジェクトにある場合に true を返します。構文は以下のとおりです :

propNameOrNumber in objectName

ここで propNameOrNumber はプロパティ名または配列のインデックスを表す文字列式または数値式を、objectName はオブジェクトの名前をそれぞれ表します。

次の例で in 演算子の使用法を示します。

// 配列
var trees = ["redwood", "bay", "cedar", "oak", "maple"];
0 in trees;        // true を返す
3 in trees;        // true を返す
6 in trees;        // false を返す
"bay" in trees;    // false を返す(インデックスの指す値ではなく、
                   // インデックスの数字を指定しなければならない)
"length" in trees; // true を返す(length は Array のプロパティ)

// 定義済みオブジェクト
"PI" in Math;          // true を返す
var myString = new String("coral");
"length" in myString;  // true を返す

// ユーザ定義オブジェクト
var mycar = { make: "Honda", model: "Accord", year: 1998 };
"make" in mycar;  // true を返す
"model" in mycar; // true を返す

instanceof

instanceof 演算子は、指定されたオブジェクトが指定されたオブジェクトの種類である場合に true を返します。構文は以下のとおりです :

objectName instanceof objectType

ここで objectNameobjectType と比較するオブジェクトの名前を、objectTypeDateArray のようなオブジェクトの種類をそれぞれ表します。

実行時にオブジェクトの種類を確認する必要があるときは instanceof を使用してください。例えば例外を受け取るとき、発生した例外の種類に応じて、別々の例外を扱うコードに分岐することができます。

例えば次のコードでは、instanceof を使用して theDayDate オブジェクトであるかを判断しています。theDayDate オブジェクトであるため、if 文中の文が実行されます。

var theDay = new Date(1995, 12, 17);
if (theDay instanceof Date) {
  // 実行する文
}

演算子の優先順位

演算子の優先順位によって、式評価の際に演算子が適用される順番が定義されています。括弧を用いることで演算子の優先順位をオーバーライドすることができます。

次の表では演算子の優先順位を、高いものから低い順に並べています。

演算子の優先順位
演算子の種類 対応する演算子
メンバ . []
インスタンスの呼び出し/作成 () new
否定/インクリメント ! ~ - + ++ -- typeof void delete
乗算/除算 * / %
加算/減算 + -
ビットシフト << >> >>>
関係 < <= > >= in instanceof
等値 == != === !==
ビット論理積 &
ビット排他的論理和 ^
ビット論理和 |
論理積 &&
論理和 ||
条件 ?:
代入 = += -= *= /= %= <<= >>= >>>= &= ^= |=
コンマ ,

それぞれの演算子についてのリンクを含むこの表の詳細版に関しては JavaScript リファレンスを参照してください。

とは、ある値へと決定される有効な構成単位からなるコードのことです。

概念的に、式は 2 つの種類に分けることができます。ある値を変数に代入するものと、単純にある値を持つものです。

x = 7 という式がこの最初の例です。この式では x に 7 という値を代入するのに = 演算子を使っています。この式自体は 7 と評価されます。

3 + 4 という式は 2 つ目の例です。この式では計算結果の 7 を変数に代入することなく 3 と 4 を加算するのに + 演算子を使っています。

JavaScript には、以下の種類の式があります :

  • 算術式 : 評価結果は数値になります。例えば 3.14159 など。(一般に算術演算子を使用します)
  • 文字列式 : 評価結果は文字列になります。例えば "Fred" や "234" など。(一般に文字列演算子を使用します)
  • 論理式 : 評価結果は true または false になります。(よく論理演算子を用います)
  • 基本式 : JavaScript にある基本のキーワードと一般的な式です。
  • 左辺式 : 左辺の値が代入先になるような式です。

基本式

JavaScript における基本のキーワードと一般的な式です。

this

this キーワードを使用することでカレントオブジェクトを参照できます。一般的に this は、あるメソッド内で呼び出されるオブジェクトを参照します。this の使用法は以下のとおりです :

this["propertyName"]
this.propertyName

オブジェクトと上限および下限の値を渡し、そのオブジェクトの value プロパティを検証する validate という関数があるとしましょう :

function validate(obj, lowval, hival){
  if ((obj.value < lowval) || (obj.value > hival))
    console.log("Invalid Value!");
}

次の例のように、各フォーム要素の onChange イベントハンドラにおいて validate を呼び出し、その関数にフォーム要素を渡すのに this を使うことができます :

<p>Enter a number between 18 and 99:</p>
<input type="text" name="age" size=3 onChange="validate(this, 18, 99);">

グループ化演算子

グループ化演算子 ( ) は式内での評価の優先順位を制御します。例えば、加算が最初に評価されるよう、最初に行われる演算を乗算と除算から加算と減算へとオーバーライドすることができます。

var a = 1;
var b = 2;
var c = 3;

// デフォルトの優先順位
a + b * c     // 7
// デフォルトではこのように評価される
a + (b * c)   // 7

// 優先順位をオーバーライドし、
// 乗算の前に加算を行う
(a + b) * c   // 9

// この式と同等となる
a * c + b * c // 9

内包表記

内包表記は ECMAScript の今後のバージョンで導入予定の JavaScript における実験段階の機能です。内包表記には 2 つのバージョンがあります :

[for (x of y) x]
配列内包表記。
(for (x of y) y)
ジェネレータ内包表記。

内包表記は多くのプログラミング言語に存在し、例のようにすでに存在する配列を元に新しい配列を即座に構成することができます。

[for (i of [ 1, 2, 3 ]) i*i ]; 
// [ 1, 4, 9 ]

var abc = [ "A", "B", "C" ];
[for (letters of abc) letters.toLowerCase()];
// [ "a", "b", "c" ]

左辺式

new

new 演算子は、ユーザ定義オブジェクトやビルトインオブジェクトのインスタンス作成に使用します。new の使用法は以下のとおりです :

var objectName = new objectType([param1, param2, ..., paramN]);

super

super キーワードは自分の親のオブジェクトに関数を呼び出すのに使います。これは下の例のように、クラスと共に使って親のコンストラクタを呼び出すのに便利です。

super([arguments]); // 親のコンストラクタを呼び出す。
super.functionOnParent([arguments]);

展開演算子

展開演算子によって、複数の引数(関数を呼び出す時)や要素(配列リテラルを書く場合)がくるべき場所にそれらを展開できる式を書くことができます。

例えば現在のところ、ある配列があってその配列を一部分とする新しい配列を作りたい場合、配列リテラル構文だけでは不十分で、pushspliceconcat などを組み合わせた必要不可欠なコードに頼らなければなりません。展開演算子を使えば、これをより簡単に行なえます :

var parts = ['shoulder', 'knees'];
var lyrics = ['head', ...parts, 'and', 'toes'];

同様に、展開演算子は関数の呼び出しでも機能します :

function f(x, y, z) { }
var args = [0, 1, 2];
f(...args);

ドキュメントのタグと貢献者

 このページの貢献者: x2357, tiny-studio, teoli, ethertank, syar, akiroom, Potappo, yyss, Electrolysis
 最終更新者: x2357,