Cara menulis ekspresi operator terner (alias jika) tanpa mengulang sendiri

Misalnya, seperti ini:

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

Apakah ada cara yang lebih baik untuk menulisnya? Sekali lagi, saya tidak mencari jawaban untuk pertanyaan persis di atas, hanya contoh ketika Anda mungkin telah mengulangi operan dalam ekspresi operator terner ...

Secara pribadi saya menemukan cara terbaik untuk melakukan ini masih ifpernyataan lama yang baik :

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

Kode harus dapat dibaca, jadi singkat tidak berarti menjadi singkat berapa pun biayanya - untuk itu Anda harus memposting ulang ke https://codegolf.stackexchange.com/ - jadi saya akan merekomendasikan menggunakan variabel lokal kedua yang diberi nama indexuntuk memaksimalkan pemahaman bacaan ( dengan biaya runtime minimal juga, saya perhatikan):

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

Tetapi jika Anda benar-benar ingin mengurangi ungkapan ini, karena Anda kejam dan sadis bagi rekan kerja atau kolaborator proyek Anda, berikut adalah 4 pendekatan yang dapat Anda gunakan:

1: Variabel sementara dalam sebuah varpernyataan

Anda dapat menggunakan kemampuan varpernyataan untuk mendefinisikan (dan menetapkan) variabel sementara kedua indexketika dipisahkan dengan koma:

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

2: Fungsi anonim yang dijalankan sendiri

Opsi lainnya adalah fungsi anonim yang dijalankan sendiri:

// 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 koma

Ada juga "operator koma" terkenal yang didukung JavaScript, yang juga ada dalam C dan C ++.

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

Anda dapat menggunakan operator koma saat Anda ingin menyertakan beberapa ekspresi di lokasi yang membutuhkan ekspresi tunggal.

Anda dapat menggunakannya untuk menimbulkan efek samping, dalam hal ini dengan menetapkan kembali ke value:

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

Ini berfungsi karena var valuediinterpretasikan terlebih dahulu (sebagai pernyataan), laluvalue penugasan paling kiri, paling dalam , dan kemudian operator koma sebelah kanan, lalu operator terner - semua JavaScript legal.

4: Tetapkan ulang dalam subekspresi

Komentator @IllusiveBrian menunjukkan bahwa penggunaan operator koma (dalam contoh sebelumnya) tidak diperlukan jika penugasan ke valuedigunakan sebagai subekspresi dalam tanda kurung:

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

Perhatikan bahwa penggunaan negatif dalam ekspresi logika bisa lebih sulit diikuti oleh manusia - jadi semua contoh di atas dapat disederhanakan untuk dibaca dengan mengubah idx !== -1 ? x : yke idx == -1 ? y : x:

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

Untuk angka

Anda dapat menggunakan Math.max()fungsinya.

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

Ini akan membuat batasan hasil dari 0sampai hasil pertama lebih besar daripada 0jika itu masalahnya. Dan jika hasilnya indexOfadalah -1itu akan mengembalikan 0 as lebih besar dari -1.

Untuk nilai boolean dan boolean-y

Untuk JS tidak ada aturan umum AFAIK khusus karena bagaimana falsy nilai-nilai dievaluasi.

Tetapi jika sesuatu yang dapat membantu Anda sebagian besar waktu adalah atau operator ( ||):

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

Anda harus sangat berhati-hati dengan hal ini, karena dalam contoh pertama Anda, indexOfdapat kembali 0dan jika Anda mengevaluasi 0 || -1itu akan kembali -1karena 0merupakan falsy nilai.

Tidak juga, gunakan saja variabel lain.

Contoh Anda menggeneralisasi sesuatu seperti ini.

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

Anda menguji nilai yang dihitung, lalu menetapkan nilai itu ke variabel jika melewati beberapa predikat. Cara untuk menghindari penghitungan ulang nilai yang dihitung sudah jelas: gunakan variabel untuk menyimpan hasilnya.

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

Saya mengerti maksud Anda - sepertinya harus ada cara untuk melakukan ini yang terlihat sedikit lebih bersih. Tapi saya pikir itulah cara terbaik (secara idiomatis) untuk melakukan ini. Jika Anda sering mengulangi pola ini dalam kode Anda karena suatu alasan, Anda mungkin menulis sedikit fungsi pembantu:

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

EDIT: Ini dia, proposal untuk penggabungan Nullary sekarang dalam JavaScript!

Menggunakan ||

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

setara dengan

const result = a || 'fallback value';

Jika casting auntuk Booleankembali false, resultakan diberikan 'fallback value', jika tidak nilai a.

Waspadai kasus edge a === 0, yang di-cast ke falsedan resultakan (salah) ambil 'fallback value'. Gunakan trik seperti ini dengan risiko Anda sendiri.

PS. Bahasa seperti Swift memiliki operator penggabung nil ( ??), yang memiliki tujuan serupa. Misalnya, di Swift Anda akan menulis result = a ?? "fallback value"yang sangat mirip dengan JavaScriptconst result = a || 'fallback value';

Gunakan pemfaktoran ulang variabel ekstrak :

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

Bahkan lebih baik dengan constdaripada var. Anda juga bisa melakukan ekstraksi tambahan:

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

Dalam prakteknya, menggunakan nama yang lebih bermakna dari index, condition, dan value.

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

Anda mungkin mencari operator penggabungan. Untungnya, kami dapat memanfaatkan Arrayprototipe untuk membuatnya:

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

Ini bisa digeneralisasikan lebih lanjut untuk kasus Anda, dengan menambahkan parameter ke fungsi:

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

