Anda ingin jenis operator. Secara khusus:

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

The jenis operator akan memeriksa apakah variabel adalah benar-benar tidak terdefinisi.

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

The jenis operator, tidak seperti operator lain, doesn't melempar ReferenceError kecuali bila digunakan dengan sebuah variabel dideklarasikan.

Namun, tidak diketahui bahwa typeof null akan kembali "objek". Kita harus berhati-hati untuk menghindari kesalahan inisialisasi variabel untuk null. Untuk amannya, ini adalah apa yang bisa kita gunakan sebagai gantinya:

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

Untuk info lebih lanjut tentang menggunakan perbandingan === bukan sederhana kesetaraan ==, lihat:
https://stackoverflow.com/q/359494/584192

Dalam JavaScript, sebuah variabel dapat didefinisikan, tetapi memegang nilai undefined, sehingga jawaban yang paling umum adalah secara teknis tidak benar, dan bukannya melakukan hal 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
}

Yang mungkin cukup untuk keperluan anda. Berikut tes yang lebih sederhana semantik, yang membuatnya lebih mudah untuk secara tepat menggambarkan kode's perilaku dan memahami diri 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, menganggap anda berjalan di browser (di mana jendela adalah nama untuk objek global). Tapi jika anda're penyia-nyiaan waktu dengan globals seperti ini, anda're mungkin di browser. Secara subyektif, menggunakan 'nama' di jendela adalah gaya yang konsisten dengan menggunakan jendela.nama untuk merujuk kepada globals. Mengakses globals sebagai sifat dari jendela bukan sebagai variabel memungkinkan anda untuk meminimalkan jumlah dideklarasikan variabel referensi anda dalam kode anda (untuk kepentingan linting), dan menghindari kemungkinan anda global yang dibayangi oleh variabel lokal. Juga, jika globals membuat kulit anda merangkak anda mungkin merasa lebih nyaman menyentuh mereka hanya dengan ini relatif tongkat panjang.

Dalam banyak kasus, menggunakan:

