So schreiben Sie einen ternären Operatorausdruck (auch bekannt als if), ohne sich zu wiederholen

Zum Beispiel so etwas:

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

Gibt es einen besseren Weg, das zu schreiben? Auch hier suche ich keine Antwort auf die genaue Frage oben, sondern nur ein Beispiel dafür, wann Sie möglicherweise Operanden in ternären Operatorausdrücken wiederholt haben ...

Persönlich finde ich, dass der beste Weg, dies zu tun, immer noch die gute alte ifAussage ist:

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

Code sollte lesbar sein, also sollte Prägnanz nicht bedeuten, dass Sie um jeden Preis knapp sind - dafür sollten Sie erneut auf https://codegolf.stackexchange.com/ posten - stattdessen würde ich empfehlen, eine zweite lokale Variable mit dem Namen indexzu verwenden, um die Lesbarkeit zu maximieren ( bei minimalen Laufzeitkosten stelle ich auch fest):

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

Aber wenn Sie diesen Ausdruck wirklich reduzieren möchten, weil Sie ein grausamer Sadist gegenüber Ihren Mitarbeitern oder Projektmitarbeitern sind, dann sind hier 4 Ansätze, die Sie verwenden können:

1: Temporäre Variable in einer varAnweisung

Sie können die varFähigkeit der Anweisung verwenden, eine zweite temporäre Variable zu definieren (und zuzuweisen), indexwenn sie durch Kommas getrennt wird:

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

2: Selbstausführende anonyme Funktion

Eine weitere Option ist eine selbstausführende anonyme Funktion:

// 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: Kommaoperator

Es gibt auch den berüchtigten "Komma-Operator", den JavaScript unterstützt und der auch in C und C ++ vorhanden ist.

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

Sie können den Kommaoperator verwenden, wenn Sie mehrere Ausdrücke an einer Stelle einfügen möchten, für die ein einzelner Ausdruck erforderlich ist.

Sie können es verwenden, um Nebenwirkungen einzuführen, in diesem Fall indem Sie Folgendes neu zuweisen value:

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

Dies funktioniert, weil var valuezuerst interpretiert wird (da es sich um eine Anweisung handelt), dann die valueZuordnung ganz links, ganz innen und dann die rechte Hand des Kommaoperators und dann der ternäre Operator - alles legales JavaScript.

4: Neuzuweisung in einem Unterausdruck

Der Kommentator @IllusiveBrian wies darauf hin, dass die Verwendung des Komma-Operators (im vorherigen Beispiel) nicht erforderlich ist, wenn die Zuweisung an valueals Unterausdruck in Klammern verwendet wird:

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

Beachten Sie, dass die Verwendung von Negativen in logischen Ausdrücken härter sein können für den Menschen zu folgen - so alle oben genannten Beispiele kann durch Änderung für das Lesen vereinfacht werden idx !== -1 ? x : yzu idx == -1 ? y : x:

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

Für Zahlen

Sie können die Math.max()Funktion verwenden.

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

Dadurch bleiben die Grenzen des Ergebnisses 0bis zum ersten Ergebnis größer als in 0diesem Fall. Und wenn das Ergebnis von indexOfist -1, wird 0 zurückgegeben, da es größer als ist -1.

Für Boolesche und Boolesche-y-Werte

Für JS gibt es keine allgemeine Regel AFAIK, insbesondere weil, wie falsche Werte ausgewertet werden.

Aber wenn Ihnen die meiste Zeit etwas helfen kann, ist der Operator ( ||):

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

Sie müssen damit sehr vorsichtig sein, da in Ihrem ersten Beispiel zurückgegeben werden indexOfkann 0und wenn Sie bewerten 0 || -1, wird es zurückgegeben, -1weil 0es sich um einen falschen Wert handelt.

Nicht wirklich, verwenden Sie einfach eine andere Variable.

Ihr Beispiel verallgemeinert sich auf so etwas.

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

