Bagaimana cara memeriksa variabel yang tidak terdefinisi atau nol dalam JavaScript?

Kami sering menggunakan pola kode berikut dalam kode JavaScript kami

if (typeof(some_variable) != 'undefined' && some_variable != null)
{
    // Do something with some_variable
}

Apakah ada cara pengecekan yang memiliki efek yang sama?

Menurut beberapa forum dan literatur, hanya mengatakan berikut ini harus memiliki efek yang sama.

if (some_variable)
{
    // Do something with some_variable
}

Sayangnya, Firebug mengevaluasi pernyataan seperti itu sebagai kesalahan saat runtime ketika some_variabletidak terdefinisi, sedangkan yang pertama baik-baik saja untuk itu. Apakah ini hanya perilaku Firebug (yang tidak diinginkan) atau apakah memang ada perbedaan antara kedua cara itu?

Anda harus membedakan antara kasus:

1. Variabel dapat undefinedatau tidak dideklarasikan . Anda akan mendapatkan kesalahan jika Anda mengakses variabel yang tidak dideklarasikan dalam konteks apa pun selain typeof.

if(typeof someUndeclaredVar == whatever) // works
if(someUndeclaredVar) // throws error

Variabel yang telah dideklarasikan tetapi tidak diinisialisasi adalah undefined.

let foo;
if (foo) //evaluates to false because foo === undefined

2. Properti tidak terdefinisi , seperti someExistingObj.someUndefProperty. Properti tidak terdefinisi tidak menghasilkan kesalahan dan hanya mengembalikan undefined, yang, ketika dikonversi menjadi boolean, dievaluasi menjadi false. Jadi, jika Anda tidak peduli 0dan false, menggunakan if(obj.undefProp)tidak apa-apa. Ada idiom umum berdasarkan fakta ini:

   value = obj.prop || defaultValue

   yang berarti "jika objmemiliki properti prop, tetapkan ke value, atau tetapkan nilai defaultdefautValue ".

   Beberapa orang menganggap perilaku ini membingungkan, dengan alasan bahwa ini mengarah pada kesalahan yang sulit ditemukan dan merekomendasikan untuk menggunakan inoperator sebagai gantinya

   value = ('prop' in obj) ? obj.prop : defaultValue

Saya pikir cara paling efisien untuk menguji "nilai adalah nullatau undefined" adalah

if ( some_variable == null ){
  // some_variable is either null or undefined
}

Jadi dua baris ini setara:

if ( typeof(some_variable) !== "undefined" && some_variable !== null ) {}
if ( some_variable != null ) {}

Catatan 1

Seperti disebutkan dalam pertanyaan, varian pendek mengharuskan yang some_variabletelah dinyatakan, jika tidak ReferenceError akan dibuang. Namun dalam banyak kasus penggunaan Anda dapat menganggap bahwa ini aman:

periksa argumen opsional:

