Tại sao null là một đối tượng và sự khác biệt giữa null và không xác định?

Tại sao được nullcoi là một objectJavaScript?

Đang kiểm tra

if ( object == null )
      Do something

giống như

if ( !object )
      Do something

?

Và cũng:

Sự khác biệt giữa nullvà là undefinedgì?

(name is undefined)

Bạn: là namegì? ^(*)
JavaScript : name ? Một là gì name? Tôi không biết bạn đang nói về cái gì. Bạn chưa từng đề cập đến bất kỳ nametrước đây. Bạn có thấy một số ngôn ngữ kịch bản khác ở phía (client-) không?

name = null;

Bạn: là namegì?
JavaScript: Tôi không biết.

Nói ngắn gọn; undefinedlà nơi không có khái niệm về sự vật tồn tại; nó không có loại và nó chưa bao giờ được tham chiếu trước trong phạm vi đó; nulllà nơi mà sự vật được biết là tồn tại, nhưng nó không biết giá trị là gì.

Một điều cần nhớ là null, về mặt khái niệm, không giống falsehoặc ""hoặc như vậy, ngay cả khi chúng đánh đồng sau khi đúc kiểu, nghĩa là

name = false;

Bạn: là namegì?
JavaScript: Boolean sai.

name = '';

Bạn: là namegì?
JavaScript: Chuỗi rỗng

^{*: nametrong ngữ cảnh này có nghĩa là một biến chưa bao giờ được xác định. Nó có thể là bất kỳ biến không xác định nào, tuy nhiên, tên là thuộc tính của bất kỳ thành phần biểu mẫu HTML nào. Nó đi, cách trở lại và được thiết lập tốt trước khi id. Nó rất hữu ích vì id phải là duy nhất nhưng tên không phải là.}

Sự khác biệt có thể được tóm tắt trong đoạn trích này:

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

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

Kiểm tra

object == nulllà khác nhau để kiểm tra if ( !object ).

Cái sau bằng ! Boolean(object), bởi vì toán tử đơn nguyên !tự động chuyển toán hạng bên phải vào Boolean.

Vì Boolean(null)bằng sai rồi !false === true.

Vì vậy, nếu đối tượng của bạn không phải là null , nhưng sai hoặc 0 hoặc "" , kiểm tra sẽ vượt qua vì:

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

nulllà không phải là một đối tượng , đó là một giá trị nguyên thủy . Ví dụ, bạn không thể thêm thuộc tính cho nó. Đôi khi mọi người sai lầm cho rằng đó là một đối tượng, bởi vì typeof nulltrả lại "object". Nhưng đó thực sự là một lỗi (thậm chí có thể được sửa trong ECMAScript 6).

Sự khác biệt giữa nullvà undefinednhư sau:

• undefined: được sử dụng bởi JavaScript và có nghĩa là không có giá trị. Các biến chưa được khởi tạo, các tham số bị thiếu và các biến chưa biết có giá trị đó.

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

  Tuy nhiên, việc truy cập các biến không xác định sẽ tạo ra một ngoại lệ:

  > unknownVariable
  ReferenceError: unknownVariable is not defined

• null: được sử dụng bởi các lập trình viên để chỉ ra không có giá trị, ví dụ như một tham số cho hàm.

Kiểm tra một biến:

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

Theo nguyên tắc chung, bạn phải luôn sử dụng === và không bao giờ == trong JavaScript (== thực hiện tất cả các loại chuyển đổi có thể tạo ra kết quả không mong muốn). Kiểm tra x == nulllà một trường hợp cạnh, bởi vì nó hoạt động cho cả hai nullvà undefined:

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

Một cách phổ biến để kiểm tra xem một biến có giá trị hay không là chuyển đổi nó thành boolean và xem liệu nó có true. Chuyển đổi đó được thực hiện bởi ifcâu lệnh và toán tử boolean! ("không phải").

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";
}

Hạn chế của phương pháp này: Tất cả các giá trị sau đây ước tính false, vì vậy bạn phải cẩn thận (ví dụ: các kiểm tra ở trên không thể phân biệt giữa undefinedvà 0).

