この章では 代入、比較、算術、ビット、論理、文字列、三項演算子などに関わる JavaScript の式 (expression) や演算子 (operator) について説明しています。
演算子と式について網羅した詳しいリストはリファレンスでもご覧いただけます。
JavaScript では以下の種類の演算子を使用できます。この節では演算子の優先順位についての説明も含めて演算子について説明します。
JavaScript は二項演算子や単項演算子を実装しており、さらには三項演算子や条件演算子も実装しています。二項演算子は以下のような形で演算子 (operator) を一つ、その前後となるようにオペランド (operand) が二つ必要となります。
operand1 operator operand2
例えば 3+4 や x*y です。
単項演算子は演算子の前後いずれかに、一つのオペランドが必要です。
operator operand
もしくは
operand operator
例えば x++ や ++x です。
代入演算子は右オペランドの値を元に、左のオペランドへ値を代入するものです。簡単なものでは equal (=) があり、右オペランドの値を左オペランドへ代入します。つまり、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 |
| 論理積代入 | x &&= y |
x && (x = y) |
| 論理和代入 | x ||= y |
x || (x = y) |
| Null 合体代入 | x ??= y |
x ?? (x = y) |
ほとんどの式と同様に、x = y のような代入には戻り値があります。戻り値は式の代入やロギング等により取得することができます。
const z = (x = y); // 右記と等価 const z = x = y; console.log(z); // 代入 x = y の戻り値をログする。 console.log(x = y); // または、戻り値を直接ログする。
戻り値は上の表の「意味」列の = 記号の右側の式と一致します。つまり (x = y) は y を返し、(x += y) は加算 x + y の結果を返し、(x **= y) はべき乗 x ** y の結果を返します。
論理代入、(x &&= y) 、(x ||= y) および (x ??= y) の場合、戻り値は代入を除いた論理演算の結果であり、それぞれ x && y 、x || y および x ?? y を返します。
戻り値は常に演算前のオペランドの値に基づくことに注意してください。
これらの式を連鎖させると、それぞれの代入は右から左に評価されます。以下の例で考えてみましょう。
w = z = x = y は w = (z = (x = y)) または x = y; z = y; w = y と等価ですz += x *= y は z += (x *= y) または tmp = x * y; x *= y; z += tmp（tmp がないことを除く）と等価ですより複雑な代入方法、分割代入構文は、配列やオブジェクトのリテラル構造を反映した構文を用いて、配列やオブジェクトからデータを抽出することができる 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; var var2 = 4;
| 演算子 | 説明 | true を返す例 |
|---|---|---|
等価 (==) |
被演算子が等しい場合に true を返します。 |
3 == var1
3 == '3' |
不等価 (!=) |
被演算子が等しくない場合に true を返します。 |
var1 != 4 |
厳密等価 (===) |
被演算子が等しく、かつ同じ型である場合に true を返します。{{jsxref("Object.is")}} や JavsScript での等価も参照してください。 |
3 === var1 |
厳密不等価 (!==) |
被演算子が等しくなく、かつ/または同じ型でない場合に true を返します。 |
var1 !== "3" |
より大きい (>) |
左の被演算子が右の被演算子よりも大きい場合に true を返します。 |
var2 > var1 |
以上 (>=) |
左の被演算子が右の被演算子以上である場合に true を返します。 |
var2 >= var1 |
より小さい (<) |
左の被演算子が右の被演算子よりも小さい場合に true を返します。 |
var1 < var2 |
以下 (<=) |
左の被演算子が右の被演算子以下である場合に true を返します。 |
var1 <= var2 |
メモ: (=>) は演算子ではなく、アロー関数を表す記法です。
算術演算子は被演算子として数値（リテラルまたは変数）をとり、1 つの数値を返します。標準的な算術演算子は、加算 (+)、減算 (-)、乗算 (*)、除算 (/) です。これらの演算子は、他のほとんどのプログラミング言語で浮動小数点数を用いた場合と同じように機能します（特に、0 で除算をすると {{jsxref("Infinity")}} になることに注意してください）。例えば以下のようになります。
1 / 2; // 0.5 1 / 2 == 1.0 / 2.0; // true になります
標準的な算術演算子に加え、さらに JavaScript では、以下の表で示す算術演算子も使用できます。
| 演算子 | 説明 | 例 |
|---|---|---|
剰余 (%) |
二項演算子です。2 つの被演算子で除算したときの、整数の余りを返します。 | 12 % 5 は 2 を返します。 |
インクリメント (++) |
単項演算子です。被演算子に 1 を加えます。前置演算子 (++x) として用いると、被演算子に 1 を加えた後にその値を返します。後置演算子 (x++) として用いると、被演算子に 1 を加える前にその値を返します。 |
x が 3 の場合、++x は x に 4 を設定して 4 を返します。一方、x++ は 3 を返したあと x に 4 を設定します。 |
デクリメント (--) |
単項演算子です。被演算子から 1 を引きます。戻り値はインクリメント演算子のものと同様です。 | x が 3 の場合、--x は x に 2 を設定して 2 を返します。一方、x-- は 3 を返したあと x に 2 を設定します。 |
単項符号反転 (-) |
単項演算子です。被演算子の符号を反転して、その値を返します。 | x が 3 のとき、-x は -3 を返します。 |
単項プラス (+) |
単項演算子です。数値でない被演算子の数値への変換を試みます。 | +"3" は 3 を返します。+true は 1 を返します。 |
べき乗演算子 (**) {{experimental_inline}} |
基数部を指数部乗したものを計算します、つまり、基数部指数部 となります。 |
2 ** 3 は 8 を返します。10 ** -1 は 0.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進表現の |
| 符号維持右シフト | a >> b |
2進表現の a を b ビット分だけ右にシフトします。溢れたビットは破棄します。 |
| ゼロ埋め右シフト | a >>> b |
2進表現の a を b ビット分だけ右にシフトします。溢れたビットは破棄し、左から 0 で詰めます。 |
概念上、ビット論理演算子は以下のように機能します。
変換前: 11100110111110100000000000000110000000000001 変換後: 10100000000000000110000000000001
例えば 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 の補数表現）ことに注意してください。~x は -x - 1 と同じ値に評価されます。
ビットシフト演算子は 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、NaN、空文字列 ("")、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 番目のケースでは、最新のコードで || のように機能する新しい Null 合体演算子 (??) を使用できますが、最初の式が "nullish"、つまり null または undefined の場合にのみ 2 番目の式を返すことに注意してください。したがって、'' や 0 などの値が最初の式の有効な値である場合は、デフォルトを提供することをお勧めします。
文字列に対して使用することができる演算子には、比較演算子に加えて、2 つの文字列を結合する結合演算子 (+) があり、2 つの被演算子の文字列を結合した文字列を返します。
例えば、
console.log('my ' + 'string'); // 文字列 "my string" がログに表示される。
短縮表記した代入演算子 += も文字列の結合に使用できます。
例えば、
var mystring = 'alpha'; mystring += 'bet'; // "alphabet" と評価されて、mystring にその値を代入します。
条件演算子は JavaScript で唯一 3 つの被演算子を取る演算子です。条件に基づいて 2 つの値のうち 1 つを選択します。構文は以下の通りです。
条件 ? 値1 : 値2
条件が真の場合、演算子は値1 の値を選択します。そうでない場合、値2 の値を選択します。標準的な演算子を使用できる場所ならどこでも条件演算子を使用できます。
例えば、
var status = (age >= 18) ? 'adult' : 'minor';
この文では、age が 18 以上の場合、変数 status に "adult" の値が代入されます。そうでない場合 status には "minor" が代入されます。
カンマ演算子 (,) は両側の被演算子を単純に評価し、最後の被演算子の値を返します。この演算子は主に for ループ内で使用され、これによりループのたびに複数の変数を更新できます。
例えば、一辺が 10 要素の 2 次元配列 a があったとして、以下のコードでカンマ演算子を用いて 2 つの変数を同時にインクリメントしています。このコードでは配列の対角成分の値を出力します。
var x = [0,1,2,3,4,5,6,7,8,9]
var a = [x, x, x, x, x];
for (var i = 0, j = 9; i <= j; i++, j--)
// ^
console.log('a[' + i + '][' + j + ']= ' + a[i][j]);
単項演算は被演算子を 1 つだけ取る演算です。
deletedelete 演算子はオブジェクトやオブジェクトのプロパティ、配列の指定されたインデックスの要素を削除します。構文は以下のとおりです。
delete object.property; delete object[propertyKey]; delete objectName[index]; delete property; // legal only within a with statement
ここで object はオブジェクトの名前を、property は既存のプロパティを、propertyKey は配列の要素の位置を示す整数をそれぞれ表しています。
4番目の形式は with 文内でのみ有効で、これはあるオブジェクトからプロパティを削除します。
delete を用いて暗黙的に宣言された変数を削除できますが、var 文で宣言された変数は削除できません。
delete 演算が成功すると、そのプロパティや要素には undefined がセットされます。また、演算が可能だった場合に delete 演算子は true を返します。演算が不可能である場合は false を返します。
x = 42; // 暗黙のうちに window.x を作成
var y = 43;
var myobj = {h: 4}; // プロパティ h を持つオブジェクトを作成
delete x; // false を返す (暗黙的に作成された場合は削除不可能)
delete y; // false を返す (var つきで宣言された場合は削除不可能)
delete Math.PI; // false を返す (定義済みプロパティは削除不可能)
delete myobj.h; // true を返す (ユーザー定義プロパティは削除可能)
配列は単なるオブジェクトの集まりであるため、技術的には各要素を削除することが可能です。しかしそれは悪しき慣例とみなされており、使用しないでください。配列の要素を削除したとき、配列の長さは影響を受けず、他の要素は再インデックスされません。この振る舞いを達成するのであれば、単に要素を undefined で上書きするほうがはるかに良い方法です。実際に配列を操作するためには、splice のようなさまざまな配列のメソッドを使用してください。
typeoftypeof 演算子は次の方法のうち、どちらかの方法で使用します。
typeof 被演算子 typeof (被演算子)
typeof 演算子は、未評価の被演算子の型を指す文字列を返します。被演算子には返される型を調べる対象となる文字列、キーワード、オブジェクトを指定します。括弧はあってもなくてもかまいません。
以下の変数を定義することにしましょう。
var myFun = new Function('5 + 2');
var shape = 'round';
var size = 1;
var foo = ['Apple', 'Mango', 'Orange'];
var today = new Date();
typeof 演算子は、変数の型に応じて以下の値を返します。
typeof myFun; // "function" を返す typeof shape; // "string" を返す typeof size; // "number" を返す typeof foo; // "object" を返す typeof today; // "object" を返す typeof doesntExist; // "undefined" を返す
true や null というキーワードに対して、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" を返す
voidvoid 演算子は以下のどちらかの方法で使用します。
void (式) void 式
void 演算子は、値を返さずに評価する式を指定します。式は評価する JavaScript の式となります。式の周りの括弧はあってもなくてもかまいませんが、使用する方が見た目がよいです。
関係演算子は被演算子を比較し、比較結果が真かどうかに基づいて Boolean の値を返します。
inin 演算子は、指定したプロパティが指定のオブジェクトにある場合に true を返します。構文は以下のとおりです。
プロパティ名または数値 in オブジェクト名
ここで プロパティ名または数値はプロパティ名または配列のインデックスを表す文字列、数値または記号式を、オブジェクト名はオブジェクトの名前をそれぞれ表します。
次の例で 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; // returns true
'model' in mycar; // returns true
instanceofinstanceof 演算子は、指定されたオブジェクトが指定されたオブジェクトの種類である場合に true を返します。構文は以下のとおりです。
オブジェクト名 instanceof オブジェクト型
ここでオブジェクト名はオブジェクト型と比較するオブジェクトの名前を、オブジェクト型は {{jsxref("Date")}} や {{jsxref("Array")}} のようなオブジェクトの種類をそれぞれ表します。
実行時にオブジェクトの種類を確認する必要があるときは instanceof を使用してください。例えば例外を受け取るとき、発生した例外の種類に応じて、別々の例外を扱うコードに分岐することができます。
例えば次のコードでは、instanceof を使用して theDay が Date オブジェクトであるかを判断しています。theDay は Date オブジェクトであるため、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 という式は後者の例です。この式では 3 と 4 を加算するのに + 演算子を使っており、計算結果の 7 を変数に代入していません。
JavaScript には、以下の種類の式があります。
JavaScript における基本のキーワードと一般的な式です。
thisthis キーワードを使用することで現在のオブジェクトを参照できます。一般的に 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
左辺値は、代入する宛先です。
newnew 演算子は、ユーザー定義オブジェクトやビルトインオブジェクトのインスタンス作成に使用します。new の使用法は以下のとおりです。
var オブジェクト名 = new objectType([引数1, 引数2, ..., 引数N]);
super キーワードは自分の親のオブジェクトに関数を呼び出すのに使います。これは下の例のように、クラスと共に使って親のコンストラクタを呼び出すのに便利です。
super([引数]); // 親のコンストラクタを呼び出す。 super.親の関数([引数]);