JavaScript
比較操作

備考

ブール値を持つ論理演算子

var x = true,
    y = false;

そして

両方の式が真であると評価された場合、この演算子は真を返します。このブール演算子は短絡を使用し、 xがfalse評価された場合はy評価しません。

x && y;

yはfalseなので、falseを返します。

または

この演算子は、2つの式の1つが真と評価される場合にtrueを返します。このブール演算子は、短絡を採用し、 yあれば評価されませんxに評価true 。

x || y;

xが真であるため、これはtrueを返します。

NOT

この演算子は、右側の式がtrueと評価される場合はfalseを返し、右側の式がfalseの場合はtrueを返します。

!x;

xが真であるため、falseを返します。

抽象的な平等（==）

抽象均等演算子のオペランドは、共通型に変換された後に比較されます。この変換がどのように起こるかは、演算子の仕様に基づいています。

==演算子の指定：

7.2.13抽象的な等価比較

比較x == y （ xとyは値）は、 trueまたはfalse生成しtrue 。このような比較は以下のように行われる。

1. Type(x)がType(y)と同じ場合、次のようになります。

• a。厳密な等式比較の結果を返しますx === y 。

2. xがnull 、 yがundefined場合はtrue返しtrue 。
3. xがundefined 、 yがnull場合はtrue返しtrue 。
4. Type(x)がNumberでType(y)がStringの場合は、比較結果x == ToNumber(y)ます。
5. Type(x)がStringでType(y)がNumber場合、 ToNumber(x) == y比較結果を返します。
6. Type(x)がBoolean場合、比較結果を返しますToNumber(x) == y 。
7. Type(y)がBoolean場合、 comparison x == ToNumber(y)結果comparison x == ToNumber(y)ます。
8. Type(x)がString 、 Number 、 Symbolいずれかで、 Type(y)がObjectの場合は、比較結果x == ToPrimitive(y)ます。
9. Type(x)がObjectでType(y)がString 、 NumberまたはSymbolの場合は、比較結果ToPrimitive(x) == yます。
10. false返しfalse 。

例：

1 == 1;                     // true
1 == true;                  // true  (operand converted to number: true => 1)
1 == '1';                   // true  (operand converted to number: '1' => 1 )
1 == '1.00';                // true
1 == '1.00000000001';       // false
1 == '1.00000000000000001'; // true  (true due to precision loss)
null == undefined;          // true  (spec #2)
1 == 2;                     // false
0 == false;                 // true
0 == undefined;             // false
0 == "";                    // true

関係演算子（<、<=、>、> =）

両方のオペランドが数値の場合、それらは通常と比較されます。

1 < 2        // true
2 <= 2       // true
3 >= 5       // false
true < false // false (implicitly converted to numbers, 1 > 0)

両方のオペランドが文字列の場合、アルファベット順に比較されます。

'a' < 'b'    // true
'1' < '2'    // true
'100' > '12' // false ('100' is less than '12' lexicographically!)

1つのオペランドが文字列であり、もう1つが数値の場合、文字列は比較前の数値に変換されます。

'1' < 2      // true
'3' > 2      // true
true > '2'   // false (true implicitly converted to number, 1 < 2)

文字列が非数値の場合、数値変換はNaN （not-a-number）を返します。 NaNと比較すると、常にfalseが返されfalse 。

1 < 'abc'    // false
1 > 'abc'    // false

しかし、数値をnull 、 undefinedまたは空の文字列と比較するときは注意が必要です。

1 > ''        // true
1 < ''        // false
1 > null      // true
1 < null      // false
1 > undefined // false
1 < undefined // false

一方のオペランドがオブジェクトであり、他方が数値である場合、オブジェクトはcomparison.Soの前の数字に変換されるnull 、特定の場合であるので、 Number(null);//0

new Date(2015)< 1479480185280            // true
null > -1                                //true
({toString:function(){return 123}}) > 122  //true

不平等

演算子!=は、 ==演算子の逆です。
オペランドが等しくない場合はtrue返しtrue 。
javascriptエンジンは、同じ型でない場合、両方のオペランドを一致する型に変換しようとします。 注： 2つのオペランドのメモリ内の内部参照が異なる場合、 falseが返されます。

サンプル：

1 != '1'     // false
1 != 2       // true

