blocks|key|1511098|text|空性是引用类型的自然结果。如果你有一个引用，它必须引用某个对象--或者是空的。如果要禁止空性，则必须始终确保每个变量都是用某个非空表达式初始化的-即使这样，如果在初始化阶段读取变量，也会出现问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1511099|你会如何建议删除无效的概念？|1511100|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Nullity is a natural consequence of reference types. If you have a reference, it has to refer to some object - or be null. If you were to prohibit nullity, you would always have to make sure that every variable was initialized with some non-null expression - and even then you'd have issues if variables were read during the initialization phase.

How would you propose removing the concept of nullity?

blocks|key|1511654|text|像面向对象编程中的许多事情一样，这一切都要追溯到ALGOL。Tony+Hoare+just+called+it+his+"billion-dollar+mistake."如果有什么不同的话，那就是轻描淡写。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1511655|这里是关于如何使可空性不再是a+really+interesting+thesis中的缺省值的a+really+interesting+thesis。与C#的相似之处显而易见。|1511656|entityMap|0|LINK|mutability|MUTABLE|url|http://lambda-the-ultimate.org/node/3186|1|http://www.ccs.neu.edu/scheme/pubs/dissertation-cobbe.pdf|2^0|U|1J|0|0|E|R|1|1B|R|2|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]|$A|Y|B|Z|1|10]]|C|$]]|$1|F|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]|N|$5|I|J|K|C|$L|O]]|P|$5|I|J|K|C|$L|O]]]]

Like many things in object-oriented programming, it all goes back to ALGOL. <a href="http://lambda-the-ultimate.org/node/3186" rel="noreferrer" title="Tony Hoare / Historically Bad Ideas: &#39;Null References: The Billion Dollar Mistake&#39;">Tony Hoare just called it his "billion-dollar mistake."</a> If anything, that's an understatement.

Here is <a href="http://www.ccs.neu.edu/scheme/pubs/dissertation-cobbe.pdf" rel="noreferrer">a really interesting thesis</a> on how to make nullability not the default in Java. The parallels to C# are obvious.

blocks|key|1511142|text|删除null不会解决太多问题。对于在init上设置的大多数变量，您都需要有一个默认引用。与空引用异常不同，你会得到意外的行为，因为变量指向了错误的对象。至少空引用失败得很快，而不是导致意外的行为。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1511143|您可以查看null-object模式来解决这个问题的一部分|1511144|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Removing null wouldn't solve much. You would need to have a default reference for most variables that is set on init. Instead of null-reference exceptions you would get unexpected behaviour because the variable is pointing to the wrong objects. At least null-references fail fast instead of causing unexpected behaviour.

You can look at the null-object pattern for a way to solve part of this problem

blocks|key|1726085|text|Null是一个非常强大的特性。如果缺少值，该怎么办？是空的！|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1726086|一个学派的思想是永远不返回null，另一个学派的思想是永远不返回null。例如，有人说您应该返回一个有效但为空的对象。|1726087|我更喜欢null，因为对我来说，它是一个更真实的指示。如果我不能从我的持久层中检索一个实体，我想要null。我不想要一些空值。但那就是我。|1726088|它在处理原语时特别方便。例如，如果我有true或false，但它是在安全表单上使用的，其中权限可以是允许、拒绝或不设置。好吧，我希望这个值不设为空。所以我可以用bool吗？|1726089|还有更多我可以继续讲的，但我就到此为止。|1726090|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|M|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|N|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|O|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|P|8|@]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|K|$]]

Null is an extremely powerful feature. What do you do if you have an absence of a value? It's NULL!

One school of thought is to never return null, another is to always. For example, some say you should return a valid but empty object.

I prefer null as to me it's a truer indication of what it actually is. If I can't retrieve an entity from my persistence layer, I want null. I don't want some empty value. But that's me. 

It is especially handy with primitives. For example, if I have true or false, but it's used on a security form, where a permission can be Allow, Deny, or not set. Well, I want that not set to be null. So I can use bool?

There are a lot more I could go on about, but I will leave it there.

