JavaScript
単項演算子

構文

• void expression; //式を評価して戻り値を破棄する
• +式; //式を数値に変換しようとします。
• オブジェクトを削除します。 //オブジェクトのプロパティを削除する
• オブジェクトを削除する["property"]; //オブジェクトのプロパティを削除する
• 型オペランド。 //オペランドの型を返す
• 〜式; //式の各ビットに対してNOT演算を実行する
• ！式; //式に論理否定を実行する
• -expression; //数値への変換を試みた後に式を否定します

単項プラス演算子（+）

単項プラス（ + ）はそのオペランドの前にあり、そのオペランドに評価されます。オペランドを数値に変換しようと試みます。

構文：

+expression

戻り値：

• Number 。

説明

単項プラス（ + ）演算子は、何かを数値に変換する最も速い（そして好ましい）方法です。

それは変換することができます：

• 整数（10進数または16進数）と浮動小数点数の文字列表現。
• false ： true 、 false 。
• null

変換できない値はNaNと評価されます。

例：

+42           // 42
+"42"         // 42
+true         // 1
+false        // 0
+null         // 0
+undefined    // NaN
+NaN          // NaN
+"foo"        // NaN
+{}           // NaN
+function(){} // NaN

配列を変換しようとすると、予期しない戻り値が返されることに注意してください。
バックグラウンドでは、配列はまず文字列表現に変換されます。

[].toString() === '';
[1].toString() === '1';
[1, 2].toString() === '1,2';

演算子は、これらの文字列を数値に変換しようとします。

+[]           // 0   ( === +'' )
+[1]          // 1   ( === +'1' )
+[1, 2]       // NaN ( === +'1,2' )

削除演算子

delete演算子は、オブジェクトからプロパティを削除します。

構文：

delete object.property

delete object['property']

戻り値：

削除が成功した場合、またはプロパティが存在しなかった場合：

• true

削除するプロパティが構成できない独自のプロパティ（削除できない場合）：

• 非strictモードではfalseです。
• 厳密モードでエラーを投げる

説明

delete演算子は、メモリを直接解放しません。オペレーションがプロパティへのすべての参照がなくなった場合、間接的にメモリを解放できます。

deleteはオブジェクトのプロパティで機能します。オブジェクトのプロトタイプチェーン上に同じ名前のプロパティが存在する場合、プロパティはプロトタイプから継承されます。
変数や関数名に対してdeleteは機能しません。

例：

// Deleting a property
foo = 1;              // a global variable is a property of `window`: `window.foo`
delete foo;           // true
console.log(foo);     // Uncaught ReferenceError: foo is not defined

// Deleting a variable
var foo = 1;
delete foo;           // false
console.log(foo);     // 1 (Not deleted)

// Deleting a function
function foo(){ };
delete foo;           // false
console.log(foo);     // function foo(){ } (Not deleted)

// Deleting a property
var foo = { bar: "42" };
delete foo.bar;       // true
console.log(foo);     // Object { } (Deleted bar)

// Deleting a property that does not exist
var foo = { };
delete foo.bar;       // true
console.log(foo);     // Object { } (No errors, nothing deleted)

// Deleting a non-configurable property of a predefined object
delete Math.PI;       // false  ()
console.log(Math.PI); // 3.141592653589793 (Not deleted)

typeof演算子

typeof演算子は、未評価のオペランドのデータ型を文字列として返します。

構文：

typeof operand

戻り値：

typeofから返される可能性のある戻り値は次のとおりです。

typeof演算子を使用したdocument.allの異常な動作は、従来のブラウザを検出するための以前の使用によるものです。詳細については 、 なぜdocument.allが定義されていますが、typeof document.allが "undefined"を返すのかを参照してください。

例：

// returns 'number'
typeof 3.14;
typeof Infinity;
typeof NaN;               // "Not-a-Number" is a "number"

// returns 'string'
typeof "";
typeof "bla";
typeof (typeof 1);        // typeof always returns a string

// returns 'boolean'
typeof true;
typeof false;

// returns 'undefined'
typeof undefined;
typeof declaredButUndefinedVariable;
typeof undeclaredVariable;
typeof void 0;
typeof document.all       // see above

// returns 'function'
typeof function(){};
typeof class C {};
typeof Math.sin;