上記のサンプルでは、​​プリミティブな数値型がchar値と比較されているため、 1 != '1'はfalseです。したがって、JavascriptエンジンはRHS値のデータ型を気にしません。

演算子： !==は、 ===演算子の逆です。オペランドが等しくないか、型が一致しない場合はtrueを返します。

例：

1 !== '1'    // true
1 !== 2      // true
1 !== 1      // false

非ブール値を持つ論理演算子（ブール型強制）

論理OR（ || ）は、左から右に読み、最初の真理値に評価されます。 本当の値が見つからなければ、最後の値が返されます。

var a = 'hello' || '';             // a = 'hello'
var b = '' || [];                  // b = []
var c = '' || undefined;           // c = undefined
var d = 1 || 5;                    // d = 1
var e = 0 || {};                   // e = {}
var f = 0 || '' || 5;              // f = 5
var g = '' || 'yay' || 'boo';      // g = 'yay'

論理AND（ && ）は、左から右に読むと、最初の偽値に評価されます。 偽の値が見つからない場合は、最後の値が返されます。

var a = 'hello' && '';                  // a = ''
var b = '' && [];                       // b = ''
var c = undefined && 0;                 // c = undefined
var d = 1 && 5;                         // d = 5
var e = 0 && {};                        // e = 0
var f = 'hi' && [] && 'done';           // f = 'done'
var g = 'bye' && undefined && 'adios';  // g = undefined

このトリックは、たとえば、デフォルト値を関数引数に設定するために使用できます（ES6より前）。

var foo = function(val) {
    // if val evaluates to falsey, 'default' will be returned instead.
    return val || 'default';
}

console.log( foo('burger') );  // burger
console.log( foo(100) );       // 100
console.log( foo([]) );        // []
console.log( foo(0) );         // default
console.log( foo(undefined) ); // default

引数には、 0と（それほどの程度はありませんが）空の文字列も、明示的に渡すことができ、デフォルトを上書きできる有効な値であることがよくあります。 虚偽です ）。

ヌルと未定義

nullとundefinedの違い

nullとundefined共有抽象的な等号==厳密な等式===ではなく、

null == undefined   // true
null === undefined  // false

それらはわずかに異なるものを表します：

• undefinedは、識別子/オブジェクトプロパティが作成される前、または識別子/関数パラメータの作成と最初に設定されている間の期間など、値が存在しないことを表します。
• nullはすでに作成された識別子またはプロパティの値が意図的に存在しないことを表しnull 。

それらは異なる構文のタイプです：

• undefinedはグローバルオブジェクトのプロパティで 、通常はグローバルスコープでは変更できundefined 。これはどこに隠すことができグローバル名前空間以外の識別子を定義することができることを意味しundefined （物事はまだすることができますが、その範囲からundefined ）
• nullは単語リテラルなので、決して変更することはできませんし、そうしようとするとエラーが発生します。

nullとundefinedの類似点

nullとundefinedは両方とも偽です。

if (null) console.log("won't be logged");
if (undefined) console.log("won't be logged");

nullでもundefinedもfalseません（ この質問を参照）。

false == undefined   // false
false == null        // false
false === undefined  // false
false === null       // false

undefined使用

• 現在のスコープが信頼できない場合、 未定義に評価されるもの、例えばvoid 0; 。
• undefinedが別の値でシャドーされている場合は、 ArrayまたはNumberをシャドーするほど悪いです。
• 何かをundefinedとして設定しないでください。 オブジェクト fooからプロパティバーを削除する場合は、 delete foo.bar;代わりに。
• 存在しundefinedテスト識別子fooがundefined 、参照エラーが発生する可能性があります。代わりに"undefined"に対してtypeof fooを使用してください。

グローバルオブジェクトのNaNプロパティ

NaN （「N Nのアンバーをotの」）によって定義された特別な値である浮動小数点演算のためのIEEE規格 （非数値が設けられているが、数が予想されるときに使用され、 1 * "two" ）、又は計算に有効なnumber結果（ Math.sqrt(-1) ）がない場合。

NaNとの等価関係または関係比較は、それ自体と比較してもfalse返します。なぜなら、 NaNは無意味な計算の結果を表すはずであり、したがって、他の無意味な計算の結果と同じではないからです。

(1 * "two") === NaN  //false

NaN === 0;          // false
NaN === NaN;        // false
Number.NaN === NaN; // false

