web-dev-qa-db-fra.com

Quand dois-je initialiser des variables en JavaScript avec null ou pas du tout?

J'ai vu différents exemples de code avec des variables déclarées et définies sur non défini et nul. Tel que:

var a; // undefined - unintentional value, object of type 'undefined'
var b = null; // null - deliberate non-value, object of type 'object'

Si le code à suivre ces déclarations attribue une valeur à a ou à b, quelle est la raison d'utiliser un type de déclaration plutôt qu'un autre?

javascriptvariablesnullundefined
31
KMcA

Le premier exemple n'affecte rien à la variable, il fait donc implicitement référence à la valeur undefined (voir 10.5 dans la spécification pour les détails). Il est couramment utilisé lors de la déclaration de variables pour une utilisation ultérieure. Il n'est pas nécessaire de leur attribuer explicitement quoi que ce soit avant que nécessaire.

Le deuxième exemple est explicitement assigné à null (qui est en fait de type null, mais en raison d'un hasard de la spécification JavaScript, prétend avoir le type "objet"). Il est couramment utilisé pour effacer une valeur déjà stockée dans une variable existante. L'utilisation de null lors de l'effacement de la valeur peut être considérée comme plus robuste, car il est possible d'écraser undefined et, dans cette situation, l'assignation de undefined entraînerait un comportement inattendu.

En passant, cette bizarrerie de null est une bonne raison d’utiliser une forme plus robuste de vérification de type:

Object.prototype.toString.call(null); // Returns "[object Null]"
27
James Allardice

Je ne pense pas qu'il existe une meilleure façon de faire les choses, mais je suis enclin à éviter autant que possible les indéfinis. Peut-être est-ce dû à un fort OOP - fond.

Lorsque j'essaie d'imiter OOP avec Javascript, je déclare généralement et initialise explicitement mes variables en tant que null (comme le fait <OOP) les langages lorsque vous déclarez une variable d'instance sans l'initialiser explicitement Si je ne vais pas les initialiser, pourquoi même les déclarer en premier lieu? Lorsque vous déboguez, si vous n'avez pas défini de valeur pour une variable que vous regardez, vous la verrez comme indéfinie, que vous l'ayez déclarée ou non ...

Je préfère garder undefined pour des comportements spécifiques:

  • lorsque vous appelez une méthode, tout argument que vous ne fournissez pas aura une valeur indéfinie. Bon moyen d'avoir un argument optionnel, implémentant un comportement spécifique si l'argument n'est pas défini.
  • init paresseux ... dans mon livre, non défini signifie "non initialisé: va chercher la valeur" et null signifie "initialisé mais la valeur était nulle (par exemple, il y avait une erreur de serveur?)"
  • tableaux: myArray [myKey] === null s'il existe une valeur null pour cette clé, indéfini si une valeur n'a jamais été définie pour cette clé.

Attention cependant, myVar == null et myVar == undefined renvoient la même valeur, que myVar soit indéfini, null ou autre chose. Utilisez === si vous voulez savoir si une variable est indéfinie.

10
Evren Kuzucuoglu

Je viens de voir ce lien qui clarifie ma question. Quelle raison y a-t-il d'utiliser null au lieu de indéfini en JavaScript?

Javascript pour les développeurs Web indique "Lors de la définition d'une variable destinée à contenir ultérieurement un objet, il est conseillé d'initialiser la variable à null, par opposition à toute autre option. Vous pouvez ainsi vérifier explicitement la valeur null a été rempli ultérieurement avec une référence d’objet. "

7
KMcA

Je choisirais explicitement null pour ne pas avoir un objet dont l'identifiant aurait été écrasé ultérieurement:

var foo = {}; // empty object, has id etc.
var foo2 = null; // good practice, // filled with an object reference at a later time
var foo3;// undefined, I would avoid it
console.log(typeof foo);
console.log(typeof foo2);
console.log(typeof foo3);

null assure également une bonne lisibilité pour identifier le type de données (objet), 

object
object
undefined

Source (JavaScript professionnel pour les développeurs Web 3e édition):

Lorsque vous définissez une variable destinée à contenir ultérieurement un objet, il s'agit de Il est conseillé d’initialiser la variable à null par opposition à quoi que ce soit autre. De cette façon, vous pouvez vérifier explicitement la valeur null à détermine si la variable a été remplie avec une référence d'objet à une date ultérieure, comme dans cet exemple:

if (foo2 != null){
    //do something with foo2
}

La valeur indéfinie est un dérivé de null, donc ECMA-262 les définit superficiellement comme étant les suivantes:

console.log(null == undefined); // prints true
console.log(null === undefined);// prints false
1
ItsmeJulian

null est un objet .. Quand quelque chose est indéfini, il n'est rien .. ce n'est pas un objet, ni une chaîne, car il n'a pas encore été défini .. évidemment .. alors c'est simplement une propriété sans fonction .. 

exemple:

Vous déclarez une variable avec var mais ne la définissez jamais.

var foo; 
alert(foo); //undefined.

Vous essayez d'accéder à une propriété sur un objet que vous n'avez jamais défini.

var foo = {};
alert(foo.bar); //undefined

Vous essayez d'accéder à un argument qui n'a jamais été fourni.

function myFunction (foo) {
  alert(foo); //undefined.
}
0
Dimser