Perché esiste un valore `null` in JavaScript?

https://stackoverflow.com/questions/461966

19-08-2019
|

Domanda

In JavaScript, ci sono due valori che sostanzialmente dicono "Non esisto" - undefined e null .

Una proprietà a cui un programmatore non ha assegnato nulla sarà non definito , ma affinché una proprietà diventi null , null deve essere assegnato esplicitamente ad esso.

Una volta ho pensato che fosse necessario null perché undefined è un valore primitivo e null un oggetto. Non lo è, anche se typeof null produrrà 'oggetto' : in realtà, entrambi sono valori primitivi - il che significa né non definito né null può essere restituito da una funzione di costruzione, poiché entrambi verranno convertiti in un oggetto vuoto (si deve lanciare un errore per proclamare un errore nei costruttori).

Entrambi valutano anche false in contesti booleani. L'unica vera differenza che mi viene in mente è che uno valuta NaN , l'altro su 0 in contesti numerici.

Quindi perché ci sono sia undefined che null se questo confonde i programmatori che stanno controllando erroneamente null quando provano a scoprire se un proprietà è stata impostata o no?

Quello che vorrei sapere è se qualcuno ha un esempio ragionevole in cui è necessario usare null che non può essere espresso usando undefined invece.

Quindi il consenso generale sembra essere che undefined significhi "non esiste tale proprietà" mentre null significa "la proprietà esiste, ma non contiene alcun valore".

Potrei convivere con questo se le implementazioni JavaScript applicassero effettivamente questo comportamento, ma undefined è un valore di base perfettamente valido, quindi può essere facilmente assegnato a proprietà esistenti per rompere questo contratto. Pertanto, se si desidera assicurarsi che esista una proprietà, è necessario utilizzare l'operatore in o hasOwnProperty () . Quindi, ancora una volta: qual è l'uso pratico di valori separati per undefined e null ?

In realtà utilizzo undefined quando desidero annullare l'impostazione dei valori delle proprietà non più in uso ma che non desidero elimina . Dovrei usare null invece?

Soluzione

La domanda non è davvero " perché esiste un valore nullo in JS " - esiste un valore nullo di qualche tipo nella maggior parte delle lingue ed è generalmente considerato molto utile.

La domanda è: "perché c'è un valore indefinito in JS". Luoghi principali in cui viene utilizzato:

quando dichiari "var x;" ma non assegnarlo ad esso, x rimane indefinito;
quando la tua funzione ottiene meno argomenti di quanti ne dichiara;
quando si accede a una proprietà di oggetto inesistente.

'null' avrebbe sicuramente funzionato altrettanto bene per (1) e (2) *. (3) dovrebbe davvero generare immediatamente un'eccezione, e il fatto che non lo faccia, invece di restituire questo strano "indefinito" che fallirà in seguito, è una grande fonte di difficoltà di debug.

*: potresti anche sostenere che (2) dovrebbe generare un'eccezione, ma poi dovresti fornire un meccanismo migliore e più esplicito per argomenti predefiniti / variabili.

Tuttavia JavaScript non aveva originariamente eccezioni o alcun modo per chiedere a un oggetto se avesse un membro con un certo nome - l'unico modo era (e talvolta lo è ancora) di accedere al membro e vedere cosa ottieni. Dato che "null" aveva già uno scopo e potresti voler impostare un membro su di esso, era richiesto un diverso valore fuori banda. Quindi abbiamo "indefinito", è problematico come fai notare, ed è un'altra grande "funzione" di JavaScript di cui non saremo mai in grado di sbarazzarci.

In realtà utilizzo undefined quando desidero annullare l'impostazione dei valori delle proprietà non più in uso ma che non desidero eliminare. Dovrei usare null invece?

Sì. Mantieni "non definito" come valore speciale per la segnalazione quando altre lingue potrebbero generare un'eccezione.

'null' è generalmente migliore, tranne che su alcune interfacce IE DOM in cui l'impostazione di 'null' può darti un errore. Spesso in questo caso l'impostazione della stringa vuota tende a funzionare.

Altri suggerimenti

Meglio descritto qui , ma in sintesi:

undefined è la mancanza di un tipo e valore e null è la mancanza di un valore.

Inoltre, se stai facendo dei semplici confronti '==', hai ragione, escono allo stesso modo. Ma prova ===, che confronta sia il tipo che il valore, e noterai la differenza.

Non credo che ci sia alcun motivo per avere sia null che undefined , perché l'unica ragione per cui molte persone hanno suggerito (" undefined significa che non esiste una tale variabile / proprietà ") non è valida, almeno in JavaScript. undefined non può dirti se la variabile / proprietà esiste o meno.

console.log(foo);               // "ReferenceError: foo is not defined"
                                // foo does not exist
var foo;
console.log(foo);               // "undefined", a different response
console.log(foo === undefined); // "true", but it does exist

var obj = {};
console.log(obj.hasOwnProperty("foo")); // "false", no such property
obj.foo = undefined;
console.log(obj.hasOwnProperty("foo")); // "true", it exists and has the value "undefined"
console.log(obj.foo === undefined);     // "true", but it does exist