• undefined, null
• Booleans: false
• Số: +0, -0,NaN
• Dây: ""

Bạn có thể kiểm tra chuyển đổi sang boolean bằng cách sử dụng Booleannhư một hàm (thông thường nó là hàm tạo, được sử dụng với new):

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

Sự khác biệt giữa null và không xác định là gì ??

Một thuộc tính khi nó không có định nghĩa, là không xác định. null là một đối tượng Loại của nó là đối tượng. null là một giá trị đặc biệt có nghĩa là "không có giá trị. không xác định không phải là một đối tượng, loại của nó là không xác định.

Bạn có thể khai báo một biến, đặt nó thành null và hành vi giống hệt nhau ngoại trừ việc bạn sẽ thấy "null" được in ra so với "không xác định". Bạn thậm chí có thể so sánh một biến không xác định thành null hoặc ngược lại và điều kiện sẽ là đúng:

 undefined == null
 null == undefined

Tham khảo Sự khác biệt của JavaScript giữa null và không xác định để biết thêm chi tiết.

và với chỉnh sửa mới của bạn, vâng

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

Khi kiểm tra nếu đối tượng là sai, cả hai chỉ đáp ứng điều kiện khi kiểm tra nếu sai , nhưng không phải khi đúng

Kiểm tra tại đây: Javascript gotcha

Phần đầu tiên của câu hỏi:

Tại sao null được coi là một đối tượng trong JavaScript?

Đây là lỗi thiết kế JavaScript mà họ không thể khắc phục ngay bây giờ. Nó nên là loại null, không phải loại đối tượng, hoặc không có nó ở tất cả. Nó đòi hỏi phải kiểm tra thêm (đôi khi bị lãng quên) khi phát hiện vật thể thật và là nguồn gây ra lỗi.

Phần thứ hai của câu hỏi:

Đang kiểm tra


if (object == null)
Do something

giống như

if (!object)
Do something

Hai kiểm tra luôn luôn là sai ngoại trừ:

• đối tượng không xác định hoặc null: cả hai đều đúng.

• đối tượng là nguyên thủy và 0 "", hoặc sai: đầu tiên kiểm tra sai, thứ hai đúng.

Nếu đối tượng không phải là một nguyên thủy, nhưng một đối tượng thực, giống như new Number(0), new String("")hoặc new Boolean(false), sau đó cả hai tờ séc đều sai.

Vì vậy, nếu 'đối tượng' được hiểu là một Đối tượng thực thì cả hai kiểm tra luôn giống nhau. Nếu nguyên thủy được cho phép thì kiểm tra khác 0 ""và sai.

Trong trường hợp như object==null, kết quả không rõ ràng có thể là một nguồn lỗi. Sử dụng ==không được khuyến khích bao giờ, sử dụng ===thay thế.

Phần thứ ba của câu hỏi:

Và cũng:

sự khác biệt giữa null và không xác định là gì?

Trong JavaScript, một điểm khác biệt là null thuộc loại đối tượng và không xác định là loại không xác định.

Trong JavaScript, null==undefinedlà đúng và được coi là bằng nhau nếu loại bị bỏ qua. Tại sao họ quyết định điều đó, nhưng 0 ""và sai không bằng nhau, tôi không biết. Nó dường như là một ý kiến ​​độc đoán.

Trong JavaScript, điều null===undefinednày không đúng vì loại phải giống nhau ===.

Trong thực tế, null và không xác định là giống hệt nhau, vì cả hai đều đại diện cho sự không tồn tại. Vì vậy, làm 0, và ""cho vấn đề đó quá, và có thể các container rỗng []và {}. Vì vậy, nhiều loại giống nhau không có gì là một công thức cho lỗi. Một loại hoặc không có gì là tốt hơn. Tôi sẽ cố gắng sử dụng càng ít càng tốt.

'sai', 'đúng' và '!' là một túi giun khác có thể được đơn giản hóa, ví dụ, if(!x)và if(x)một mình là đủ, bạn không cần đúng và sai.

