条件付きステートメントを短縮する方法

次のような非常に長い条件文があります。

if(test.type == 'itema' || test.type == 'itemb' || test.type == 'itemc' || test.type == 'itemd'){
    // do something.
}

この表現/ステートメントをより簡潔な形式にリファクタリングできるかどうか疑問に思っていました。

これを達成する方法について何か考えはありますか？

値を配列に入れ、項目が配列にあるかどうかを確認します。

if ([1, 2, 3, 4].includes(test.type)) {
    // Do something
}

サポートしているブラウザにArray#includesメソッドがない場合は、このポリフィルを使用できます。

~チルダショートカットの簡単な説明：

アップデート：私たちが今持っているのでincludes方法を、使用にはポイントがない~ハックはもう。それがどのように機能するかを知ることに興味がある、および/または他のコードでそれに遭遇した人のために、これをここに保持してください。

代わりに結果がかどうかをチェックするのindexOfで>= 0、ちょっといいのショートカットがあります：

if ( ~[1, 2, 3, 4].indexOf(test.type) ) {
    // Do something
}

ここにフィドルがあります：http : //jsfiddle.net/HYJvK/

これはどのように作動しますか？配列でアイテムが見つかった場合は、indexOfそのインデックスを返します。アイテムが見つからなかった場合は、が返され-1ます。詳細に触れずに、~はビットごとのNOT演算子であり、0に対してのみ返され-1ます。

~戻り値を比較するよりも簡潔なので、ショートカットを使用するのが好きです。JavaScriptにin_arrayブール値を直接返す関数（PHPと同様）があればいいのにと思っていますが、それはあくまでも希望的なものです（更新：現在はそうです。と呼ばれていincludesます。上記参照）。jQueryはinArray、PHPのメソッドシグネチャを共有しながら、実際にはネイティブindexOf機能を模倣していることに注意してください（これは、インデックスが本当に必要な場合に、さまざまなケースで役立ちます）。

重要な注意：ティルデショートカットを使用すると、コードが十分に明確ではなく、すべての犠牲を払って回避すべきであると激しく信じているため、論争の渦中になっているようです（この回答のコメントを参照）。あなたが彼らの感情を共有するなら、あなたは.indexOf(...) >= 0解決策に固執するべきです。

もう少し長い説明：

JavaScriptの整数は符号付きです。つまり、左端のビットは符号ビットとして予約されています。数値が正であるか負であるかを示すフラグ1。

32ビットのバイナリ形式の正の数の例を次に示します。

1 :    00000000000000000000000000000001
2 :    00000000000000000000000000000010
3 :    00000000000000000000000000000011
15:    00000000000000000000000000001111

ここに同じ数字がありますが、負です：

-1 :   11111111111111111111111111111111
-2 :   11111111111111111111111111111110
-3 :   11111111111111111111111111111101
-15:   11111111111111111111111111110001

なぜ負の数のこのような奇妙な組み合わせですか？シンプル。負の数は正の数の逆数+ 1です。負の数を正の数に加算すると、常にが生成され0ます。

これを理解するために、簡単な2進算術を実行してみましょう。

以下に追加-1する方法を示します+1。

   00000000000000000000000000000001      +1
+  11111111111111111111111111111111      -1
-------------------------------------------
=  00000000000000000000000000000000       0

そして、これは私たちがどのように追加-15するか+15です：

   00000000000000000000000000001111      +15
+  11111111111111111111111111110001      -15
--------------------------------------------
=  00000000000000000000000000000000        0

どのようにしてそれらの結果を得るのですか？定期的に足し算を行うことで、学校で教えられたように、一番右の列から始めて、すべての行を足します。合計が最大の1桁の数値（10進数では9ですが、2進数では1）より大きい場合、残りを次の列に繰り越します。

ここで、お気づきのように、負の数を正の数に追加すると、すべて0のであるとは限らない右端の列には常に2つ1のがあり、合計するとになり2ます。2のバイナリ表現はなので、次の列10にを運び、結果の1a 0を最初の列に入れます。左にある他のすべての列には、行が1つだけある1ため、1前の列から繰り越された値は再び合計され2、次に繰り越されます...このプロセスは、左端の列に到達するまで繰り返されます。1引き継がれるために、それがオーバーフローすると失われるので、行き場がない、と私たちはを残している0すべてにわたって秒。

