Esiste un nome per il problema non specificato / null / vuoto? [chiuso]

Non penso che ci sia un nome del genere (ho guardato, ma ovviamente come puoi trovare la mancanza di un nome)?

Suggerisco il nome "Incorporeal Horde", anche se lo applicherei alla collezione completa di oggetti nulli o degenerati: collezioni di dimensioni zero, null, indefinite, nulla, None, NAN (probabilmente è un diverso tipo di edge case) , DBNull, void, stringa vuota (probabilmente un caso speciale della raccolta vuota), voci del dizionario mancanti, ecc.

E non lo definirei un anti-pattern di per sé, ma come un problema nello sviluppo di software, specialmente nel caso in cui l'ambiente di programmazione richieda di scrivere codice separato per molti di questi casi.

Chiedo scusa per una risposta abbastanza non informativa, ma penso che sia il meglio che si possa fare. Inoltre, se il mondo adotta un nome a causa della tua domanda, potrebbe diventare una risposta corretta.

In F # viene fornito tramite un tipo di opzione (in modo simile alle lingue precedenti della stessa famiglia). Ho usato lo stesso concetto in un progetto C # in cui ho una regola che cerco di non restituire mai null da una funzione, ma restituisco il Option<T> di quel tipo di c'è la possibilità di un valore None. In questo modo il codice chiamante sa che deve trattare questa possibilità nel valore di ritorno.

Preferirei avere tipi di riferimento non annullabili, proprio come ora abbiamo tipi di valori nullable, ma questa è un'altra storia.

In JavaScript, questo è indicato come undefined , che è un valore sentinella univoco, distinto da null .

Ottieni undefined valutando la variabile globale undefined , o una proprietà di un oggetto, che non è definita o valutando una dichiarazione, che non restituisce un valore, come le chiamate alle funzioni, che non restituire nulla, o un blocco o una dichiarazione di variabile (anche se questi due non sono espressioni valide, quindi lo incontrerai solo in un REPL JavaScript).

Quando il valore undefined è forzato ad essere un Object diventa null , ma non è null .

Ecco un piccolo esempio:

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

Penso che sia ragionevole chiamare valori non definiti (a differenza di quelli definiti come null ) indefiniti, se questa è la tua domanda. L'utilizzo di un valore sentinella univoco per comunicare l'assenza di un valore definito è una soluzione praticabile per i linguaggi dinamici, anche se è spesso capita male.