Một khai báo var xlà loại không xác định nếu không có giá trị nào được đưa ra, nhưng nó sẽ giống như nếu x không bao giờ được khai báo. Một nguồn lỗi khác là một container không có gì. Vì vậy, tốt nhất là khai báo và định nghĩa nó cùng nhau, như thế nào var x=1.

Mọi người đang đi vòng tròn trong vòng tròn cố gắng tìm ra tất cả các loại không có gì, nhưng tất cả chỉ là cùng một thứ trong những bộ quần áo phức tạp khác nhau. Thực tế là

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

Và có lẽ tất cả nên ném ngoại lệ.

var x = null;

x được định nghĩa là null

y không được xác định; // vì tôi không định nghĩa nó

if (!x)

null được đánh giá là sai

Một cách để hiểu ý nghĩa của null và không xác định là hiểu từng nơi xảy ra.

Mong đợi giá trị trả về null trong các tình huống sau:

• Các phương thức truy vấn DOM

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

• Các phản hồi JSON nhận được từ một yêu cầu Ajax

    {
      name: "Bob",
      address: null
    }

• RegEx.exec .

• Chức năng mới trong tình trạng thông lượng. Các giá trị sau trả về null:

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

       // But this returns undefined:

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

Tất cả các trường hợp không tồn tại khác được biểu thị bằng không xác định (như được ghi chú bởi @Axel). Mỗi bản in sau "không xác định":

    var uninitalised;
    console.log(uninitalised);

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

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

    missingParam();

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

Tất nhiên nếu bạn quyết định viết var unitialised = null; hoặc tự trả về null từ một phương thức sau đó bạn có null xảy ra trong các tình huống khác. Nhưng điều đó nên khá rõ ràng.

Trường hợp thứ ba là khi bạn muốn truy cập một biến nhưng bạn thậm chí không biết nếu nó đã được khai báo. Trong trường hợp đó, hãy sử dụng typeof để tránh lỗi tham chiếu:

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

Tóm lại, hãy kiểm tra null khi bạn thao tác DOM, xử lý Ajax hoặc sử dụng các tính năng ECMAScript 5 nhất định. Đối với tất cả các trường hợp khác, an toàn để kiểm tra không xác định với sự bình đẳng nghiêm ngặt:

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

So sánh nhiều kiểm tra null khác nhau trong 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-undained-and.html

null và không xác định đều sai cho đẳng thức giá trị (null == không xác định): cả hai đều sụp đổ thành boolean false. Chúng không phải là cùng một đối tượng (null! == không xác định).

không xác định là một thuộc tính của đối tượng toàn cầu ("cửa sổ" trong trình duyệt), nhưng là một kiểu nguyên thủy và không phải là một đối tượng. Đó là giá trị mặc định cho các biến và hàm chưa được khởi tạo kết thúc mà không có câu lệnh return.

null là một thể hiện của Object. null được sử dụng cho các phương thức DOM trả về các đối tượng bộ sưu tập để chỉ ra kết quả trống, cung cấp giá trị sai mà không chỉ ra lỗi.

Một số giới hạn:

null và không xác định là hai giá trị khác nhau. Một là đại diện cho sự vắng mặt của một giá trị cho một tên và cái còn lại đại diện cho sự vắng mặt của một tên.

Điều gì xảy ra trong một ifđi như sau cho if( o ):

Biểu thức trong ngoặc đơn o được ước tính, và sau đó các ifcú đá trong kiểu ép buộc giá trị của biểu thức trong ngoặc đơn - trong trường hợp của chúng tôi o.

Các giá trị Falsy (sẽ bị ép buộc thành false) trong JavaScript là: '', null, không xác định, 0 và false .

Để thêm vào câu trả lời Sự khác biệt giữa undefinedvànull , từ Hướng dẫn xác định JavaScript Phiên bản thứ 6, tr.41 trên trang này :

Bạn có thể xem xét undefinedđể thể hiện sự vắng mặt giá trị ở cấp độ hệ thống, bất ngờ hoặc giống như lỗi và nullđể thể hiện sự vắng mặt của giá trị ở cấp độ chương trình, bình thường hoặc dự kiến. Nếu bạn cần gán một trong các giá trị này cho một biến hoặc thuộc tính hoặc truyền một trong các giá trị này cho hàm, nullhầu như luôn luôn là lựa chọn đúng.

