Metode yang memeriksa apakah suatu variabel telah diinisialisasi lebih baik/benar? (Dengan asumsi variabel bisa memegang apa-apa (string, int, obyek, fungsi, dll.))
if (elem) { // or !elem
atau
if (typeof(elem) !== 'undefined') {
atau
if (elem != null) {
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:
undefined
''
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.
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";
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
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.
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!
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
, sepertivar
, 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()
:
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...
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
}
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");
}