Metode pengecekan apakah variabel yang telah diinisialisasi lebih baik / benar? (Dengan asumsi variabel dapat menampung apa saja (string, int, objek, fungsi, dll.))

if (elem) { // or !elem

atau

if (typeof(elem) !== 'undefined') {

atau

if (elem != null) {

Anda ingin yang typeofOperator . Secara khusus:

if (typeof variable !== 'undefined') {
    // the variable is defined
}

The typeofOperator akan memeriksa apakah variabel tersebut benar-benar tidak terdefinisi.

if (typeof variable === 'undefined') {
    // variable is undefined
}

The typeofoperator, tidak seperti operator lain, tidak melempar ReferenceError pengecualian ketika digunakan dengan variabel dideklarasikan.

Namun, harap diperhatikan bahwa typeof nullakan kembali "object". Kita harus berhati-hati untuk menghindari kesalahan menginisialisasi variabel null. Agar aman, ini yang bisa kita gunakan:

if (typeof variable === 'undefined' || variable === null) {
    // variable is undefined or null
}

Untuk info lebih lanjut tentang menggunakan perbandingan ketat, ===bukan kesetaraan sederhana ==, lihat: Operator
mana yang sama dengan (== vs ===) yang harus digunakan dalam perbandingan JavaScript?

Dalam banyak kasus, menggunakan:

if (elem) { // or !elem

akan melakukan pekerjaan untuk Anda! ... ini akan memeriksa kasus-kasus di bawah ini:

1. undefined : jika nilainya tidak ditentukan dan ituundefined
2. null : jika nol, misalnya, jika elemen DOM tidak ada ...
3. string kosong :''
4. 0 : angka nol
5. NaN : bukan angka
6. Salah

Jadi itu akan mencakup semua jenis kasus, tetapi selalu ada kasus aneh yang ingin kami bahas juga, misalnya, string dengan spasi, seperti ini ' ', ini akan didefinisikan dalam javascript karena memiliki spasi di dalam string ... misalnya dalam hal ini Anda menambahkan satu lagi cek menggunakan trim (), seperti:

if(elem) {

if(typeof elem === 'string' && elem.trim()) {
///

Juga, pemeriksaan ini hanya untuk nilai , karena objek dan array bekerja secara berbeda dalam Javascript, array []kosong dan objek kosong {}selalu benar .

Saya membuat gambar di bawah ini untuk menunjukkan jawaban singkatnya:

Dalam JavaScript, sebuah variabel dapat didefinisikan, tetapi memiliki nilainya undefined, sehingga jawaban yang paling umum tidak benar secara teknis, dan sebaliknya melakukan yang berikut:

if (typeof v === "undefined") {
   // no variable "v" is defined in the current scope
   // *or* some variable v exists and has been assigned the value undefined
} else {
   // some variable (global or local) "v" is defined in the current scope
   // *and* it contains a value other than undefined
}

Itu mungkin cukup untuk tujuan Anda. Tes berikut memiliki semantik yang lebih sederhana, yang membuatnya lebih mudah untuk menggambarkan perilaku kode Anda secara tepat dan memahaminya sendiri (jika Anda peduli tentang hal-hal seperti itu):

if ("v" in window) {
   // global variable v is defined
} else {
   // global variable v is not defined
}

Ini, tentu saja, mengasumsikan Anda berjalan di browser (di mana windowadalah nama untuk objek global). Tetapi jika Anda bercanda dengan global seperti ini, Anda mungkin berada di browser. Secara subyektif, penggunaan 'name' in windowkonsisten dengan gaya menggunakan window.nameuntuk merujuk ke global. Mengakses global sebagai properti dari windowbukan sebagai variabel memungkinkan Anda untuk meminimalkan jumlah variabel yang tidak dideklarasikan yang Anda referensi dalam kode Anda (untuk kepentingan linting), dan menghindari kemungkinan global Anda dibayangi oleh variabel lokal. Juga, jika global membuat kulit Anda merangkak, Anda mungkin merasa lebih nyaman menyentuhnya hanya dengan tongkat yang relatif panjang ini.

Dalam sebagian besar kasus, Anda akan menggunakan:

elem != null

Tidak seperti sederhana if (elem), memungkinkan 0, false, NaNdan '', tetapi menolak nullatau undefined, membuatnya menjadi baik, tes umum untuk kehadiran argumen, atau properti dari objek.

Pemeriksaan lainnya juga tidak salah, mereka hanya memiliki kegunaan yang berbeda:

• if (elem): Dapat digunakan jika elemdijamin menjadi objek, atau jika false, 0, dll dianggap "default" nilai-nilai (maka setara dengan undefinedatau null).

• typeof elem == 'undefined'dapat digunakan dalam kasus di mana yang ditentukan nullmemiliki arti berbeda dengan variabel atau properti yang tidak diinisialisasi.

  • Ini adalah satu-satunya pemeriksaan yang tidak akan menimbulkan kesalahan jika elemtidak dideklarasikan (yaitu tidak ada varpernyataan, bukan properti window, atau bukan argumen fungsi). Ini, menurut saya, agak berbahaya karena memungkinkan kesalahan pengetikan lewat tanpa diketahui. Untuk menghindari ini, lihat metode di bawah ini.

Juga bermanfaat adalah perbandingan ketat terhadap undefined:

if (elem === undefined) ...

Namun, karena global undefineddapat ditimpa dengan nilai lain, yang terbaik adalah mendeklarasikan variabel undefineddalam cakupan saat ini sebelum menggunakannya:

var undefined; // really undefined
if (elem === undefined) ...

Atau:

(function (undefined) {
    if (elem === undefined) ...
})();

Keuntungan sekunder dari metode ini adalah bahwa JS minifiers dapat mengurangi undefinedvariabel menjadi satu karakter, menghemat beberapa byte setiap kali.

Periksa apakah window. hasOwnProperty( " varname" )

Alternatif untuk kebanyakan typeofjawaban;

Variabel global dideklarasikan dengan var varname = value;pernyataan dalam lingkup global

dapat diakses sebagai properti dari objek jendela.

Karena itu, hasOwnProperty()metode, yang

mengembalikan boolean yang menunjukkan apakah objek memiliki properti yang ditentukan sebagai properti sendiri (sebagai lawan pewarisannya)

dapat digunakan untuk menentukan apakah

a vardari "varname" telah dinyatakan secara global yaitu merupakan properti dari window.

// Globally established, therefore, properties of window
var foo = "whatever", // string
    bar = false,      // bool
    baz;              // undefined
//  window.qux does not exist

console.log( [
    window.hasOwnProperty( "foo" ), // true
    window.hasOwnProperty( "bar" ), // true
    window.hasOwnProperty( "baz" ), // true
    window.hasOwnProperty( "qux" )  // false
] );

Apa yang hebat tentang hasOwnProperty() ini adalah bahwa dalam memanggilnya, kita tidak menggunakan variabel yang mungkin belum dideklarasikan - yang tentu saja merupakan setengah dari masalah.

Meskipun tidak selalu yang sempurna atau yang ideal , dalam keadaan tertentu, itu hanya pekerjaan!

Catatan

Di atas benar ketika menggunakan varuntuk mendefinisikan variabel , yang bertentangan dengan letyang:

mendeklarasikan variabel lokal ruang lingkup blok, secara opsional menginisialisasi nilai.

tidak seperti var kata kunci, yang mendefinisikan variabel secara global, atau secara lokal untuk seluruh fungsi terlepas dari ruang lingkup blok.

Di tingkat atas program dan fungsi let, tidak seperti var, tidak membuat properti pada objek global.

Untuk kelengkapan: const konstanta, menurut definisi, sebenarnya bukan variabel (walaupun isinya bisa); lebih relevan:

Konstanta global tidak menjadi properti objek jendela, tidak seperti varvariabel. Penginisialisasi untuk konstanta diperlukan; yaitu, Anda harus menentukan nilainya dalam pernyataan yang sama dengan yang dinyatakannya.

Nilai konstanta tidak dapat berubah melalui penugasan kembali, dan itu tidak dapat dideklarasikan ulang.

Deklarasi const menciptakan referensi read-only ke suatu nilai. Itu tidak berarti nilai yang dipegangnya tidak berubah, hanya saja pengenal variabel tidak dapat dipindahkan.

Karena letvariabel atau constkonstanta tidak pernah merupakan properti dari objek apa pun yang mewarisi hasOwnProperty()metode ini, maka variabel tersebut tidak dapat digunakan untuk memeriksa keberadaannya.

Mengenai ketersediaan dan penggunaan hasOwnProperty():

Setiap objek yang diturunkan dari Object mewarisi hasOwnProperty()metode ini. [...] tidak seperti inoperator, metode ini tidak memeriksa rantai prototipe objek.

Cara memeriksa apakah ada variabel

Ini adalah solusi yang cukup anti peluru untuk pengujian jika ada variabel dan telah diinisialisasi:

var setOrNot = typeof variable !== typeof undefined;

Ini paling sering digunakan dalam kombinasi dengan operator ternary untuk menetapkan default jika variabel tertentu belum diinisialisasi:

var dark = typeof darkColor !== typeof undefined ? darkColor : "black";

Masalah dengan enkapsulasi

Sayangnya, Anda tidak bisa hanya merangkum cek Anda dalam suatu fungsi.

Anda mungkin berpikir untuk melakukan sesuatu seperti ini:

function isset(variable) {
    return typeof variable !== typeof undefined;
}

Namun, ini akan menghasilkan kesalahan referensi jika Anda menelepon mis. isset(foo)dan variabel foobelum didefinisikan, karena Anda tidak bisa meneruskan variabel yang tidak ada ke fungsi:

ReferenceError Uncaught: foo tidak didefinisikan

Menguji apakah parameter fungsi tidak terdefinisi

Sementara issetfungsi kami tidak dapat digunakan untuk menguji apakah suatu variabel ada atau tidak (karena alasan yang dijelaskan di atas), itu memungkinkan kami untuk menguji apakah parameter fungsi tidak terdefinisi:

var a = '5';

var test = function(x, y) {
    console.log(isset(x));
    console.log(isset(y));
};

test(a);

// OUTPUT :
// ------------
// TRUE
// FALSE

Meskipun tidak ada nilai untuk yditeruskan ke fungsi test, issetfungsi kami berfungsi dengan baik dalam konteks ini, karena ydikenal dalam fungsi testsebagai undefinednilai.

Ada cara pintas lain untuk memeriksa ini, ketika Anda melakukan tugas sederhana dan cek terkait. Cukup gunakan Operator Bersyarat (Ternary).

var values = typeof variable !== 'undefined' ? variable : '';

Ini juga akan sangat membantu, ketika Anda mencoba untuk mendeklarasikan variabel Global dengan penetapan instan variabel referensi.

Jika Anda ingin memeriksa variabel tidak boleh undefinedatau null. Kemudian lakukan pemeriksaan di bawah ini.

Ketika variabel dideklarasikan, dan jika Anda ingin memeriksa nilainya, ini bahkan sederhana: dan itu akan melakukan undefineddan nullmemeriksa bersama.

var values = variable ? variable : '';

Cara singkat untuk menguji suatu variabel tidak dinyatakan (tidak terdefinisi) adalah

if (typeof variable === "undefined") {
  ...
}

Saya merasa berguna untuk mendeteksi skrip yang berjalan di luar browser (tidak memiliki windowvariabel yang dideklarasikan ).

Itu tergantung jika Anda hanya peduli bahwa variabel telah didefinisikan atau jika Anda ingin memiliki nilai yang bermakna.

Memeriksa apakah tipe tidak terdefinisi akan memeriksa apakah variabel telah ditentukan.

=== nullatau !== nullhanya akan memeriksa apakah nilai variabel tepat null.

== nullatau != nullakan memeriksa apakah nilainya undefinedatau null.

if(value)akan memeriksa apakah variabel adalah undefined, null, 0, atau string kosong.

Jawaban tertinggi benar, gunakan typeof.

Namun, apa yang ingin saya tunjukkan adalah bahwa dalam JavaScript undefinedbisa berubah (untuk beberapa alasan fasik). Jadi, sekadar melakukan pemeriksaan varName !== undefinedmemiliki potensi untuk tidak selalu kembali seperti yang Anda harapkan, karena lib lain bisa berubah tidak terdefinisi. Beberapa jawaban (@ skalee, misalnya), tampaknya lebih suka tidak menggunakan typeof, dan itu bisa membuat masalah.

Cara "lama" untuk menangani hal ini adalah menyatakan tidak ditentukan sebagai var untuk mengimbangi potensi mutasi / over-riding undefined. Namun, cara terbaik masih digunakan typeofkarena akan mengabaikan pengesampingan dari undefinedkode lain. Terutama jika Anda menulis kode untuk digunakan di alam liar di mana siapa tahu apa lagi yang bisa berjalan di halaman ...

if (typeof console != "undefined") {    
   ...
}

Atau lebih baik

if ((typeof console == "object") && (typeof console.profile == "function")) {    
   console.profile(f.constructor);    
}

Bekerja di semua browser

Untuk berkontribusi dalam debat, jika saya tahu variabelnya harus berupa string atau objek yang selalu saya sukai if (!variable), jadi periksa apakah itu salah. Ini dapat membawa ke kode yang lebih bersih sehingga, misalnya:

if (typeof data !== "undefined" && typeof data.url === "undefined") {
    var message = 'Error receiving response';
    if (typeof data.error !== "undefined") {
        message = data.error;
    } else if (typeof data.message !== "undefined") {
        message = data.message;
    }
    alert(message); 
}

..dapat dikurangi menjadi:

if (data && !data.url) {
  var message = data.error || data.message || 'Error receiving response';
  alert(message)
} 

Sulit untuk membedakan antara undefined dan null. Null adalah nilai yang dapat Anda tetapkan ke variabel saat Anda ingin menunjukkan bahwa variabel tidak memiliki nilai tertentu. Undefined adalah nilai khusus yang akan menjadi nilai default dari variabel yang tidak ditetapkan.

var _undefined;
var _null = null;

alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

Null adalah nilai dalam JavaScript dan typeof nullkembali"object"

Karenanya, jawaban yang diterima tidak akan berfungsi jika Anda memberikan nilai nol. Jika Anda lulus nilai nol, Anda perlu menambahkan pemeriksaan tambahan untuk nilai nol:

if ((typeof variable !== "undefined") && (variable !== null))  
{
   // the variable is defined and not null
}

Pemeriksaan 'is it defined' yang paling kuat adalah dengan typeof

if (typeof elem === 'undefined')

Jika Anda hanya memeriksa variabel yang ditentukan untuk menetapkan default, untuk satu liner yang mudah dibaca Anda sering dapat melakukan ini:

elem = elem || defaultElem;

Ini sering baik untuk digunakan, lihat: Cara idiomatis untuk menetapkan nilai default dalam javascript

Ada juga yang satu ini menggunakan kata kunci typeof :

elem = (typeof elem === 'undefined') ? defaultElem : elem;

Anda dapat menggunakan typeofoperator.

Sebagai contoh,

var dataSet;

alert("Variable dataSet is : " + typeof dataSet);

Cuplikan kode di atas akan menghasilkan output seperti

set data variabel adalah: tidak terdefinisi.

Untuk memeriksa apakah suatu variabel telah dinyatakan / diset, saya melakukan trik kotor ini.

Saya belum menemukan cara untuk mengekstrak kode ke suatu fungsi, bahkan dengan eval.

"use strict";

// var someVar;

var declared;
try {
  someVar;
  declared = true;
} catch(e) {
  declared = false;
}

if (declared) {
  console.log("someVar is declared; now has the value: " + someVar);
} else {
  console.log("someVar is not declared");
}

Jawaban-jawaban ini (selain dari solusi Fred Gandt) semuanya salah atau tidak lengkap.

Misalkan saya perlu saya variableName;membawa undefinednilai, dan karena itu telah dinyatakan dengan cara seperti var variableName;yang berarti sudah diinisialisasi ; - Bagaimana saya memeriksa apakah sudah dinyatakan?

Atau bahkan lebih baik - bagaimana saya segera memeriksa apakah "Book1.chapter22.paragraph37" ada dengan satu panggilan, tetapi tidak menimbulkan kesalahan referensi?

Kami melakukannya dengan menggunakan operator JasvaScript paling kuat, operator in . :

"[variable||property]" in [context||root] 
>> true||false

Pada masa popularitas AJAX memuncak saya telah menulis sebuah metode (kemudian dinamai) isNS () yang mampu menentukan apakah namespace ada termasuk tes mendalam untuk nama properti seperti "Book1.chapter22.paragraph37" dan banyak lagi.

Tetapi karena sudah diterbitkan sebelumnya dan karena sangat penting untuk diterbitkan dalam utas terpisah, saya tidak akan mempostingnya di sini tetapi akan memberikan kata kunci ( javascript + isNS ) yang akan membantu Anda menemukan kode sumber, didukung dengan semua penjelasan yang diperlukan.

Dalam situasi khusus yang dijabarkan dalam pertanyaan,

typeof window.console === "undefined"

identik dengan

window.console === undefined

Saya lebih suka yang terakhir karena lebih pendek.

Harap perhatikan bahwa kami consolehanya mencari dalam lingkup global (yang merupakan windowobjek di semua browser). Dalam situasi khusus ini diinginkan. Kami tidak mauconsole didefinisikan di tempat lain.

@BrianKelley dalam jawabannya yang luar biasa menjelaskan perincian teknis. Saya hanya menambahkan kesimpulan yang kurang dan mencernanya menjadi sesuatu yang lebih mudah dibaca.

Saya menggunakan dua cara berbeda tergantung pada objek.

if( !variable ){
  // variable is either
  // 1. '';
  // 2. 0;
  // 3. undefined;
  // 4. null;
  // 5. false;
}

Terkadang saya tidak ingin mengevaluasi string kosong sebagai falsey, jadi saya menggunakan case ini

function invalid( item ){
  return (item === undefined || item === null);
}

if( invalid( variable )){
  // only here if null or undefined;
}

Jika Anda membutuhkan kebalikannya, maka dalam instance pertama! Variabel menjadi !! variabel, dan dalam fungsi yang tidak valid === menjadi! = Dan nama fungsi berubah menjadi notInvalid.

Preferensi saya adalah typeof(elem) != 'undefined' && elem != null.

Bagaimanapun Anda memilih, pertimbangkan untuk meletakkan cek dalam fungsi seperti itu

function existy (x) {
    return typeof (x) != 'undefined' && x != null;
}

Jika Anda tidak tahu variabelnya dinyatakan, lanjutkan dengan typeof (x) != 'undefined' && x != null;

Di mana Anda tahu variabelnya dideklarasikan tetapi mungkin tidak ada, Anda bisa menggunakan

existy(elem) && doSomething(elem);

Variabel yang Anda periksa mungkin properti bersarang kadang-kadang. Anda dapat menggunakan prop || {} untuk pergi ke garis memeriksa keberadaan ke properti yang bersangkutan:

var exists = ((((existy(myObj).prop1||{}).prop2||{}).prop3||{})[1]||{}).prop4;

Setelah setiap penggunaan properti (... '|| {}') .Top berikutnya agar properti yang hilang tidak akan menimbulkan kesalahan.

Atau Anda bisa menggunakan yang ada seperti existy(o) && existy(o.p) && existy(o.p.q) && doSomething(o.p.q)

Itu tergantung situasi. Jika Anda memeriksa sesuatu yang mungkin atau mungkin belum didefinisikan secara global di luar kode Anda (seperti jQuery mungkin), Anda ingin:

if (typeof(jQuery) != "undefined")

(Tidak perlu untuk kesetaraan yang ketat di sana, typeof selalu mengembalikan string.) Tetapi jika Anda memiliki argumen untuk fungsi yang mungkin atau mungkin tidak telah lulus, mereka akan selalu didefinisikan, tetapi nol jika dihilangkan.

function sayHello(name) {
    if (name) return "Hello, " + name;
    else return "Hello unknown person";
}
sayHello(); // => "Hello unknown person"

Coba tangkap

Jika variabel tidak didefinisikan sama sekali, Anda dapat memeriksa ini tanpa eksekusi kode istirahat menggunakan blok try-catch sebagai berikut (Anda tidak perlu use strictmode)

try{
  notDefinedVariable;
} catch(e) {
  console.log('detected: variable not exists');
}

console.log('but the code is still executed');

notDefinedVariable; // without try-catch wrapper code stops here

console.log('code execution stops. You will NOT see this message on console');

BONUS: (merujuk pada jawaban lain) Mengapa ===lebih jelas daripada ==( sumber )

jika (a == b)

jika (a === b)

Saya terkejut ini belum disebutkan ...

berikut adalah beberapa variasi tambahan yang digunakan this['var_name']

manfaat menggunakan metode ini yang dapat digunakan sebelum variabel didefinisikan.

if (this['elem']) {...}; // less safe than the res but works as long as you're note expecting a falsy value
if (this['elem'] !== undefined) {...}; // check if it's been declared
if (this['elem'] !== undefined && elem !== null) {...}; // check if it's not null, you can use just elem for the second part

// these will work even if you have an improper variable definition declared here
elem = null; // <-- no var here!! BAD!

Anda dapat menggunakan try ... catch block seperti berikut:

var status = 'Variable exists'

try {
	myVar
} catch (ReferenceError) {
	status = 'Variable does not exist'
}

console.log(status)

Kerugiannya adalah Anda tidak bisa memasukkannya ke dalam fungsi karena akan membuang ReferenceError

function variableExists(x) {
  var status = true
  try {
	  x
  } catch (ReferenceError) {
	  status = false
  }
  
  return status
}

console.log(variableExists(x))