Existe um nome para o problema não especificado / nulo / vazio? [fechadas]

Trabalho com código, onde os dados são armazenados / trocados em estruturas do tipo Hashtable / Dictionary / Associative-Array, como este

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

não há muita padronização, qual campo é 'fornecido' e, quando fornecido, se pode ser fornecido como Nenhum / Nulo / Nulo ou uma sequência vazia. Como resultado, o código está repleto de verificações como if hasattr(obj, 'alpha')e fallbacks padrão.

Existe um nome ou termo de gíria para esse tipo de (imho) anti-padrão?

ATUALIZAR:

parece, atualmente não há nome, então eu gostaria de ouvir sugestões. Atualmente, temos os seguintes:

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

Eu não acho que exista esse nome (eu olhei, mas é claro como você pode encontrar a falta de um nome)?

Sugiro o nome "Horda incorpórea", embora eu o aplique à coleção completa de objetos nulos ou degenerados - coleções de tamanho zero, nulo, indefinido, nada, nenhum, NAN (sem dúvida, é um tipo diferente de caso de borda), DBNull, cadeia vazia, vazia (sem dúvida um caso especial de coleção vazia), entradas de dicionário ausentes etc.

E eu não chamaria isso de antipadrão, por si só, mas como um problema no desenvolvimento de software, especialmente no caso em que seu ambiente de programação exige que você escreva um código separado para muitos desses casos.

Pedimos desculpas por uma resposta bastante não informativa, mas acho que é o melhor que pode ser feito. Além disso, se o mundo adotar um nome devido à sua pergunta, pode se tornar uma resposta correta.

No F #, isso é fornecido por meio de um Tipo de opção (de maneira semelhante aos idiomas anteriores da mesma família). Eu usei o mesmo conceito em um projeto C # em que tenho uma regra que tento nunca retornar nulo de uma função, mas retorno o Option<T>tipo de que existe a possibilidade de um valor Nenhum. Dessa forma, o código de chamada sabe que precisa lidar com essa possibilidade no valor de retorno.

Eu preferiria ter tipos de referência não anuláveis, assim como agora temos tipos de valores anuláveis, mas isso é outra história.

Em JavaScript, isso é chamado de undefined, que é um valor sentinela exclusivo, diferente de null.

Você undefinedavalia a variável global undefinedou a propriedade de um objeto que não está definido ou avalia uma instrução que não retorna um valor, como chamadas para funções, que não retornam nada ou um bloco ou uma declaração de variável (embora essas duas não sejam expressões válidas, você encontrará apenas isso em um JavaScript REPL).

Quando o undefinedvalor é coagido a ser um, Objectele se torna null, mas não é null.

Aqui está uma pequena ilustração:

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

Eu acho que é razoável chamar valores indefinidos (em contraste com os valores definidos para serem null) indefinidos, se essa é a sua pergunta. Usar um valor sentinela exclusivo para comunicar a ausência de um valor definido é uma solução viável para linguagens dinâmicas, embora muitas vezes seja pouco compreendido.