Pertanyaan Bagaimana cara memeriksa “tidak terdefinisi” di JavaScript? [duplikat]


Pertanyaan ini sudah memiliki jawaban di sini:

Apa cara yang paling tepat untuk menguji apakah suatu variabel tidak terdefinisi dalam JavaScript? Saya telah melihat beberapa kemungkinan cara:

if (window.myVariable)

Atau

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

Atau

if (myVariable) //This throws an error if undefined. Should this be in Try/Catch?

1872
2017-08-02 17:53


asal


Jawaban:


Jika Anda tertarik untuk mengetahui apakah suatu variabel telah dideklarasikan terlepas dari nilainya, maka gunakan in operator adalah cara teraman untuk pergi. Pertimbangkan contoh ini.

// global scope
var theFu; // theFu has been declared, but its value is undefined
typeof theFu; // "undefined"

Tetapi ini mungkin bukan hasil yang dimaksudkan untuk beberapa kasus, karena variabel atau properti dideklarasikan tetapi tidak diinisialisasi. Menggunakan in operator untuk pemeriksaan yang lebih kuat.

"theFu" in window; // true
"theFoo" in window; // false

Jika Anda tertarik untuk mengetahui apakah variabel belum dinyatakan atau memiliki nilai undefined, lalu gunakan typeof operator.

if (typeof myVar != 'undefined')

Itu typeof operator dijamin mengembalikan string. Perbandingan langsung dengan undefined menyusahkan undefined dapat ditimpa.

window.undefined = "omg";
"omg" == undefined // true

Seperti ditunjukkan oleh @CMS, ini telah ditambal di ECMAScript edisi ke-6, dan undefined tidak bisa ditulis.

if (window.myVar) juga akan menyertakan nilai-nilai falsy ini, jadi tidak terlalu kuat:

Salah
0
""
NaN
batal
tidak terdefinisi

Terima kasih kepada @CMS untuk menunjukkan bahwa kasus ketiga Anda - if (myVariable) juga bisa melempar kesalahan dalam dua kasus. Yang pertama adalah ketika variabel belum didefinisikan yang melempar a ReferenceError.

// abc was never declared.
if (abc) {
    // ReferenceError: abc is not defined
} 

Kasus lainnya adalah ketika variabel telah didefinisikan, tetapi memiliki fungsi pengambil yang melempar kesalahan saat dipanggil. Sebagai contoh,

// or it's a property that can throw an error
Object.defineProperty(window, "myVariable", { 
    get: function() { throw new Error("W00t?"); }, 
    set: undefined 
});
if (myVariable) {
    // Error: W00t?
}

2156
2017-08-02 17:58



Saya pribadi menggunakannya

myVar === undefined

Peringatan: Harap dicatat bahwa === digunakan lebih == dan itu myVar telah sebelumnya dideklarasikan (tidak didefinisikan).


saya tidak suka typeof myVar === "undefined". Saya pikir itu panjang lebar dan tidak perlu. (Saya bisa melakukan hal yang sama dengan kode yang lebih sedikit.)

Sekarang beberapa orang akan jatuh sakit ketika membaca ini, berteriak: "Tunggu! WAAITTT !!! undefined dapat didefinisikan ulang! "

Keren. Saya tahu ini. Kemudian lagi, sebagian besar variabel dalam Javascript dapat didefinisikan ulang. Jika Anda tidak pernah menggunakan identifier built-in yang dapat didefinisikan ulang?

Jika Anda mengikuti aturan ini, baik untuk Anda: Anda bukan seorang munafik.

Masalahnya adalah, untuk melakukan banyak pekerjaan nyata di JS, pengembang harus bergantung pada identifier yang dapat didefinisikan ulang untuk menjadi apa mereka. Saya tidak mendengar orang mengatakan kepada saya bahwa saya tidak boleh menggunakannya setTimeout karena seseorang bisa

window.setTimeout = function () {
    alert("Got you now!");
};

Intinya, argumen "itu dapat didefinisikan ulang" untuk tidak menggunakan mentah === undefined adalah palsu.

(Jika Anda masih takut undefined sedang didefinisikan ulang, mengapa Anda membabi buta mengintegrasikan kode perpustakaan belum teruji ke dalam basis kode Anda? Atau bahkan lebih sederhana: alat linting.)


Juga, seperti typeof pendekatan, teknik ini dapat "mendeteksi" variabel yang dideklarasikan:

if (window.someVar === undefined) {
    doSomething();
}

Namun kedua teknik ini bocor dalam abstraksinya. Saya mendorong Anda untuk tidak menggunakan ini atau bahkan

if (typeof myVar !== "undefined") {
    doSomething();
}

Mempertimbangkan:

var iAmUndefined;

Untuk menangkap apakah variabel itu dinyatakan atau tidak, Anda mungkin perlu menggunakan in operator. (Dalam banyak kasus, Anda cukup membaca kode O_o).

if ("myVar" in window) {
    doSomething();
}

Tapi tunggu! Masih ada lagi! Bagaimana jika beberapa keajaiban rantai prototipe terjadi ...? Sekarang bahkan atasannya in operator tidak memadai. (Oke, saya sudah selesai di sini tentang bagian ini kecuali mengatakan bahwa untuk 99% dari waktu, === undefined (dan **** batuk **** typeof) bekerja dengan baik. Jika Anda benar-benar peduli, Anda dapat membaca tentang subjek ini sendiri.)


888
2017-08-02 18:26



Menggunakan typeof adalah kesukaan saya. Ini akan bekerja ketika variabel tidak pernah dideklarasikan, tidak seperti perbandingan apa pun dengan == atau === operator atau jenis pemaksaan menggunakan if. (undefinedtidak seperti null, juga dapat didefinisikan ulang dalam lingkungan ECMAScript 3, membuatnya tidak dapat diandalkan untuk perbandingan, meskipun hampir semua lingkungan umum sekarang sesuai dengan ECMAScript 5 atau lebih tinggi).

if (typeof someUndeclaredVariable == "undefined") {
    // Works
}

if (someUndeclaredVariable === undefined) { 
    // Throws an error
}

149
2017-08-02 18:05



Anda perlu menggunakan typeof .

if (typeof something != "undefined") {
    // ...
}

51
2018-06-06 20:22



Jika tidak terdefinisi, itu tidak akan sama dengan string yang berisi karakter "tidak terdefinisi", karena string tidak terdefinisi.

Anda dapat memeriksa jenis variabel:

if (typeof(something) != "undefined") ...

Terkadang Anda bahkan tidak perlu memeriksa jenisnya. Jika nilai variabel tidak dapat dievaluasi menjadi salah ketika sudah diatur (misalnya jika itu fungsi), maka Anda dapat menilai variabel. Contoh:

if (something) {
  something(param);
}

20
2018-06-06 20:23



Beberapa skenario yang mengilustrasikan hasil dari berbagai jawaban: http://jsfiddle.net/drzaus/UVjM4/

(Perhatikan bahwa penggunaan var untuk in tes membuat perbedaan ketika dalam pembungkus scoped)

Kode untuk referensi:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.log(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

Dan hasilnya:

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined

17
2018-01-13 15:39



if (typeof foo == 'undefined') {
 // Do something
};

Perhatikan bahwa perbandingan yang ketat (!==) tidak diperlukan dalam kasus ini, karena typeof akan selalu mengembalikan string.


16
2018-06-06 20:26



Di artikel ini Saya membaca kerangka seperti itu Underscore.js gunakan fungsi ini:

function isUndefined(obj){
    return obj === void 0;
}

15
2017-12-19 10:42