boolean dalam pernyataan if

Hari ini saya mendapat komentar tentang kode mengingat cara saya memeriksa apakah variabel benar atau salah dalam tugas sekolah.

Kode yang saya tulis kira-kira seperti ini:

var booleanValue = true;

function someFunction(){
    if(booleanValue === true){
        return "something";
    }
}

Mereka mengatakan lebih baik / rapi menulis seperti ini:

var booleanValue = true;

function someFunction(){
    if(booleanValue){
        return "something";
    }
}

Pernyataan yang saya dapatkan tentang bagian "=== true" adalah bahwa itu tidak diperlukan dan dapat membuat kebingungan.

Namun ide saya adalah bahwa lebih baik untuk memeriksa apakah variabel tersebut boolean atau tidak, terutama karena Javascript adalah bahasa loosetyped.

Dalam contoh kedua string juga akan mengembalikan "sesuatu";

Jadi pertanyaan saya; Apakah lebih baik kehilangan bagian "=== true" di masa depan, atau apakah itu praktik yang baik untuk memeriksa jenis variabel juga.

Sunting: Dalam kode "asli" saya, boolean menunjukkan apakah suatu gambar telah dihapus atau tidak, jadi satu-satunya nilai yang harus dimiliki boolValue adalah benar atau salah.

0 dan 1 misalnya tidak boleh dalam variabel itu.

Pertama, fakta:

if (booleanValue)

Akan memenuhi ifpernyataan untuk setiap nilai kebenaran booleanValuetermasuk true, setiap angka tidak nol, nilai string tidak kosong, objek atau array array apa pun, dll ...

Di samping itu:

if (booleanValue === true)

Ini hanya akan memenuhi ifkondisi jika booleanValuesama persis dengan true. Tidak ada nilai kebenaran lain yang akan memuaskannya.

Di sisi lain jika Anda melakukan ini:

if (someVar == true)

Lalu, apa yang akan dilakukan Javascript adalah mengetikkan koersi trueagar sesuai dengan tipe someVardan kemudian membandingkan kedua variabel tersebut. Ada banyak situasi di mana ini kemungkinan tidak sesuai dengan keinginan seseorang. Karena itu, dalam kebanyakan kasus Anda ingin menghindari ==karena ada seperangkat aturan yang cukup panjang tentang bagaimana Javascript akan mengetik memaksa dua hal menjadi jenis yang sama dan kecuali Anda memahami semua aturan itu dan dapat mengantisipasi segala sesuatu yang mungkin dilakukan penerjemah JS ketika diberikan dua jenis berbeda (yang sebagian besar pengembang JS tidak bisa), Anda mungkin ingin menghindari ==seluruhnya.

Sebagai contoh betapa membingungkannya hal itu:

var x;

x = 0;
console.log(x == true);   // false, as expected
console.log(x == false);  // true as expected

x = 1;
console.log(x == true);   // true, as expected
console.log(x == false);  // false as expected

x = 2;
console.log(x == true);   // false, ??
console.log(x == false);  // false 

Untuk nilainya 2, Anda akan berpikir bahwa itu 2adalah nilai yang sebenarnya sehingga akan lebih baik dibandingkan true, tetapi itu bukanlah cara kerja paksaan tipe. Ini mengonversi nilai tangan kanan untuk mencocokkan jenis nilai tangan kiri sehingga mengkonversi trueke angka 1sehingga itu membandingkan 2 == 1yang tentu saja bukan yang Anda inginkan.

Jadi, pembeli berhati-hatilah. Kemungkinan besar untuk menghindari ==dalam hampir semua kasus kecuali jika Anda secara eksplisit tahu jenis yang akan Anda bandingkan dan tahu bagaimana semua jenis algoritma pemaksaan bekerja.

