La différence et l'utilisation de undefined et null qui représentent un espace vide en JavaScript

Quand j'ai commencé à apprendre JavaScript

, je sentais qu'indéfini était assez nouveau
parce que d'autres langages ne l'avaient pas
et non seulement il avait undéfini, mais il y avait aussi un null signifiant vide
Je crois que de nombreux étudiants ne peuvent pas faire la différence entre undefined et null
Aujourd'hui, je vais résumer la différence entre undefined et null qui signifie vide en JavaScript

Similaire

Undefined et null sont tous deux JavaScript. Les types de base dans
et ils n'ont qu'une seule valeur de type chacun, qui sont indéfinis et null, qui ont le même nom que leurs types
Normalement, il n'y a vraiment pas différence entre ces deux valeurs

var foo = undefined;

var foo = null;

Et la norme stipule également que

console.log(null == undefined) // true

(mais null !== undefined)

est converti en un Valeur booléenne et est faux

if(!undefined){
    console.log(1);//1}if(!null){
    console.log(1);//1}

différence

Mais en fait, il y a une différence
Jetons d'abord un coup d'œil à ces lignes de code

console.log(undefined in window);// trueconsole.log(null in window);// false

C'est la différence
null est un mot-clé en JavaScript
undéfini est un attribut spécial sur la fenêtre (le même que NaN et Infinity)
Bien que ES5 undéfini devienne un attribut en lecture seule, il y a encore des choses déraisonnables , comme ceci

function fn(){
    var undefined = 1;// 注意：前方高能
    console.log(undefined);// 1}
fn();

Regardez , car undefined n'est pas un mot clé, on peut donc déclarer undefined dans des variables locales (sans voix)
Même si vous êtes en mode strict

function fn(){    "use strict";    var undefined = 1;
    console.log(undefined);// 1}
fn();

Nous ne devons pas écrire un code aussi scandaleux

Il y a aussi une différence lors des opérations mathématiques

console.log(undefined + 1); //NaNconsole.log(null + 1); //1

non défini car toute opération est convertie en NaN
tandis que null est converti en 0

Historique

Il est logique que JavaScript ait deux valeurs qui représentent null
Brendan Eich, le père de js, l'a conçu à l'origine comme Java, avec seulement null
Mais il considérait que js avait deux types de valeurs de base et de valeurs de référence
Utiliser un objet pour représenter l'étrange typeof null === 'object' et convertir null en nombre 0 rendait de nombreux bugs difficiles à trouver
Donc il a conçu undéfini

Utilisation

Selon js Le design du père
undéfini signifie valeur manquante
null signifie un objet vide
Mais on ne l'utilise pas comme ceci maintenant

Cela peut être compris de cette façon
undéfini signifie que la variable n'est pas initialisée, non La valeur
null signifie que la variable a été initialisée et la valeur est "valeur nulle"

undefined est utilisé par js, et null est pour nous
Je ne sais pas si vous pouvez comprendre cette phrase
Par exemple, si vous déclarez une variable dans ces cas

• var a;, le moteur lui attribuera une valeur par défaut de indéfini lors de la précompilation

• function a(){} Fonction de déclaration, aucune valeur de retour, la valeur par défaut renvoie undéfini

• Lors de l'accès aux propriétés d'un objet inexistant, la valeur par défaut est indéfinievar obj = {};obj.a;

• non spécifié Paramètres réels, valeur du paramètre par défaut non définie var a = function(a){};a();

• ......

C'est l'indéfini par défaut qui nous est donné par le système, qui est le Ce que nous voulons utiliser est nul

Par exemple,

• Créer un objet vide

  var obj = Object.create(null);

• Délier l'événement

  demo.onclick = null;

......
Tant que nous voulons utiliser null, il est tout à fait correct d'utiliser null dans certains cas. , cela peut également faciliter le recyclage des déchets du navigateur

Résumé

Enfin, permettez-moi de résumer pour vous

indéfini est un attribut spécial sur la fenêtre, un identifiant et peut se voir attribuer une valeur ; null est une clé spéciale. Les mots, et non les identifiants, ne peuvent pas être attribués
undefined == null –> > false
Indéfini est converti en nombre et est NaN, null est converti en nombre et est 0
indéfini et null est converti en les booléens sont tous deux faux
undefined signifie aucune valeur, null signifie une valeur vide
Nous devrions utiliser null pour signifier vide au lieu de indéfini
Ne jamais redéfinir undéfini
Ce qui précède est la différence et l'utilisation de undéfini et de null en JavaScript. Pour plus de contenu connexe, veuillez faire attention au chinois PHP. site Web (www.php.cn) !