为什么是空的一个目和之间的区别是什么null和未定义的?

StackOverflow https://stackoverflow.com/questions/801032

题

为什么 null 考虑一个 object 在JavaScript?

正在检查 

if ( object == null )
      Do something

同 

if ( !object )
      Do something

?

并且：

之间的区别是什么 null 和 undefined?

有帮助吗？

解决方案 

(name is undefined)

您：什么是 name ？（*）
JavaScript： name ？什么是 name ？我不知道你在说什么。您以前从未提及任何 name 。您是否在（客户端）方面看到了其他一些脚本语言？

name = null;

您：什么是 name ？
JavaScript：我不知道。

总之; undefined 是没有概念存在的地方;它没有类型，并且在该范围之前从未被引用过; null 是已知存在的东西，但不知道该值是什么。

要记住的一件事是 null 在概念上与 false 或＆quot;＆quot; 等相同，即使他们在类型铸造之后等同，即

name = false;

您：什么是 name ？
JavaScript：布尔值false。

name = '';

您：什么是 name ？
JavaScript：空字符串

*：此上下文中的 name 表示从未定义过的变量。它可以是任何未定义的变量，但是，name是几乎任何HTML表单元素的属性。它顺便说一下，并且在id之前很好地制定了。它很有用，因为id必须是唯一的，但名称不一定是。 功能

其他提示

差异可归纳为此片段：

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

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

检查

object == null 与检查 if（！object）不同。

后者等于！布尔（对象），因为一元！运算符会自动将右操作数转换为布尔值。

由于 Boolean（null）等于false，所以！false === true 。

因此，如果您的对象不为空，但 false 或 0 或＆quot;＆quot; ; ，支票将通过 这是因为：

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

null 是 不对象, 它是一个 原始价值.例如，你不能添加的属性。人们有时错误地假设，这是一个目的，因为 typeof null 返回 "object".但是，实际上是一个错误(这甚至可能被固定在写6).

之间的差异 null 和 undefined 如下：

  • undefined:使用的JavaScript和手段的"无价值"。初始化的变量，丢失的参数和未知变量有价值。

    > var noValueYet;
> console.log(noValueYet);
undefined

> function foo(x) { console.log(x) }
> foo()
undefined

> var obj = {};
> console.log(obj.unknownProperty)
undefined

    访问未知变量，但是，产生一个例外：

    > unknownVariable
ReferenceError: unknownVariable is not defined

  • null:使用的程序表示"无价值"，例如作为一个参数的一个函数。

审查的一个变量：

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

作为一般规则，应始终使用===并不==JavaScript(==执行 所有种类的转换 可能产生意想不到的结果)。检查 x == null 是一种边缘情况，因为它适用于两个 null 和 undefined:

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

一种常见的检查是否是一个变量都有一个价值是，将其转换为布尔，看看它是否 true.这种转换是通过执行 if 声明和布尔员！("不").

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

缺点的这样的方法：所有的下列价值评估 false, 所以你必须小心(例如，上述检查不能之间的区分 undefined 和 0).

  • undefined, null
  • 布尔: false
  • 数字： +0, -0, NaN
  • Strings: ""

你可以测试转化为布尔通过使用 Boolean 作为一个功能(通常是一个构造，应使用与 new):

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

null和undefined有什么区别??

没有定义的属性未定义。 null是一个对象。它的类型是对象。 null是一个特殊值，意思是“没有价值。 undefined不是一个对象，它的类型是未定义的。

您可以声明一个变量，将其设置为null，并且行为是相同的，除了您将看到“null”打印出来与“未定义”相对应。您甚至可以将未定义的变量与null进行比较，反之亦然，条件为真：

 undefined == null
 null == undefined

请参阅 JavaScript null和undefined 之间的区别更多细节。

并使用新的修改 是 

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

当测试对象是否为false时，它们仅在测试 false 时满足条件，但在真实时不符合

点击此处： Javascript gotcha

第一部分的问题：

为什么是空的考虑对象中JavaScript?

这是一个JavaScript设计错误，他们不能修复。它应该有类型空，没有类型的对象，或者没有。它需要一个额外的检查(有时会忘记)当检测到真实的物体和源的的错误。

第二部分的问题：

正在检查


if (object == null)
Do something

同

if (!object)
Do something

这两个检查总是假除外：

  • 目的是未定或null：这两个真实的。

  • 对象是原始的，以及0, "", false:第一次检查虚假的，第二真实的。

如果目的不是原始的，但一个真正的目的，喜欢 new Number(0), new String(""), 或 new Boolean(false), 然后两个检查都是假的。

所以，如果"对象"被解释为是指一个真正的对象，那么这两个检查都是一样的。如果元是允许的，然后检查是不同的，对于0, "", 和虚假的。

在这样的情况 object==null, ，不明显的结果可能的来源的错误。使用 == 不是建议，使用 === 代替。

第三部分的问题：

并且：

之间的区别是什么null和未定义的?

在JavaScript，一个区别是，null object类型和未定义的类型未定义。

在JavaScript, null==undefined 是真实的，并被认为是相等的，如果类型被忽略。他们为什么决定，但0, "" 和虚假的不平等，我不知道。这似乎是任意的意见。

在JavaScript, null===undefined 是不是真的因为类型必须同在 ===.

在现实中，空和不确定的是相同的，因为它们都表示非的存在。这样做0， "" 对于这个问题也可能空容器 [] 和 {}.因此，许多类型相同的什么都不是食谱的错误。一种类型或根本没有好。我将尝试使用尽可能少作为可能。