Sie testen einen berechneten Wert und weisen diesen Wert dann einer Variablen zu, wenn sie ein Prädikat übergibt. Die Möglichkeit, eine Neuberechnung des berechneten Werts zu vermeiden, liegt auf der Hand: Verwenden Sie eine Variable, um das Ergebnis zu speichern.

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

Ich verstehe, was du meinst - es scheint, dass es einen Weg geben sollte, der etwas sauberer aussieht. Aber ich denke, das ist der beste Weg (idiomatisch), dies zu tun. Wenn Sie dieses Muster aus irgendeinem Grund häufig in Ihrem Code wiederholt haben, können Sie eine kleine Hilfsfunktion schreiben:

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

EDIT: Hier ist es, der Vorschlag für Nullary-Coalescing jetzt in JavaScript!

Verwenden ||

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

ist äquivalent zu

const result = a || 'fallback value';

Wenn Gießen aauf BooleanRückkehr false, resultwird zugewiesen 'fallback value', andernfalls den Wert a.

Achten Sie auf den Randfall a === 0, der (falsch) geworfen wird falseund resultwird 'fallback value'. Verwenden Sie solche Tricks auf eigenes Risiko.

PS. Sprachen wie Swift haben den Null-Koaleszenz- Operator ( ??), der einem ähnlichen Zweck dient. Zum Beispiel würden Sie in Swift schreiben, result = a ?? "fallback value"was JavaScript ziemlich nahe kommtconst result = a || 'fallback value';

Verwenden Sie ein Refactoring für Extraktvariablen :

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

Es ist noch besser mit conststatt var. Sie können auch eine zusätzliche Extraktion durchführen:

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

In der Praxis verwendet aussagekräftigeren Namen als index, conditionund value.

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

Sie suchen wahrscheinlich nach einem Koaleszenzoperator. Glücklicherweise können wir den ArrayPrototyp nutzen, um einen zu erstellen:

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

Dies könnte durch Hinzufügen eines Parameters zur Funktion weiter auf Ihren Fall verallgemeinert werden:

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

Ich persönlich bevorzuge zwei Varianten:

1. Rein wenn, wie @slebetman vorgeschlagen hat

2. Separate Funktion, die einen ungültigen Wert durch einen Standardwert ersetzt, wie in diesem Beispiel:

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

Ich mag die Antwort von @ slebetman. Der Kommentar darunter äußert sich besorgt darüber, dass sich die Variable in einem "Zwischenzustand" befindet. Wenn dies ein großes Problem für Sie ist, schlage ich vor, es in eine Funktion zu kapseln:

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

Dann ruf einfach an

var value = get_value( someArray );

Sie könnten allgemeinere Funktionen ausführen, wenn Sie sie an anderen Stellen verwenden, aber nicht überentwickeln, wenn es sich um einen ganz bestimmten Fall handelt.

Aber um ehrlich zu sein, würde ich nur als @slebetman arbeiten, wenn ich nicht von mehreren Stellen aus wiederverwenden müsste.

Es gibt zwei Möglichkeiten, wie ich Ihre Frage betrachten kann: Sie möchten entweder die Zeilenlänge reduzieren oder Sie möchten speziell vermeiden, eine Variable in einem Ternär zu wiederholen. Der erste ist trivial (und viele andere Benutzer haben Beispiele veröffentlicht):

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

kann (und sollte angesichts der Funktionsaufrufe) wie folgt gekürzt werden:

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

Wenn Sie nach einer allgemeineren Lösung suchen, die die Wiederholung einer Variablen in einem Ternär verhindert, wie folgt:

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

wo foonur einmal erscheint. Lösungen der Form verwerfen:

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

Wenn Sie technisch korrekt sind, aber den Punkt verfehlen, haben Sie kein Glück. Es gibt Operatoren, Funktionen und Methoden, die die von Ihnen gesuchte knappe Syntax besitzen, aber solche Konstrukte sind per Definition keine ternären Operatoren .

Beispiele:

Javascript, ||um die RHS zurückzugeben, wenn die LHS ist falsey:

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

Verwenden Sie eine Hilfsfunktion:

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

Jetzt ist Ihr Code sehr gut lesbar und es gibt keine Wiederholung.

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

Die Hierarchie der Codierungsprobleme lautet:

1. Richtig (einschließlich wahrer Leistung oder SLA-Bedenken)
2. klar
3. Prägnant
4. Schnell

Alle Antworten auf der Seite scheinen bisher korrekt zu sein, aber ich denke, meine Version hat die höchste Klarheit, was wichtiger ist als Prägnanz. Wenn Sie die Hilfsfunktion nicht zählen, da sie wiederverwendet werden kann, ist sie auch die prägnanteste. Der etwas ähnliche Vorschlag, eine Hilfsfunktion zu verwenden, verwendet leider ein Lambda, das für mich nur verdeckt, was es tut. Eine einfachere Funktion mit einem Zweck, der kein Lambda, sondern nur Werte benötigt, ist für mich viel besser.

PS Wenn Sie die ES6-Syntax mögen:

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

Ich denke, der ||Betreiber kann zugeschnitten werden auf indexOf:

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

Der zurückgegebene Wert wird um 1 nach oben verschoben, was 0 von -1 ergibt, was falsch ist und daher durch die zweite 1 ersetzt wird. Dann wird er zurück verschoben.

Beachten Sie jedoch, dass die Lesbarkeit der Vermeidung von Wiederholungen überlegen ist.

Dies ist eine einfache Lösung mit bitweisem NICHT und einem Standardwert, der -1später zu Null führt.

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

Es funktioniert grundsätzlich mit einem doppelten bitweisen NOT, das den ursprünglichen Wert zurückgibt, oder einem Standardwert, der nach dem Anwenden des bitweisen NOT Null zurückgibt.

Werfen wir einen Blick auf die Tabelle der Wahrheit:

 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

Sie könnten eine Neuzuweisung verwenden:

• Variable auf einen Wert initialisieren
• Verwenden Sie die Serialisierung des &&Operators für die Neuzuweisung, da der zweite Ausdruck nicht ausgewertet wird, wenn die erste Bedingung falsch ist

Ex.

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);

Angesichts des Beispielcodes bei Frage ist nicht klar, wie bestimmt werden würde, ob der 3Index 0von festgelegt ist oder nicht someArray. -1Eine Rückgabe von .indexOf()wäre in diesem Fall wertvoll, um eine vermutete Nichtübereinstimmung auszuschließen, die eine Übereinstimmung sein könnte.

Wenn 3nicht im Array enthalten, -1wird zurückgegeben. Wir können hinzufügen , 1um Ergebnis .indexOf()zu bewerten falsefür Ergebnis Wesen -1, wo durch gefolgt || ORBetreiber und 0. Wenn darauf valueverwiesen wird, subtrahieren Sie 1, um den Index des Elements des Arrays oder zu erhalten -1.

Was dazu führt .indexOf(), dass -1ein ifZustand einfach verwendet und überprüft wird. Oder definiert , valuewie undefinedzu vermeiden , mögliche Verwirrung in Bezug auf tatsächliches Ergebnis des ausgewerteten Zustandes ursprüngliche Referenz beziehen.

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);

Ein Ternär ist wie ein Wenn-Sonst. Wenn Sie den Sonst-Teil nicht benötigen, warum nicht einfach einen einzigen, wenn stattdessen.

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

In diesem speziellen Fall können Sie einen Kurzschluss mit dem logischen ||Operator verwenden. Als 0falsy betrachtet wird, können Sie hinzufügen , 1um Ihren Index, wenn also index+1ist 0dann werden Sie mit der rechten Seite des logischen oder als Ihr Ergebnis erhalten, andernfalls werden Sie Ihre bekommen index+1. Da Ihr gewünschtes Ergebnis um versetzt ist 1, können Sie es subtrahieren 1, um Ihren Index zu erhalten:

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