obj.bar = "delete me";
obj.bar = undefined;
console.log(obj.hasOwnProperty("bar")); // "true", not actually deleted
delete obj.bar;
console.log(obj.hasOwnProperty("bar")); // "false", deleted

Come puoi vedere, il controllo di foo === undefined non ti dice se esiste foo e l'impostazione di obj.bar = undefined in realtà non elimina bar .

Potrebbe essere l'intento originale dell'autore JavaScript che undefined dovrebbe rappresentare "inesistenza". Tuttavia, l'implementazione non è andata in questo modo.

È del tutto possibile aver bisogno di entrambi. Ad esempio, se si esegue una query su WMI, è del tutto possibile avere una proprietà di ritorno di classe che ha un valore nullo. Sono definiti, in quel momento non hanno valore.

Penso che la tua conclusione che JavaScript definisce undefined come " non esiste tale proprietà " e null come " la proprietà non ha valore " è perfettamente corretto. E in un linguaggio dinamico come JavaScript è una distinzione molto importante. L'uso della tipizzazione anatra significa che dobbiamo essere in grado di distinguere tra una proprietà non esistente e non avere un valore. È il nostro mezzo principale per ricavare informazioni sul tipo. in una lingua tipizzata staticamente esiste una netta distinzione tra un campo che è nullo e un campo inesistente. In JavaScript questo non è diverso. Tuttavia, viene verificato in fase di esecuzione e può essere modificato fino a quel momento.

Dovrò concordare sul fatto che l'implementazione è strana poiché la distinzione è molto sfocata. Comunque penso che in JavaScript la distinzione sia importante. E essere in grado di assegnare undefined è essenziale.

Ricordo di aver letto un post sul blog qualche tempo fa su un gioco di ruolo online scritto in JavaScript. Ha usato esempi in cui gli oggetti sono stati creati come copie di istanze esistenti anziché come prototipi (classi, funzioni, qualunque cosa) e sono stati quindi modificati. Questo mi ha fatto davvero capire quanto potente potrebbe essere undefined quando si modificano oggetti esistenti, ma non ricordo chi l'abbia scritto.

Semanticamente significano cose diverse. Il tipo null ha esattamente un valore nel suo dominio, null e una proprietà può essere assegnata a questo valore specifico. Undefined rappresenta una netta mancanza di valore assegnato.

Come programmatore Java, vedo un'enorme differenza tra undefined e null. Codificare JavaScript, non tanto, perché JavaScript non è fortemente tipizzato e le differenze tra indefinito e nullo sono sfocate dalle conversioni automatiche che vengono spesso eseguite dal runtime. A proposito, approfitto spesso di quelle conversioni; rendono il mio codice JS più compatto e leggibile.

Per rispondere alla tua domanda, indefinito significa che non è mai stato impostato un valore. In pratica, ciò indica generalmente un bug. Se yourObject.property non è definito, significa che non hai impostato la proprietà per qualche motivo o sto cercando qualcosa che non esiste affatto. Questo è un vero problema quando si lavora su un progetto con più di un programmatore.

null significa che "nessun valore" è stato impostato esplicitamente. In pratica, mi stai dicendo qualcosa sulla proprietà, forse che non è utilizzata in questo contesto o che un valore deve ancora essere determinato.

In Java, i tentativi di accedere a un campo indefinito comporteranno sempre un'eccezione. In effetti, il compilatore può essere creato per avvisarti di questo nel tuo codice.

Prova questo esempio:

<html>
<head>
    <script type="text/javascript">
        function ShowObjProperties(obj) {
            var property, propCollection = "";

            for(property in obj) {
                propCollection += (property + ": " + obj[property] + "\n");
            }

            alert(propCollection);
        }

        var obj = {
            userid: 3,
            name: 'me!',
            speak: function() { alert('Hi! My name is ' + this.name + ' and my ID is ' + this.userid + '.'); }
        }

        //Shows all properties
        ShowObjProperties(obj);

        //The Speak function is no longer in the list!
        delete obj.speak;
        alert(typeof obj.speak);
        ShowObjProperties(obj);

        //The UserID is still listed, it just has no value!
        obj.userid = null;
        ShowObjProperties(obj);
    </script>
</head>
<body>

</body>
</html>

Penso che ci sia un reale utilizzo per 2 tipi diversi qui.

Ciò che si riduce è la natura dinamica javascript.

Le cose potrebbero essere indefinite in modo da poterle aggiungere in un secondo momento. Questo è probabilmente il motivo per cui JavaScript è così potente ed estensibile.

è una funzione linguistica importante se avvolgi il tuo programma attorno al paradigma evented di javascript.

// a key exists as a placeholder for something
if(obj[name] === null) 
// no key exists int eh hashtable that is in this object
if(obj[name] === undefined)

questo è molto utile se hai a che fare con un set di dati che ha bisogno di un valore per rappresentare "niente" per indicare un'azione diversa dall'uso di "niente" per indicare l'azione predefinita.

