¿Hay un nombre para el problema no dado / nulo / vacío? [cerrado]

Trabajo con código, donde los datos se almacenan / intercambian en estructuras Hashtable / Dictionary / Associative-Array, como esta

{
   'alpha': None,
   'bravo': '',
   # 'charlie' is not given
}

no hay mucha estandarización, qué campo se 'da', y cuando se da, si se puede dar como Ninguno / Nulo / Nulo o una cadena vacía. Como resultado, el código está plagado de verificaciones if hasattr(obj, 'alpha')y fallos predeterminados.

¿Existe un nombre o un término de argot para este tipo de (patrón) anti-patrón?

ACTUALIZAR:

parece que actualmente no hay nombre, así que me gustaría escuchar sugerencias. Actualmente tenemos estos:

• Horda incorpórea (créditos a psr)

No creo que haya tal nombre (lo busqué, pero, por supuesto, ¿cómo puedes encontrar la falta de un nombre?)

Sugiero el nombre "Horda incorpórea", aunque lo aplicaría a la colección completa de objetos nulos o degenerados: colecciones de tamaño cero, nulas, indefinidas, nada, Ninguna, NAN (posiblemente sea un tipo de caso diferente), DBNull, vacío, cadena vacía (posiblemente un caso especial de colección vacía), entradas de diccionario faltantes, etc.

Y no lo llamaría un anti-patrón, per se, sino como un problema en el desarrollo de software, especialmente en el caso en que su entorno de programación requiera que escriba un código separado para muchos de esos casos.

Disculpas por una respuesta bastante no informativa, pero creo que es lo mejor que se puede hacer. Además, si el mundo adopta un nombre debido a su pregunta, podría convertirse en una respuesta correcta.

En F # esto se proporciona a través de un Tipo de opción (de manera similar a los idiomas anteriores de la misma familia). He usado el mismo concepto en un proyecto de C # donde tengo una regla que trato de no devolver nunca null de una función, pero devuelvo el Option<T>de ese tipo de que existe la posibilidad de un valor None. De esa manera, el código de llamada sabe que tiene que lidiar con esa posibilidad en el valor de retorno.

Preferiría tener tipos de referencia no anulables, al igual que ahora tenemos tipos de valores anulables, pero esa es otra historia.

En JavaScript, esto se conoce como undefinedun valor centinela único, distinto de null.

Se obtiene undefinedevaluando la variable global undefined, o una propiedad de un objeto, que no está definida o evaluando una declaración, que no devuelve un valor, como llamadas a funciones, que no devuelve nada, o un bloque o una declaración de variable (aunque esas dos no son expresiones válidas, por lo que solo lo encontrará en un REPL de JavaScript).

Cuando el undefinedvalor es forzado a ser, Objectse convierte null, pero no lo es null.

Aquí hay una pequeña ilustración:

var a = [1, 2, 3];//undefined
a[0];//1
a[4];//undefined

var o = { foo: "123" };//undefined
o.foo;//"123";
o.bar;//undefined

function bar() { return null; };//undefined
bar();//null
function foo() { /*just an empty block*/};//undefined
foo();//undefined

typeof undefined;//"undefined"
typeof null;//"object"
null == undefined;//true - that is because undefined is converted to an object for comparison and thus yields null
null === undefined;//false - because they are not the same

Creo que es razonable llamar indefinidos los valores (en contraste con los valores definidos como null), si esa es su pregunta. El uso de un valor centinela único para comunicar la ausencia de un valor definido es una solución viable para lenguajes dinámicos, aunque a menudo se entiende mal.