Jak napisać operator trójskładnikowy (aka if) bez powtarzania siebie

Na przykład coś takiego:

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

Czy jest lepszy sposób, aby to napisać? Ponownie, nie szukam odpowiedzi na dokładne pytanie powyżej, tylko przykład tego, kiedy możesz mieć powtarzające się operandy w wyrażeniach operatorów trójskładnikowych ...

Osobiście uważam, że najlepszym sposobem, aby to zrobić, jest wciąż stare dobre ifstwierdzenie:

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

Kod powinien być czytelny, więc bycie zwięzłym nie powinno oznaczać zwięzłości bez względu na koszty - w tym celu prześlij ponownie na https://codegolf.stackexchange.com/ - więc zamiast tego zalecałbym użycie drugiej zmiennej lokalnej o nazwie, indexaby zmaksymalizować czytelność tekstu ( przy minimalnych kosztach czasu działania, zauważam):

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

Ale jeśli naprawdę chcesz uciąć to wyrażenie, ponieważ jesteś okrutnym sadystą dla swoich współpracowników lub współpracowników projektu, oto 4 podejścia, których możesz użyć:

1: Zmienna tymczasowa w varinstrukcji

Możesz użyć varzdolności instrukcji do zdefiniowania (i przypisania) drugiej zmiennej tymczasowej index, oddzielonej przecinkami:

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

2: Samowykonująca się funkcja anonimowa

Inną opcją jest samowykonująca się anonimowa funkcja:

// 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: Operator przecinka

Istnieje również niesławny „operator przecinka” obsługiwany przez JavaScript, który jest również obecny w C i C ++.

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

Możesz użyć operatora przecinka, jeśli chcesz dołączyć wiele wyrażeń w lokalizacji, która wymaga jednego wyrażenia.

Możesz go użyć do wprowadzenia efektów ubocznych, w tym przypadku ponownie przypisując do value:

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

To działa, ponieważ var valuejest najpierw interpretowane (ponieważ jest to instrukcja), a następnievalue przypisanie skrajne lewe, najbardziej wewnętrzne , a następnie prawa ręka operatora przecinka, a następnie operator trójskładnikowy - cały legalny JavaScript.

4: Przypisz ponownie w podwyrażeniu

Komentator @IllusiveBrian zwrócił uwagę, że użycie operatora przecinka (w poprzednim przykładzie) jest niepotrzebne, jeśli przypisanie do valuejest używane jako podwyrażenie w nawiasach:

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

Zauważ, że używanie negatywów w wyrażeniach logicznych może być trudniejsze do naśladowania dla ludzi - dlatego wszystkie powyższe przykłady można uprościć do czytania, zmieniając idx !== -1 ? x : yna idx == -1 ? y : x:

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

Dla liczb

Możesz użyć Math.max()funkcji.

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

Zachowa granice wyniku od 0aż do pierwszego wyniku większe niż 0w takim przypadku. I jeśli wynik ze indexOfjest -1to zwróci 0, jak jest większa niż -1.

Dla wartości logicznych i logicznych-y

W przypadku JS nie ma ogólnej reguły AFAIK, szczególnie ze względu na sposób oceny fałszywych wartości.

Ale jeśli coś może ci pomóc przez większość czasu, to operator lub ( ||):

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

Musisz być z tym bardzo ostrożny, ponieważ w pierwszym przykładzie indexOfmoże powrócić 0i jeśli oszacujesz 0 || -1, zwróci, -1ponieważ 0jest fałszywą wartością.

Niezupełnie, po prostu użyj innej zmiennej.

Twój przykład uogólnia coś takiego.

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

Testujesz obliczoną wartość, a następnie przypisujesz ją do zmiennej, jeśli przekazuje ona jakiś predykat. Sposób uniknięcia ponownego obliczania obliczonej wartości jest oczywisty: użyj zmiennej do przechowywania wyniku.

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

Rozumiem, co masz na myśli - wygląda na to, że powinien być jakiś sposób na zrobienie tego, który będzie wyglądał na trochę czystszy. Ale myślę, że to najlepszy sposób (idiomatycznie), aby to zrobić. Jeśli z jakiegoś powodu często powtarzałeś ten wzorzec w swoim kodzie, możesz napisać małą funkcję pomocniczą:

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

EDYCJA: Oto propozycja koalescencji zerowej teraz w JavaScript!

Posługiwać się ||

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

jest równa

const result = a || 'fallback value';

Jeśli rzutowanie ana Booleanzwraca false, resultzostanie przypisana 'fallback value', w przeciwnym razie wartość a.

Uważaj na przypadek krawędzi a === 0, który rzuca falsei result(nieprawidłowo) przyjmie 'fallback value'. Używaj takich sztuczek na własne ryzyko.

PS. Języki takie jak Swift mają operator koalescencji nil ( ??), który służy podobnemu celowi. Na przykład w Swift można napisać, result = a ?? "fallback value"który jest bardzo zbliżony do JavaScriptconst result = a || 'fallback value';

Użyj wyodrębnionej zmiennej refaktoryzacji :

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

Jest jeszcze lepiej z constzamiast var. Możesz także wykonać dodatkową ekstrakcję:

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

W praktyce użyć więcej niż znaczące nazwy index, conditioni value.

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

Prawdopodobnie szukasz operatora koalescencji. Na szczęście możemy wykorzystać Arrayprototyp do stworzenia jednego:

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

Można to dodatkowo uogólnić w Twoim przypadku, dodając parametr do funkcji:

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

Osobiście wolę dwa warianty:

1. Czyste, jeśli, jak sugerował @slebetman

2. Oddzielna funkcja, która zamienia nieprawidłową wartość na domyślną, jak w tym przykładzie:

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

Podoba mi się odpowiedź @ slebetman. Komentarz pod nim wyraża zaniepokojenie, że zmienna znajduje się w „stanie pośrednim”. jeśli jest to dla Ciebie duży problem, sugeruję zamknięcie go w funkcji:

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

Po prostu zadzwoń

var value = get_value( someArray );

Możesz zrobić bardziej ogólne funkcje, jeśli masz ich zastosowania w innych miejscach, ale nie przesadzaj, jeśli jest to bardzo specyficzny przypadek.

Ale szczerze mówiąc, zrobiłbym po prostu jako @slebetman, chyba że musiałbym ponownie użyć z kilku miejsc.

Są dwa sposoby, w jakie mogę spojrzeć na twoje pytanie: albo chcesz zmniejszyć długość linii, albo specjalnie chcesz uniknąć powtarzania zmiennej w trójskładniku. Pierwsza jest trywialna (i wielu innych użytkowników zamieściło przykłady):

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

można (i powinno się, biorąc pod uwagę wywołania funkcji) skrócić w następujący sposób:

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

Jeśli szukasz bardziej ogólnego rozwiązania, które zapobiega powtarzaniu się zmiennej w trójskładniku, na przykład:

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

gdzie foopojawia się tylko raz. Odrzucenie rozwiązań formularza:

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

jako technicznie poprawne, ale nie ma sensu, to nie masz szczęścia. Istnieją operatory, funkcje i metody, które mają zwięzłą składnię, której szukasz, ale takie konstrukcje z definicji nie są operatorami trójskładnikowymi .

Przykłady:

javascript, używając ||do zwrócenia RHS, gdy LHS to falsey:

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

Użyj funkcji pomocniczej:

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

Teraz twój kod jest bardzo czytelny i nie ma powtórzeń.

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

Hierarchia problemów związanych z kodowaniem jest następująca:

1. Prawidłowe (w tym rzeczywiste problemy z wydajnością lub SLA)
2. Jasny
3. Zwięzły
4. Szybki

Wszystkie dotychczasowe odpowiedzi na stronie wydają się poprawne, ale myślę, że moja wersja jest najbardziej przejrzysta, co jest ważniejsze niż zwięzłość. Jeśli nie policzysz funkcji pomocniczej - ponieważ można jej użyć ponownie - jest ona również najbardziej zwięzła. Nieco podobna sugestia użycia funkcji pomocniczej niestety wykorzystuje lambdę, która według mnie tylko przesłania to, co robi. Prostsza funkcja z jednym celem, która nie przyjmuje wartości lambda, a tylko wartości, jest dla mnie znacznie lepsza.

PS Jeśli lubisz składnię ES6:

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

Myślę, że ||operator można dostosować do indexOf:

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

Zwracana wartość jest przesuwana w górę o 1, co daje 0 z -1, co jest błędem i dlatego jest zastępowane przez drugą 1. Następnie jest cofana.

Należy jednak pamiętać, że czytelność jest lepsza niż unikanie powtórzeń.

Jest to proste rozwiązanie z bitowym NIE i wartością domyślną, -1która jest późniejsza do zera.

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

Działa w zasadzie z podwójnym bitowym NIE, które zwraca oryginalną wartość lub wartość domyślną, która po zastosowaniu bitowego NIE zwraca zero.

Spójrzmy na tabelę prawdy:

 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

Możesz użyć ponownego przypisania:

• zainicjuj zmienną do jednej wartości
• użyj serializacji &&operatora do ponownego przypisania, ponieważ jeśli pierwszy warunek jest fałszywy, drugie wyrażenie nie zostanie ocenione

Dawny.

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

Biorąc pod uwagę przykładowy kod w pytaniu nie jest jasne, w jaki sposób zostać stwierdzone, że 3jest lub nie jest ustawiony na indeks 0z someArray. -1zwrócona z .indexOf()będzie wartościowa w tym przypadku, w celu wykluczenia domniemanego niezgodności, która może być zgodna.

Jeśli 3nie jest uwzględnione w tablicy, -1zostanie zwrócone. Możemy dodać 1do wyniku of, .indexOf()aby oszacować, że falsewynik jest -1, gdzie następuje || ORoperator i 0. Kiedy valuewystępuje odwołanie, odejmij, 1aby uzyskać indeks elementu tablicy lub -1.

Która prowadzi z powrotem po prostu używając .indexOf()i sprawdzanie -1pod ifwarunkiem. Lub zdefiniowanie valuew undefinedcelu uniknięcia możliwego pomyłki co do rzeczywistego wyniku ocenianego stanu w odniesieniu do pierwotnego odniesienia.

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

Trójskładnik jest jak if-else, jeśli nie potrzebujesz części else, dlaczego nie tylko pojedynczej, jeśli zamiast ..

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

W tym konkretnym przypadku możesz użyć zwarcia z ||operatorem logicznym . Ponieważ 0jest to uważane za fałszywe, możesz dodać 1do swojego indeksu, więc jeśli index+1tak 0, otrzymasz prawą stronę logiki - lub jako wynik, w przeciwnym razie otrzymasz swój index+1. Ponieważ pożądany wynik jest równoważony 1, możesz odjąć 1od niego, aby uzyskać indeks:

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