Quelle raison y a-t-il d'utiliser null au lieu de non défini dans JavaScript?

Je n'ai pas vraiment de réponse, mais selon Nicholas C. Zakas , page 30 de son livre JavaScript Professionnel pour les développeurs Web " :

lors de la définition d'une variable pour tenir plus tard un objet, il est conseillé d'initialiser la variable à null par opposition à toute autre chose. De cette façon, vous pouvez vérifier explicitement la valeur null à déterminer si la variable a été remplie ultérieurement d'une référence d'objet

vous pourriez adopter la convention suggérée ici, mais il n'y a vraiment pas de bonne raison. Il n'est pas utilisé assez régulièrement pour être significatif.

afin de rendre la convention utile, vous devez d'abord savoir que la fonction appelée suit la convention. Ensuite, vous devez tester explicitement la valeur retournée et décider quoi faire. Si vous obtenez Non défini , vous pouvez supposer qu'une sorte d'erreur s'est produite que la fonction appelée il savait pour . Mais si une erreur s'est produite, et la fonction savait à ce sujet, et il est utile de l'envoyer dans un environnement plus large, pourquoi ne pas utiliser un objet d'erreur? c'est à dire jeter une erreur?

donc en fin de compte, la convention est pratiquement inutile dans tout autre que de très petits programmes dans des environnements simples.

Non défini est là où aucune notion de la chose n'existe; il n'a aucun type, et il n'a jamais été référencé avant dans cette portée; null est là où la chose est connue pour exister, mais il n'a aucune valeur.

tout le monde a sa propre façon de coder et sa propre sémantique interne, mais au fil des ans, j'ai trouvé que c'était le Conseil le plus intuitif que je donnais aux gens qui posaient cette question: dans le doute, faites ce que JavaScript fait .

disons que vous travaillez avec des propriétés d'objet comme des options pour un plugin jQuery...demandez-vous quelle valeur JavaScript donne à une propriété qui n'a pas encore été définie -- la réponse est undefined . Donc, dans ce contexte, je voudrais initialiser ces types de choses avec 'undefined' pour être cohérent avec JavaScript (pour les variables, vous pouvez faire var myVar; au lieu de var myVar = undefined; ).

maintenant, disons que vous faites de la manipulation DOM...quelle valeur JavaScript attribue-t-il aux éléments inexistants? La réponse est null . C'est la valeur que j'initialiserais si vous créez une variable placeholder qui contiendra plus tard une référence à un élément, un fragment de document, ou similaire. qui se rapporte à la DOM.

si vous travaillez avec JSON, alors un cas spécial doit être fait: pour des valeurs de propriété non définies, vous devez soit les définir à "" ou null parce qu'une valeur de undefined n'est pas considérée comme format JSON approprié.

avec ceci dit, comme une affiche précédente a exprimé, si vous trouvez que vous initialisez des trucs avec null ou undefined plus d'une fois dans une lune bleue, alors peut-être vous devriez reconsidérez votre façon de coder votre application.

les noeuds et éléments de DOM ne sont pas non définis, mais peuvent être nuls.

• le nextSibling du dernier enfant d'un élément est nul.

• le précédent divorce du premier enfant est nul.

• Un document.la référence getElementById est nulle si l'élément n'existe pas dans le document.

mais dans aucun des ces cas sont la valeur non définie ; il n'y a tout simplement pas de noeud.

Je ne suis pas du tout d'accord que l'usage nul ou non défini est inutile. l'indéfini est la chose qui maintient en vie tout le processus de chaînage de prototype. Ainsi le compilateur seulement avec null ne peut pas vérifier si cette propriété juste égale à null, ou son non défini dans le prototype de point final. Dans d'autres langues dynamiques dactylographiées(F. E. Python) il lance l'exception si vous voulez accéder à une propriété non définie, mais pour les langages basés sur des prototypes, le compilateur devrait aussi vérifier les prototypes parents et voici l'endroit où il n'est pas défini ont le plus besoin.

le sens entier de l'utilisation de null est seulement lient la variable ou la propriété avec l'objet qui est singleton et ont la signification de vide,et aussi null usage ont des fins de performance. Ces 2 Codes ont un temps d'exécution différent.

var p1 = function(){this.value = 1};
var big_array = new Array(100000000).fill(1).map((x, index)=>{
    p = new p1();
    if(index > 50000000){
       p.x = "some_string";
    }

    return p;
});
big_array.reduce((sum, p)=> sum + p.value, 0)

var p2 = function(){this.value = 1, p.x = null};
var big_array = new Array(100000000).fill(1).map((x, index)=>{
    p = new p2();
    if(index > 50000000){
       p.x = "some_string";
    }

    return p; 
});
big_array.reduce((sum, p)=> sum + p.value, 0)