Saya pribadi lebih suka dua varian:

1. Murni jika, seperti saran @slebetman

2. Fungsi terpisah, yang menggantikan nilai yang tidak valid dengan yang default, seperti dalam contoh ini:

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

Saya suka jawaban @ slebetman. Komentar di bawahnya mengungkapkan kekhawatiran tentang variabel yang berada dalam "status perantara". jika ini adalah masalah besar bagi Anda, saya sarankan untuk merangkumnya dalam sebuah fungsi:

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

Kalau begitu telepon saja

var value = get_value( someArray );

Anda dapat melakukan lebih banyak fungsi umum jika Anda memiliki kegunaan untuk fungsi tersebut di tempat lain, tetapi jangan melakukan rekayasa berlebihan jika itu kasus yang sangat spesifik.

Tapi jujur ​​saya hanya akan melakukan sebagai @slebetman kecuali saya perlu menggunakan kembali dari beberapa tempat.

Ada dua cara yang dapat saya lihat dalam melihat pertanyaan Anda: Anda ingin mengurangi panjang baris, atau Anda secara khusus ingin menghindari pengulangan variabel dalam terner. Yang pertama sepele (dan banyak pengguna lain telah memposting contoh):

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

dapat (dan seharusnya, diberikan pemanggilan fungsi) dipersingkat seperti:

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

Jika Anda mencari solusi yang lebih umum yang mencegah pengulangan variabel dalam terner, seperti:

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

dimana foohanya muncul sekali. Membuang solusi dalam bentuk:

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

karena secara teknis benar tetapi melewatkan intinya, maka Anda kurang beruntung. Ada operator, fungsi, dan metode yang memiliki sintaks singkat yang Anda cari, tetapi konstruksi seperti itu, menurut definisi, tidak operator terner .

Contoh:

javascript, gunakan ||untuk mengembalikan RHS saat LHS adalah falsey:

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

Gunakan fungsi helper:

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

Sekarang kode Anda sangat mudah dibaca, dan tidak ada pengulangan.

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

Hierarki masalah pengkodean adalah:

1. Benar (termasuk kinerja sebenarnya atau masalah SLA)
2. Bersih
3. Ringkas
4. Cepat

Sejauh ini semua jawaban di halaman tampaknya benar, tetapi menurut saya versi saya memiliki kejelasan tertinggi, yang lebih penting daripada ringkasan. Jika Anda tidak menghitung fungsi helper — karena dapat digunakan kembali — ini juga yang paling ringkas. Saran yang agak mirip untuk menggunakan fungsi helper sayangnya menggunakan lambda yang, bagi saya, hanya mengaburkan apa yang dilakukannya. Fungsi yang lebih sederhana dengan satu tujuan yang tidak menggunakan lambda, hanya nilai, bagi saya jauh lebih baik.

PS Jika Anda menyukai sintaks ES6:

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

Saya pikir ||operator dapat disesuaikan dengan indexOf:

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

Nilai yang dikembalikan digeser ke atas sebesar 1, menghasilkan 0 dari -1, yang merupakan falsey dan oleh karena itu akan digantikan oleh nilai 1. Kemudian digeser kembali.

Namun, harap diingat bahwa keterbacaan lebih baik daripada menghindari pengulangan.

Ini adalah solusi sederhana dengan bitwise NOT dan nilai default -1yang hasilnya nanti nol.

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

Ini bekerja pada dasarnya dengan bitwise NOT ganda, yang mengembalikan nilai asli atau nilai default, yang setelah menerapkan bitwise NOT mengembalikan nol.

Mari kita lihat tabel kebenaran:

 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

Anda bisa menggunakan penugasan ulang:

• menginisialisasi variabel ke satu nilai
• gunakan serialisasi &&operator untuk penugasan ulang, karena jika kondisi pertama salah, ekspresi kedua tidak akan dievaluasi

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

Mengingat kode contoh di Question, tidak jelas bagaimana cara menentukannya 3 ini atau tidak diatur pada indeks 0dari someArray. -1dikembalikan dari .indexOf()akan menjadi berharga dalam hal ini, untuk tujuan mengecualikan non-pertandingan yang dianggap cocok.

Jika 3tidak termasuk dalam array, -1akan dikembalikan. Kita bisa menambahkan 1ke hasil .indexOf()untuk mengevaluasi sebagai falsehasil -1, di mana diikuti oleh || ORoperator dan0 . Jika valuedireferensikan, kurangi 1untuk mendapatkan indeks elemen array atau -1.

Yang mengarah kembali ke hanya menggunakan .indexOf()dan memeriksa -1pada suatu ifkondisi. Atau, mendefinisikan valuesebagai undefineduntuk menghindari kemungkinan kebingungan dengan hasil yang sebenarnya dari kondisi dievaluasi berkaitan dengan referensi asli.

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

Terner itu seperti jika-lain, jika Anda tidak membutuhkan bagian lain, mengapa tidak hanya satu jika saja ..

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

Untuk kasus khusus ini, Anda dapat menggunakan hubungan arus pendek dengan ||operator logika . Sebagai 0dianggap falsy, Anda dapat menambahkan 1ke indeks, sehingga, jika index+1ini 0maka Anda akan mendapatkan sisi kanan dari hasil Anda logis-atau, jika tidak, Anda akan mendapatkan Anda index+1. Karena hasil yang Anda inginkan diimbangi 1, Anda kemudian dapat menguranginya 1untuk mendapatkan indeks Anda:

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