filter_func_pt = {
  date:function(d){ return Math.round(d.getTime()/1000);},
  user: null,
}

function transform(obj){
    var ret = {};
    for( var prop in obj){
       var f = filter_func_pt[prop];
       if(f)
          ret[prop] = f(obj);
       else if(filter_func_pt[prop] === null)
         continue;
       else
         ret[prop] == obj;
    }
  return ret;
}

var a = {
   date: new Date(),
   user: 'sam'
   votes: [23, 41, 55] 
};

var b = transform(a);

/* b = {
 *    date: 1298582417
 *    votes: [23, 41, 55]
 * }
 */

nel codice sopra la parola chiave null e il server indefinito hanno scopi molto chiari e diversi. la ricerca che non si trova nell'oggetto filter_func_pt che restituisce non definito significa aggiungere la proprietà all'oggetto return così com'è, mentre un valore null indica che il valore deve essere trattenuto e non aggiunto e la presenza di qualsiasi valore vero in questo caso rappresenta una funzione utilizzata per trasformare il valore prima di aggiungerlo all'oggetto ret .

null è bellissimo

come tutti gli altri tipi di Live Script.

cita: in JavaScript, ci sono due valori che sostanzialmente dicono 'Io no esiste "- indefinito e nullo.

Perché dovresti voler dire cose sbagliate ?!

" null " è " oggetto vuoto " proprio come " 0 " è un " numero vuoto " . 0, è nulla, tuttavia esiste come un tipo di cosa Numero. null è ovviamente anche vuoto ma " è " ed è una cosa ben definita di un Tipo di oggetto .

È comune parlare di queste cose come di "tipi", quando non lo sono. In realtà sono "categorie". Ma ora è finita.

Quindi attenersi ad esso per dire che " null " è un tipo di oggetto senza un tipo. E "null" dice " Esisto molto [!], ma non ho contenuti del mio tipo " ;.

Considerando che undefined manca sia del Tipo sia del Tipo dove undefined sembra essere anche la sua definizione di Tipo. Un tipo indefinito di un tipo diventa la sua tipologia distintiva. Una sorta di [non fa nulla " esiste e come si definisce la domanda "niente"?].

cita: undefined né null può essere restituito da una funzione di costruzione, poiché entrambi saranno convertiti in un oggetto vuoto

Sei riuscito a dire ancora una volta una cosa sbagliata. Certo che no, il "non definito" non è un oggetto, è un semplice token che noi umani comprendiamo; ma contrariamente a quanto null è - e ti dice che: il suo Tipo è corretto, ma il Tipo che stai cercando non è contenuto al suo interno, o almeno -non in questo momento. Vieni a trovarci più tardi quando mettiamo \ assegniamo un oggetto in \ ad esso.

cita: l'unica vera differenza che mi viene in mente è che si valuta NaN, l'altro a 0 in contesti numerici.

Ciò rende il punto fondamentale della loro distinzione principale, come detto: indefinito è un semplice segno e poiché è costituito dallo stesso materiale "genetico" dei suoi parenti lontani: stringhe, il [ + undefined] l'operazione lo convertirà in NaN, allo stesso modo ovviamente null si trasformerà in un tipo corretto 0 \ Number, e al contrario di undefined che si trasformerà in una stringa (! che è non vuoto!) ed è esattamente per questo che produce invece NaN . Dove: + undefined > > + & Quot; indefinito " & Gt; > NaN. Poiché il contesto numerico prevede un valore esplicito.

Mentre il contesto booleano prevede riferimenti - non trova nulla da convertire e produce "falso".

Vediamo ora ...

cita: Quindi, ancora una volta: qual è l'uso pratico di valori separati per indefinito e nullo?

Proverò a darti solo due esempi empirici e spero di bastare

oElement.onclick >> null

// significa che esiste la proprietà; il suo valore atteso è di Tipo: Oggetto , e che oElement supporta il " onclick " evento!

oElement.innerText >> ""

// significa: la proprietà esiste; il suo valore atteso è di Tipo: Stringa , il che significa che oElement supporta il " innerText " Proprietà.

in entrambi i casi -se ricevi " undefined " significa che la proprietà non esiste; non è supportato o ha un'implementazione errata (ua vendor).

Stai al gelo e divertiti.

dopo aver letto una discussione straordinaria su undefined vs null, una piccola ricerca su google mi ha portato alla documentazione di Mozilla https://developer.mozilla.org/en- USA / docs / Web / JavaScript / Reference / Global_Objects / null è menzionato - null viene spesso recuperato in un luogo in cui ci si può aspettare un oggetto ma nessun oggetto è rilevante.

Non è simile al modello di oggetti Null https://en.wikipedia.org/wiki/Null_object_pattern

Quindi credo che abbia senso avere un tipo di dati Null.

Documentazione menzionata anche come tipo di null // "oggetto" (non " null " per motivi legacy)

Non sono sicuro di quali motivi legacy siano

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow