自分自身を繰り返さずに三項演算子（別名if）式を記述する方法

たとえば、次のようなもの：

var value = someArray.indexOf(3) !== -1 ? someArray.indexOf(3) : 0

それを書くより良い方法はありますか？繰り返しますが、私は上記の正確な質問に対する答えを求めているのではなく、三項演算子式でオペランドを繰り返した可能性がある場合の例にすぎません...

個人的に私はこれを行う最善の方法がまだ古き良きif声明であることを発見しました：

var value = someArray.indexOf(3);
if (value === -1) {
  value = 0;
}

コードは、読取り可能である必要がありますので、という簡潔べきコストは何でもない平均ビーイングの簡潔な-あなたに再投稿する必要があり、そのためにhttps://codegolf.stackexchange.com/ -その代わりに、私は名前の第二のローカル変数を使用することをお勧めしますindex（読みわかりやすさを最大化するために、実行時のコストも最小限に抑えられます。

var index = someArray.indexOf( 3 );
var value = index == -1 ? 0 : index;

しかし、同僚やプロジェクトの協力者にとって残酷なサディストであるため、この表現を削減したい場合は、次の4つの方法を使用できます。

1：varステートメント内の一時変数

varステートメントの機能を使用して、indexコンマで区切られたときに2番目の一時変数を定義（および割り当て）できます。

var index = someArray.indexOf(3), value = index !== -1 ? index: 0;

2：自己実行匿名関数

別のオプションは、自己実行の無名関数です。

// Traditional syntax:
var value = function( x ) { return x !== -1 ? x : 0 }( someArray.indexOf(3) );

// ES6 syntax:
var value = ( x => x !== -1 ? x : 0 )( someArray.indexOf(3) );

3：カンマ演算子

JavaScriptがサポートする悪名高い「カンマ演算子」もあり、これはCおよびC ++にも存在します。

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator

単一の式を必要とする場所に複数の式を含める場合は、カンマ演算子を使用できます。

これを使用して副作用を導入できます。この場合は、に再割り当てしvalueます。

var value = ( value = someArray.indexOf(3), value !== -1 ? value : 0 );

これが機能するのvar valueは、最初に解釈されるため（ステートメントであるため）、次に左端、最も内側のvalue代入、次にコンマ演算子の右側、次に三項演算子-すべての正当なJavaScriptです。

4：部分式で再割り当て

解説者@IllusiveBrianは、への割り当てがvalue括弧で囲まれた部分式として使用されている場合、コンマ演算子（前の例）の使用は不要であることを指摘しました。

var value = ( ( value = someArray.indexOf(3) ) !== -1 ? value : 0 );

論理式での否定の使用は、人間にとって理解しにくい場合があることに注意してください。上記の例はすべて、次のように変更idx !== -1 ? x : yすることで読みやすくすることができますidx == -1 ? y : x。

var value = ( ( value = someArray.indexOf(3) ) == -1 ? 0 : value );

数字について

Math.max()関数を使用できます。

var value = Math.max( someArray.indexOf('y'), 0 );

その場合0、最初の結果までの結果の境界をより大きく保ち0ます。以下とからもし結果がindexOfある-1以上であるとして、それは0を返します-1。

ブール値とブール値-yの値

JSの場合、偽の値がどのように評価されるのかについては、特にAFAIKの一般的なルールはありません。

しかし、ほとんどの場合、何かがor演算子（||）で役立つ場合：

// Instead of
var variable = this_one === true ? this_one : or_this_one;
// you can use
var variable = this_one || or_this_one;

最初の例でindexOfはが返される可能性が0あり、評価0 || -1すると偽の値が返される-1ため、これには非常に注意する必要0があります。

実際には、別の変数を使用してください。

あなたの例はこのようなものに一般化されます。

var x = predicate(f()) ? f() : default;

計算された値をテストし、それが何らかの述語を渡す場合、その値を変数に割り当てます。計算値の再計算を回避する方法は明らかです。変数を使用して結果を保存します。

var computed = f();
var x = predicate(computed) ? computed : default;

私はあなたが何を意味するかを理解します-これを行うには少しすっきりした方法があるはずです。しかし、これは（慣用的に）これを行うための最良の方法だと思います。何らかの理由でコードでこのパターンを何度も繰り返していた場合は、小さなヘルパー関数を作成できます。

var setif = (value, predicate, default) => predicate(value) ? value : default;
var x = setif(someArray.indexOf(3), x => x !== -1, 0)