NaN < 0;            // false
NaN > 0;            // false
NaN > 0;            // false
NaN >= NaN;         // false
NaN >= 'two';       // false

等しくない比較は常にtrueを返しtrue ：

NaN !== 0;          // true
NaN !== NaN;        // true

値がNaNかどうかを確認する

Number.isNaN(NaN);         // true
Number.isNaN(0 / 0);       // true
Number.isNaN('str' - 12);  // true

Number.isNaN(24);          // false
Number.isNaN('24');        // false
Number.isNaN(1 / 0);       // false
Number.isNaN(Infinity);    // false

Number.isNaN('str');       // false
Number.isNaN(undefined);   // false
Number.isNaN({});          // false

value !== value;    // true for NaN, false for any other value

Number.isNaN = Number.isNaN || function(value) {     
    return value !== value;
}

対照的に、グローバル関数isNaN()は、 NaNだけでなく、数値に強制変換できない値または式に対してもtrue返しtrue 。

isNaN(NaN);         // true
isNaN(0 / 0);       // true
isNaN('str' - 12);  // true

isNaN(24);          // false
isNaN('24');        // false
isNaN(Infinity);    // false

isNaN('str');       // true
isNaN(undefined);   // true
isNaN({});          // true

ECMAScriptは、ECMAScript 6以降、 Object.isで呼び出すことができるSameValueという "同一性"のアルゴリズムを定義しObject.is 。 ==と===比較とは異なり、 Object.is()を使用すると、 NaNはそれ自体と同じである（ -0は+0と同じではないObject.is()とObject.is()れます。

Object.is(NaN, NaN)      // true
Object.is(+0, 0)         // false

NaN === NaN              // false
+0 === 0                 // true

if (!Object.is) {
  Object.is = function(x, y) {
    // SameValue algorithm
    if (x === y) { // Steps 1-5, 7-10
      // Steps 6.b-6.e: +0 != -0
      return x !== 0 || 1 / x === 1 / y;
    } else {
      // Step 6.a: NaN == NaN
      return x !== x && y !== y;
    }
  };
}

メモするポイント

NaN自体は数値であり、文字列 "NaN"と等しくないことを意味します。最も重要なのは（おそらく直感的ではないかもしれませんが）：

typeof(NaN) === "number"; //true

ブール演算子での短絡

オペレータ（ && ）とオペレータ（ || ）は、作業の結果が余分な作業によって変化しない場合、不必要な作業を防ぐために短絡を使用します。

x && y 、 yあれば評価されませんxあると評価false式全体があることが保証されているため、 false 。

x || y 、 yあれば評価されませんxに評価されtrue式全体があることが保証されているので、 true 。

関数の例

次の2つの機能を実行します。

function T() { // True
  console.log("T");
  return true;
}

function F() { // False
  console.log("F");
  return false;
}

例1

T() && F(); // false

出力：

'T'
'F'

例2

F() && T(); // false

出力：

'F'

例3

T() || F(); // true

出力：

'T'

例4

F() || T(); // true

出力：

'F'
'T'

誤差を防ぐための短絡

var obj; // object has value of undefined
if(obj.property){ }// TypeError: Cannot read property 'property' of undefined
if(obj.property && obj !== undefined){}// Line A TypeError: Cannot read property 'property' of undefined

行A：順序を逆にした場合、最初の条件文は、エラーをスローする場合は実行せずに2番目の条件文でエラーを防止します

if(obj !== undefined && obj.property){}; // no error thrown 

ただし、 undefinedが予想される場合にのみ使用する必要があります

if(typeof obj === "object" && obj.property){}; // safe option but slower

短絡してデフォルト値を提供する

||演算子を使用して、「真実」値またはデフォルト値のいずれかを選択できます。

たとえば、これを使用して、null値が確実にnull値に変換されるようにすることができます。

var nullableObj = null;
var obj = nullableObj || {};  // this selects {}

var nullableObj2 = {x: 5};
var obj2 = nullableObj2 || {} // this selects {x: 5}

または、最初の真理値を返す

var truthyValue = {x: 10};
return truthyValue || {}; // will return {x: 10}

同じものを複数回フォールバックするために使うことができます：

envVariable || configValue || defaultConstValue // select the first "truthy" of these

オプションの関数を呼び出すための短絡

コールバックが渡された場合にのみ、 &&演算子を使用してコールバックを評価できます。

