Üçlü bir operatör (aka if) ifadesi kendinizi tekrar etmeden nasıl yazılır

Örneğin, bunun gibi bir şey:

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

Bunu yazmanın daha iyi bir yolu var mı? Yine, yukarıdaki soruya tam olarak bir yanıt aramıyorum, sadece üç terimli operatör ifadelerinde tekrarlanan operandlara sahip olabileceğinize bir örnek ...

Şahsen ben bunu yapmanın en iyi yolunu hala eski güzel söz buluyorum if:

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

Kod okunabilir olmalıdır, bu nedenle kısa ve öz olmak, maliyeti ne olursa olsun kısa olmak anlamına gelmemelidir - bunun için https://codegolf.stackexchange.com/ adresinde yeniden yayınlamalısınız - bunun yerine, indexokunabilirliği en üst düzeye çıkarmak için adlı ikinci bir yerel değişken kullanmanızı öneririm ( minimum çalışma süresi maliyetiyle de not ediyorum):

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

Ancak bu ifadeyi gerçekten azaltmak istiyorsanız, çünkü iş arkadaşlarınız veya proje ortaklarınız için acımasız bir sadistsiniz, o zaman işte kullanabileceğiniz 4 yaklaşım:

1: a'daki geçici değişken var ifadede

Sen kullanabilirsiniz varikinci geçici değişken tanımlamak (ve atama) için ifadenin yeteneğini indexvirgülle ayrılmış:

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

2: Kendi kendine çalışan anonim işlev

Diğer bir seçenek, kendi kendine çalışan anonim bir işlevdir:

// 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: Virgül operatörü

Ayrıca JavaScript'in desteklediği, C ve C ++ 'da da bulunan kötü şöhretli "virgül operatörü" vardır.

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

Tek bir ifade gerektiren bir konuma birden çok ifade eklemek istediğinizde virgül operatörünü kullanabilirsiniz.

Bunu, bu durumda yeniden atayarak yan etkilere yol açmak için kullanabilirsiniz value:

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

Bu işe yarar çünkü var valueönce (bir ifade olduğu gibi), ardından en soldaki, en içteki valueatama ve sonra virgül operatörünün sağ eli ve ardından üç terimli operatör - tümü yasal JavaScript olarak yorumlanır.

4: Bir alt ifadede yeniden atama

Yorumcu @IllusiveBrian, atama valueparantezli bir alt ifade olarak kullanılıyorsa , virgül operatörünün (önceki örnekte) kullanılmasının gereksiz olduğuna dikkat çekti :

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

Not mantıksal ifadelerde negatif kullanımı zor insanlar takip etmek için olabilir - Yukarıdaki örneklerin tümünde değiştirerek okumak için basitleştirilmiş böylece idx !== -1 ? x : yiçin idx == -1 ? y : x:

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

Sayılar için

Math.max()Fonksiyonu kullanabilirsiniz .

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

0İlk sonuca kadar sonucun sınırlarını 0bu durumda olduğundan daha büyük tutacaktır . Ve sonuç ise gelen indexOfolduğunu -1daha büyüktür gibi 0 döndürecektir -1.

Boole'lar ve boole-y değerleri için

JS için özel olarak genel bir AFAIK kuralı yoktur çünkü yanlış değerler nasıl değerlendirilir.

Ancak çoğu zaman size yardımcı olabilecek bir şey veya operatörü ( ||) ise:

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

Sen, çünkü ilk örnekte, bu çok dikkatli olmak zorunda indexOfdönebilir 0ve değerlendirmek eğer 0 || -1o dönecektir -1çünkü 0bir olduğunu falsy değer.

Pek değil, sadece başka bir değişken kullanın.

Örneğiniz böyle bir şeye genelleme yapıyor.

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

Hesaplanan bir değeri test ediyor, ardından bir koşulu geçmesi durumunda bu değeri bir değişkene atıyorsunuz. Hesaplanan değeri yeniden hesaplamaktan kaçınmanın yolu açıktır: sonucu saklamak için bir değişken kullanın.

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

Ne demek istediğini anlıyorum - bunu yapmanın biraz daha temiz görünen bir yolu olmalı gibi görünüyor. Ama bence bunu yapmanın en iyi yolu (deyimsel olarak). Bu kalıbı herhangi bir nedenle kodunuzda çok tekrarlıyorsanız, küçük bir yardımcı işlev yazabilirsiniz:

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

DÜZENLEME: İşte şimdi JavaScript'te Nullary-coalescing önerisi !

Kullanım ||

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

eşdeğerdir

const result = a || 'fallback value';

Döküm Eğer aiçin Booleangetiri false, resultatanacak 'fallback value', aksi takdirde değeri a.

a === 0Yönlendiren falseve result(yanlış olarak) alacak olan uç durumun farkında olun 'fallback value'. Bunun gibi hileleri kendi sorumluluğunuzda kullanın.

PS. Swift gibi dillerde , benzer amaca hizmet eden sıfır birleştirme operatörü ( ??) vardır. Örneğin, Swift'de result = a ?? "fallback value"JavaScript'e oldukça yakın olanconst result = a || 'fallback value';

Bir ayıklama değişkeni yeniden düzenleme kullanın :

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

O bile daha iyidir constyerine var. Ayrıca ek bir ekstraksiyon da yapabilirsiniz:

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

Uygulamada, daha anlamlı adlar kullanmak index, conditionve value.

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

Muhtemelen birleştirme operatörü arıyorsunuz. Neyse ki, Arraybir tane oluşturmak için prototipten faydalanabiliriz :

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

Bu, işleve bir parametre ekleyerek durumunuza daha da genelleştirilebilir:

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

Şahsen iki çeşidi tercih ediyorum:

1. @Slebetman'ın önerdiği gibi safsa

2. Aşağıdaki örnekte olduğu gibi, geçersiz değeri varsayılan değerle değiştiren ayrı işlev:

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'ın cevabını beğendim. Altındaki yorum, değişkenin "ara durumda" olmasıyla ilgili endişeleri ifade etmektedir. Bu sizin için büyük bir endişeyse, onu bir işlevde özetlemenizi öneririm:

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

O zaman sadece ara

var value = get_value( someArray );

Başka yerlerde kullanımlarınız varsa daha genel işlevler yapabilirsiniz, ancak çok özel bir durumsa aşırı mühendislik yapmayın.

Ama dürüst olmak gerekirse, birkaç yerden tekrar kullanmam gerekmedikçe @slebetman olarak yapardım.

Sorunuza bakmanın iki yolu var: ya satır uzunluğunu azaltmak istiyorsunuz ya da bir değişkeni üçlüde tekrar etmekten özellikle kaçınmak istiyorsunuz. İlki önemsizdir (ve diğer birçok kullanıcı örnekler yayınlamıştır):

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

kısaltılabilir (ve işlev çağrıları verildiğinde) şu şekilde kısaltılabilir:

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

Üçlü sayıdaki bir değişkenin tekrarını engelleyen daha genel bir çözüm arıyorsanız, şöyle:

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

burada fooyalnızca bir kez görünür. Formun çözümlerini atma:

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

teknik olarak doğru ama asıl noktayı kaçırırsanız, şansınız kalmaz. Aradığınız kısa sözdizimine sahip operatörler, işlevler ve yöntemler vardır, ancak bu tür yapılar tanım gereği üçlü operatörler değildir .

Örnekler:

javascript, ||LHS aşağıdaki durumlarda RHS'yi döndürmek için kullanılır falsey:

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

Yardımcı bir işlev kullanın:

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

Artık kodunuz çok okunabilir ve tekrar yok.

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

Kodlama endişelerinin hiyerarşisi şudur:

1. Doğru (gerçek performans veya SLA endişeleri dahil)
2. Açık
3. Özlü
4. Hızlı

Sayfadaki tüm cevaplar şu ana kadar doğru görünüyor, ancak bence benim versiyonum, özlü olmaktan daha önemli olan en yüksek netliğe sahip. Yardımcı işlevi saymazsanız - yeniden kullanılabileceği için - en kısa olanıdır. Bir yardımcı işlevi kullanmak için biraz benzer öneri maalesef bana göre ne yaptığını belirsizleştiren bir lambda kullanıyor. Lambda almayan, sadece değerler alan tek bir amacı olan daha basit bir işlev benim için çok daha iyidir.

PS ES6 sözdizimini seviyorsanız:

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

||Operatörün aşağıdakilere göre uyarlanabileceğini düşünüyorum indexOf:

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

Döndürülen değer 1 yukarı kaydırılır, -1'den 0 yapılır, bu yanlıştır ve bu nedenle ikinci 1 ile değiştirilir. Daha sonra geri kaydırılır.

Ancak, okunabilirliğin tekrardan kaçınmaktan daha üstün olduğunu lütfen unutmayın.

Bu, bitsel NOT ile basit bir çözümdür ve varsayılan değeri -1daha sonra sıfıra döner.

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

Temel olarak, orijinal değeri veya bitsel NOT uygulandıktan sonra sıfır döndüren varsayılan değeri döndüren çift bit düzeyinde NOT ile çalışır.

Doğruluk tablosuna bir göz atalım:

 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

Yeniden atamayı kullanabilirsiniz:

• değişkeni bir değerle başlat
• Yeniden &&atama için operatörün serileştirmesini kullanın , çünkü ilk koşul yanlışsa, ikinci ifade değerlendirilmeyecektir

Örn.

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

Buna belirlenmiştir olacağını nasıl belli değil Soru de örnek kodlar verilecektir 3veya dizinde ayarlanmamış 0ait someArray. Bu örnekte, eşleşme olabileceği varsayılan bir eşleşmenin hariç tutulması amacıyla -1döndürülen .indexOf()değer değerli olacaktır.

Eğer 3dizide yer almayan, -1iade edilecektir. 1Sonuç .indexOf()olarak değerlendirmek falseiçin sonucuna ekleyebiliriz -1, ardından || ORoperatörü ve 0. Ne zaman valuebaşvuruda bulunulan, çıkarma 1dizi veya bir öğenin dizinini almak için -1.

Bu , bir koşulu basitçe kullanmaya .indexOf()ve kontrol etmeye geri götürür . Ya da, tanımlama olarak orijinal referans ilişkin değerlendirilen durumun fiili sonucu olarak olası karışıklığı önlemek için.-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);

Üçlü bir eğer-değilse gibidir, eğer else bölümüne ihtiyacınız yoksa, bunun yerine neden sadece tek bir tane olmasın?

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

Bu özel durum için, mantıksal ||operatör ile kısa devre yapmayı kullanabilirsiniz . Gibi 0falsy kabul edilir, ekleyebilir 1eğer, bu nedenle, sizin dizine index+1olduğunu 0o zaman mantıksal-veya gibi sonucun sağ tarafını alırsınız aksi takdirde, senin alırsınız, index+1. İstediğiniz sonuç dengelendiğinden , endeksinizi almak için ondan 1çıkartabilirsiniz 1:

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