blocks|key|1511545|text|Null不会导致NullPointerExceptions...|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1511546|程序员造成了NullPointerExceptions。|1511547|如果没有空值，我们又可以使用实际的任意值来确定函数或方法的返回值是否无效。您仍然需要检查返回的-1+(或其他值)，删除空值不会神奇地解决惰性问题，但会稍微混淆它。|1511548|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Null do not cause NullPointerExceptions...

Programers cause NullPointerExceptions.

Without nulls we are back to using an actual arbitrary value to determine that the return value of a function or method was invalid. You still have to check for the returned -1 (or whatever), removing nulls will not magically solve lazyness, but mearly obfuscate it.

blocks|key|1726464|text|如果你得到一个“NullReferenceException”，也许你一直在引用不再存在的对象。这不是'null‘的问题，而是你的代码指向不存在的地址的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1726465|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you're getting a 'NullReferenceException', perhaps you keep referring to objects which no longer exist. This is not an issue with 'null', it's an issue with your code pointing to non-existent addresses.

blocks|key|1726572|text|其中一个回复提到，数据库中存在空值。这是真的，但它们与C#中的空值有很大的不同。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1726573|在C#中，空值是不引用任何内容的引用的标记。|1726574|在数据库中，空值是不包含值的值单元格的标记。我所说的值单元格通常指的是表中一行和一列的交集，但是值单元格的概念可以扩展到表之外。|1726575|乍一看，这两者之间的区别似乎微不足道。但事实并非如此。|1726576|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

One response mentioned that there are nulls in databases. That's true, but they are very different from nulls in C#.

In C#, nulls are markers for a reference that doesn't refer to anything.

In databases, nulls are markers for value cells that don't contain a value. By value cells, I generally mean the intersection of a row and a column in a table, but the concept of value cells could be extended beyond tables.

The difference between the two seems trivial, at first clance. But it's not.

blocks|key|1726027|text|我不能谈论你的具体问题，但听起来问题不是null的存在。Null存在于数据库中，您需要在应用程序级别对其进行说明。请注意，我不认为这是它存在于.net中的唯一原因。但我认为这是其中一个原因。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1726028|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I can't speak to your specific issue, but it sounds like the problem isn't the existence of null. Null exists in databases, you need some way to account for that in the application level. I don't think that's the only reason it exists in .net, mind you. But I figure it's one of the reasons.

blocks|key|1726526|text|我很惊讶没有人谈论他们的答案的数据库。数据库有可以为空的字段，任何从DB接收数据的语言都需要处理这一点。这意味着有一个空值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1726527|事实上，这一点非常重要，对于像int这样的基本类型，您可以将它们设置为可空的！|1726528|还要考虑函数的返回值，如果你想让一个函数除以几个数字，并且分母可以是0，该怎么办？在这种情况下，唯一的“正确”答案将是null。(我知道，在这样一个简单的例子中，例外可能是更好的选择……但在某些情况下，所有值都是正确的，但有效数据可能会产生无效或无法计算的答案。不确定在这种情况下是否应该使用异常...)|1726529|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

I'm surprised no one has talked about databases for their answer. Databases have nullable fields, and any language which will be receiving data from a DB needs to handle that. That means having a null value.

In fact, this is so important that for basic types like int you can make them nullable!

Also consider return values from functions, what if you wanted to have a function divide a couple numbers and the denominator could be 0? The only "correct" answer in such a case would be null. (I know, in such a simple example an exception would likely be a better option... but there can be situations where all values are correct but valid data can produce an invalid or uncalculable answer. Not sure an exception should be used in such cases...)

blocks|key|1726706|text|除了前面提到的所有原因之外，当您需要一个尚未创建的对象的占位符时，也需要使用NULL。例如。如果在一对对象之间有循环引用，则需要null，因为不能同时实例化这两个对象。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1726707|class+A+{
++B+fieldb;
}

class+B+{
++A+fielda;
}

A+a+=+new+A()+//+a.fieldb+is+null
B+b+=+new+B()+{+fielda+=+a+}+//+b.fielda+isnt
a.fieldb+=+b+//+now+it+isnt+null+anymore|code-block|syntax|javascript|1726708|编辑:你也许能够找出一种没有空值的语言，但它肯定不是一种面向对象的语言。例如，prolog没有空值。|1726709|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Besides ALL of the reasons already mentioned, NULL is needed when you need a placeholder for a not-yet created object. For example. if you have a circular reference between a pair of objects, then you need null since you cannot instantiate both simultaneously.