function myMethod(cb) {
    // This can be simplified
    if (cb) {
       cb();
    }

    // To this
    cb && cb();
}

もちろん、上記のテストでは、 cbは実際にはObject / Array / String / Numberだけではなく、 functionであることが検証されていfunction 。

抽象平等/不等式と型変換

問題

抽象等価演算子と不等式演算子（ ==と!= ）は、オペランドの型が一致しない場合、そのオペランドを変換します。この型強制は、これらの演算子の結果に関する混乱の一般的な原因です。特に、これらの演算子は、期待通り推移的ではありません。

"" ==  0;     // true A
 0 == "0";    // true A
"" == "0";    // false B
false == 0;   // true
false == "0"; // true

"" !=  0;     // false A
 0 != "0";    // false A
"" != "0";    // true B
false != 0;   // false
false != "0"; // false

JavaScriptが空の文字列を数字に変換する方法を検討すると、結果は意味をなさなくなります。

Number("");    // 0
Number("0");   // 0
Number(false); // 0

ソリューション

ステートメントfalse Bでは、両方のオペランドが文字列（ ""と"0" ） "0" 、タイプ変換はなく、 ""と"0"は同じ値ではないので、 "" == "0"はfalse予想通り。

ここで予想外の動作を排除する1つの方法は、常に同じ型のオペランドを比較することです。たとえば、数値比較の結果に明示的な変換を使用する場合は、次のようにします。

var test = (a,b) => Number(a) == Number(b); 
test("", 0);        // true;
test("0", 0);       // true
test("", "0");      // true;
test("abc", "abc"); // false as operands are not numbers 

または、文字列の比較を行う場合は、次のようにします。

var test = (a,b) => String(a) == String(b);
test("", 0);   // false;
test("0", 0);  // true
test("", "0"); // false;

サイドノート ： Number("0")とnew Number("0")は同じではありません！前者は型変換を実行しますが、後者は型変換を行います。オブジェクトは、以下の結果を説明する値ではなく、参照によって比較されます。

Number("0") == Number("0");         // true;
new Number("0") == new Number("0"); // false 

最後に、暗黙の型変換を実行しない厳密な等価演算子と不等号演算子を使用するオプションがあります。

"" ===  0;  // false
 0 === "0"; // false
"" === "0"; // false

このトピックへのさらなる参照は、ここで見つけることができます：

演算子（== vs ===）と等しいJavaScriptは、JavaScriptの比較で使用する必要がありますか？ 。

抽象的な平等（==）

空の配列

/* ToNumber(ToPrimitive([])) == ToNumber(false) */
[] == false; // true

[].toString()が実行されている場合、 [].join()が存在する場合はそれを呼び出し、それ以外の場合はObject.prototype.toString()ます。この比較はtrue返しtrue 。 [].join()は''を返します。これは0に強制され、false ToNumberに等しくなります。

しかし、すべてのオブジェクトは真実であり、 ArrayはObjectインスタンスです：

// Internally this is evaluated as ToBoolean([]) === true ? 'truthy' : 'falsy'
[] ? 'truthy' : 'falsy'; // 'truthy'

等価比較演算

JavaScriptには4つの異なる等価比較操作があります。

同じ値

両方のオペランドが同じ型に属し、同じ値であればtrue返します。

注：オブジェクトの値は参照です。

この比較アルゴリズムは、 Object.is （ECMAScript 6）で使用できます。

例：

Object.is(1, 1);            // true
Object.is(+0, -0);          // false
Object.is(NaN, NaN);        // true
Object.is(true, "true");    // false
Object.is(false, 0);        // false
Object.is(null, undefined); // false
Object.is(1, "1");          // false
Object.is([], []);          // false

このアルゴリズムは、 等価関係のプロパティを持ちます。

• 反射性 ： Object.is(x, x)は任意の値xに対してtrue
• 対称性 ： Object.is(x, y)あるtrue 、及び場合にのみ場合、 Object.is(y, x)であるtrueの任意の値のために、 xおよびy 。
• Transitivity ： Object.is(x, y)とObject.is(y, z)がtrueであるtrue 、 Object.is(x, z)も任意のx 、 y 、 z値x trueです。

SameValueZero

SameValueのように動作しますが、 +0 0と-0は等しいとみなします。

この比較アルゴリズムはArray.prototype.includes （ECMAScript 7）で使用できます。

例：