'false','真实的'、和'!'是另一个袋子的蠕虫，可以简化，例如， if(!x) 和 if(x) 独自一人是足够了，你不需要真正的和虚假的。

一个声明 var x 类型未定义如果没有任何价值给予的，但它应该是一样的，如果x是从来没有宣布的。另一个错误来源是空的，没有什么容器。所以最好是宣布和定义合在一起，喜欢 var x=1.

人们兜兜圈子试图找出所有这些不同类型的什么，但这一切都只是同样事情复杂化不同的衣服。现实是

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

也许应该扔例外情况。

var x = null;

x定义为null

y未定义; //因为我没有定义它

if (!x)

null被评估为false

一种方式有意义的空和未定义的是了解其中每一个的发生。

期待的空返回的价值，在以下情况：

  • 方法，查询DOM

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

  • JSON收到的答复从阿贾克斯的请求


    {
      name: "Bob",
      address: null
    }

  • RegEx.exec.

  • 新的功能是在一个国家的通量。以下返回null：


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

       // But this returns undefined:

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

所有其他情况下，不存在标未定义的(如指出@Axel).以下每个印痕"不确定":

    var uninitalised;
    console.log(uninitalised);

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

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

    missingParam();

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

当然如果你决定要写var unitialised=null;或返回null从一个方法你自己那么你有空中发生的其他情况。但是，这应该是很明显的。

第三种情况是，当你想要访问一个可变的，但是你甚至不知道，如果它已经宣布。对于这种情况下使用的类型以避免的参考错误：

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

在摘要检查空当你操纵DOM，处理阿贾克斯，或使用某些写5的功能。对于所有其他情况下它是安全检查未定义与严格的平等：

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

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的空检查的未定义-and.html

对于值相等，

null和undefined都为false（null == undefined）：它们都会崩溃为布尔值false。它们不是同一个对象（null！== undefined）。

undefined是全局对象的属性（浏览器中的“窗口”），但它是基本类型而不是对象本身。它是未初始化变量和函数的默认值，没有返回语句。

null是Object的一个实例。 null用于返回集合对象的DOM方法，以指示空结果，该结果提供false值而不指示错误。

一些准确性：

null和undefined 是两个不同的值。一个代表缺少名称的值，另一个代表缺少名称。

如果如下所示 if（o）：

评估括号中的表达式o，然后 if 在括号中强制表达式的类型 - 在我们的例子中 o 。

JavaScript中的Falsy（将被强制为false）值包括：''，null，undefined，0和false 。

以下功能说明了原因并且能够解决差异：

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

如果你打电话

test();

你得到了

  

未定义

     

空

第一个 console.log（...）尝试从 myObj 获取 myProperty ，但尚未定义 - 所以它得到了返回“未定义”。在为它分配null之后，第二个 console.log（...）显然返回“null”。因为 myProperty 存在，但它分配了值 null 。

为了能够查询这种差异，JavaScript有 null 和 undefined ：而 null 是 - 就像在其他语言中一样对象， undefined 不能是对象，因为没有可用的实例（甚至没有 null 实例）。

null 是一个对象。它的类型为null。 undefined 不是对象;它的类型未定义。

例如 window.someWeirdProperty 未定义，所以

＆quot; window.someWeirdProperty === null＆quot; 评估为false，而

＆quot; window.someWeirdProperty === undefined＆quot; 评估为true。

此外checkif if（！o）与检查 if（o == null）与 o 不同假

与undefined相比，null的另一个有趣的事情是它可以递增。 

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

这对于设置计数器的默认数值很有用。你在声明中将变量设置为-1的次数是多少次？

在 Javascript null 不是对象类型，它是 primitave 类型。

有什么区别？ 未定义是指尚未设置的指针。 Null 是指空指针，例如某些东西已手动将变量设置为 null

的类型

看看这个：

   <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

从"原则的面向对象的Javascript"通过尼古拉斯*C.Zakas

但是，为什么一个对象类型时空?(实际上，这已被承认为一个错误的TC39，该委员会，设计和维护JavaScript。你能原因，null是一个空的对象的指针，使得"反对"一个逻辑回归的价值，但是这仍然令人困惑。)

Zakas，尼古拉斯*C.(2014-02-07).该原则的面向对象的JavaScript(点燃地点226-227).没有淀粉的新闻。点燃版。

这说：

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;

不确定的情况下：

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.

最好的方式来思考'null'是要回想一下如何类似的概念使用的数据库，其中它表示，一场包含"任何价值。"

  • 是的，项目的价值是所周知的；它的 是 '定义。' 它的 已 被初始化了。
  • 该项目的价值是： "没有任何价值"。

这是一个非常有用的技术，用于编写程序，更容易调试。一个'定义'可变的可能结果的一个错误... (你会怎么知道的?) ...但是，如果变量包含的价值'null'你知道"有人在什么地方在这一程序， 设置它 为'null.'" 因此，我建议，当你需要摆脱的一个变量的值，不要"删除"...它设定为'null.' 旧的价值将是孤立的，很快将垃圾收集；新的价值是，"没有任何价值(现在)。" 在这两种情况下，该变量的国家是肯定的："这显然是故意的，有了这种方式。"

  1. 未定义意味着变量已经宣布，但它没有分配任何价值，同时Null可以分配给可变表示"无价值"。(Null分配运营商)

2.不确定的是一个类型本身，同时空是一个对象。

3.Javascript可以本身的初始化的任何未分配的变量定义，但它永远不可能设定值的变量空。这必须通过程序.

不隶属于 StackOverflow
scroll top