Undefined values: Difference between revisions

 

=={{header|ActionScript}}==

ActionScript 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)

 

ActionScript also has a '''null''' value: see [[Null object#ActionScript]].

This pragma is required to be applied to the whole partition, which would require recompilation of the run-time library. For this reason, the presented example uses another pragma Initialize_Scalars.

This one has the effect similar to Normalize_Scalars, but is [[GNAT]]-specific:

pragma Initialize_Scalars;

with Ada.Text_IO; use Ada.Text_IO;

end if;

end Invalid_Value;

Sample output:

<pre>

 

Note: Some implementations (eg [[ALGOL 68C]]) also have a procedure named ''undefined'' that is called to indicated that the behaviour at a particular point in a program is unexpected, undefined, or non-standard.

R r := NIL;

 

(VOID):print(("u is EMPTY", new line))

OUT print(("u isnt EMPTY", new line))

Output:

<pre>

u is EMPTY

</pre>

 

=={{header|BASIC}}==

Classic BASIC does have the concept of un-initialised or undefined variables.

 

=={{header|C}}==

C programs can also read garbage values from uninitialized memory. There is no way to test for these garbage values, because they might equal anything.

 

#include <stdlib.h>

 

int main()

{

 

 

 

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

In C# it's important to see the difference between reference and value types. For reference types (class instances) there is <code>null</code> as a general undefined reference.

Dereferencing a null reference will throw a <code>NullReferenceException</code>.

 

This can't be used normally for value types (<code>int</code>, <code>double</code>, <code>DateTime</code>, etc.) since they are no ''references,'' so the following is a compiler error:

With .NET 2.0 there is an additional <code>Nullable<T></code> structure which enables those semantics for value types as well:

if (answer == null) {

answer = 42;

There is a bit syntactic sugar involved here. The <code>?</code> after the type name signals the compiler that it's a ''nullable'' type. This only works for value types since reference types are nullable due to their very nature.

 

But since value types still can't actually ''have'' a <code>null</code> value this gets converted into the following code by the compiler:

if (!answer.HasValue) {

answer = new Nullable<int>(42);

So it's a little compiler magic but in the end works just as one would expect.

 

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

In Lisp, there are three possibilities with regard to a dynamic variable. It may exist, and have a value. It may exist, but not have a value. Or it may not exist at all. These situations can be probed with certain functions that take a symbol as an argument:

 

;; assumption: none of these variables initially exist

 

(boundp '*y*) -> T

 

 

Furthermore, a variable which is bound can be made unbound:

 

(makunbound '*y*) ;; *y* no longer has a value; it is erroneous to evaluate *y*

 

 

By contrast, lexical variables never lack a binding. Without an initializer, they are initialized to nil.

The same goes for local re-binding of special variables:

 

(defvar *dyn*) ;; special, no binding

 

(list (boundp '*dyn*) *dyn* (boundp 'lex) lex)) -> (T NIL NIL NIL)

 

 

Here we can see that inside the scope of the let, the special variable has a binding (to the value <code>NIL</code>) and so <code>(boundp '*dyn*)</code> yields <code>T</code>. But <code>boundp</code> does not "see" the lexical variable <code>lex</code>; it reports that <code>lex</code> is unbound. Local binding constructs never leave a variable without a value, be it dynamic or lexical: both <code>*dyn*</code> and <code>lex</code> evaluate to NIL, but using very different mechanisms.

=={{header|D}}==

In D variables are initialized either with an explicit Initializer or are set to the default value for the type of the variable. If the Initializer is void, however, the variable is not initialized. If its value is used before it is set, undefined program behavior will result. "void" initializers can be used to avoid the overhead of default initialization in performance critical code.

 

 

 

=={{header|Delphi}}==

 

For Referenced data types like pointers, classes and interfaces a reference can be explicitely set to undefined by assigning the NIL value for it. No memory management like garbage collection (except for interfaces) is done.

P: PInteger;

begin

Dispose(P); //Release memory allocated by New

end;

 

If P was a Class only the Assigned function would be available; in addition Dispose would have to be replaced by FreeAndNil or calling the .Free method of the instance. For Interfaces no such last call would be necessary as simple removal of the reference would be sufficient to trigger the Garbage Collector.

=={{header|E}}==

 

Each variable's behavior is defined by a <em>slot</em> object with <code>get</code> and <code>put</code> methods. If the slot throws when invoked, then a program may contain a reference to that variable, but not actually access it. A notable way for the slot to throw is for the slot to itself be a broken reference. This may occur when slots are being passed around as part of metaprogramming or export/import; it is also used in certain control structures. For example:

 

...

 

The slot for <var>baz</var> is broken if the left side of the <code>||</code> was true and the right side was therefore not evaluated.

 

Ordinarily, the programmer need not think about broken slots, and only works with null or broken values.

 

=={{header|GAP}}==

# true

 

 

IsBound(a);

 

=={{header|Go}}==

 

For this task, I demonstrate,

# Successful (non panicking) use of initialized objects.

# One more quirky little feature involving a type switch on a nil interface.

 

import "fmt"

close(c)

fmt.Println("channel closed")

Output:

<pre>

In Haskell, there is a semantic concept called [http://www.haskell.org/haskellwiki/Bottom "bottom"], which is a computation that never terminates or runs into an error. So <code>undefined</code> is not a proper value at all; it is a bottom that causes an exception when evaluated. For example,

 

-- When run in GHC:

 

This isn't quite as dangerous as it sounds because of Haskell's laziness. For example, this program:

 

 

prints <code>3</code>, since <code>length</code> doesn't need to evaluate any of the elements of its input.

In practice, one uses <code>undefined</code> less often than <code>error</code>, which behaves exactly the same except that it lets you choose the error message. So if you say

 

 

then if you make the mistake of writing your program such that it at some point requires the value of <code>resurrect 0</code>, you'll get the error message "I'm out of orange smoke!". <code>undefined</code> may be defined in the same way:

 

 

Since <code>undefined</code> causes an exception, the usual exception handling mechanism can be used to catch it:

 

import System.IO.Unsafe (unsafePerformIO)

import Prelude hiding (catch)

main = do

print $ safeHead ([] :: String)

 

== Icon and Unicon ==

 

==={{header|Unicon}}===

 

procedure main(arglist)

write((localnames|paramnames|staticnames|globalnames)(&current,0)) # ... visible in the current co-expression at this calling level (0)

return

 

The output looks like:

J does not have a concept of an "undefined value" as such, but J does allow treatment of undefined names. The verb <code>nc</code> finds the (syntactic) class of a name. This result is negative one for names which have not been defined.

 

foo=: 3

nc;:'foo bar'

 

From this we can infer that <code>foo</code> has a definition (and its definition is a noun, since 0 is the syntactic [http://www.jsoftware.com/help/dictionary/dx004.htm name class] for nouns), and we can also infer that <code>bar</code> does not have a definition.

This task also asked that we ''identify and exercise .. mechanisms for ... manipulating a variable's value's status as being undefined''. So: a name can be made to be undefined using the verb <code>erase</code>. The undefined status can be removed by assigning a value to the name.

 

erase;:'foo bar'

1 1

bar=:99

nc;:'foo bar'

 

=={{header|Java}}==

 

Java has a special null type, the type of the expression <code>null</code>, that can be cast to any reference type; in practice the null type can be ignored and <code>null</code> can be treated as a special literal that can be of any reference type. When a reference variable has the special value <code>null</code> it refers to no object, meaning that it is undefined.

System.out.println(string); //prints "null" to std out

 

Variables of primitive types cannot be assigned the special value <code>null</code>, but there are wrapper classes corresponding to the primitive types (eg. <code>Boolean</code>, <code>Integer</code>, <code>Long</code>, <code>Double</code>, &c), that can be used instead of the corresponding primitive; since they can have the special value <code>null</code> it can be used to identify the variable as undefined.

if (i == null) { // compilation error: incomparable types: int and <nulltype>

i = 1;

But this piece of code can be made valid by replacing <code>int</code> with <code>Integer</code>, and thanks to the automatic conversion between primitive types and their wrapper classes (called autoboxing) the only change required is in the declaration of the variable:

if (i == null) {

i = 1;

 

=={{header|JavaScript}}==

 

 

var obj = {}; // Empty object.

 

obj.c = 42;

 

delete obj.c;

 

=={{header|Logo}}==

UCB Logo has separate namespaces for procedures and variables ("names"). There is no distinction between a proc/name with no value and an undefined proc/name.

 

to square :x

output :x * :x

ern "n

show name? "n ; false

=={{header|Lua}}==

 

local b

b = 5

end

Output:

<pre>nil

5</pre>

 

Mathematical expressions containing Undefined evaluate to Undefined:

 

=={{header|MATLAB}} / {{header|Octave}}==

 

If a variable is generated without defing a value, e.g. with

the variable is empty, and can be tested with

 

For numerical values (e.g. vectors or arrays) with a predefined size, often not-a-numbers (NaN's) user used to indicate missing values,

These can be tested with:

 

<pre>

=={{header|MUMPS}}==

<p>MUMPS does have variables with undefined values, but referencing them usually causes an error. To test for whether a value is undefined use the $Data function. If you are trying to read a value that may be undefined, use $Get as a wrapper. Note that an alternate form of $Get can return a specified value, which must be defined.</p>

 

=={{header|OCaml}}==

 

but if you really need this you can use the built-in "option" type.

It is defined like this: type 'a option = None | Some of 'a *)

 

inc None;;

 

=={{header|Oz}}==

However, variables can be "unbound" or "free". If a program tries to read such a variable, the current thread will be suspended until the variable's value becomes determined.

 

 

thread

{Delay 1000}

{System.showInfo "Setting X."}

 

Explicitly checking the status of a variable with <code>IsFree</code> is discouraged because it can introduce race conditions.

=={{header|PARI/GP}}==

In GP, undefined variables test equal to the monomial in the variable with the name of that variable. So to test if <var>v</var> is undefined, do

 

In PARI, you can do the same but the function <code>is_entry()</code> is more appropriate:

 

=={{header|Pascal}}==

 

=={{header|Perl}}==

use strict;

 

# Because most of the output is conditional, this serves as

# a clear indicator that the program has run to completion.

 

Results in:

</pre>

 

 

=={{header|PHP}}==

// Check to see whether it is defined

if (!isset($var))

// a clear indicator that the program has run to completion.

echo "Done\n";

 

Results in:

An internal symbol is initialized to NIL. Depending on the context, this is

interpreted as "undefined". When called as a function, an error is issued:

!? (myfoo 3 4)

myfoo -- Undefined

The function 'default' can be used to initialize a variable if and only

if its current value is NIL:

-> NIL

 

 

: MyVar

=={{header|Pike}}==

In Pike variables are always defined. <code>UNDEFINED</code> is only used to indicate the nonexistence of a key or object member. <code>UNDEFINED</code> is not a value and can not be assigned. in such cases it is converted to <math>0</math>. <code>zero_type()</code> is used to test if a key exists or not:

> zero_type(UNDEFINED);

Result: 1

> zero_type(bar->baz);

Result: 0

 

=={{header|Prolog}}==

<pre>?- var(Y).

true.

=={{header|PureBasic}}==

Variables are defined through a formal declaration or simply upon first use. Each variable is initialized to a value. PureBasic does not allow changing of a variable's status at runtime. It can be tested at compile-time and acted upon, however, it cannot be undefined once it is defined.

 

CompilerIf Defined(var, #PB_Variable)

CloseConsole()

Sample output:

<pre>var is undefined at first check

In Python names, (variables), can be dynamically created and deleted at run time.

 

try: name

except NameError: print "name is undefined at first check"

# Because most of the output is conditional, this serves as

# a clear indicator that the program has run to completion.

 

Results in:

=={{header|R}}==

There are four cases to consider. To test whether a varaible has previously been defined, use <code>exists</code>.

exists("x")

 

If you want to declare a variable with undefined contents, use <code>NULL</code>.

x <- NULL

 

If you want to declare a variable with missing values, use <code>NA</code>.

y <- c(1, 4, 9, NA, 25)

z <- c("foo", NA, "baz")

(Note that there are different types of <code>NA</code>, namely <code>NA_integer_</code>, <code>NA_real_</code>, <code>NA_character_</code>, <code>NA_complex_</code> and plain (logical) <code>NA</code>. In practice, you should hardly ever need to explicitly set which type of NA you are using, as it will be done automatically.)

 

Finally, you test for arguments that haven't been passed into a function with <code>missing</code>.

print_is_missing <- function(x)

{

print_is_missing() # TRUE

print_is_missing(123) # FALSE

 

 

 

 

 

 

 

 

 

Output:

</pre>

 

=={{header|Ruby}}==

puts "var is undefined at first check" unless defined? var

 

# Because most of the output is conditional, this serves as

# a clear indicator that the program has run to completion.

 

Results in:

Done

</pre>

 

=={{header|Seed7}}==

 

=={{header|Tcl}}==

Tcl does not have undefined ''values'', but ''variables'' may be undefined by being not set.

 

# Check to see whether it is defined

if {![info exists var]} {puts "var is undefind at fourth check"}

 

Yields this output:

<pre>

 

=={{header|UNIX Shell}}==

echo ${VAR1:-"Not set."}

<pre>VAR1

Not set.</pre>

 

{{omit from|GUISS}}