[1].includes(1);            // true
[+0].includes(-0);          // true
[NaN].includes(NaN);        // true
[true].includes("true");    // false
[false].includes(0);        // false
[1].includes("1");          // false
[null].includes(undefined); // false
[[]].includes([]);          // false

このアルゴリズムは、 等価関係の特性を依然として有する。

• 反射性 ： [x].includes(x)は任意の値xに対してtrue
• 対称 ： [x].includes(y)であるtrue場合、および場合のみ、 [y].includes(x)であるtrueの任意の値のために、 xおよびy 。
• 推移性 ： [x].includes(y)と[y].includes(z)がtrueであれば、 [x].includes(z)もすべてx 、 y 、 z値x trueです。

厳格な平等比較

それはSameValueのように振る舞いますが、

• +0と-0が等しいと-0ます。
• 任意の値と異なるNaNそれ自体を含む）を考慮する

この比較アルゴリズムは、 ===演算子（ECMAScript 3）を使用して使用できます。

!==演算子（ECMAScript 3）もあり!==これは===の結果を無効にします。

例：

1 === 1;            // true
+0 === -0;          // true
NaN === NaN;        // false
true === "true";    // false
false === 0;        // false
1 === "1";          // false
null === undefined; // false
[] === [];          // false

このアルゴリズムは、以下の特性を有する。

• 対称性 ： x === yあるtrue Y === X、もし、及び場合のみでis真, for any values X and y`。
• 推移性 ： x === yとy === zがtrueであれば、任意のx 、 y 、 z値x x === zもtrueです。

しかし等価関係ではない。なぜなら、

• NaNは反射的ではありません： NaN !== NaN

抽象的な等価比較

両方のオペランドが同じタイプに属している場合、厳密な等価比較のように動作します。

それ以外の場合は、次のように強制します。

• undefinedとnullは等しいとみなされます
• 数値と文字列を比較すると、文字列は数値に強制変換されます
• ブール値と他の値を比較すると、ブール値は数値に強制変換されます
• オブジェクトを数値、文字列、またはシンボルと比較する場合、オブジェクトはプリミティブに強制変換されます

強制があった場合、強制的に値が再帰的に比較されます。それ以外の場合、アルゴリズムはfalse返しfalse 。

この比較アルゴリズムは、 ==演算子（ECMAScript 1）で使用できます。

!=演算子（ECMAScript 1）もあり、 ==の結果は無効になります。

例：

1 == 1;            // true
+0 == -0;          // true
NaN == NaN;        // false
true == "true";    // false
false == 0;        // true
1 == "1";          // true
null == undefined; // true
[] == [];          // false

このアルゴリズムは、以下の特性を有する。

• 対称 ： x == yあるtrue 、もし、及び場合にのみy == xされるtrueの任意の値のために、 xおよびy 。

しかし等価関係ではない。なぜなら、

• NaNは反射的ではありません： NaN != NaN
• 例えば0 == ''と0 == '0' 、 '' != '0' 推移性は保持されません'' != '0'

複数の論理ステートメントのグループ化

括弧内に複数のブール論理文をグループ化すると、より複雑な論理評価を作成できます。特に、if文で役立ちます。

if ((age >= 18 && height >= 5.11) || (status === 'royalty' && hasInvitation)) {
  console.log('You can enter our club');
}

グループ化されたロジックを変数に移動して、ステートメントを少し短く記述的にすることもできます。

var isLegal = age >= 18;
var tall = height >= 5.11;
var suitable = isLegal && tall;
var isRoyalty = status === 'royalty';
var specialCase = isRoyalty && hasInvitation;
var canEnterOurBar = suitable || specialCase;

if (canEnterOurBar) console.log('You can enter our club');

この特定の例（および他の多くの例）では、括弧でステートメントをグループ化することは、それらを削除した場合と同じように機能し、リニアなロジック評価に従うだけで同じ結果が得られることに注意してください。私は括弧を使用するほうが好きです。なぜなら、私が意図したことを明確に理解し、論理ミスを防ぐためです。

自動型変換

数値が誤って文字列やNaN（Not a Number）に変換される可能性があることに注意してください。

JavaScriptは大まかに型付けされています。変数には異なるデータ型を含めることができ、変数はそのデータ型を変更できます。

var x = "Hello";     // typeof x is a string
x = 5;               // changes typeof x to a number

数学演算を行うとき、JavaScriptは数値を文字列に変換できます：

var x = 5 + 7;       // x.valueOf() is 12,  typeof x is a number
var x = 5 + "7";     // x.valueOf() is 57,  typeof x is a string
var x = "5" + 7;     // x.valueOf() is 57,  typeof x is a string
var x = 5 - 7;       // x.valueOf() is -2,  typeof x is a number
var x = 5 - "7";     // x.valueOf() is -2,  typeof x is a number
var x = "5" - 7;     // x.valueOf() is -2,  typeof x is a number
var x = 5 - "x";     // x.valueOf() is NaN, typeof x is a number

文字列から文字列を引くと、エラーは発生しませんが、NaN（Not a Number）が返されます。

"Hello" - "Dolly"    // returns NaN

比較演算子のリスト

マルチ状態データの比較を最適化するためのビットフィールド

ビットフィールドは、さまざまなブール状態を個々のビットとして保持する変数です。ビットがオンの場合はtrue、オフの場合はfalseとなります。過去のビットフィールドでは、メモリを節約し処理負荷を軽減するため、通常、フィールドが使用されていました。ビットフィールドを使用する必要性はもはや重要ではありませんが、多くの処理タスクを単純化できるいくつかの利点があります。

たとえば、ユーザー入力。キーボードの方向キーの入力を上、下、左、右から入力するときは、各方向をビットで割り当てて、さまざまなキーを1つの変数にエンコードできます。

キーボードをビットフィールドで読む例

var bitField = 0;  // the value to hold the bits
const KEY_BITS = [4,1,8,2]; // left up right down
const KEY_MASKS = [0b1011,0b1110,0b0111,0b1101]; // left up right down
window.onkeydown = window.onkeyup = function (e) {
    if(e.keyCode >= 37 && e.keyCode <41){
        if(e.type === "keydown"){
            bitField |= KEY_BITS[e.keyCode - 37];
        }else{
            bitField &= KEY_MASKS[e.keyCode - 37];
        }
    }    
}

配列として読み取る例

var directionState = [false,false,false,false];
window.onkeydown = window.onkeyup = function (e) {
    if(e.keyCode >= 37 && e.keyCode <41){
        directionState[e.keyCode - 37] = e.type === "keydown";
    }    
}

ビットをオンにするには、ビット単位または |使用します|そのビットに対応する値。したがって、2番目のビットを設定したい場合は、 bitField |= 0b10がオンになります。ビットをオフにしたい場合は、ビット単位で使用し、 &を必要なビット単位でオンにします。 4ビットを使用し、第2ビットをbitfield &= 0b1101;からオフにするbitfield &= 0b1101;

上の例は、さまざまなキー状態を配列に代入するよりもはるかに複雑に思えます。はい設定するのがもう少し複雑ですが、状態を調べるときに利点があります。

すべてのキーがアップしているかどうかをテストしたい場合。

// as bit field
if(!bitfield) // no keys are on

// as array test each item in array
if(!(directionState[0] && directionState[1] && directionState[2] && directionState[3])){

いくつかの定数を設定すると、作業が簡単になります

// postfix U,D,L,R for Up down left right
const KEY_U = 1;
const KEY_D = 2;
const KEY_L = 4;
const KEY_R = 8;
const KEY_UL = KEY_U + KEY_L; // up left
const KEY_UR = KEY_U + KEY_R; // up Right
const KEY_DL = KEY_D + KEY_L; // down left
const KEY_DR = KEY_D + KEY_R; // down right

その後、さまざまなキーボードの状態をすばやくテストできます

if ((bitfield & KEY_UL) === KEY_UL) { // is UP and LEFT only down
if (bitfield  & KEY_UL) {             // is Up left down 
if ((bitfield & KEY_U) === KEY_U) {   // is Up only down
if (bitfield & KEY_U) {               // is Up down (any other key may be down)
if (!(bitfield & KEY_U)) {            // is Up up (any other key may be down)
if (!bitfield ) {                     // no keys are down
if (bitfield ) {                      // any one or more keys are down

キーボード入力は一例にすぎません。ビットフィールドは、組み合わせて使用​​する必要のあるさまざまな状態がある場合に便利です。 Javascriptでは、ビットフィールドに32ビットまで使用できます。これらを使用することで、大幅なパフォーマンス向上を実現できます。彼らはよく知っておく価値があります。