<pre><code>class A {
 B fieldb;
}

class B {
 A fielda;
}

A a = new A() // a.fieldb is null
B b = new B() { fielda = a } // b.fielda isnt
a.fieldb = b // now it isnt null anymore
</code></pre>

Edit: You may be able to pull out a language that works without nulls, but it will definitely not be an object oriented language. For example, prolog doesn't have null values.

blocks|key|1726424|text|如果你创建一个对象的实例变量是对某个对象的引用，那么在你给这个变量分配任何对象引用之前，你建议这个变量的值是多少？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1726425|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

If you create an object with an instance variable being a reference to some object, what value would you suggest has this variable before you assigned any object reference to it?

blocks|key|1511758|text|如果框架允许创建某种类型的数组，而不指定应该如何处理新的项，则该类型必须有一些默认值。对于实现可变引用语义(*)的类型，通常没有合理的默认值。我认为这是.NET框架的一个弱点，即没有办法指定非虚函数调用应该禁止任何null检查。这将允许像String这样的不可变类型通过返回像Length这样的属性的合理值来表现为值类型。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1511759|(*)请注意，在VB.NET和C#中，可变引用语义可以由类或结构类型实现；结构类型将通过充当它持有不可变引用的类对象的包装实例的代理来实现可变引用语义。|1511760|如果可以指定类应该具有不可为空的可变值类型语义(这意味着至少实例化该类型的字段将使用默认构造函数创建新的对象实例，而复制该类型的字段将通过复制旧实例创建新实例(递归处理任何嵌套的值类型类))，这也是很有帮助的。|1511761|然而，目前还不清楚到底应该在框架中为此提供多少支持。让框架本身识别可变值类型、可变引用类型和不可变类型之间的区别，将允许本身持有来自外部类的对可变和不可变类型的混合引用的类，从而有效地避免对深度不可变对象进行不必要的复制。|1511762|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

If a framework allows the creation of an array of some type without specifying what should be done with the new items, that type must have some default value. For types which implement mutable reference semantics (*) there is in the general case no sensible default value. I consider it a weakness of the .NET framework that there is no way to specify that a non-virtual function call should suppress any null check. This would allow immutable types like String to behave as value types, by returning sensible values for properties like Length.

(*) Note that in VB.NET and C#, mutable reference semantics may be implemented by either class or struct types; a struct type would implement mutable reference semantics by acting as a proxy for a wrapped instance of a class object to which it holds an immutable reference.

