Mengapa null sebuah objek dan apa perbedaan antara nol dan tidak terdefinisi?

Mengapa nulldianggap sebagai objectJavaScript?

Sedang memeriksa

if ( object == null )
      Do something

sama seperti

if ( !object )
      Do something

?

Dan juga:

Apa perbedaan antara nulldan undefined?

(name is undefined)

Anda: Apa itu name? ^(*)
JavaScript name :? Apa itu name? Saya tidak tahu apa yang Anda bicarakan. Anda belum pernah menyebutkan namesebelumnya. Apakah Anda melihat beberapa bahasa skrip lain di sisi (klien-)?

name = null;

Anda: Apa itu name?
JavaScript: Saya tidak tahu.

Pendeknya; undefinedadalah di mana tidak ada gagasan tentang hal itu ada; tidak memiliki tipe, dan itu belum pernah dirujuk sebelumnya dalam lingkup itu; nulladalah tempat benda diketahui ada, tetapi tidak diketahui nilainya.

Satu hal yang perlu diingat adalah bahwa nulltidak, secara konseptual, sama dengan falseatau ""atau seperti itu, bahkan jika mereka menyamakan setelah pengecoran tipe, yaitu

name = false;

Anda: Apa itu name?
JavaScript: Boolean salah.

name = '';

Anda: Apa itu name?
JavaScript: String kosong

^{*: namedalam konteks ini dimaksudkan sebagai variabel yang belum pernah didefinisikan. Ini bisa berupa variabel yang tidak terdefinisi, namun, nama adalah properti dari hampir semua elemen bentuk HTML. Ini berjalan jauh, kembali dan dilembagakan jauh sebelum id. Ini berguna karena id harus unik tetapi nama tidak harus.}

Perbedaannya dapat diringkas ke dalam cuplikan ini:

alert(typeof(null));      // object
alert(typeof(undefined)); // undefined

alert(null !== undefined) //true
alert(null == undefined)  //true

Memeriksa

object == nullberbeda untuk diperiksa if ( !object ).

Yang terakhir sama dengan ! Boolean(object), karena !operator unary secara otomatis melemparkan operan yang tepat ke dalam Boolean.

Karena Boolean(null)sama dengan yang salah maka !false === true.

Jadi, jika objek Anda bukan nol , tetapi salah atau 0 atau "" , centang akan lolos karena:

alert(Boolean(null)) //false
alert(Boolean(0))    //false
alert(Boolean(""))   //false

nulladalah bukan obyek , itu adalah nilai yang primitif . Misalnya, Anda tidak dapat menambahkan properti ke dalamnya. Terkadang orang salah menganggap bahwa itu adalah objek, karena typeof nullkembali "object". Tapi itu sebenarnya bug (yang mungkin diperbaiki di ECMAScript 6).

Perbedaan antara nulldan undefinedadalah sebagai berikut:

• undefined: digunakan oleh JavaScript dan berarti "tidak ada nilai". Variabel tidak diinisialisasi, parameter yang hilang dan variabel yang tidak diketahui memiliki nilai itu.

  > var noValueYet;
  > console.log(noValueYet);
  undefined
  
  > function foo(x) { console.log(x) }
  > foo()
  undefined
  
  > var obj = {};
  > console.log(obj.unknownProperty)
  undefined

  Mengakses variabel yang tidak dikenal, menghasilkan pengecualian:

  > unknownVariable
  ReferenceError: unknownVariable is not defined

• null: digunakan oleh programmer untuk menunjukkan "tidak ada nilai", misalnya sebagai parameter untuk suatu fungsi.

Memeriksa variabel:

console.log(typeof unknownVariable === "undefined"); // true

var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true

var bar = null;
console.log(bar === null); // true

Sebagai aturan umum, Anda harus selalu menggunakan === dan tidak pernah == dalam JavaScript (== melakukan semua jenis konversi yang dapat menghasilkan hasil yang tidak terduga). Pemeriksaan x == nullini merupakan kasus tepi, karena berfungsi untuk keduanya nulldan undefined:

> null == null
true
> undefined == null
true

Cara yang umum untuk memeriksa apakah suatu variabel memiliki nilai adalah dengan mengubahnya menjadi boolean dan melihat apakah variabel itu bernilai true. Konversi itu dilakukan oleh ifpernyataan dan operator boolean! ("tidak").

