Pelajari kemahiran javascript yang tidak ditentukan dan null_javascript daripada saya

Apabila membincangkan jenis data primitif dalam JavaScript, kebanyakan orang mengetahui asas daripada String ke Nombor kepada Boolean. Jenis primitif ini agak mudah dan berkelakuan seperti akal. Walau bagaimanapun, artikel ini akan lebih memfokuskan pada jenis data primitif unik Null dan Undefined, dan perkara yang menjadikannya begitu serupa namun paradoks.

1. Faham null dan undefined

Dalam JavaScript, null ialah literal dan kata kunci dalam bahasa, digunakan untuk mewakili nilai objek yang tidak dikenali. Dalam erti kata lain, ini digunakan untuk bermaksud "tiada nilai", tetapi anda boleh memutuskan bila untuk mendapatkan nilai yang dijangkakan.

Walaupun serupa, undefined sebenarnya mewakili ketiadaan nilai, yang bermaksud anda mempunyai sesuatu yang hilang. Kedua-duanya tidak boleh diubah sepenuhnya, tidak mempunyai sifat dan kaedah, dan sifatnya tidak boleh diberikan nilai. Malah, TypeError akan dibangkitkan apabila anda cuba mengakses atau menentukan sifat yang batal atau tidak ditentukan.

Nilai Boolean yang diwakili tanpa nilai adalah palsu, yang bermaksud nilai tersebut akan dinilai palsu dalam konteks bersyarat, seperti pernyataan if. Gunakan pengendali kesamaan (==) untuk membandingkan kedua-dua nilai ini dengan nilai palsu yang lain, ia tidak sama kecuali diri mereka sendiri:

null == 0; // false 
undefined == ""; // false 
null == false; // false 
undefined == false; // false 
null == undefined; // true 

Walau bagaimanapun, dan persamaan lain, null dan undefined adalah tidak bersamaan. Masing-masing adalah ahli unik dari jenisnya sendiri, undefined adalah jenis Undefined dan null adalah jenis Object. Bandingkan kedua-dua nilai ini menggunakan operator kesamaan (===), yang memerlukan kedua-dua jenis dan nilai adalah sama, seperti yang ditunjukkan di bawah:

null === undefined; //false
typeof null; //"object"
typeof undefined; //"undefined"

Perihalan di atas: null Ini adalah objek, tetapi ia kosong. Dan null ialah kata kunci simpanan JavaScript.
Di samping itu, apabila null mengambil bahagian dalam operasi berangka, nilainya akan ditukar secara automatik kepada 0. Oleh itu, ungkapan berikut akan memperoleh nilai yang betul selepas pengiraan:

123 + null;　　　//123 
123 * null;　　　//0 

undefined ialah sifat istimewa objek global (tetingkap) dan nilainya tidak ditentukan. Tetapi jenis pulangan yang tidak ditentukan 'tidak ditentukan' .
Walaupun undefined mempunyai makna yang istimewa, ia sememangnya harta, dan ia adalah harta objek global (tetingkap). Sila lihat kod di bawah:

alert('undefined' in window);//输出：true 
var anObj = {}; 
alert('undefined' in anObj); //输出：false 

Ia boleh dilihat daripada ini bahawa undefined ialah sifat objek tetingkap, tetapi ia bukan sifat objek anObj.
Nota:

• Walaupun undefined ialah atribut dengan makna istimewa, ia bukan kata kunci simpanan dalam JavaScript. Apabila undefined mengambil bahagian dalam sebarang pengiraan berangka, hasilnya mestilah NaN. Ngomong-ngomong, NaN ialah satu lagi sifat istimewa objek global (tetingkap), dan begitu juga Infinity. Tiada satu pun daripada atribut istimewa ini adalah kata kunci yang dikhaskan untuk JavaScript!
• Apabila mengesahkan bahawa nilai atau objek adalah batal, anda perlu menggunakan "===" untuk menentukan Jika anda hanya menggunakan "==", anda tidak boleh menentukan sama ada ia adalah batal atau tidak ditentukan.