function(foo){
    if( foo == null ) {...}

periksa properti pada objek yang ada

if(my_obj.foo == null) {...}

Di sisi lain typeofdapat menangani variabel global yang tidak dideklarasikan (hanya mengembalikan undefined). Namun kasus-kasus ini harus dikurangi seminimal mungkin untuk alasan yang baik, seperti dijelaskan Alsciende.

Catatan 2

Varian ini - bahkan lebih pendek - tidak setara:

if ( !some_variable ) {
  // some_variable is either null, undefined, 0, NaN, false, or an empty string
}

begitu

if ( some_variable ) {
  // we don't get here if some_variable is null, undefined, 0, NaN, false, or ""
}

Catatan 3

Secara umum disarankan untuk menggunakan ===bukan ==. Solusi yang diusulkan adalah pengecualian untuk aturan ini. The JSHint sintaks checker bahkan menyediakan eqnullpilihan untuk alasan ini.

Dari panduan gaya jQuery :

Pemeriksaan kesetaraan yang ketat (===) harus digunakan untuk ==. Satu-satunya pengecualian adalah ketika memeriksa tidak terdefinisi dan null dengan nol.

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

Memeriksa null dengan persamaan normal juga akan mengembalikan true untuk undefined.

if (window.variable == null) alert('variable is null or undefined');

Dalam standar JavaScript yang lebih baru seperti ES5 dan ES6 bisa Anda katakan

> Boolean(0) //false
> Boolean(null)  //false
> Boolean(undefined) //false

semua return false, yang mirip dengan pemeriksaan Python tentang variabel kosong. Jadi jika Anda ingin menulis logika kondisional di sekitar variabel, katakan saja

if (Boolean(myvar)){
   // Do something
}

di sini "null" atau "string kosong" atau "tidak terdefinisi" akan ditangani secara efisien.

Jika Anda mencoba dan mereferensikan variabel yang tidak dideklarasikan, kesalahan akan terjadi pada semua implementasi JavaScript.

Properti objek tidak tunduk pada kondisi yang sama. Jika properti objek belum ditentukan, kesalahan tidak akan terjadi jika Anda mencoba dan mengaksesnya. Jadi dalam situasi ini Anda dapat mempersingkat:

 if (typeof(myObj.some_property) != "undefined" && myObj.some_property != null)

untuk

if (myObj.some_property != null)

Dengan mengingat hal ini, dan fakta bahwa variabel global dapat diakses sebagai properti dari objek global ( windowdalam hal browser), Anda dapat menggunakan yang berikut untuk variabel global:

if (window.some_variable != null) {
    // Do something with some_variable
}

Dalam lingkup lokal, selalu berguna untuk memastikan variabel dideklarasikan di bagian atas blok kode Anda, ini akan menghemat penggunaan berulang typeof.

Pertama, Anda harus sangat jelas tentang apa yang Anda uji. JavaScript memiliki semua jenis konversi implisit untuk membuat Anda marah, dan dua jenis pembanding kesetaraan: ==dan ===.

Suatu fungsi, test(val)yang menguji nullatau undefinedharus memiliki karakteristik berikut:

 test(null)         => true
 test(undefined)    => true
 test(0)            => false
 test(1)            => false
 test(true)         => false
 test(false)        => false
 test('s')          => false
 test([])           => false

Mari kita lihat ide mana di sini yang benar-benar lulus dari tes kami.

Pekerjaan ini:

val == null
val === null || val === undefined
typeof(val) == 'undefined' || val == null
typeof(val) === 'undefined' || val === null

Ini tidak berfungsi:

typeof(val) === 'undefined'
!!val

Saya membuat entri jsperf untuk membandingkan kebenaran dan kinerja dari pendekatan ini. Hasil tidak meyakinkan untuk saat ini karena belum ada cukup berjalan di berbagai browser / platform. Silakan luangkan waktu sebentar untuk menjalankan tes di komputer Anda!

Saat ini, tampaknya val == nulltes sederhana memberikan kinerja terbaik. Ini juga yang terpendek. Tes dapat dinegasikan ke val != nulljika Anda ingin melengkapi.

ini adalah satu-satunya kasus yang ==harus digunakan:

if (val == null) console.log('val is null or undefined')

Karena tidak ada jawaban yang lengkap dan benar, saya akan mencoba merangkum:

Secara umum, ungkapan:

if (typeof(variable) != "undefined" && variable != null)

tidak dapat disederhanakan, karena variablemungkin tidak dideklarasikan sehingga menghilangkan typeof(variable) != "undefined"akan menghasilkan ReferenceError. Tetapi, Anda dapat menyederhanakan ekspresi sesuai dengan konteksnya :

Jika variableadalah dunia , Anda dapat menyederhanakan ke:

if (window.variable != null)

Jika bersifat lokal , Anda mungkin dapat menghindari situasi ketika variabel ini tidak dideklarasikan, dan juga menyederhanakan untuk:

if (variable != null)

Jika memang properti objek , Anda tidak perlu khawatir tentang ReferenceError:

if (obj.property != null)

Anda bisa memeriksa apakah variabel memiliki nilai atau tidak. Berarti,

if( myVariable ) {
//mayVariable is not :
//null
//undefined
//NaN
//empty string ("")
//0
//false

}

Jika Anda tidak tahu apakah ada variabel (artinya, jika dideklarasikan), Anda harus memeriksa dengan typeof operator. misalnya

if( typeof myVariable !== 'undefined' ) {
    // myVariable will get resolved and it is defined
}

Saya telah melakukan ini dengan menggunakan metode ini

simpan id dalam beberapa variabel

var someVariable = document.getElementById("someId");

kemudian gunakan jika kondisinya

if(someVariable === ""){
 //logic
} else if(someVariable !== ""){
 //logic
}

Ini adalah contoh acara yang sangat langka di mana dianjurkan untuk digunakan ==sebagai gantinya ===. Ekspresi somevar == nullakan mengembalikan true untuk undefineddan null, tetapi false untuk yang lainnya (kesalahan jika variabel tidak dideklarasikan).

Menggunakan !=akan membalik hasilnya, seperti yang diharapkan.

Editor modern tidak akan memperingatkan untuk menggunakan ==atau !=dengan operator null, karena ini hampir selalu perilaku yang diinginkan.

Perbandingan paling umum:

undeffinedVar == null     // true
obj.undefinedProp == null // true
null == null              // true
0 == null                 // false
'0' == null               // false
'' == null                // false

Cobalah sendiri:

let undefinedVar;
console.table([
    { test : undefinedVar,     result: undefinedVar     == null },
    { test : {}.undefinedProp, result: {}.undefinedProp == null },
    { test : null,             result: null             == null },
    { test : false,            result: false            == null },
    { test : 0,                result: 0                == null },
    { test : '',               result: ''               == null },
    { test : '0',              result: '0'              == null },
]);

Seperti yang disebutkan dalam salah satu jawaban, Anda bisa beruntung jika Anda berbicara tentang variabel yang memiliki cakupan global. Seperti yang Anda ketahui, variabel yang Anda tetapkan secara global cenderung ditambahkan ke objek windows. Anda dapat mengambil keuntungan dari fakta ini jadi katakanlah Anda sedang mengakses variabel yang disebut bleh, cukup gunakan operator pembalik ganda (!!)

!!window['bleh'];

Ini akan menghasilkan false sementara bleh belum dinyatakan DAN diberi nilai.

inilah cara lain menggunakan metode Array mencakup () :

[undefined, null].includes(value)

apa pun yyy Anda tidak terdefinisi atau nol, itu akan mengembalikan true

if (typeof yyy == 'undefined' || !yyy) {
    console.log('yes');
} else {
    console.log('no');
}

Iya

if (!(typeof yyy == 'undefined' || !yyy)) {
    console.log('yes');
} else {
    console.log('no');
}

tidak

Buka alat Pengembang di browser Anda dan coba saja kode yang ditunjukkan pada gambar di bawah ini.

Untuk memahami, Mari kita menganalisis apa yang akan menjadi nilai yang dikembalikan oleh Javascript Engine ketika mengkonversi undefined, null, dan '' (An string kosong juga). Anda dapat langsung memeriksa yang sama di konsol pengembang Anda.

Anda dapat melihat semua konversi menjadi false, artinya ketiganya menganggap 'tidak adanya' dengan javascript. Jadi, Anda tidak perlu memeriksa ketiganya secara eksplisit dalam kode Anda seperti di bawah ini.

if (a === undefined || a === null || a==='') {
    console.log("Nothing");
} else {
    console.log("Something");
}

Saya juga ingin menunjukkan satu hal lagi.

Apa yang akan menjadi hasil dari Boolean (0)?

Tentu saja salah. Ini akan membuat bug dalam kode Anda ketika 0 adalah nilai yang valid dalam hasil yang Anda harapkan. Jadi pastikan Anda memeriksa ini ketika Anda menulis kode.

Mirip dengan apa yang Anda miliki, Anda dapat melakukan sesuatu seperti

if (some_variable === undefined || some_variable === null) { do stuff }

Pengujian nullity ( if (value == null)) atau non-nullity ( if (value != null)) kurang verbose daripada pengujian status definisi variabel.

Selain itu, pengujian if (value)(atau if( obj.property)) untuk memastikan keberadaan variabel Anda (atau properti objek) gagal jika didefinisikan dengan falsenilai boolean . Kaisar peringatan :)