function foo(param) {
    if (param) {
        // ...
    }
}
function foo(param) {
    if (! param) param = "abc";
}
function foo(param) {
    // || returns first operand that can't be converted to false
    param = param || "abc";
}

Kelemahan dari pendekatan ini: Semua nilai berikut dievaluasi false, jadi Anda harus berhati-hati (mis. Cek di atas tidak dapat membedakan antara undefineddan 0).

• undefined, null
• Boolean: false
• Nomor: +0, -0,NaN
• String: ""

Anda dapat menguji konversi ke boolean dengan menggunakan Booleansebagai fungsi (biasanya itu adalah konstruktor, untuk digunakan bersama new):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

Apa perbedaan antara null dan undefined ??

Properti ketika tidak memiliki definisi, tidak ditentukan. null adalah sebuah objek. Jenisnya adalah objek. null adalah nilai khusus yang berarti "tidak ada nilai. undefined bukan objek, tipenya tidak terdefinisi.

Anda dapat mendeklarasikan variabel, setel ke nol, dan perilaku itu identik kecuali bahwa Anda akan melihat "null" dicetak versus "tidak terdefinisi". Anda bahkan dapat membandingkan variabel yang tidak ditentukan ke nol atau sebaliknya, dan kondisinya akan benar:

 undefined == null
 null == undefined

Lihat Perbedaan JavaScript antara nol dan tidak terdefinisi untuk detail lebih lanjut.

dan dengan suntingan baru Anda ya

if (object == null)  does mean the same  if(!object)

saat menguji apakah objek salah, keduanya hanya memenuhi kondisi saat menguji jika salah , tetapi tidak ketika benar

Periksa di sini: Gotcha Javascript

Bagian pertama dari pertanyaan:

Mengapa null dianggap sebagai objek dalam JavaScript?

Ini adalah kesalahan desain JavaScript yang tidak dapat mereka perbaiki sekarang. Seharusnya tipe null, bukan tipe objek, atau tidak memilikinya sama sekali. Itu memerlukan pemeriksaan tambahan (kadang-kadang dilupakan) ketika mendeteksi objek nyata dan merupakan sumber bug.

Bagian kedua dari pertanyaan:

Memeriksa


if (object == null)
Do something

sama dengan

if (!object)
Do something

Kedua cek selalu salah, kecuali untuk:

• objek tidak terdefinisi atau nol: keduanya benar.

• objek primitif, dan 0 "",, atau false: centang pertama salah, kedua benar.

Jika objek tidak primitif, tapi Obyek nyata, seperti new Number(0), new String(""), atau new Boolean(false), maka kedua cek palsu.

Jadi jika 'objek' diartikan sebagai Obyek nyata maka kedua pemeriksaan selalu sama. Jika primitif diizinkan maka cek berbeda untuk 0 "",, dan salah.

Dalam kasus seperti object==null, hasil yang tidak jelas bisa menjadi sumber bug. Penggunaan ==tidak disarankan, gunakan ===saja.

Bagian ketiga dari pertanyaan:

Dan juga:

Apa perbedaan antara null dan undefined?

Dalam JavaScript, satu perbedaan adalah bahwa null adalah tipe objek dan undefined adalah tipe undefined.

Dalam JavaScript, null==undefinedbenar, dan dianggap sama jika jenisnya diabaikan. Mengapa mereka memutuskan itu, tetapi 0, ""dan salah tidak sama, saya tidak tahu. Tampaknya itu pendapat yang sewenang-wenang.

Dalam JavaScript, null===undefinedtidak benar karena jenisnya harus sama dalam ===.

Pada kenyataannya, nol dan tidak terdefinisi identik, karena keduanya mewakili ketidakberadaan. Begitu juga 0, dan ""dalam hal ini juga, dan mungkin wadah kosong []dan {}. Begitu banyak jenis yang sama tidak ada resep untuk bug. Satu jenis atau tidak sama sekali lebih baik. Saya akan mencoba menggunakan sesedikit mungkin.

'salah', 'benar', dan '!' adalah sekumpulan cacing lain yang dapat disederhanakan, misalnya, if(!x)dan if(x)sendirian saja sudah cukup, Anda tidak perlu benar dan salah.

Deklarasi var xadalah tipe yang tidak terdefinisi jika tidak ada nilai yang diberikan, tetapi harus sama seperti jika x tidak pernah dideklarasikan sama sekali. Sumber bug lain adalah wadah kosong apa pun. Jadi yang terbaik adalah mendeklarasikan dan mendefinisikannya bersama var x=1.

Orang-orang berputar-putar berusaha mencari tahu semua jenis yang berbeda ini, tetapi semuanya sama saja dengan pakaian yang berbeda dan rumit. Kenyataannya adalah

undefined===undeclared===null===0===""===[]==={}===nothing

Dan mungkin semua harus membuang pengecualian.

var x = null;

x didefinisikan sebagai null

y tidak didefinisikan; // karena saya tidak mendefinisikannya

if (!x)

null dievaluasi sebagai false

Salah satu cara untuk memahami nol dan tidak terdefinisi adalah dengan memahami di mana masing-masing terjadi.

Harapkan nilai pengembalian nol dalam situasi berikut:

• Metode yang menanyakan DOM

  console.log(window.document.getElementById("nonExistentElement"));
  //Prints: null

• Respons JSON diterima dari permintaan Ajax

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• Fungsionalitas baru yang dalam keadaan fluks. Berikut ini mengembalikan nol:

        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

        Object.getOwnPropertyDescriptor({}, "a");

Semua kasus ketidak-hadiran lainnya dilambangkan dengan tidak terdefinisi (sebagaimana dicatat oleh @Axel). Setiap cetakan berikut "tidak terdefinisi":

    var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());        

Tentu saja jika Anda memutuskan untuk menulis var unitialised = null; atau mengembalikan nol dari metode sendiri maka Anda memiliki nol terjadi dalam situasi lain. Tetapi itu harus cukup jelas.

Kasus ketiga adalah ketika Anda ingin mengakses variabel tetapi Anda bahkan tidak tahu apakah itu telah dinyatakan. Untuk itu gunakan typeof untuk menghindari kesalahan referensi:

if(typeof unknown !== "undefined"){
    //use unknown
}

Dalam ringkasan cek untuk null ketika Anda memanipulasi DOM, berurusan dengan Ajax, atau menggunakan fitur ECMAScript 5 tertentu. Untuk semua kasus lain, aman untuk memeriksa tidak terdefinisi dengan kesetaraan yang ketat:

if(value === undefined){
  // stuff
}

Perbandingan berbagai pemeriksaan nol dalam JavaScript:

http://jsfiddle.net/aaronhoffman/DdRHB/5/

// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;

...trim...

http://aaron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html

null dan undefined keduanya false untuk persamaan nilai (null == undefined): keduanya runtuh menjadi boolean false. Mereka bukan objek yang sama (null! == tidak terdefinisi).

undefined adalah properti dari objek global ("window" di browser), tetapi merupakan tipe primitif dan bukan objek itu sendiri. Ini nilai default untuk variabel dan fungsi yang tidak diinisialisasi yang berakhir tanpa pernyataan pengembalian.

null adalah turunan dari Object. null digunakan untuk metode DOM yang mengembalikan objek koleksi untuk menunjukkan hasil kosong, yang memberikan nilai palsu tanpa menunjukkan kesalahan.

Beberapa ketentuan:

null dan undefined adalah dua nilai yang berbeda. Satu mewakili tidak adanya nilai untuk nama dan yang lainnya mewakili tidak adanya nama.

Apa yang terjadi dalam suatu ifberjalan sebagai berikut untuk if( o ):

Ekspresi dalam tanda kurung dievaluasi, dan kemudian iftendangan dalam tipe-paksaan nilai ekspresi dalam tanda kurung - dalam kasus kami o.

Nilai Falsy (yang akan dipaksa menjadi salah) dalam JavaScript adalah: '', null, undefined, 0, dan false .

Untuk menambah jawaban Apa perbedaan antara undefineddannull , dari JavaScript Definitive Guide 6th Edition, hal.41 di halaman ini :

Anda mungkin mempertimbangkan undefineduntuk mewakili nullketidakhadiran nilai tingkat sistem, tidak terduga, atau seperti kesalahan dan untuk mewakili ketidakhadiran nilai tingkat program, normal, atau yang diharapkan. Jika Anda perlu menetapkan salah satu dari nilai-nilai ini ke variabel atau properti atau meneruskan salah satu dari nilai-nilai ini ke suatu fungsi, nullhampir selalu merupakan pilihan yang tepat.

nulladalah sebuah objek. Jenisnya adalah nol. undefinedbukan obyek; jenisnya tidak terdefinisi.

Fungsi berikut menunjukkan mengapa dan mampu mengatasi perbedaan:

function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

Jika Anda menelepon

test();

Kamu mendapatkan

tidak terdefinisi

batal

Yang pertama console.log(...)mencoba untuk mendapatkan myPropertydari myObjsaat belum ditetapkan - sehingga ia akan kembali "tidak terdefinisi". Setelah menetapkan nol untuk itu, yang kedua console.log(...)jelas mengembalikan "null" karena myPropertyada, tetapi memiliki nilai yang nullditetapkan untuk itu.

Untuk dapat menanyakan perbedaan ini, JavaScript memiliki nulldan undefined: Sementara null- seperti dalam bahasa lain objek, undefinedtidak dapat menjadi objek karena tidak ada instance (bahkan bukan nullinstance) tersedia.

Misalnya window.someWeirdPropertytidak terdefinisi, jadi

"window.someWeirdProperty === null" mengevaluasi ke false saat

"window.someWeirdProperty === undefined" mengevaluasi ke true.

Checkif apalagi if (!o)tidak sama seperti memeriksa if (o == null)untuk omenjadi false.

Hal menyenangkan lainnya tentang null, dibandingkan dengan tidak terdefinisi, adalah bahwa hal itu dapat ditingkatkan.

x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

Ini berguna untuk mengatur nilai numerik default untuk penghitung. Berapa kali Anda menetapkan variabel ke -1 dalam deklarasi?

Dalam Javascript null bukan objecttipe itu adalah primitavetipe.

Apa bedanya? Undefined mengacu pada pointer yang belum diatur. Null mengacu pada pointer nol misalnya sesuatu telah secara manual mengatur variabel menjadi tipenull

Lihat ini:

   <script>
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}
</script>
                                          //return:
<button onclick="f()">nothing</button>    //undefined    null    false
<button onclick="f(null)">null</button>   //object       null    false
<button onclick="f('')">empty</button>    //string               false
<button onclick="f(0)">zero</button>      //number               false
<button onclick="f(1)">int</button>       //number               true
<button onclick="f('x')">str</button>     //string               true

Dari "Prinsip-prinsip Javascript Berorientasi Objek" oleh Nicholas C. Zakas

Tapi mengapa sebuah objek saat tipenya nol? (Faktanya, ini telah diakui sebagai kesalahan oleh TC39, komite yang mendesain dan mengelola JavaScript. Anda bisa beralasan bahwa null adalah penunjuk objek kosong, membuat "objek" nilai pengembalian logis, tetapi itu masih membingungkan.)

Zakas, Nicholas C. (2014-02-07). Prinsip JavaScript Berorientasi Objek (Lokasi Kindle 226-227). Tanpa Starch Press. Edisi menyalakan.

Yang mengatakan:

var game = null; //typeof(game) is "object"

game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

Kasing tidak ditentukan:

var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.

Cara terbaik untuk berpikir tentang 'nol' adalah dengan mengingat bagaimana konsep yang sama digunakan dalam database, di mana ini menunjukkan bahwa bidang berisi "tidak ada nilai sama sekali."

• Ya, nilai item diketahui; itu adalah 'didefinisikan.' Ini telah diinisialisasi.
• Nilai itemnya adalah: "tidak ada nilai."

Ini adalah teknik yang sangat berguna untuk menulis program yang lebih mudah didebug. Variabel 'tidak terdefinisi' mungkin merupakan hasil dari bug ... (bagaimana Anda tahu?) ... tetapi jika variabel tersebut berisi nilai 'null,' Anda tahu bahwa "seseorang, di suatu tempat dalam program ini, atur ke 'null.' "Oleh karena itu, saya sarankan bahwa, ketika Anda perlu menyingkirkan nilai variabel, jangan" hapus "... setel ke 'null.' Nilai lama akan menjadi yatim piatu dan akan segera dikumpulkan; nilai baru adalah, "tidak ada nilai (sekarang)." Dalam kedua kasus, keadaan variabel itu pasti: "jelas, sengaja, seperti itu."

1. Tidak terdefinisi berarti suatu variabel telah dideklarasikan tetapi belum diberi nilai apa pun sementara Null dapat ditetapkan ke variabel yang mewakili "tidak ada nilai". (Null adalah operator penugasan)

2.Defined adalah tipe itu sendiri sementara Null adalah objek.

3.Javascript itu sendiri dapat menginisialisasi variabel yang tidak ditetapkan untuk undefined tetapi tidak pernah dapat mengatur nilai variabel menjadi nol. Ini harus dilakukan secara terprogram.