2. Situasi yang tidak ditentukan berlaku
Terdapat banyak cara untuk menjana kod dengan nilai yang tidak ditentukan. Ia biasanya ditemui apabila cuba mengakses nilai yang tidak wujud. Dalam kes ini, dalam bahasa yang dinamik dan ditaip lemah seperti JavaScript, nilai yang tidak ditentukan akan dikembalikan secara lalai dan bukannya meningkat kepada ralat.

1. Mana-mana pembolehubah yang diisytiharkan tanpa nilai awal akan mempunyai nilai lalai yang tidak ditentukan:

var foo; // 默认值为 undefined 

2. Apabila cuba mengakses sifat objek atau item tatasusunan yang tidak wujud, nilai yang tidak ditentukan dikembalikan:

var array = [1, 2, 3]; 
var foo = array.foo; // foo 属性不存在, 返回 undefined 
var item = array[5]; // 数组中没有索引为5的项，返回 undefined 

3 Jika penyataan pemulangan fungsi ditinggalkan, atau penyataan pemulangan tidak mengambil sebarang parameter dan mengembalikan tidak ditentukan:

var value = (function(){

})(); // 返回 undefined 
var value1 = (function(){
  return;
})(); // 返回 undefined 

4 Apabila memanggil fungsi, parameter yang sepatutnya disediakan tidak disediakan, dan parameter adalah sama dengan undefined

function f(x){
  console.log(x)
}
f(); // undefined

Akhir sekali, undefined ialah pembolehubah global yang dipratentukan (tidak seperti kata kunci nol) yang dimulakan kepada nilai yang tidak ditentukan:

'undefined' in window; // true 

ECMAScript 5中，这个变量是只读的，以前并非如此。

三、null的用例

null的用例是使他与众不同的主要方面，因为不像undefined，null被认为是更有用。这正是为什么typeof操作符作用于null值 时返回“object”。最初的理由是，现在仍然是，通常用作一个空引用一个空对象的预期,就像一个占位符。typeof的这种行为已经被确认为一个错 误，虽然提出了修正，出于后兼容的目的，这一点已经保持不变。

一般来说,如果你需要给一个变量或属性指定一个不变值，将它传递给一个函数，或者从一个函数返回null，null几乎总是最好的选择。简而言之，JavaScript使用undefined并且程序员应该使用null。

null的另一个可行的用例，也被认为是良好的实践是一个显式指定变量为无效(object= null)当一个引用不再是必需的。通过分配null值，有效地清除引用，并假设对象没有引用其他代码，指定垃圾收集，确保回收内存。

四、提高undefined性能

当我们在程序中使用undefined值时，实际上使用的是window对象的undefined属性。 同样，当我们定义一个变量但未赋予其初始值，例如：

var aValue; 

这时，JavaScript在所谓的预编译时会将其初始值设置为对window.undefined属性的引用， 于是，当我们将一个变量或值与undefined比较时，实际上是与window对象的undefined属性比较。这个比较过程中，JavaScript会搜索window对象名叫‘undefined'的属性，然后再比较两个操作数的引用指针是否相同。

由于window对象的属性值是非常多的，在每一次与undefined的比较中，搜索window对象的undefined属性都会花费时 间。在需要频繁与undefined进行比较的函数中，这可能会是一个性能问题点。因此，在这种情况下，我们可以自行定义一个局部的undefined变 量，来加快对undefined的比较速度。例如：

function anyFunc() { 
  var undefined; 
  //自定义局部undefined变量 
  if(x == undefined) 
  //作用域上的引用比较 
  while(y != undefined) 
  //作用域上的引用比较 
}; 

其中，定义undefined局部变量时，其初始值会是对window.undefined属性值的引用。新定义的局部undefined变 量存在与该函数的作用域上。在随后的比较操作中，JavaScript代码的书写方式没有任何的改变，但比较速度却很快。因为作用域上的变量数量会远远少 于window对象的属性，搜索变量的速度会极大提高。

这就是许多前端JS框架为什么常常要自己定义一个局部undefined变量的原因！

以上就是本文的全部内容，希望对大家的学习有所帮助。