if (elem) { // or !elem

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

1. terdefinisi: jika nilai tidak ditentukan dan's undefined
2. null: jika's null, misalnya, jika elemen DOM tidak ada...
3. string kosong: ''
4. 0: jumlah nol
5. NaN: tidak jumlah
6. palsu

Sehingga akan menutupi off jenis dari semua kasus, tetapi selalu ada kasus aneh yang kita'd seperti untuk penutup serta, misalnya, string dengan spasi, seperti ini' ' satu, ini akan ditentukan di javascript seperti itu memiliki ruang-ruang di dalam string... misalnya dalam kasus ini, anda menambahkan satu lagi cek menggunakan trim(), seperti:

if(elem) {

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

Juga, pemeriksaan ini adalah untuk nilai hanya sebagai objek dan array bekerja dengan cara yang berbeda dalam Javascript, array kosong [] dan obyek kosong {} selalu sejati.

Saya membuat gambar di bawah ini untuk menampilkan penjelasan singkat dari jawaban:

Dalam sebagian besar kasus, anda akan menggunakan:

elem != null

Tidak seperti sederhana jika (elem), hal ini memungkinkan 0, false, NaN dan'', tapi menolak null atau undefined, sehingga yang baik, tes umum untuk kehadiran dari sebuah argumen, atau properti sebuah objek.

Lainnya cek yang tidak benar baik, mereka hanya memiliki kegunaan yang berbeda:

• jika (elem): dapat digunakan jika elem dijamin akan suatu objek, atau jika false, 0, dll. dianggap "default" nilai-nilai (oleh karena itu setara dengan undefined atau nol).

• typeof elem == 'undefined' dapat digunakan dalam kasus-kasus di mana ditentukan null memiliki makna yang berbeda untuk sebuah uninitialised variabel atau properti.

• Ini adalah satu-satunya memeriksa bahwa tidak't melempar kesalahan jika elem tidak menyatakan (yaitu tidak ada var pernyataan, bukan properti dari jendela, atau tidak fungsi argumen). Hal ini, menurut pendapat saya, agak berbahaya karena memungkinkan kesalahan ketik untuk lewat tanpa diketahui. Untuk menghindari hal ini, lihat di bawah ini metode.

Juga berguna adalah perbandingan terhadap undefined:

if (elem === undefined) ...

Namun, karena global undefined dapat diganti dengan nilai lain, yang terbaik adalah untuk mendeklarasikan variabel undefined di lingkup saat ini sebelum menggunakannya:

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

Atau:

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

Sekunder keuntungan dari metode ini adalah bahwa JS minifiers dapat mengurangi undefined variabel untuk satu karakter, menghemat anda beberapa byte setiap waktu.

Bagaimana cara memeriksa apakah suatu variabel ada

Ini adalah cukup antipeluru solusi untuk menguji apakah variabel yang ada dan telah diinisialisasi :

var setOrNot = typeof variable !== typeof undefined;

Hal ini paling sering digunakan dalam kombinasi dengan ternary operator untuk mengatur default dalam kasus tertentu variabel belum diinisialisasi :

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

Masalah dengan enkapsulasi

Sayangnya, anda tidak bisa hanya merangkum anda check-in fungsi.

Anda mungkin berpikir untuk melakukan sesuatu seperti ini :

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

Namun, hal ini akan menghasilkan galat referensi jika anda're memanggil misalnya. isset(foo) dan variabel foo belum ditetapkan, karena anda tidak bisa lulus bersama non-variabel yang ada untuk fungsi :

exception ReferenceError: foo tidak didefinisikan

Menguji apakah parameter fungsi yang tidak terdefinisi

Sementara kami isset fungsi tidak dapat digunakan untuk menguji apakah suatu variabel ada atau tidak (untuk alasan yang dijelaskan hereabove), itu tidak memungkinkan kita untuk menguji apakah parameter dari suatu fungsi yang 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 y diteruskan ke fungsi test, kita isset fungsi bekerja sempurna dalam konteks ini, karena y yang dikenal dalam fungsi test sebagai undefined nilai.

Periksa apakah window.hasOwnProperty("varname")

Alternatif untuk kebanyakan jenis jawaban;

Global variabel yang dideklarasikan dengan var namavar = nilai; pernyataan dalam lingkup global

dapat diakses sebagai sifat dari objek window.

Seperti, hasOwnProperty() metode, yang

mengembalikan boolean yang menunjukkan apakah objek memiliki properti yang telah ditentukan sebagai milik sendiri (sebagai lawan untuk mewarisi)

dapat digunakan untuk menentukan apakah

a var dari "varname" telah dinyatakan secara global yaitu adalah properti dari jendela.

// 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's besar tentang hasOwnProperty() adalah bahwa dalam pemanggilan itu, kita don't menggunakan variabel yang mungkin belum dapat dideklarasikan - yang tentu saja adalah setengah masalah di tempat pertama.

Meskipun tidak selalu yang ideal atau ideal solusi, dalam keadaan tertentu, it's hanya pekerjaan!

Catatan

Di atas adalah benar ketika menggunakan var untuk mendefinisikan variabel, sebagai lawan dari membiarkan yang:

menyatakan suatu blok ruang lingkup variabel lokal, opsional inisialisasi nilai.

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

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

Untuk kelengkapan: p konstanta, menurut definisi, tidak benar-benar variabel (meskipun konten mereka dapat); lebih relevan:

konstanta Global tidak menjadi sifat dari objek window, tidak seperti var variabel. Sebuah penginisialisasi yang konstan diperlukan; itu adalah, anda harus menentukan nilainya dalam pernyataan yang sama di mana ia's menyatakan.

nilai konstan tidak berubah melalui penugasan, dan hal ini dapat't dapat redeclared.

const deklarasi menciptakan hanya-baca referensi untuk sebuah nilai. Itu tidak berarti nilai yang dimilikinya adalah kekal, hanya bahwa variabel identifier tidak dapat dipindahkan.

Sejak membiarkan variabel atau const konstanta yang tidak pernah properti dari setiap objek yang telah mewarisi hasOwnProperty (), metode ini tidak dapat digunakan untuk memeriksa keberadaan mereka.

Mengenai ketersediaan dan penggunaan hasOwnProperty():

Setiap objek yang diturunkan dari Objek mewarisi hasOwnProperty() metode. [...] seperti tahun operator, metode ini tidak memeriksa ke objek's prototipe rantai.

Ada lagi tangan pendek cara untuk memeriksa hal ini, ketika anda melakukan sederhana tugas dan terkait pemeriksaan. Cukup menggunakan Bersyarat (Ternary) Operator.

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

Juga ini akan sangat membantu, ketika anda mencoba untuk mendeklarasikan variabel Global dengan contoh tugas referensi variabel.

Jika anda ingin memeriksa variabel seharusnya't undefined atau null. Kemudian melakukan cek di bawah ini.

Saat variabel dideklarasikan, dan jika anda ingin memeriksa nilai, ini bahkan Sederhana: dan itu akan melakukan undefined dan null cek bersama-sama.

var values = variable ? variable : '';

Itu tergantung jika anda hanya peduli bahwa variabel yang telah ditentukan atau jika anda ingin memiliki nilai yang berarti.

Memeriksa apakah tipe terdefinisi akan memeriksa apakah variabel telah didefinisikan lagi.

=== null atau !== null hanya akan memeriksa apakah nilai dari variabel adalah persis null.

== null atau != null akan memeriksa apakah nilai adalah undefined atau null.

jika(nilai) akan memeriksa jika variabel undefined, null, 0, atau string kosong.

Cara singkat untuk menguji variabel tidak dideklarasikan (tidak terdefinisi) adalah

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

Saya menemukan itu berguna untuk mendeteksi script berjalan di luar browser (tidak bisa dinyatakan jendela variabel).

Tertinggi jawabannya adalah benar, menggunakan typeof.

Namun, apa yang saya ingin tekankan adalah bahwa dalam JavaScript undefined bisa berubah (untuk beberapa orang-orang durhaka alasan). Jadi hanya melakukan cek untuk namavar !== undefined memiliki potensi untuk tidak selalu kembali seperti yang anda harapkan, karena lain libs bisa berubah terdefinisi. Beberapa jawaban (@skalee's, untuk yang satu), tampaknya lebih memilih tidak menggunakan jenis, dan itu bisa menjadi masalah.

&Quot;tua" cara untuk menangani hal ini menyatakan tidak terdefinisi sebagai var untuk mengimbangi potensi mematikan/over-riding undefined. Namun, cara terbaik adalah masih menggunakan jenis karena itu akan mengabaikan utama dari undefined dari kode lainnya. 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 memberikan kontribusi terhadap perdebatan, jika aku tahu variabel harus menjadi sebuah string atau suatu objek aku selalu suka jika (!variabel), jadi memeriksa jika falsy. Hal ini dapat membawa lebih banyak kode yang 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); 
}

..bisa dikurangi dengan:

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

Sulit untuk membedakan antara terdefinisi dan null. Null adalah nilai yang anda dapat menetapkan ke variabel ketika anda ingin menunjukkan bahwa variabel tidak memiliki nilai tertentu. Terdefinisi adalah nilai khusus yang akan menjadi default nilai dari variable.

var _undefined;
var _null = null;
alert(_undefined); 
alert(_null); 
alert(_undefined == _null);
alert(_undefined === _null);

Null adalah nilai dalam JavaScript dan typeof null kembali "objek"

Oleh karena itu, jawaban yang diterima tidak akan bekerja jika anda lulus nilai-nilai null. Jika anda lulus nilai-nilai null, anda perlu menambahkan pemeriksaan tambahan untuk nilai-nilai null:

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

anda dapat menggunakan jenis operator.

Misalnya,

var dataSet;

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

Kode di atas potongan akan kembali output seperti

variabel dataSet ini : undefined.

Jawaban-jawaban ini (selain dari Fred Gandt solusi ) adalah semua entah benar atau tidak lengkap.

Misalkan saya perlu variableName; membawa undefined nilai, dan oleh karena itu telah dinyatakan dalam cara yang seperti var variableName; yang berarti's sudah diinisialisasi; - Bagaimana cara memeriksa apakah itu's sudah dinyatakan?

Atau bahkan lebih baik - bagaimana saya segera periksa jika "Book1.chapter22.paragraph37" ada dengan satu panggilan, tetapi tidak meningkat referensi kesalahan?

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

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

Di saat AJAX memuncak popularitasnya I've tertulis metode (yang kemudian bernama) isNS() yang mampu menentukan jika namespace termasuk dalam tes untuk nama properti seperti "Book1.chapter22.paragraph37" dan banyak lagi.

Tapi sejak itu telah diterbitkan sebelumnya dan karena bentuknya yang sangat penting yang layak akan diterbitkan di thread terpisah saya tidak akan posting di sini tapi akan memberikan kata kunci (javascript + isNS ) yang akan membantu anda menemukan kode sumber, yang didukung dengan semua penjelasan yang diperlukan.

Yang paling kuat 'itu didefinisikan' cek dengan jenis

if (typeof elem === 'undefined')

Jika anda hanya memeriksa untuk mendefinisikan variabel untuk menetapkan standar, untuk aplikasi yang mudah untuk membaca salah satu kapal anda dapat sering melakukan hal ini:

elem = elem || defaultElem;

It's sering baik-baik saja untuk menggunakan, lihat: https://stackoverflow.com/questions/505840/idiomatic-way-to-set-default-value-in-javascript

Ada juga satu kapal dengan menggunakan jenis kata kunci:

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

Dalam situasi tertentu yang diuraikan dalam pertanyaan,

typeof window.console === "undefined"

identik dengan

window.console === undefined

Saya lebih memilih yang terakhir karena itu's lebih pendek.

Harap dicatat bahwa kami mencari untuk konsol hanya dalam lingkup global (yang merupakan jendela objek di semua browser). Dalam situasi tertentu itu's diinginkan. Kami don't ingin konsol didefinisikan di tempat lain.

@BrianKelley dalam jawaban menjelaskan rincian teknis. I've hanya menambahkan kurang kesimpulan dan dicerna itu menjadi sesuatu yang lebih mudah untuk dibaca.

Untuk memeriksa apakah suatu variabel sudah dideklarasikan/set saya melakukan trik kotor ini.

Aku ingin't menemukan cara untuk mengekstrak kode untuk 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");
}