It would also be helpful if one could specify that a class should have non-nullable mutable value-type semantics (implying that--at minimum--instantiating a field of that type would create a new object instance using a default constructor, and that copying a field of that type would create a new instance by copying the old one (recursively handling any nested value-type classes).

It's unclear, however, exactly how much support should be built into the framework for this. Having the framework itself recognize the distinctions between mutable value types, mutable reference types, and immutable types, would allow classes which themselves hold references to a mixture of mutable and immutable types from outside classes to efficiently avoid making unnecessary copies of deeply-immutable objects.

blocks|key|1511830|text|没有null就不能工作的功能是能够表示“对象的缺失”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1511831|对象的缺失是一个重要的概念。在面向对象的编程中，我们需要它来表示对象之间的关联，这是可选的:对象A可以附加到对象B，或者A可能没有对象B。如果没有null，我们仍然可以这样模拟:例如，我们可以使用对象列表将B与A关联。该列表可以包含一个元素(一个B)，也可以是空的。这有点不方便，并没有真正解决任何问题。假设存在B的代码，如aobj.blist.first().method()，将以类似于空引用异常的方式崩溃：(如果blist为空，blist.first()的行为是什么？)|offset|length|style|CODE|1511832|说到列表，null允许您终止一个链表。一个ListNode可以包含对另一个ListNode的引用，该引用可以为空。对于其他动态集合结构，例如树，也可以这样说。null允许您拥有一个普通的二叉树，其叶节点通过具有为Null的子引用来标记。|1511833|列表和树可以在没有null的情况下构建，但它们必须是循环的，或者是无限的/惰性的。这可能会被大多数程序员视为不可接受的约束，他们更愿意在设计数据结构时有选择。|1511834|与空引用相关的痛苦，比如由于错误和导致异常而意外产生的空引用，在一定程度上是静态类型系统的结果，静态类型系统将空值引入到每个类型中:有一个空字符串、空整数、空Widget……|1511835|在动态类型的语言中，可以有一个空对象，它有自己的类型。这样做的结果是，您拥有null的所有表示优势，以及更高的安全性。例如，如果您编写了一个接受字符串参数的方法，那么就可以保证该参数将是一个字符串对象，而不是null。String类中没有null引用:已知为字符串的对象不能为null。引用在动态语言中没有类型。存储位置(如类成员或函数参数)包含一个值，该值可以是对对象的引用。该对象具有类型，而不是引用。|1511836|因此，这些语言提供了一个干净的，或多或少是纯数学的"null“模型，然后静态语言把它变成了一个有点像科学怪人的怪物。|1511837|entityMap^0|0|4I|R|5T|5|61|D|0|L|8|11|8|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|U|8|@$D|V|E|W|F|G]|$D|X|E|Y|F|G]|$D|Z|E|10|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|11|8|@$D|12|E|13|F|G]|$D|14|E|15|F|G]]|9|@]|A|$]]|$1|J|3|K|5|6|7|16|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|17|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|18|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|19|8|@]|9|@]|A|$]]|$1|R|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|S|$]]

The feature that couldn't work without null is being able to represent "the absence of an object".

The absence of an object is an important concept. In object-oriented programming, we need it in order to represent an association between objects that is optional: object A can be attached to an object B, or A might not have an object B. Without null we could still emulate this: for instance we could use a list of objects to associate B with A. That list could contain one element (one B), or be empty. This is somewhat inconvenient and doesn't really solve anything. Code which assumes that there is a B, such as <code>aobj.blist.first().method()</code> is going to blow up in a similar way to a null reference exception: (if <code>blist</code> is empty, what is the behavior of <code>blist.first()</code>?)

Speaking of lists, null lets you terminate a linked list. A <code>ListNode</code> can contain a reference to another <code>ListNode</code> which can be null. The same can be said about other dynamic set structures such as trees. Null lets you have an ordinary binary tree whose leaf nodes are marked by having child references that are null.

Lists and trees can be built without null, but they have to be circular, or else infinite/lazy. That would probably be regarded as an unacceptable constraint by most programmers, who would prefer to have choices in designing data structures.

The pains associated with null references, like null references arising accidentally due to bugs and causing exceptions, are partially a consequence of the static type system, which introduces a null value into every type: there is a null String, null Integer, null Widget, ...

In a dynamically typed language, there can be a single null object, which has its own type. The upshot of this is that you have all the representational advantages of null, plus greater safety. For instance if you write a method which accepts a String parameter, then you're guaranteed that the parameter will be a string object, and not null. There is no null reference in the String class: something that is known to be a String cannot be the object null. References do not have type in a dynamic language. A storage location such as a class member or function parameter contains a value which can be a reference to an object. That object has type, not the reference.

So these languages provide a clean, more or less matematically pure model of "null", and then the static ones turn it into somewhat of a Frankenstein's monster.

blocks|key|1511037|text|Null是任何面向对象语言的基本要求。任何没有被赋值对象引用的对象变量都必须为空。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1511038|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Null is an essential requirement of any OO language. Any object variable that hasn't been assigned an object reference has to be null.

We noticed that lots of bugs in our software developed in C# (or Java) cause a NullReferenceException.

Is there a reason why "null" has even been included in the language?

After all, if there were no "null", I would have no bug, right?

In other words, what feature in the language couldn't work without null?

Why is "null" present in C# and Java?

数据结构

数据库

Java

我们注意到我们用C# (或Java)开发的软件中的许多bug都会导致NullReferenceException。语言中包含"null“有什么原因吗？毕竟，如果没有"null"，我就不会有bug，对吧？换句话说，语言中的什么功能在没有null的情况下不能工作？

问为什么"null“出现在C#和Java中？
EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么"null“出现在C#和Java中？EN

回答 14

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么"null“出现在C#和Java中？
EN