Tipo anulable

Los tipos anulables son una característica de algunos lenguajes de programación que permite asignar el valor especial NULL a un valor en lugar de los valores posibles habituales del tipo de dato . En los lenguajes de tipado estático, un tipo anulable es un tipo de opción , mientras que en los lenguajes de tipado dinámico (donde los valores tienen tipos, pero las variables no), se proporciona un comportamiento equivalente mediante un único valor nulo.

NULL se usa frecuentemente para representar un valor faltante o no válido, como el de una función que no devolvió ningún valor o un campo faltante en una base de datos, como en SQL . En otras palabras, NULL no está definido.

Los tipos primitivos como los enteros y los booleanos generalmente no pueden ser nulos, pero los tipos anulables correspondientes (entero anulable y booleano anulable, respectivamente) también pueden asumir el valor NULL. Esto se puede representar en lógica ternaria como FALSE, NULL, TRUE, al igual que en la lógica trivalente .

Una variable entera puede representar enteros, pero 0 (cero) es un caso especial porque 0 en muchos lenguajes de programación puede significar "falso". Además, esto no proporciona ninguna noción de decir que la variable está vacía, una necesidad que surge en muchas circunstancias. Esta necesidad se puede lograr con un tipo anulable. En lenguajes de programación como C# 2.0, un entero anulable, por ejemplo, se puede declarar con un signo de interrogación (int? x). ^{[ 1 ] [ 2 ] : 46} En lenguajes de programación como C# 1.0, los tipos anulables pueden ser definidos por una biblioteca externa ^{[ 3 ]} como nuevos tipos (por ejemplo, NullableInteger, NullableBoolean). ^{[ 4 ]}

Una variable booleana hace que el efecto sea más claro. Sus valores pueden ser "verdadero" o "falso", mientras que una variable booleana que admite valores nulos también puede contener una representación para "indeciso". Sin embargo, la interpretación o el tratamiento de una operación lógica que involucre dicha variable depende del lenguaje de programación.

El siguiente es un ejemplo de T?(o explícitamente System.Nullable<T>) en C# .

usando el sistema ;public class Example { static void Main ( string [] args ) { // Usando notación abreviada int? a = 10 ; double? b = null ;// Usando Nullable<T> explícito Nullable < int > c = 20 ; Nullable < double > d = 5.5 ;// Comprobando si las variables anulables tienen valores Console.WriteLine ( a.HasValue ) ; // Verdadero Console.WriteLine ( b.HasValue ) ; // Falso Console.WriteLine ( c.HasValue ) ; // Verdadero Console.WriteLine ( d.HasValue ) ; // Verdadero​// Accediendo a los valores if ( a . HasValue ) { Console . WriteLine ( a . Value ); // 10 }if ( b . HasValue ) { Console . WriteLine ( b . Value ); // (no se ejecutará porque b es nulo) } } }

En cambio, en la mayoría de los lenguajes comunes, los punteros a objetos pueden establecerse en NULL por defecto, lo que significa que el puntero o referencia no apunta a ninguna parte, que no se asigna ningún objeto (la variable no apunta a ningún objeto). Las referencias anulables fueron inventadas por CAR Hoare en 1965 como parte del lenguaje Algol W. Hoare describió posteriormente su invención como un "error de mil millones de dólares". ^{[ 5 ]} Esto se debe a que los punteros a objetos que pueden ser NULL requieren que el usuario verifique el puntero antes de usarlo y requieren código específico para manejar el caso en que el puntero a objeto sea NULL.

Java cuenta con clases que se corresponden con valores escalares, como Integer, Boolean y Float. Combinado con el autoboxing (conversión automática basada en el uso entre objeto y valor), esto permite, en la práctica, el uso de variables anulables para valores escalares.

Las implementaciones de tipos anulables generalmente se adhieren al patrón de objeto nulo .

Existe un concepto más general y formal que extiende el concepto de tipo anulable: proviene de los tipos de opción , que imponen un manejo explícito del caso excepcional.

Los siguientes lenguajes de programación admiten tipos anulables.

Los lenguajes de tipado estático con soporte nativo para valores nulos incluyen:

• Bailarina ^{[ 6 ]}
• C# ^{[ 7 ]}
• Dardo ^{[ 8 ]}
• Kotlin ^{[ 9 ]}
• Ceilán
• SQL
• SAS (Valores faltantes)

Los lenguajes de tipado estático con soporte para valores nulos en la biblioteca incluyen:

• C# (desde la versión 2) ^{[ 2 ] : 5}
• Delfos
• Pascal libre
• VB.NET ^{[ 10 ]}
• Java (desde la versión 8)
• Scala
• Oxígeno
• F#
• Lenguajes de línea de comandos con tipado estático

Los lenguajes de tipado dinámico con null incluyen:

• JavaScript tiene valores nully undefined.
• Julia tiene el nothingvalor (que es de tipo Nothing) y el Union{T, Nothing}modismo de tipo. ^{[ 11 ]}
• Las variables escalares de Perlundef tienen un valor predeterminado y se pueden configurar a undef.
• PHP con tipo NULL y método is_null(), tipo anulable nativo en la versión 7.1 ^{[ 12 ]}
• Python tiene Nonevalor. ^{[ 13 ]}
• Ruby tiene el valor nil y el tipo NilClass.

• Operador de coalescencia nula
• Problema de semipredicado
• Tipo Unión
• Tipo de unidad