je travaille à travers cette question exacte en ce moment, et en regardant la philosophie suivante:

1. toute fonction qui est destinée à retourner un résultat doit retourner null si elle ne trouve pas un résultat
2. toute fonction qui n'est pas destinée à retourner un résultat retourne implicitement Non défini.

pour moi, cette question est importante parce que quiconque appelle une fonction qui renvoie un résultat ne devrait pas avoir question de savoir si, à l'essai pour l'indéfini vs null.

Cette réponse ne tente pas de répondre:

1. valeurs de propriété de nul vs non défini
2. Variables dans vos fonctions étant nul vs non défini

à mon avis, les variables sont votre propre entreprise et ne font pas partie de votre API, et les propriétés dans n'importe quel système OO sont définis et doivent donc être définis avec une valeur différente de ce qu'ils seraient s'ils n'étaient pas définis (null pour défini, Non défini est ce que vous obtenez en accédant à quelque chose qui n'est pas dans votre objet).

une propriété utile dans null que Non défini n'est pas admissible:

> null + 3
3
> undefined + 3
NaN

j'utilise null quand je veux "désactiver" une valeur numérique, ou d'initialisation. Ma dernière utilisation a été la manipulation CSS transform:

const transforms = { perspective : null, rotateX : null };
// if already set, increase, if not, set to x
runTimeFunction((x) => { trasforms.perspective += x; });
// still useful, as setting perspective to 0 is different than turning it off
runTimeFunction2((x) => { transforms.perspective = null; });

// toCss will check for 'null' values and not set then at all
runTimeFunction3(() => { el.style.transform = toCss(transforms); });

pas sûr si je devrait utiliser cette propriété pensée...

Voici une raison: var undefined = 1 est légal javascript, mais var null = 1 est une erreur de syntaxe. La différence est que null est un mot-clé de langue, tandis que undefined est, pour une raison quelconque, pas.

si votre code s'appuie sur des comparaisons avec undefined comme si c'était un mot-clé ( if (foo == undefined) -- une erreur très facile à faire) qui ne fonctionne que parce que personne n'a défini une variable avec ce nom. Tout ce code est vulnérable à quelqu'un accidentellement ou malicieusement définir une variable globale avec ce nom. Bien sûr, nous savons tous que définir accidentellement une variable globale est totalement impossible en javascript...

à la fin de la journée, parce que les deux null et undefined coerce à la même valeur ( Boolean(undefined) === false && Boolean(null) === false ), vous pouvez techniquement utiliser l'un ou l'autre pour obtenir le travail fait. Cependant, il y a une bonne voie, IMO.

1. laisser l'utilisation de undefined au compilateur JavaScript.

   undefined sert à décrire des variables qui ne renvoient pas à une référence. C'est quelque chose que le compilateur JS prendra soin de vous. Au moment de la compilation, le moteur JS définira la valeur de toutes les variables hissées à undefined . Lorsque le moteur passe à travers le code et les valeurs devient disponible, le moteur assignera des valeurs respectives aux variables respectives. Pour les variables pour lesquelles il n'a pas trouvé de valeurs, les variables continueraient à maintenir une référence à la primitive undefined .

2. n'utilisez null que si vous voulez explicitement indiquer la valeur d'une variable comme ayant "aucune valeur".

   comme le dit @com2gz: null est utilisé pour définir quelque chose de vide par programmation. undefined signifie que la référence n'existe pas. Une valeur null a une référence définie à"rien". Si vous appelez une propriété non existante d'un objet, alors vous obtiendrez undefined . Si je rendais ce bien vide intentionnellement, alors il doit être null donc vous savez que c'est fait exprès.

TLDR; N'utilisez pas le undefined primitive. C'est une valeur que le compilateur JS automatiquement pour vous lorsque vous déclarez des variables sans affectation ou si vous essayez d'accéder aux propriétés des objets pour lesquels il n'existe pas de référence. D'un autre côté, utilisez null si et seulement si vous voulez intentionnellement qu'une variable n'ait "aucune valeur".

Je n'ai jamais explicitement défini quoi que ce soit à non défini (et je n'ai jamais rencontré ceci dans les nombreuses bases de données avec lesquelles j'ai interagi). De plus, j'utilise rarement null . Les seules fois où j'utilise null est quand je veux dénoter la valeur d'un argument à une fonction comme n'ayant aucune valeur, i.e.,

function printArguments(a,b) {
  console.log(a,b);
}

printArguments(null, " hello") // logs: null hello