// returns 'object'
typeof { /*<...>*/ };
typeof null;
typeof /regex/;           // This is also considered an object
typeof [1, 2, 4];         // use Array.isArray or Object.prototype.toString.call.
typeof new Date();
typeof new RegExp();
typeof new Boolean(true); // Don't use!
typeof new Number(1);     // Don't use!
typeof new String("abc"); // Don't use!

// returns 'symbol'
typeof Symbol();
typeof Symbol.iterator;

void演算子

void演算子は、与えられた式を評価し、 undefinedを返します。

構文：

void expression

戻り値：

• undefined

説明

void演算子は、 void 0またはvoid(0)を書くことによって、 undefinedプリミティブ値を得るためによく使用されます。 voidは関数ではなく演算子なので、 ()は必須ではありません。

通常、 void式とundefinedの結果は同じ意味で使用できます。
しかし、古いバージョンのECMAScriptでは、 window.undefined任意の値を割り当てることができ、 undefinedの値に依存する他のコードを混乱させるように、関数内の関数パラメータ変数の名前としてundefinedを使用することは可能です。
しかし、 voidは常に真の undefined値を生成します 。

void 0は、 undefinedを書くより短い方法として、コードの縮小化でもよく使われます。さらに、他のコードがwindow.undefinedを改ざんしている可能性があるので、おそらくもっと安全window.undefined 。

例：

返されるundefined ：

function foo(){
    return void 0;
}
console.log(foo()); // undefined

特定のスコープ内でundefinedの値を変更する：

(function(undefined){
    var str = 'foo';
    console.log(str === undefined); // true
})('foo');

単項否定演算子（ - ）

単項否定（ - ）は、そのオペランドの前にあり、numberに変換しようとした後で否定します。

構文：

-expression

戻り値：

• Number 。

説明

単項否定（ - ）は、単項プラス（ + ）演算子と同じ型/値を変換できます。

変換できない値はNaNと評価されます（ -NaNはありませ-NaN ）。

例：

-42           // -42
-"42"         // -42
-true         // -1
-false        // -0
-null         // -0
-undefined    // NaN
-NaN          // NaN
-"foo"        // NaN
-{}           // NaN
-function(){} // NaN

配列を変換しようとすると、予期しない戻り値が返されることに注意してください。
バックグラウンドでは、配列はまず文字列表現に変換されます。

[].toString() === '';
[1].toString() === '1';
[1, 2].toString() === '1,2';

演算子は、これらの文字列を数値に変換しようとします。

-[]           // -0  ( === -'' )
-[1]          // -1  ( === -'1' )
-[1, 2]       // NaN ( === -'1,2' )

ビット単位のNOT演算子（〜）は、

ビット単位のNOT（ ~ ）は、値の各ビットに対してNOT演算を実行します。

構文：

~expression

戻り値：

• Number 。

説明

NOT演算の真理値表は次のとおりです。

1337  (base 10) = 0000010100111001 (base 2)
~1337 (base 10) = 1111101011000110 (base 2) = -1338 (base 10)

数値ではないビットは、 -(x + 1)ます。

例：

論理NOT演算子（！）は、

論理NOT（ ! ）演算子は式に対して論理否定を実行します。

構文：

!expression

戻り値：

• Boolean

説明

論理NOT（ ! ）演算子は式に対して論理否定を実行します。

ブール値は単純に反転します： !true === falseおよび!false === true 。
ブール値でない値はブール値に変換されてからネゲートされます。

つまり、二重論理NOT（ !! ）を使用して任意の値をブール値にキャストできます。

!!"FooBar" === true
!!1 === true
!!0 === false

これらはすべて!true ：

!'true' === !new Boolean('true');
!'false' === !new Boolean('false');
!'FooBar' === !new Boolean('FooBar');
![] === !new Boolean([]);
!{} === !new Boolean({});

これらはすべて!falseと等しい：

!0 === !new Boolean(0);
!'' === !new Boolean('');
!NaN === !new Boolean(NaN);
!null === !new Boolean(null);
!undefined === !new Boolean(undefined);

例：

!true         // false
!-1           // false
!"-1"         // false
!42           // false
!"42"         // false
!"foo"        // false
!"true"       // false
!"false"      // false
!{}           // false
![]           // false
!function(){} // false

!false        // true
!null         // true
!undefined    // true
!NaN          // true
!0            // true
!""           // true

概要

単項演算子は、1つのオペランドしか持たない演算子です。単項演算子は、標準のJavaScript関数呼び出しより効率的です。さらに、単項演算子はオーバーライドできないため、その機能は保証されています。

次の単項演算子を使用できます。