nulllà một đối tượng. Loại của nó là null. undefinedkhông phải là một đối tượng; loại của nó là không xác định.

Các chức năng sau đây cho thấy tại sao và có khả năng tìm ra sự khác biệt:

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

Nếu bạn gọi

test();

Bạn đang nhận được

chưa xác định

vô giá trị

Là người đầu tiên console.log(...)cố gắng để có được myPropertytừ myObjkhi nó chưa được xác định - vì vậy nó được trở lại "không xác định". Sau khi gán null cho nó, thứ hai console.log(...)trả về rõ ràng là "null" vì nó myPropertytồn tại, nhưng nó có giá trị nullđược gán cho nó.

Để có thể truy vấn sự khác biệt này, JavaScript có nullvà undefined: Trong khi null- giống như trong các ngôn ngữ khác, một đối tượng, undefinedkhông thể là một đối tượng vì không có phiên bản (thậm chí không phải là một nullthể hiện).

Ví dụ window.someWeirdPropertykhông xác định, vì vậy

"window.someWeirdProperty === null" đánh giá thành sai trong khi

"window.someWeirdProperty === undefined" đánh giá là đúng.

Checkif Hơn nữa if (!o)không giống như kiểm tra if (o == null)cho olà false.

Một điều thú vị khác về null, so với không xác định, là nó có thể được tăng lên.

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

Điều này rất hữu ích để thiết lập các giá trị số mặc định cho các bộ đếm. Đã bao nhiêu lần bạn đặt một biến thành -1 trong khai báo của nó?

Trong Javascript null không phải là một objectloại nó là một primitaveloại.

Sự khác biệt là gì? Không xác định đề cập đến một con trỏ chưa được thiết lập. Null đề cập đến con trỏ null, ví dụ, một cái gì đó đã tự đặt một biến thành kiểunull

Nhìn vào cái này

   <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

Từ "Những nguyên tắc của Javascript hướng đối tượng" của Nicholas C. Zakas

Nhưng tại sao một đối tượng khi loại là null? .

Zakas, Nicholas C. (2014/02/07). Các nguyên tắc của JavaScript hướng đối tượng (Địa điểm Kindle 226-227). Không có báo chí tinh bột. Phiên bản Kindle.

Mà nói:

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;

Trường hợp không xác định:

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.

Cách tốt nhất để suy nghĩ về 'null' là nhớ lại cách sử dụng khái niệm tương tự trong cơ sở dữ liệu, trong đó nó chỉ ra rằng một trường chứa "không có giá trị nào cả".

• Có, giá trị của mặt hàng được biết đến; đó là 'định nghĩa.' Nó đã được khởi tạo.
• Giá trị của mặt hàng là: "không có giá trị."

Đây là một kỹ thuật rất hữu ích để viết các chương trình dễ gỡ lỗi hơn. Biến 'không xác định' có thể là kết quả của lỗi ... (làm sao bạn biết?) ... nhưng nếu biến chứa giá trị 'null', bạn biết rằng "ai đó, ở đâu đó trong chương trình này, hãy đặt nó thành 'null.' "Do đó, tôi khuyên bạn rằng, khi bạn cần loại bỏ giá trị của một biến, đừng" xóa "... hãy đặt nó thành 'null.' Giá trị cũ sẽ mồ côi và sẽ sớm được thu gom rác; giá trị mới là "không có giá trị (bây giờ)." Trong cả hai trường hợp, trạng thái của biến là chắc chắn: "rõ ràng, cố tình, có cách đó."

1. Không xác định có nghĩa là một biến đã được khai báo nhưng nó không được gán bất kỳ giá trị nào trong khi Null có thể được gán cho một biến đại diện cho "không có giá trị". (Null là toán tử gán)

2.Und xác định là một loại chính nó trong khi Null là một đối tượng.

3.Javascript có thể tự khởi tạo bất kỳ biến chưa được gán nào thành không xác định nhưng nó không bao giờ có thể đặt giá trị của biến thành null. Điều này phải được thực hiện theo chương trình.