Jadi, itu benar-benar tergantung pada nilai-nilai yang diharapkan booleanValuedan bagaimana Anda ingin kode berfungsi. Jika Anda tahu sebelumnya bahwa itu hanya pernah akan memiliki trueatau falsenilai, kemudian membandingkannya secara eksplisit dengan

if (booleanValue === true)

hanya kode tambahan dan tidak perlu dan

if (booleanValue)

lebih kompak dan bisa dibilang lebih bersih / lebih baik.

Sebaliknya, jika Anda tidak tahu apa yang booleanValuemungkin terjadi dan ingin menguji apakah benar-benar diatur truetanpa konversi tipe otomatis lainnya diizinkan, maka

if (booleanValue === true)

bukan hanya ide yang bagus, tetapi juga dibutuhkan.

Misalnya, jika Anda melihat implementasi .on()di jQuery, ia memiliki nilai pengembalian opsional. Jika panggilan balik kembali false, maka jQuery akan secara otomatis menghentikan penyebaran acara. Dalam kasus khusus ini, karena jQuery ingin propagasi berhenti hanya jika falsedikembalikan, mereka memeriksa nilai kembali eksplisit untuk === falsekarena mereka tidak ingin undefinedatau 0atau ""atau apa pun yang akan secara otomatis ketik-convert ke false untuk juga memenuhi perbandingan.

Misalnya, inilah acara jQuery yang menangani kode panggilan balik:

ret = ( specialHandle || handleObj.handler ).apply( matched.elem, args );

if ( ret !== undefined ) {
     event.result = ret;
     if ( ret === false ) {
         event.preventDefault();
         event.stopPropagation();
     }
 }

Anda dapat melihat bahwa jQuery mencari secara eksplisit ret === false.

Tapi, ada juga banyak tempat lain di kode jQuery di mana pemeriksaan yang lebih sederhana sesuai diberikan keinginan kode. Sebagai contoh:

// The DOM ready check for Internet Explorer
function doScrollCheck() {
    if ( jQuery.isReady ) {
        return;
    }
    ...

Jika Anda menulis:, if(x === true)Ini hanya berlaku untuk x = true

Jika Anda menulis:, if(x)itu akan benar untuk setiap x yang bukan: '' (string kosong), false, null, undefined, 0, NaN.

Dalam "jika" variabel akan dipaksa ke Boolean dan menggunakan toBoolean pada objek: -

    Argument Type   Result

    Undefined       false
    Null            false
    Boolean         The result equals the input argument (no conversion).
    Number          The result is false if the argument is +0, −0, or NaN;
                    otherwise the result is true.
    String          The result is false if the argument is the empty 
                    String (its length is zero); otherwise the result is true.
    Object          true.

Tetapi perbandingan dengan === tidak memiliki paksaan tipe apa pun, jadi mereka harus sama tanpa paksaan.

Jika Anda mengatakan bahwa objek tersebut mungkin bukan Boolean maka Anda mungkin harus mempertimbangkan lebih dari sekadar benar / salah.

if(x===true){
...
} else if(x===false){
....
} else {
....
}

Itu tergantung pada usecase Anda. Mungkin masuk akal untuk memeriksa jenisnya juga, tetapi jika itu hanya sebuah bendera, itu tidak benar.

Secara umum, lebih bersih dan sederhana untuk menghilangkan === true.

Namun, dalam Javascript, pernyataan tersebut berbeda.

if (booleanValue)akan mengeksekusi jika booleanValueadalah truthy - apa pun selain 0, false, '', NaN, null, dan undefined.

if (booleanValue === true)hanya akan mengeksekusi jika booleanValuesama dengan true.

(===)Operator identitas berperilaku identik dengan (==)operator persamaan kecuali tidak ada konversi jenis dilakukan, dan jenis harus sama agar dianggap sama.

Karena nilai yang dicentang Booleanitu lebih disukai untuk menggunakannya secara langsung untuk lebih sedikit pengkodean dan sama sekali melakukan hal yang sama==true

Karena Anda sudah diinisialisasi dengan jelas sebagai bool, saya pikir ===operator tidak diperlukan.

Jika variabel hanya bisa mengambil nilai boolean, maka masuk akal untuk menggunakan sintaks yang lebih pendek.

Jika berpotensi dapat ditugaskan jenis lain, dan Anda perlu membedakan truedari 1atau "foo", maka Anda harus menggunakannya === true.

Saya pikir alasan Anda masuk akal. Tetapi dalam praktiknya saya telah menemukan bahwa jauh lebih umum untuk menghilangkan ===perbandingan. Saya pikir ada tiga alasan untuk itu:

1. Biasanya tidak menambah makna ungkapan - itu dalam kasus-kasus di mana nilainya dikenal sebagai boolean.
2. Karena ada banyak ketidakpastian jenis dalam JavaScript, pemaksaan pemeriksaan jenis cenderung menggigit Anda saat Anda mendapat nilai undefinedatau nullnilai tak terduga . Seringkali Anda hanya ingin tes Anda gagal dalam kasus seperti itu. (Meskipun saya mencoba menyeimbangkan pandangan ini dengan moto "gagal cepat").
3. Programmer JavaScript suka bermain cepat dan longgar dengan tipe - terutama dalam ekspresi boolean - karena kita bisa.

Pertimbangkan contoh ini:

var someString = getInput();
var normalized = someString && trim(someString);  
// trim() removes leading and trailing whitespace

if (normalized) {
    submitInput(normalized);
}

Saya pikir kode semacam ini tidak jarang. Ini menangani kasus di mana getInput()pengembalian undefined, nullatau string kosong. Karena dua evaluasi boolean submitInput()hanya dipanggil jika input yang diberikan adalah string yang berisi karakter non-spasi.

Dalam JavaScript &&mengembalikan argumen pertama jika itu salah atau argumen kedua jika argumen pertama adalah benar; begitu normalizedjuga undefinedjika someStringtidak ditentukan dan sebagainya. Itu berarti bahwa tidak ada input ke ekspresi boolean di atas sebenarnya nilai boolean.

Saya tahu bahwa banyak programmer yang terbiasa dengan jenis ngeri yang kuat ketika melihat kode seperti ini. Tetapi catatan menerapkan pengetikan yang kuat kemungkinan akan membutuhkan pemeriksaan eksplisit untuk nullatauundefined nilai yang , yang akan mengacaukan kode. Dalam JavaScript itu tidak diperlukan.

Ini tergantung. Jika Anda khawatir bahwa variabel Anda bisa berakhir sebagai sesuatu yang berubah menjadi BENAR. Maka memeriksa sulit adalah suatu keharusan. Kalau tidak, itu terserah Anda. Namun, saya ragu bahwa sintaks whatever == TRUEakan pernah membingungkan siapa pun yang tahu apa yang mereka lakukan.

Dalam Javascript ide boolean cukup ambigu. Pertimbangkan ini:

 var bool = 0 
 if(bool){..} //evaluates to false

 if(//uninitialized var) //evaluates to false

Jadi ketika Anda menggunakan pernyataan if, (atau pernyataan kontrol lainnya), seseorang tidak harus menggunakan var tipe "boolean". Oleh karena itu, menurut pendapat saya, bagian "=== true" dari pernyataan Anda tidak perlu jika Anda tahu itu boolean, tetapi benar-benar diperlukan jika nilai Anda adalah var "kebenaran" yang ambigu. Lebih lanjut tentang boolean di javascript dapat ditemukan di sini .

Revisa https://www.w3schools.com/js/js_comparisons.asp

contoh:

var p=5;

p==5 ? true
p=="5" ?  true
p==="5" ? false

=== Berarti jenis yang sama juga nilai yang sama == hanya nilai yang sama

Juga dapat diuji dengan objek Boolean, jika Anda perlu menguji suatu objek error={Boolean(errors.email)}