Kedua nilai dapat dengan mudah dibedakan dengan menggunakan operator perbandingan ketat:

Contoh kerja di:

http://www.thesstech.com/tryme?filename=nullandundefined

Kode sampel:

function compare(){
    var a = null; //variable assigned null value
    var b;  // undefined
    if (a === b){
        document.write("a and b have same datatype.");
    }
    else{
        document.write("a and b have different datatype.");
    }   
}

Jika tujuan pernyataan if adalah untuk memeriksa nullatau undefinedmenilai sebelum memberikan nilai ke variabel, Anda dapat menggunakan Operator Nullish Coalescing , akhirnya tersedia di JavaScript, meskipun dukungan browser terbatas. Menurut data dari caniuse , hanya 48,34% browser yang didukung (per April 2020).

const a = some_variable ?? '';

Ini akan memastikan bahwa variabel akan ditugaskan ke string kosong (atau nilai default lainnya) jika some_variableada nullatau undefined.

Operator ini paling cocok untuk kasus penggunaan Anda, karena tidak mengembalikan nilai default untuk jenis nilai falsy lainnya seperti 0dan ''.

Anda harus mendefinisikan fungsi dari formulir ini:

validate = function(some_variable){
    return(typeof(some_variable) != 'undefined' && some_variable != null)
}

Dalam ES5 atau ES6 jika Anda perlu memeriksanya beberapa kali, Anda dapat melakukannya:

const excluded = [null, undefined, ''];

if (!exluded.includes(varToCheck) {
  // it will bee not null, not undefined and not void string
}

Dengan Ramda, Anda cukup melakukan R.isNil(yourValue) Lodash dan perpustakaan pembantu lainnya memiliki fungsi yang sama.