編集：これがJavaScript でのNullary-coalescingの提案です！

使用する ||

const result = a ? a : 'fallback value';

に相当

const result = a || 'fallback value';

キャストした場合aにBoolean戻りfalse、result割り当てられます'fallback value'、そうでない場合の値をa。

にa === 0キャストしfalse、result（誤って）取得するエッジケースに注意してください'fallback value'。このようなトリックは自己責任で使用してください。

PS。Swiftなどの言語には、類似の目的を果たすnil-coalescing演算子（??）があります。たとえば、Swiftでは、result = a ?? "fallback value"JavaScriptにかなり近いものを記述します。const result = a || 'fallback value';

抽出変数リファクタリングを使用します。

var index = someArray.indexOf(3);
var value = index !== -1 ? index : 0

のconst代わりにを使用することをお勧めしますvar。追加の抽出を行うこともできます。

const index = someArray.indexOf(3);
const condition = index !== -1;
const value = condition ? index : 0;

実際には、より意味のある名前を使用してindex、conditionとvalue。

const threesIndex = someArray.indexOf(3);
const threeFound = threesIndex !== -1;
const threesIndexOrZero = threeFound ? threesIndex : 0;

あなたはおそらく合体演算子を探しています。幸い、Arrayプロトタイプを利用して作成できます。

Array.prototype.coalesce = function() {
    for (var i = 0; i < this.length; i++) {
        if (this[i] != false && this[i] != null) return this[i];
    }
}

[null, false, 0, 5, 'test'].coalesce(); // returns 5

これは、関数にパラメーターを追加することにより、ケースにさらに一般化できます。

Array.prototype.coalesce = function(valid) {
    if (typeof valid !== 'function') {
        valid = function(a) {
            return a != false && a != null;
        }
    }

    for (var i = 0; i < this.length; i++) {
        if (valid(this[i])) return this[i];
    }
}

[null, false, 0, 5, 'test'].coalesce(); // still returns 5
[null, false, 0, 5, 'test'].coalesce(function(a){return a !== -1}); // returns null
[null, false, 0, 5, 'test'].coalesce(function(a){return a != null}); //returns false

私は個人的に2つのバリアントを好みます。

1. 純粋な場合、@ slebetmanのように

2. この例のように、無効な値をデフォルトの値に置き換える別の関数：

function maskNegative(v, def) {
  return v >= 0 ? v : def;
}

Array.prototype.indexOfOrDefault = function(v, def) {
  return maskNegative(this.indexOf(v), def);
}

var someArray = [1, 2];
console.log(someArray.indexOfOrDefault(2, 0)); // index is 1
console.log(someArray.indexOfOrDefault(3, 0)); // default 0 returned
console.log(someArray.indexOfOrDefault(3, 123)); // default 123 returned

@slebetmanの答えが好きです。その下のコメントは、変数が「中間状態」にあることに懸念を表明しています。これがあなたにとって大きな懸念であるなら、私はそれを関数にカプセル化することを勧めます：

function get_value(arr) {
   var value = arr.indexOf(3);
   if (value === -1) {
     value = 0;
   }
   return value;
}

次に電話する

var value = get_value( someArray );

他の場所で使用している場合は、より一般的な関数を実行できますが、非常に特殊なケースである場合は、過度に設計しないでください。

しかし、正直に言うと、いくつかの場所から再利用する必要がない限り、@ slebetmanとして実行します。

あなたの質問を見るために私が見ることができる2つの方法があります：あなたは行の長さを短くしたいか、または特に三項で変数を繰り返さないようにするかです。最初は簡単です（そして他の多くのユーザーが例を投稿しています）：

var value = someArray.indexOf(3) !== -1 ? someArray.indexOf(3) : 0;

次のように短縮することができます（関数呼び出しが与えられれば、そうする必要があります）。

var value = someArray.indexOf(3);
value = value !== -1 ? value : 0;

次のように、3項での変数の繰り返しを防ぐより一般的なソリューションを探している場合：

var value = conditionalTest(foo) ? foo : bar;

foo一度だけ現れるところ。次の形式の解決策を破棄する：

var cad = foo;
var value = conditionalTest(foo) ? cad : bar;

技術的には正しいが要点が欠けている場合は、運が悪いです。求める構文が簡潔な演算子、関数、およびメソッドはありますが、そのような構造は、定義上、三項演算子ではありません。

例：

JavaScript、||LHSがfalsey次の場合にRHSを返すために使用：

var value = foo || bar; // equivalent to !foo ? bar : foo

