Apa perbedaan antara null dan undefined dalam JavaScript?

Saya ingin tahu apa perbedaan antara nulldan undefineddalam JavaScript.

Dalam JavaScript, undefinedberarti suatu variabel telah dideklarasikan tetapi belum diberi nilai, seperti:

var TestVar;
alert(TestVar); //shows undefined
alert(typeof TestVar); //shows undefined

nulladalah nilai penugasan. Itu dapat ditugaskan ke variabel sebagai representasi tanpa nilai:

var TestVar = null;
alert(TestVar); //shows null
alert(typeof TestVar); //shows object

Dari contoh-contoh sebelumnya, jelas bahwa undefineddan nullada dua tipe berbeda: undefinedadalah tipe itu sendiri (tidak terdefinisi) sedangkan nullobjek.

null === undefined // false
null == undefined // true
null === null // true

dan

null = 'value' // ReferenceError
undefined = 'value' // 'value'

Saya mengambil ini dari sini

Nilai tidak terdefinisi adalah nilai primitif yang digunakan ketika suatu variabel belum diberi nilai.

Nilai nol adalah nilai primitif yang mewakili referensi nol, kosong, atau tidak ada.

Ketika Anda mendeklarasikan variabel melalui var dan tidak memberikan nilai, itu akan memiliki nilai yang tidak terdefinisi. Dengan sendirinya, jika Anda mencoba untuk WScript.Echo () atau mengingatkan () nilai ini, Anda tidak akan melihat apa pun. Namun, jika Anda menambahkan string kosong ke sana maka tiba-tiba itu akan muncul:

var s;
WScript.Echo(s);
WScript.Echo("" + s);

Anda dapat mendeklarasikan variabel, setel ke nol, dan perilaku itu identik kecuali bahwa Anda akan melihat "null" dicetak versus "tidak terdefinisi". Ini memang perbedaan kecil.

Anda bahkan dapat membandingkan variabel yang tidak ditentukan ke nol atau sebaliknya, dan kondisinya akan benar:

undefined == null
null == undefined

Namun, mereka dianggap dua jenis yang berbeda. Sementara undefined adalah tipe untuk dirinya sendiri, null dianggap sebagai nilai objek khusus. Anda bisa melihat ini dengan menggunakan typeof () yang mengembalikan string yang mewakili tipe umum variabel:

var a;
WScript.Echo(typeof(a));
var b = null;
WScript.Echo(typeof(b));

Menjalankan skrip di atas akan menghasilkan output berikut:

undefined
object

Terlepas dari jenis mereka yang berbeda, mereka masih akan bertindak sama jika Anda mencoba mengakses anggota dari salah satu dari mereka, misalnya yang mengatakan mereka akan melemparkan pengecualian. Dengan WSH Anda akan melihat "varname 'yang ditakuti adalah nol atau bukan objek" dan itu jika Anda beruntung (tapi itu topik untuk artikel lain).

Anda dapat secara eksplisit mengatur variabel menjadi tidak terdefinisi, tetapi saya sangat menyarankan untuk tidak melakukannya. Saya sarankan hanya mengatur variabel ke nol dan meninggalkan nilai yang tidak ditentukan untuk hal-hal yang Anda lupa atur. Pada saat yang sama, saya sangat menyarankan Anda untuk selalu mengatur setiap variabel. JavaScript memiliki rantai cakupan yang berbeda dari bahasa gaya C, dengan mudah membingungkan programmer veteran, dan mengatur variabel ke null adalah cara terbaik untuk mencegah bug berdasarkannya.

Contoh lain di mana Anda akan melihat pop up tidak terdefinisi adalah ketika menggunakan operator hapus. Kita dari dunia C mungkin salah menafsirkan ini sebagai menghancurkan objek, tetapi tidak demikian. Apa yang dilakukan operasi ini adalah menghapus subskrip dari Array atau anggota dari Object. Untuk Array itu tidak mempengaruhi panjang, melainkan bahwa subskrip sekarang dianggap tidak terdefinisi.

var a = [ 'a', 'b', 'c' ];
delete a[1];
for (var i = 0; i < a.length; i++)
WScript.Echo((i+".) "+a[i]);

Hasil dari skrip di atas adalah:

0.) a
1.) undefined
2.) c

Anda juga akan mendapatkan pengembalian yang tidak terdefinisi saat membaca subskrip atau anggota yang tidak pernah ada.