このシステムは2の補数と呼ばれます。あなたはここでこれについてもっと読むことができます：

符号付き整数の2の補数表現。

2の補数のクラッシュコース-1が終了したので、2進数表現が1全体に渡る唯一の数値であることがわかります。

~ビット単位のNOT演算子を使用すると、指定された数値のすべてのビットが反転されます。0すべてのビットを反転させることから戻る唯一の方法は、すべてので始めた場合1です。

だから、このすべてはそれが言っての長ったらしい方法だった~nだけ返され0た場合nです-1。

フォールスルーでswitchステートメントを使用できます：

switch (test.type) {

  case "itema":
  case "itemb":
  case "itemc":
  case "itemd":
    // do something
}

サイエンスを使用する：コードを短くして、idfahが言ったこととこれを最速で実行する必要があります。

これは~メソッドよりも高速です

var x = test.type;
if (x == 'itema' ||
    x == 'itemb' ||
    x == 'itemc' ||
    x == 'itemd') {
    //do something
}

http://jsperf.com/if-statements-test-techsin （上部セット：Chrome、下部セット：Firefox）

結論：

場合は可能性があり、いくつかの、あなたはその特定のものは、あなたが最大のパフォーマンスを出すよりも、発生する可能性が高くなります知っているif ||、switch fall throughとif(obj[keyval])。

可能性が多く、そのいずれかが最も発生している可能性がある場合、つまり、オブジェクトルックアップのパフォーマンスを最大限に発揮しif(obj[keyval])、regexそれが当てはまる場合よりも、どちらが発生する可能性が高いかを知ることはできません。

http://jsperf.com/if-statements-test-techsin/12

何か新しいものが出てきたらアップデートします。

文字列と比較していてパターンがある場合は、正規表現の使用を検討してください。

それ以外の場合は、短縮しようとするとコードが難読化されるだけだと思います。単に行を折り返してきれいにすることを検討してください。

if (test.type == 'itema' ||
    test.type == 'itemb' ||
    test.type == 'itemc' ||
    test.type == 'itemd') {
    do something.
}

var possibilities = {
  "itema": 1,
  "itemb": 1,
  "itemc": 1,
…};
if (test.type in possibilities) { … }

オブジェクトを連想配列として使用することはごく一般的なことですが、JavaScriptにはネイティブセットがないため、オブジェクトを安価なセットとして使用することもできます。

if( /^item[a-d]$/.test(test.type) ) { /* do something */ }

または、アイテムが均一でない場合は、次のようになります。

if( /^(itema|itemb|itemc|itemd)$/.test(test.type) ) { /* do something */ }

すばらしい答えですが、関数の中にそれらをラップすることで、コードをはるかに読みやすくすることができます。

これは複雑なifステートメントであり、あなた（または他の誰か）が数年かけてコードを読んだとき、何が起こっているのかを理解するためのセクションを見つけるためにスキャンすることになります。このレベルのビジネスロジックを使用したステートメントでは、テストしていることを理解している間、数秒間つまずきます。このようなコードでは、スキャンを続行できます。

if(CheckIfBusinessRuleIsTrue())
{
    //Do Something
}

function CheckIfBusinessRuleIsTrue() 
{
    return (the best solution from previous posts here);
}

関数に明示的に名前を付けると、何をテストしているかがすぐにわかり、コードをスキャンして理解しやすくなります。

すべての回答をJavascriptセットに入れて、そのセットを呼び出すだけ.contains()です。

すべてのコンテンツを宣言する必要がありますが、インライン呼び出しは短くなります。

何かのようなもの：

var itemSet = new Set(["itema","itemb","itemc","itemd"]);
if( itemSet.contains( test.type ){}

これを実現する私のお気に入りの方法の1つは、underscore.jsなどのライブラリを使用することです...

var isItem = _.some(['itema','itemb','itemc','itemd'], function(item) {
    return test.type === item;
});

if(isItem) {
    // One of them was true
}

http://underscorejs.org/#some

別の方法または私が見つけた別の素晴らしい方法はこれです...

if ('a' in oc(['a','b','c'])) { //dosomething }

function oc(a)
{
  var o = {};
  for(var i=0;i<a.length;i++)  o[a[i]]='';
  return o;
}

もちろん、これを見るとわかるように、物事はさらに一歩進んで、ロジックに従いやすくなっています。

http://snook.ca/archives/javascript/testing_for_a_v

〜&& ||などの演算子を使用する （（）、（））~~は、コードが後で中断する場合にのみ問題ありません。どこから始めればいいかわからない。したがって、読みやすさは非常に重要です。

必要な場合は短くすることができます。

('a' in oc(['a','b','c'])) && statement;
('a' in oc(['a','b','c'])) && (statements,statements);
('a' in oc(['a','b','c']))?statement:elseStatement;
('a' in oc(['a','b','c']))?(statements,statements):(elseStatements,elseStatements);

逆にしたい場合

('a' in oc(['a','b','c'])) || statement;

switchステートメントの代わりにifステートメントを使用するだけです。

switch (test.type) {

  case "itema":case "itemb":case "itemc":case "itemd":
    // do your process
  case "other cases":...:
    // do other processes
  default:
    // do processes when test.type does not meet your predictions.
}

Switch 内の多くの条件を比較するよりも速く動作します if

文字列の非常に長いリストの場合、このアイデアはいくつかの文字を節約します（実際に推奨するわけではありませんが、機能するはずです）。

test.typeに含まれないことがわかっている文字を選択し、それを区切り文字として使用して、すべてを1つの長い文字列に挿入し、それを検索します。

if ("/itema/itemb/itemc/itemd/".indexOf("/"+test.type+"/")>=0) {
  // doSomething
}

文字列がさらに制約されている場合は、区切り文字を省略することもできます...

if ("itemaitembitemcitemd".indexOf(test.type)>=0) {
  // doSomething
}

...しかし、その場合は誤検知に注意する必要があります（たとえば、「embite」はそのバージョンで一致します）。

読みやすくするために、テスト用の関数を作成します（はい、1行の関数）。

function isTypeDefined(test) {
    return test.type == 'itema' ||
           test.type == 'itemb' ||
           test.type == 'itemc' ||
           test.type == 'itemd';
}

それを呼び出す：

…
    if (isTypeDefined(test)) {
…
}
...

このようなif条件を書く場合、2つの目的があると思います。

1. 簡潔
2. 読みやすさ

そのため、場合によっては＃1が最速かもしれませんが、後で簡単にメンテナンスできるように＃2を使用します。シナリオによっては、ウォルターの回答のバリエーションを選択することがよくあります。

まず、既存のライブラリの一部として、グローバルに利用できる関数を用意します。

function isDefined(obj){
  return (typeof(obj) != 'undefined');
}

次に、実際にif条件を実行したい場合は、有効な値のリストを含むオブジェクトを作成します。

var validOptions = {
  "itema":1,
  "itemb":1,
  "itemc":1,
  "itemd":1
};
if(isDefined(validOptions[test.type])){
  //do something...
}

これは、switch / caseステートメントほど高速ではなく、他のいくつかの例よりも少し冗長ですが、コード内の他の場所でオブジェクトを再利用することがよくあります。

上記で作成したjsperfサンプルの1つをピギーバックして、速度を比較するためにこのテストとバリエーションを追加しました。http://jsperf.com/if-statements-test-techsin/6最も興味深いのは、Firefoxの特定のテストコンボはChromeよりもはるかに高速であることです。

これは、単純なforループで解決できます。

test = {};
test.type = 'itema';

for(var i=['itema','itemb','itemc']; i[0]==test.type && [
    (function() {
        // do something
        console.log('matched!');
    })()
]; i.shift());

forループの最初のセクションを使用して照合する引数を初期化し、2番目のセクションを使用してforループの実行を停止し、3番目のセクションを使用して最終的にループを終了します。