Null object: Difference between revisions

=={{header|ActionScript}}==

ActionScript also has a special '''undefined''' value which applies to untyped variables and properties of dynamic classes which have not been initialized.

var bar:*; // explicitly untyped

if (foo == undefined)

=={{header|Ada}}==

IF var IS REF STRING(NIL) THEN print(("The address of var IS REF STRING(NIL)",new line)) FI

Output:

result :/=: NIL

no result IS NIL

result ISNT NIL

The address of var ISNT NIL

NIL basically is an untypes REF (pointer) that does not refer anywhere.

if x is null then

display dialog "x is null"

=={{header|AutoHotkey}}==

=={{header|C}}==

=={{header|C sharp|C#}}==

As with Java, any reference type may be null, and testing for nullity uses ordinary boolean operators.

C# 2.0 introduced nullable types for situations in which even primitive value types may have undefined or unknown values (for example, when reading from a database). Prior to the introduction of nullable types, these situations would require writing wrapper classes or casting to a reference type (e.g., object), incurring the penalties of boxing and reduced type safety. A variable with nullable type can be declared simply by adding the '?' operator after the type.

{{works with|C sharp|C#|2.0+}}

Also new in C# 2.0 was the null coalescing operator, '??', which is simply syntactic sugar allowing a default value to replace an operand if the operand is null:

{{works with|C sharp|C#|2.0+}}

//Without the null coalescing operator, this would instead be written as:

//}else{

// Console.WriteLine(name);

=={{header|Common Lisp}}==

=={{header|E}}==

=={{header|Forth}}==

Haskell does not have a universal null value. There is a 'value of every type', the undefined value (sometimes written ⊥, 'bottom'), but it is essentially a sort of exception — any attempt to use it is an error.

When one would use "null" as a marker for "there is no normal value here" (e.g. a field which is either an integer or null), one uses the Maybe type instead. The definition of Maybe is:

There are many ways to work with Maybe, but here's a basic case expression:

=={{header|Io}}==

=={{header|J}}==

=={{header|Logo}}==

=={{header|Mathematica}}==

Mathematica can assign a Null value to a symbol, two examples:

Both set x to be Null. To specifically test is something is Null one can use the SameQ function (with infix operator: ===):

Or equivalent:

will give back True if and only if x is assigned to be Null. If x is empty (nothing assigned) this will return False.

To test if an object has something assigned (number, list, graphics, null, infinity, symbol, equation, pattern, whatever) one uses ValueQ:

gives:

=={{header|MAXScript}}==

=={{header|Modula-3}}==

=={{header|OCaml}}==

Maybe the closest type of OCaml would be the type option, which is defined like this in the standard library:

=={{header|Perl}}==

print "x is None"

else:

Output:<pre>

x is None

=={{header|R}}==

R has the special value NULL to represent a null object. You can test for it using the function is.null. Note that R also has a special value NA to represent missing or unknown values.

=={{header|Ruby}}==

=={{header|Slate}}==

=={{header|Standard ML}}==

Maybe the closest type of Standard ML would be the type option, which is defined like this in the standard library:

=={{header|Tcl}}==