ヘルパー関数を使用します。

function translateValue(value, match, translated) {
   return value === match ? translated : value;
}

これでコードは非常に読みやすくなり、繰り返しはありません。

var value = translateValue(someArray.indexOf(3), -1, 0);

コーディングの問題の階層は次のとおりです。

1. 正解（真のパフォーマンスまたはSLAの懸念を含む）
2. 晴れ
3. 簡潔な
4. 速い

これまでのページの答えはすべて正しいように見えますが、私のバージョンは、簡潔さよりも重要である最高の明快さを持っていると思います。ヘルパー関数は、再利用できるので数えない場合も、最も簡潔です。ヘルパー関数を使用するというやや類似した提案は、残念ながらラムダを使用しています。ラムダは、私には、それが何をしているかを覆い隠しています。ラムダをとらず、単なる値をとる1つの目的を持つ単純な関数のほうがはるかに優れています。

PS ES6の構文が気に入った場合：

const translateValue = (value, match, translated) => value === match ? translated : value;
let value = translateValue(someArray.indexOf(3), -1, 0); // or const

私が思うに||、オペレータがに合わせて調整することができますindexOf。

var value = ((someArray.indexOf(3) + 1) || 1) - 1;

戻り値は1だけ上にシフトされ、-1から0になります。これは誤っているため、2番目の1に置き換えられます。次に、後ろにシフトされます。

ただし、繰り返しを避けるよりも読みやすさが優れていることに注意してください。

これはビットごとのNOTと、-1後でゼロになるデフォルト値を持つ単純なソリューションです。

index = ~(~array.indexOf(3) || -1);

これは基本的に、元の値またはデフォルト値を返すダブルビットワイズNOTで機能し、ビットワイズNOTの適用後にゼロを返します。

真実の表を見てみましょう：

 indexOf    ~indexOf   boolean    default     value      result         comment
---------  ---------  ---------  ---------  ---------  ---------  ------------------
      -1          0     falsy          -1         -1          0   take default value
       0         -1    truthy                     -1          0
       1         -2    truthy                     -2          1
       2         -3    truthy                     -3          2

再割り当てを使用できます：

• 変数を1つの値に初期化する
• &&最初の条件が偽の場合、2番目の式は評価されないため、再割り当てに演算子のシリアル化を使用します

例

var value = someArray.indexOf(3);
value == -1 && (value=0);

var someArray = [4,3,2,1];

var value = someArray.indexOf(1);
value == -1 && (value=0);
console.log('Found:',value);

var value = someArray.indexOf(5);
value == -1 && (value=0);
console.log('Not Found:',value);

Questionのサンプルコードを考えると、の3インデックス0に設定されているかどうかがどのように判断されるかは明確ではありませんsomeArray。この例では、一致する可能性のある推定非一致を除外するために、-1から返された値.indexOf()が役立ちます。

3が配列に含まれていない場合は-1が返されます。私たちは、追加することができます1の結果に.indexOf()として評価するfalse結果であることのため-1に続いて、|| ORオペレータと0。valueが参照されている場合、減算1して配列またはの要素のインデックスを取得します-1。

これは、ある条件で単に使用.indexOf()して確認することにつながります。または、元の参照に関連する評価された条件の実際の結果に関して混乱の可能性を回避するように定義します。-1ifvalueundefined

var someArray = [1,2,3];
var value = someArray.indexOf(3) + 1 || 1;
console.log(value -= 1);

var someArray = [1,2,3];
var value = someArray.indexOf(4) + 1 || 1;
// how do we know that `4` is not at index `0`?
console.log(value -= 1);

var someArray = [1,2,3];
var value = someArray.indexOf(4) + 1 || void 0;
// we know for certain that `4` is not found in `someArray`
console.log(value, value = value || 0);

三項はif-elseのようなものです。else部分が必要ない場合は、代わりに単一のifを使用しないでください。

if ((value = someArray.indexOf(3)) < 0) value = 0;

この特定のケースでは、論理||演算子で短絡を使用できます。などが0falsy考えられている、あなたが追加することができ1、あなたのインデックスにあれば、このように、index+1ある0あなたは論理またはあなたの結果としての右側を得るでしょう、そうでない場合、あなたはあなたを得るでしょうindex+1。必要な結果はでオフセットされる1ので、それから減算1してインデックスを取得できます。

const someArray = [1, 2, 3, 4];
const v = ((someArray.indexOf(3)+1) || 1)-1;
console.log(v);