Perbedaan antara nol dan tidak terdefinisi adalah: JavaScript tidak akan pernah mengatur apa pun menjadi nol, itulah yang biasanya kami lakukan. Meskipun kita dapat mengatur variabel ke undefined, kita lebih suka null karena itu bukan sesuatu yang pernah dilakukan untuk kita. Ketika Anda melakukan debug, ini berarti bahwa apa pun yang disetel ke nol adalah pekerjaan Anda sendiri dan bukan JavaScript. Di luar itu, dua nilai khusus ini hampir setara.

(menambahkan karakter karena kekurangan karakter, jadi saya diizinkan memposting ini.)

null adalah kata kunci khusus yang menunjukkan tidak adanya nilai.

pikirkan itu sebagai nilai, seperti:

• "Foo" adalah string,
• benar adalah boolean,
• 1234 adalah angka,
• null tidak terdefinisi.

properti tidak terdefinisi menunjukkan bahwa variabel belum diberi nilai termasuk null juga. Suka

var foo;

variabel kosong yang didefinisikan adalah nulltipe dataundefined

Keduanya mewakili nilai variabel tanpa nilai

DAN null tidak mewakili string yang tidak memiliki nilai - string kosong-

Suka

var a = ''; 
console.log(typeof a); // string 
console.log(a == null); //false 
console.log(a == undefined); // false 

Sekarang jika

var a;
console.log(a == null); //true
console.log(a == undefined); //true 

TAPI

var a; 
console.log(a === null); //false 
console.log(a === undefined); // true

SO masing-masing memiliki cara sendiri untuk digunakan

undefined menggunakannya untuk membandingkan tipe data variabel

null gunakan untuk mengosongkan nilai variabel

var a = 'javascript';
a = null ; // will change the type of variable "a" from string to object 

null : tidak adanya nilai untuk variabel; undefined : tidak adanya variabel itu sendiri;

Variabel ..where adalah nama simbol yang terkait dengan nilai.

JS bisa berbaik hati secara implisit init variabel yang baru dideklarasikan dengan nol , tetapi tidak.

Silakan baca yang berikut dengan seksama. Ini akan menghapus semua keraguan Anda mengenai perbedaan antara nol dan tidak terdefinisi dalam JavaScript. Anda juga dapat menggunakan fungsi utilitas yang diberikan di bawah ini untuk secara tepat menentukan jenis.

Dalam JavaScript kita dapat memiliki tipe variabel berikut.

1. Variabel yang tidak dideklarasikan
2. Variabel yang Dideklarasikan tetapi Tidak Ditugaskan
3. Variabel yang ditetapkan dengan literal tidak terdefinisi
4. Variabel yang ditetapkan dengan null literal
5. Variabel ditugaskan dengan apa pun selain yang tidak terdefinisi atau nol

Berikut ini menjelaskan masing-masing kasus ini satu per satu

1. Variabel yang tidak dideklarasikan: Berikut ini berlaku untuk variabel yang tidak dideklarasikan

   • Hanya dapat diperiksa dengan typeof () yang mengembalikan string 'tidak terdefinisi'
   • Tidak dapat diperiksa dengan == atau === atau dengan jika atau operator kondisional ? (melempar Kesalahan Referensi)

2. Variabel yang Dideklarasikan tetapi Tidak Ditugaskan

   • typeof mengembalikan string 'tidak terdefinisi'
   • == periksa dengan null mengembalikan true
   • == periksa dengan pengembalian tidak terdefinisi true
   • === periksa dengan null mengembalikan false
   • === periksa dengan pengembalian tidak terdefinisi benar
   • jika atau operator bersyarat ? mengembalikan salah

3. Variabel yang ditugaskan dengan literal tidak terdefinisi : Variabel-variabel ini diperlakukan sama seperti Variabel yang Dideklarasikan Tetapi Tidak Ditugaskan .

4. Variabel yang ditetapkan dengan null literal

   • typeof mengembalikan string 'objek'
   • == periksa dengan null mengembalikan true
   • == periksa dengan pengembalian tidak terdefinisi true
   • === periksa dengan null mengembalikan true
   • === periksa dengan pengembalian tidak terdefinisi salah
   • jika atau operator bersyarat ? mengembalikan salah

5. Variabel ditugaskan dengan apa pun selain yang tidak terdefinisi atau nol

   • typeof mengembalikan salah satu dari string berikut: 'string' , 'number' , 'boolean' , 'function' , 'object' , 'simbol'

Berikut ini menyediakan algoritma untuk pemeriksaan tipe variabel yang benar:

1. Periksa dideklarasikan / belum ditetapkan / ditugaskan dengan terdefinisi menggunakan typeof . kembali jika string 'tidak terdefinisi' dikembalikan.
2. Periksa null menggunakan === . kembalikan 'null' jika benar .
3. Periksa jenis aktual menggunakan typeof . ketik kembali jika tidak sama dengan 'objek'
4. Panggil Object.prototype.toString.call (o) untuk menentukan jenis objek yang sebenarnya. Ini akan mengembalikan string tipe '[objek ObjectType]' untuk semua dibangun di Javascript atau DOM didefinisikan Objek. Untuk objek yang ditentukan pengguna mengembalikan '[objek objek]'

Anda juga dapat menggunakan fungsi utilitas berikut untuk menentukan jenis. Saat ini mendukung semua jenis ECMA 262 2017.

function TypeOf(o,bReturnConstructor)
 {
   if(typeof o==='undefined') return 'undefined'
   if(o===null) return 'null'   
   if(typeof o!=='object') return typeof o

   var type=Object.prototype.toString.call(o)
  switch(type)
  {
     //Value types:4
     case '[object Number]': type='number';break;
     case '[object String]': type='string';break;
     case '[object Boolean]': type='boolean';break;
     case '[object Date]': type='date';break;


   //Error Types:7
     case '[object Error]': type='error';break;
     case '[object EvalError]': type='evalerror';break;
     case '[object RangeError]': type='rangeerror';break;
     case '[object ReferenceError]': type='referenceerror';break;
     case '[object SyntaxError]': type='syntaxerror';break;
     case '[object TypeError]': type='typeerror';break;
     case '[object URIError]': type='urierror';break;


    //Indexed Collection and Helper Types:13
     case '[object Array]': type='array';break;
     case '[object Int8Array]': type='int8array';break;
     case '[object Uint8Array]': type='uint8array';break;
     case '[object Uint8ClampedArray]': type='uint8clampedarray';break;
     case '[object Int16Array]': type='int16array';break;
     case '[object Uint16Array]': type='uint16array';break;
     case '[object Int32Array]': type='int32array';break;
     case '[object Uint32Array]': type='uint32array';break;
     case '[object Float32Array]': type='float32array';break;
     case '[object Float64Array]': type='float64array';break;
     case '[object ArrayBuffer]': type='arraybuffer';break;
     case '[object SharedArrayBuffer]': type='sharedarraybuffer';break;
     case '[object DataView]': type='dataview';break;

    //Keyed Collection Types:2
     case '[object Map]': type='map';break;
     case '[object WeakMap]': type='weakmap';break;

    //Set Types:2
     case '[object Set]': type='set';break;
     case '[object WeakSet]': type='weakset';break;

    //Operation Types
    case '[object RegExp]': type='regexp';break;
    case '[object Proxy]': type='proxy';break;
    case '[object Promise]': type='promise';break;

    case '[object Object]': type='object';
             if(bReturnConstructor && o.constructor) type=o.constructor.toString().match(/^function\s*([^\s(]+)/)[1];
         break;
    default:
        type=type.split(' ')[1]
        type=type.substr(0,type.length-1)   

   }
    return type 
}

Anda mungkin menganggap tidak terdefinisi untuk mewakili tidak adanya nilai tingkat sistem, tidak terduga, atau seperti kesalahan dan nol untuk mewakili tingkat program, normal, atau tidak adanya nilai yang diharapkan.

via JavaScript: Panduan Definitif

Saya akan menjelaskan undefined, nulldan Uncaught ReferenceError:

1 - Uncaught ReferenceError: variabel belum dideklarasikan dalam skrip Anda, tidak ada referensi untuk varaible ini
2 - undefined: Variabel dideklarasikan tetapi tidak diinisialisasi
3 - null: Variabel dideklarasikan dan merupakan nilai kosong

Tidak terdefinisi berarti suatu variabel telah dideklarasikan tetapi tidak memiliki nilai:

var var1;
alert(var1); //undefined
alert(typeof var1); //undefined

Null adalah tugas:

var var2= null;
alert(var2); //null
alert(typeof var2); //object

null dan undefined adalah dua tipe objek berbeda yang memiliki kesamaan berikut:

• keduanya hanya dapat memiliki nilai tunggal, masing-masing nol dan tidak terdefinisi ;
• keduanya tidak memiliki properti atau metode dan upaya untuk membaca properti apa pun dari keduanya akan menghasilkan kesalahan run-time (untuk semua objek lainnya, Anda mendapatkan nilai yang tidak terdefinisi jika Anda mencoba membaca properti yang tidak ada);
• nilai null dan undefined dianggap sama satu sama lain dan tidak ada yang lain oleh ==dan !=operator.

Kesamaan namun berakhir di sini. Untuk sekali, ada perbedaan mendasar dalam cara kata kunci null dan undefined diimplementasikan. Ini tidak jelas, tetapi perhatikan contoh berikut:

var undefined = "foo";
WScript.Echo(undefined); // This will print: foo

tidak terdefinisi , NaN dan Infinity hanyalah nama variabel "superglobal" yang telah diinisialisasi - mereka diinisialisasi pada saat run-time dan dapat diganti oleh variabel global atau lokal normal dengan nama yang sama.

Sekarang, mari kita coba hal yang sama dengan null :

var null = "foo"; // This will cause a compile-time error
WScript.Echo(null);

Ups! null , true dan false adalah kata kunci yang dipesan - kompiler tidak akan membiarkan Anda menggunakannya sebagai nama variabel atau properti

Perbedaan lainnya adalah bahwa undefined adalah tipe primitif, sedangkan null adalah tipe objek (menunjukkan tidak adanya referensi objek). Pertimbangkan yang berikut ini:

WScript.Echo(typeof false); // Will print: boolean
WScript.Echo(typeof 0); // Will print: number
WScript.Echo(typeof ""); // Will print: string
WScript.Echo(typeof {}); // Will print: object
WScript.Echo(typeof undefined); // Will print: undefined
WScript.Echo(typeof null); // (!!!) Will print: object

Juga, ada perbedaan penting dalam cara null dan tidak terdefinisi diperlakukan dalam konteks numerik:

var a; // declared but uninitialized variables hold the value undefined
WScript.Echo(a === undefined); // Prints: -1

var b = null; // the value null must be explicitly assigned 
WScript.Echo(b === null); // Prints: -1

WScript.Echo(a == b); // Prints: -1 (as expected)
WScript.Echo(a >= b); // Prints: 0 (WTF!?)

WScript.Echo(a >= a); // Prints: 0 (!!!???)
WScript.Echo(isNaN(a)); // Prints: -1 (a evaluates to NaN!)
WScript.Echo(1*a); // Prints: -1.#IND (in Echo output this means NaN)

WScript.Echo(b >= b); // Prints: -1 (as expected)
WScript.Echo(isNaN(b)); // Prints: 0 (b evaluates to a valid number)
WScript.Echo(1*b); // Prints: 0 (b evaluates to 0)

WScript.Echo(a >= 0 && a <= 0); // Prints: 0 (as expected)
WScript.Echo(a == 0); // Prints: 0 (as expected)
WScript.Echo(b >= 0 && b <= 0); // Prints: -1 (as expected)
WScript.Echo(b == 0); // Prints: 0 (!!!)

null menjadi 0 ketika digunakan dalam ekspresi aritmatika atau perbandingan numerik - mirip dengan false , pada dasarnya hanya jenis khusus "nol". undefined , di sisi lain, adalah "tidak ada" yang benar dan menjadi NaN ("bukan angka") ketika Anda mencoba menggunakannya dalam konteks numerik.

Perhatikan bahwa nol dan tidak terdefinisi menerima perlakuan khusus dari ==dan !=operator, tetapi Anda dapat menguji kesetaraan numerik sebenarnya dari a dan b dengan ekspresi (a >= b && a <= b).

tl; dr

Gunakan nulluntuk mengatur variabel yang Anda tahu itu adalah Object.

Gunakan undefineduntuk mengatur variabel yang tipenya tercampur.

Ini adalah penggunaan saya atas 5 primitif dan tipe Objek, dan itu menjelaskan perbedaan antara «use case» dari undefinedatau null.

Tali

Jika Anda tahu variabel hanya berupa string sementara semua siklus hidup, berdasarkan konvensi, Anda bisa menginisialisasi variabel itu, untuk "":

("") ? true : false; // false
typeof ""; // "string";
("Hello World") ? true : false; // true
typeof "Hello World"; // "string"

Jumlah

Jika Anda tahu variabel hanya berupa angka sementara semua siklus hidup, berdasarkan konvensi, Anda dapat menginisialisasi variabel tersebut ke 0(atau NaNjika 0merupakan nilai penting dalam penggunaan Anda):

(0) ? true : false; // false
typeof 0; // "number";
(16) ? true : false; // true
typeof 16; // "number"

atau

(NaN) ? true : false; // false
typeof NaN; // "number";
(16) ? true : false; // true
typeof 16; // "number"

Boolean

Jika Anda tahu variabel hanya boolean sementara semua siklus hidup, dengan konvensi, Anda bisa menginisialisasi, untuk false:

(false) ? true : false; // false
typeof false; // "boolean";
(true) ? true : false; // true
typeof true; // "boolean"

Obyek

Jika Anda tahu bahwa variabel hanyalah Objek sementara semua siklus hidup, dengan konvensi, Anda dapat menginisialisasi variabel tersebut, untuk null:

(null) ? true : false; // false
typeof null; // "object";
({}) ? true : false; // true
typeof {}; // "object"

Catatan: penggunaan cerdas dari nol adalah menjadi versi palsu dari suatu Obyek karena Obyek selalu true, dan karena typeof nullkembali object. Itu berarti typeof myVarObjectmengembalikan nilai yang konsisten untuk objek dan tipe null.

Semua

Jika Anda tahu suatu variabel memiliki tipe campuran (semua jenis selama semua siklus hidup), dengan konvensi, Anda dapat menginisialisasi variabel tersebut ke undefined.

nulladalah nilai khusus yang berarti "tidak ada nilai". nulladalah objek khusus karena typeof nullmengembalikan 'objek'.

Di sisi lain, undefinedberarti variabel belum dideklarasikan, atau belum diberi nilai.

Cara terbaik untuk memahami perbedaannya adalah dengan terlebih dahulu menjernihkan pikiran Anda tentang cara kerja JavaScript dalam dan hanya memahami perbedaan makna antara:

let supervisor = "None"
    // I have a supervisor named "None"

let supervisor = null
    // I do NOT have a supervisor. It is a FACT that I do not.

let supervisor = undefined
    // I may or may not have a supervisor. I either don't know
    // if I do or not, or I am choosing not to tell you. It is
    // irrelevant or none of your business.

Ada perbedaan makna antara ketiga kasus ini, dan JavaScript membedakan dua kasus terakhir dengan dua nilai yang berbeda, nulldan undefined. Anda bebas menggunakan nilai-nilai itu secara eksplisit untuk menyampaikan makna tersebut.

Jadi apa saja masalah spesifik JavaScript yang muncul karena dasar filosofis ini?

1. Variabel yang dideklarasikan tanpa penginisialisasi mendapatkan nilai undefinedkarena Anda tidak pernah mengatakan apa pun tentang nilai yang dimaksud.

   let supervisor;
   assert(supervisor === undefined);

2. Properti objek yang belum pernah disetel dievaluasi undefined karena tidak ada yang pernah mengatakan apa pun tentang properti itu.

   const dog = { name: 'Sparky', age: 2 };
   assert(dog.breed === undefined);

3. null dan undefined "mirip" satu sama lain karena Brendan Eich mengatakan demikian. Tetapi mereka secara tegas tidak setara satu sama lain.

   assert(null == undefined);
   assert(null !== undefined);

4. nulldan undefineduntungnya memiliki tipe yang berbeda. nulltermasuk tipeNull danundefined tipe Undefined. Ini ada dalam spec, tetapi Anda tidak akan pernah tahu ini karena typeofkeanehan yang tidak akan saya ulangi di sini.

5. Fungsi yang mencapai ujung tubuhnya tanpa pernyataan pengembalian yang eksplisit muncul undefinedkarena Anda tidak tahu apa-apa tentang apa yang dikembalikan.

Ngomong-ngomong, ada bentuk lain dari "ketiadaan" dalam JavaScript (ada baiknya mempelajari Filsafat ....)

• NaN
• Menggunakan variabel yang belum pernah dideklarasikan dan menerima a ReferenceError
• Menggunakan sebuah let atauconst variabel lokal didefinisikan dalam zona mati sementara dan menerimaReferenceError

• Sel kosong dalam array jarang. Ya ini bahkan tidak undefineddibandingkan ===dengan yang tidak terdefinisi.

  $ node
  > const a = [1, undefined, 2]
  > const b = [1, , 2]
  > a
  [ 1, undefined, 2 ]
  > b
  [ 1, <1 empty item>, 2 ]

Di JavasSript ada 5 tipe data primitif String, Number, Boolean, null, dan undefined. Saya akan mencoba menjelaskan dengan beberapa contoh sederhana

katakanlah kita memiliki fungsi sederhana

 function test(a) {

     if(a == null){
        alert("a is null");
     } else {
        alert("The value of a is " + a);
     }
  }

juga dalam fungsi di atas jika (a == null) sama seperti if (! a)

sekarang ketika kita memanggil fungsi ini tanpa melewati parameter a

   test(); it will alert "a is null";
   test(4); it will alert "The value of a is " + 4;

juga

var a;
alert(typeof a); 

ini akan memberikan yang tidak terdefinisi; kami telah mendeklarasikan variabel tetapi kami belum menetapkan nilai apa pun untuk variabel ini; tetapi jika kita menulis

var a = null;
alert(typeof a); will give alert as object

jadi null adalah objek. dengan cara kami telah menetapkan nilai nol ke 'a'

Untuk undefinedjenis, ada satu dan hanya satu nilai: undefined.

Untuk nulljenis, ada satu dan hanya satu nilai: null.

Jadi untuk keduanya, labelnya adalah jenis dan nilainya.

Perbedaan di antara mereka. Sebagai contoh:

• null adalah nilai kosong
• undefined adalah nilai yang hilang

Atau:

• undefined belum memiliki nilai
• null punya nilai dan tidak lagi

Sebenarnya, nullini adalah kata kunci khusus , bukan pengidentifikasi, dan dengan demikian Anda tidak dapat memperlakukannya sebagai variabel untuk ditugaskan.

Namun, undefinedmerupakan pengidentifikasi . Namun dalam non-strictmode dan strictmode, Anda dapat membuat variabel lokal dari nama yang tidak ditentukan. Tetapi ini adalah satu ide yang mengerikan!

function foo() {
    undefined = 2; // bad idea!
}

foo();

function foo() {
    "use strict";
    undefined = 2; // TypeError!
}

foo();

Ketika Anda mendeklarasikan variabel dalam javascript, itu diberi nilai undefined. Ini berarti variabel tidak tersentuh dan dapat diberi nilai apa pun di masa depan. Ini juga menyiratkan bahwa Anda tidak tahu nilai yang variabel ini akan pegang pada saat deklarasi.

Sekarang Anda dapat menetapkan variabel secara eksplisit null. Ini berarti bahwa variabel tidak memiliki nilai apa pun. Misalnya - Beberapa orang tidak memiliki nama tengah. Jadi dalam kasus seperti itu lebih baik untuk menetapkan nilai nol ke variabel middlename objek seseorang.

Sekarang anggaplah seseorang sedang mengakses variabel middlename dari objek orang Anda dan ia memiliki nilai undefined. Dia tidak akan tahu jika pengembang lupa menginisialisasi variabel ini atau jika tidak memiliki nilai. Jika memiliki nilai null, maka pengguna dapat dengan mudah menyimpulkan bahwa middlename tidak memiliki nilai apa pun dan itu bukan variabel yang tidak tersentuh.

null dan undefined keduanya digunakan untuk mewakili tidak adanya nilai.

var a = null;

a diinisialisasi dan didefinisikan.

typeof(a)
//object

null adalah objek dalam JavaScript

Object.prototype.toString.call(a) // [object Object]

var b;

b tidak ditentukan dan tidak diinisialisasi

properti objek tidak terdefinisi juga tidak terdefinisi. Misalnya "x" tidak didefinisikan pada objek c dan jika Anda mencoba mengakses cx, itu akan kembali tidak terdefinisi.

Secara umum kami menetapkan null untuk variabel yang tidak ditentukan.

Per artikel menyeluruh Ryan Morr tentang hal ini ...

"Secara umum, jika Anda perlu menetapkan nilai-tidak ke variabel atau properti, meneruskannya ke suatu fungsi, atau mengembalikannya dari suatu fungsi, null hampir selalu merupakan pilihan terbaik. Sederhananya, JavaScript menggunakan undefined dan programmer harus gunakan null. "

Lihat Menjelajahi Jurang Abadi dari Null dan Undefined

Baik Null maupun undefined dalam JavaScript menunjukkan tidak adanya nilai.

var a = null; //variable assigned null value
var b;  // undefined

Terlepas dari kenyataan keduanya ada karena tidak adanya nilai tetapi: Undefined sebenarnya berarti variabel tidak diinisialisasi. Fungsi yang tidak mengembalikan apa pun dan parameter fungsi yang tidak diberi nilai, nilai yang tidak ditentukan dikembalikan. Gunakan operator kesetaraan yang ketat === untuk membedakan antara nol dan tidak terdefinisi.

Referensi: http://www.thesstech.com/javascript/null-and-undefined

OK, kita mungkin bingung ketika kita mendengar tentang , nulldan undefinedmari kita mulai dengan sederhana, mereka berdua palsu dan mirip dalam banyak hal, tetapi bagian aneh dari JavaScript, membuat mereka beberapa perbedaan yang signifikan, misalnya, typeof null adalah 'object'sementara typeof undefined adalah 'undefined'.

typeof null; //"object"
typeof undefined; //"undefined";

Tetapi jika Anda memeriksa mereka dengan ==seperti di bawah ini, Anda melihat mereka berdua falsy :

null==undefined; //true

Anda juga dapat menetapkan nullke properti objek atau ke primitif, sementara undefinedhanya dapat dicapai dengan tidak menetapkan apa pun.

Saya membuat gambar cepat untuk menunjukkan perbedaan untuk Anda sekilas.

Sebagai typeof mengembalikan undefined, undefined adalah tipe dimana null adalah inisialisasi menunjukkan variabel poin ke objek (hampir semua yang ada di Javascript adalah objek).

Dalam javascript semua variabel disimpan sebagai pasangan nilai kunci. Setiap variabel disimpan sebagai variable_name: variable_value / referensi .

tidak terdefinisi berarti suatu variabel telah diberi ruang dalam memori, tetapi tidak ada nilai yang diberikan padanya. Sebagai praktik terbaik, Anda tidak boleh menggunakan jenis ini sebagai tugas.

Dalam hal itu bagaimana menunjukkan ketika Anda ingin variabel menjadi tanpa nilai pada titik selanjutnya dalam kode? Anda dapat menggunakan tipe nol , yang juga merupakan tipe yang digunakan untuk mendefinisikan hal yang sama, tidak adanya nilai, tetapi tidak sama dengan tidak terdefinisi, karena dalam hal ini Anda benar-benar memiliki nilai dalam memori. Nilai itu adalah nol

Keduanya serupa tetapi penggunaan dan artinya berbeda.

Saya ingin menambahkan perbedaan yang sangat halus antara nulldan undefinedmana yang baik untuk diketahui ketika Anda mencoba mempelajari JavaScript Vanilla (JS) dari awal:

• nulladalah kata kunci yang dilindungi undang-undang di JS sementara undefinedadalah variabel pada objek global dari lingkungan run-time Anda berada.

Saat menulis kode, perbedaan ini tidak dapat diidentifikasi karena keduanya nulldan undefinedselalu digunakan dalam RHS dari pernyataan JavaScript. Tetapi ketika Anda menggunakannya dalam LHS ekspresi maka Anda dapat mengamati perbedaan ini dengan mudah. Jadi JS interpreter menafsirkan kode di bawah ini sebagai kesalahan:

var null = 'foo'

Ini memberi kesalahan di bawah ini:

Uncaught SyntaxError: Token tak terduga nol

Sementara kode di bawah ini berjalan dengan sukses walaupun saya tidak akan merekomendasikan melakukannya di kehidupan nyata:

var undefined = 'bar'

Ini berfungsi karena undefinedmerupakan variabel pada objek global (objek jendela browser jika JS sisi klien)

Perbedaan antara undefineddan nullminimal, tetapi ada perbedaan. Variabel yang nilainya undefinedbelum pernah diinisialisasi. Variabel yang nilainya nullsecara eksplisit diberi nilai null, yang berarti bahwa variabel tersebut secara eksplisit diatur tidak memiliki nilai. Jika Anda membandingkan undefineddan nulldengan menggunakan null==undefinedekspresi, mereka akan sama.

Pada dasarnya, Undefined adalah variabel global yang dibuat javascript pada saat dijalankan apakah null berarti bahwa tidak ada nilai yang ditetapkan ke variabel (sebenarnya null itu sendiri merupakan objek).

Mari kita ambil contoh:

        var x;  //we declared a variable x, but no value has been assigned to it.
        document.write(x) //let's print the variable x

Tidak terdefinisi, itulah yang akan Anda dapatkan sebagai output.

Sekarang,

        x=5;
        y=null;
        z=x+y;

dan Anda akan mendapatkan 5 sebagai output. Itulah perbedaan utama antara Undefined dan null

null - Ini adalah nilai penugasan, yang digunakan dengan variabel untuk menyatakan tidak ada nilai (itu adalah objek).

undefined - Ini adalah variabel yang tidak memiliki nilai apa pun yang ditetapkan padanya, jadi JavaScript akan menetapkan yang tidak terdefinisi padanya (ini adalah tipe data).

tidak dideklarasikan - Jika suatu variabel tidak dibuat sama sekali, itu dikenal sebagai tidak dideklarasikan.

Lihat ini. Outputnya bernilai ribuan kata.

var b1 = document.getElementById("b1");

checkif("1, no argument"                        );
checkif("2, undefined explicitly",     undefined);
checkif("3, null explicitly",               null);
checkif("4, the 0",                            0);
checkif("5, empty string",                    '');
checkif("6, string",                    "string");
checkif("7, number",                      123456);

function checkif (a1, a2) {
	print("\ncheckif(), " + a1 + ":");
	if (a2 == undefined) {
		print("==undefined:    YES");
	} else {
		print("==undefined:    NO");
	}
	if (a2 === undefined) {
		print("===undefined:   YES");
	} else {
		print("===undefined:   NO");
	}
	if (a2 == null) {
		print("==null:         YES");
	} else {
		print("==null:         NO");
	}
	if (a2 === null) {
		print("===null:        YES");
	} else {
		print("===null:        NO");
	}
	if (a2 == '') {
		print("=='':           YES");
	} else {
		print("=='':           NO");
	}
	if (a2 === '') {
		print("==='':          YES");
	} else {
		print("==='':          NO");
	}
	if (isNaN(a2)) {
		print("isNaN():        YES");
	} else {
		print("isNaN():        NO");
	}
	if (a2) {
		print("if-?:           YES");
	} else {
		print("if-?:           NO");
	}
		print("typeof():       " + typeof(a2));
}

function print(v) {
	b1.innerHTML += v + "\n";
}

<!DOCTYPE html>
<html>
<body>
<pre id="b1"></pre>
</body>
</html>

Lihat juga:

• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/null
• https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators

Bersulang!

Kedua nilai khusus menyiratkan keadaan kosong.

Perbedaan utama adalah bahwa undefined mewakili nilai dari variabel yang belum diinisialisasi, sedangkan nol mewakili tidak disengaja suatu objek.

Namun, nomor variabel tidak ditentukan dengan nilai awal:

let number;
number; // => undefined

variabel angka tidak terdefinisi, yang dengan jelas menunjukkan variabel yang tidak diinisialisasi

Konsep tidak diinisialisasi yang sama terjadi ketika properti objek yang tidak ada diakses:

const obj = { firstName: 'Dmitri' };
obj.lastName; // => undefined

Karena properti lastName tidak ada di obj, JavaScript dengan benar mengevaluasi obj.lastName menjadi tidak terdefinisi.

Dalam kasus lain, Anda tahu bahwa suatu variabel mengharapkan untuk memegang suatu objek atau fungsi untuk mengembalikan suatu objek. Tetapi karena alasan tertentu, Anda tidak dapat membuat instance objek. Dalam kasus seperti itu, null adalah indikator bermakna dari objek yang hilang.

Misalnya, klon () adalah fungsi yang mengkloning objek JavaScript biasa. Fungsi ini diharapkan untuk mengembalikan objek:

function clone(obj) {
  if (typeof obj === 'object' && obj !== null) {
    return Object.assign({}, obj);
  }
  return null;
}
clone({name: 'John'}); // => {name: 'John'}
clone(15);             // => null
clone(null);           // => null

Namun, klon () dapat dipanggil dengan argumen non-objek: 15 atau nol (atau umumnya nilai primitif, nol atau tidak terdefinisi). Dalam kasus tersebut, fungsi tidak dapat membuat klon, sehingga mengembalikan null - indikator dari objek yang hilang

typeof operator membuat perbedaan antara dua nilai:

typeof undefined; // => 'undefined'
typeof null;      // => 'object'

Operator kualitas ketat === dengan benar membedakan tidak terdefinisi dari nol:

let nothing = undefined;
let missingObject = null;
nothing === missingObject; // => false

Selain makna yang berbeda ada perbedaan lain:

1. Destrukturisasi objek bekerja secara berbeda untuk dua nilai ini:

   const { a = "default" } = { a: undefined }; // a is "default"
   const { b = "default" } = { b: null };      // b is null

2. JSON.stringify () menyimpan nulltetapi menghilangkanundefined

   const json = JSON.stringify({ undefinedValue: undefined, nullValue: null });
   console.log(json); // prints {"nullValue":null}

3. typeof operator

   console.log(typeof undefined); // "undefined"
   console.log(typeof null);      // "object" instead of "null"

Jika suatu variabel tidak diinisialisasi maka itu tidak terdefinisi. undefined bukan objek. Contoh: var MyName; console.log (ketik MyName);

Periksa konsol konsol di alat pengembangan, itu akan dicetak sebagai tidak terdefinisi.

null adalah objek. Jika Anda ingin beberapa variabel menjadi nol maka null digunakan. Variabel kosong ada tetapi nilainya tidak diketahui. Ini harus ditugaskan ke variabel pro gramatikal. null tidak diinisialisasi secara otomatis.

Contoh: var MyName = null; console.log (ketik MyName); Periksa csole log in alat pengembangan, itu akan menjadi objek.