Pourquoi null est-il un objet et quelle est la différence entre null et indéfini?


866

Pourquoi est nullconsidéré comme un objectcode JavaScript?

Vérifie

if ( object == null )
      Do something

le même que

if ( !object )
      Do something

?

Et aussi:

Quelle est la difference entre nullet undefined?


6
Ce serait bien si la dernière question était ajoutée dans le titre. Les réponses ici sont impressionnantes, mais le titre peut ne pas indiquer que vous trouverez cette réponse ici
marcos.borunda

6
Null n'est pas un objet en JavaScript! typeof null === 'object'mais c'est un bug! Voici un lien Regardez toutes les vidéos et profitez :)
CoR

1
J'aime utiliser C / C ++ comme vérité axiomatique pour ce qu'est une variable non définie et à valeur NULL, car c'est très simple. Ensuite, voyez comment ces définitions se comparent aux spécifications d'autres langues.
samis

Réponses:


1488
(name is undefined)

Vous: Qu'est-ce que c'est name? (*)
JavaScript name :? C'est quoi name? Je ne sais pas de quoi tu parles. Vous n'en avez jamais mentionné nameauparavant. Voyez-vous un autre langage de script du côté (client)?

name = null;

Vous: Qu'est-ce que c'est name?
JavaScript: je ne sais pas.

En bref; undefinedc'est là où aucune notion de la chose n'existe; il n'a pas de type, et il n'a jamais été référencé auparavant dans cette portée; nullest l'endroit où la chose est connue pour exister, mais on ne sait pas quelle est la valeur.

Une chose à retenir est que ce nulln'est pas, conceptuellement, la même chose que falseou ""ou telle, même si elles sont égales après la conversion de type, c'est-à-dire

name = false;

Vous: Qu'est-ce que c'est name?
JavaScript: booléen faux.

name = '';

Vous: Qu'est-ce que c'est name?
JavaScript: chaîne vide


*: namedans ce contexte, on entend une variable qui n'a jamais été définie. Il peut s'agir de n'importe quelle variable non définie, cependant, le nom est une propriété de n'importe quel élément de formulaire HTML. Il va très loin et a été institué bien avant id. C'est utile car les identifiants doivent être uniques mais les noms ne doivent pas l'être.


14
Mais en JavaScript, la chaîne vide '' est toujours un faux booléen.
Andreas Grech

117
La chaîne vide n'est pas booléenne false, mais dans le contexte d'un conditionnel, elle est interprétée comme une valeur false (y) (coercition).
Bryan Matthews

22
Pour le deuxième cas, où nom = null, au lieu de 'Je ne sais pas', JavaScript pourrait répondre: L'objet null. A part ça, j'aime le style de la réponse.
Jean Vincent

16
Plutôt que «je ne sais pas», je dirais que la réponse nullest «rien». Null est précisément défini comme aucune valeur. Néant, nul, nada. Rien.
mikl

50
J'adore ce style de réponse. En général, «vous n'en avez jamais mentionné name auparavant» est vrai. Cependant, déclarer une variable sans lui attribuer une valeur ( var somevar;) entraînera encore assez étonnamment undefined.
MC Emperor

142

La différence peut être résumée dans cet extrait:

alert(typeof(null));      // object
alert(typeof(undefined)); // undefined

alert(null !== undefined) //true
alert(null == undefined)  //true

Vérification

object == nullest différent à vérifier if ( !object ).

Ce dernier est égal à ! Boolean(object), car l' !opérateur unaire transforme automatiquement l'opérande de droite en booléen.

Depuis Boolean(null)est égal à faux alors !false === true.

Donc, si votre objet n'est pas nul , mais faux ou 0 ou "" , la vérification passera car:

alert(Boolean(null)) //false
alert(Boolean(0))    //false
alert(Boolean(""))   //false

@kentaromiura Pour nous noobs Javascript ... peut-être seulement moi ... quelle est cette syntaxe booléenne (valeur)? Casting vers un booléen?
xr280xr

@ xr280xr Oui, c'est du casting. Essayez String(null)de voir un autre exemple de casting. Vous pouvez même faire des choses idiotes comme Number(null + 2)... mais vous ne devriez pas :-). Excellente réponse de kentaromiura.
squidbe

N'oubliez pas typeofest un opérateur. Vous ne mettriez pas l'opérande entre parenthèses pour la même raison que vous n'écririez pas var sum = 1 +(1);.
alex

124

nulln'est pas un objet , c'est une valeur primitive . Par exemple, vous ne pouvez pas lui ajouter de propriétés. Parfois, les gens supposent à tort qu'il s'agit d'un objet, car il typeof nullrevient "object". Mais c'est en fait un bogue (qui pourrait même être corrigé dans ECMAScript 6).

La différence entre nullet undefinedest la suivante:

  • undefined: utilisé par JavaScript et signifie «aucune valeur». Les variables non initialisées, les paramètres manquants et les variables inconnues ont cette valeur.

    > var noValueYet;
    > console.log(noValueYet);
    undefined
    
    > function foo(x) { console.log(x) }
    > foo()
    undefined
    
    > var obj = {};
    > console.log(obj.unknownProperty)
    undefined

    L'accès à des variables inconnues, cependant, produit une exception:

    > unknownVariable
    ReferenceError: unknownVariable is not defined
  • null: utilisé par les programmeurs pour indiquer «aucune valeur», par exemple comme paramètre d'une fonction.

Examen d'une variable:

console.log(typeof unknownVariable === "undefined"); // true

var foo;
console.log(typeof foo === "undefined"); // true
console.log(foo === undefined); // true

var bar = null;
console.log(bar === null); // true

En règle générale, vous devez toujours utiliser === et jamais == en JavaScript (== effectue toutes sortes de conversions qui peuvent produire des résultats inattendus). Le chèque x == nullest un cas de bord, car il fonctionne pour les deux nullet undefined:

> null == null
true
> undefined == null
true

Une façon courante de vérifier si une variable a une valeur est de la convertir en booléen et de voir si elle l'est true. Cette conversion est effectuée par l' ifinstruction et l'opérateur booléen! ("ne pas").

function foo(param) {
    if (param) {
        // ...
    }
}
function foo(param) {
    if (! param) param = "abc";
}
function foo(param) {
    // || returns first operand that can't be converted to false
    param = param || "abc";
}

Inconvénient de cette approche: toutes les valeurs suivantes sont évaluées à false, vous devez donc être prudent (par exemple, les vérifications ci-dessus ne peuvent pas distinguer entre undefinedet 0).

  • undefined, null
  • Booléens: false
  • Nombres: +0, -0,NaN
  • Cordes: ""

Vous pouvez tester la conversion en booléen en utilisant Booleancomme fonction (normalement c'est un constructeur, à utiliser avec new):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

1
Pourquoi faire référence +0et -0séparément si +0 === -0?
Raynos

6
Probablement parce que vous pouvez distinguer encore +0et -0: 1/+0 !== 1/-0.
néo

1
Cette réponse renvoie à un article qui renvoie à cette réponse en tant que source ... signifiait probablement un lien vers cela à la place 2ality.com/2013/10/typeof-null.html
Ricardo Tomasi

Ah oui, comme en C, où les déclarations de variables non initialisées sont considérées comme non définies (les anciennes versions pouvaient en fait contenir des données de programmes précédents).
samis

5
"Mais c'est en fait un bug (qui pourrait même être corrigé dans ECMAScript 6)" - source?
Gajus

26

Quelle est la différence entre null et undefined ??

Une propriété lorsqu'elle n'a pas de définition n'est pas définie. null est un objet. Son type est objet. null est une valeur spéciale signifiant "aucune valeur. undefined n'est pas un objet, son type n'est pas défini.

Vous pouvez déclarer une variable, la définir sur null et le comportement est identique sauf que vous verrez "null" imprimé contre "undefined". Vous pouvez même comparer une variable non définie à null ou vice versa, et la condition sera vraie:

 undefined == null
 null == undefined

Référez-vous à la différence JavaScript entre null et undefined pour plus de détails.

et avec votre nouveau montage oui

if (object == null)  does mean the same  if(!object)

lors du test si l'objet est faux, ils ne remplissent tous les deux la condition que lors du test si faux , mais pas lorsqu'ils sont vrais

Vérifiez ici: Javascript gotcha


4
Vous devez utiliser ===, puis indéfini! == null: D
olliej

1
faites attention à la dernière partie, est incorrect voir ma réponse;)
kentaromiura

6
! object n'est pas la même chose que "object == null" ... En fait, ils sont très différents. ! object renverra true si son objet est 0, une chaîne vide, Boolean false, undefined ou null.
James

3
Null est-il vraiment un objet? Le premier lien que vous avez fourni vérifie null par typeof, mais typeof (null) est évalué comme «objet» en raison d'une erreur de conception du langage.
c4il

2
nulln'est pas un objet. Cela typeof null == 'object';renvoie vrai en raison d'un bogue qui ne peut pas être corrigé en JavaScript (actuellement, mais peut changer à l'avenir).
Mohamad

21

Première partie de la question:

Pourquoi null est-il considéré comme un objet en JavaScript?

Il s'agit d'une erreur de conception JavaScript qu'ils ne peuvent pas corriger maintenant. Il aurait dû être de type null, pas de type object, ou ne pas l'avoir du tout. Elle nécessite une vérification supplémentaire (parfois oubliée) lors de la détection d'objets réels et est source de bugs.

Deuxième partie de la question:

Vérifie


if (object == null)
Do something

la même chose que

if (!object)
Do something

Les deux chèques sont toujours tous les deux faux sauf:

  • l'objet est indéfini ou nul: les deux sont vrais.

  • l'objet est primitif, et 0, ""ou faux: premier contrôle faux, deuxième vrai.

Si l'objet n'est pas une primitive, mais un vrai objet, comme new Number(0), new String("")ou new Boolean(false), puis les deux contrôles sont faux.

Donc, si «objet» est interprété comme signifiant un véritable objet, les deux vérifications sont toujours les mêmes. Si les primitives sont autorisées, les contrôles sont différents pour 0 "", et faux.

Dans des cas comme object==null, les résultats non évidents pourraient être une source de bugs. L'utilisation de ==n'est pas recommandée, utilisez ===plutôt.

Troisième partie de la question:

Et aussi:

Quelle est la différence entre null et indéfini?

En JavaScript, une différence est que null est de type objet et undefined est de type undefined.

En JavaScript, null==undefinedest vrai et considéré comme égal si le type est ignoré. Pourquoi ils ont décidé cela, mais 0 ""et faux ne sont pas égaux, je ne sais pas. Il semble que ce soit une opinion arbitraire.

En JavaScript, ce null===undefinedn'est pas vrai car le type doit être le même dans ===.

En réalité, nul et non défini sont identiques, car ils représentent tous deux la non-existence. Faites donc 0, et ""d'ailleurs, et peut-être les conteneurs vides []et {}. Tant de types du même rien sont une recette pour les bugs. Un type ou aucun, c'est mieux. J'essaierais d'en utiliser le moins possible.

«faux», «vrai» et «!» sont un autre sac de vers qui pourraient être simplifiés, par exemple, if(!x)et if(x)seuls suffisent, vous n'avez pas besoin de vrai et de faux.

Un déclaré var xest de type non défini si aucune valeur n'est donnée, mais il devrait être le même que si x n'a jamais été déclaré du tout. Une autre source de bogue est un conteneur rien vide. Il est donc préférable de le déclarer et de le définir ensemble, comme var x=1.

Les gens tournent en rond en essayant de comprendre tous ces différents types de rien, mais c'est la même chose dans des vêtements différents et compliqués. La réalité est

undefined===undeclared===null===0===""===[]==={}===nothing

Et peut-être que tous devraient lever des exceptions.


8
Excellente réponse, mais cela va un peu trop loin avec []: " En réalité, nul et non défini sont identiques ... et peut-être les conteneurs vides [] et {}. " Vous pourriez probablement me faire penser que {} devrait être saveur de null, mais mon intuition est que cela ne devrait pas. Mais de façon moins controversée, un tableau vide []a naturellement une .push()fonction , il n'y a donc pas de bon argument pour que [] soit nul. 0,02 $.
ruffin

11
var x = null;

x est défini comme nul

y n'est pas défini; // parce que je ne l'ai pas défini

if (!x)

null est évalué comme faux


8

Une façon de donner un sens à null et indéfini est de comprendre où chacun se produit.

Attendez-vous à une valeur de retour nulle dans les situations suivantes:

  • Méthodes interrogeant le DOM

    console.log(window.document.getElementById("nonExistentElement"));
    //Prints: null
  • Réponses JSON reçues d'une demande Ajax


    {
      name: "Bob",
      address: null
    }
  • RegEx.exec .

  • Nouvelle fonctionnalité en pleine mutation. Ce qui suit renvoie null:


        var proto = Object.getPrototypeOf(Object.getPrototypeOf({}));

       // But this returns undefined:

        Object.getOwnPropertyDescriptor({}, "a");

Tous les autres cas de non-existence sont indiqués par undefined (comme noté par @Axel). Chacune des impressions suivantes est "indéfinie":

    var uninitalised;
    console.log(uninitalised);

    var obj = {};
    console.log(obj.nonExistent);

    function missingParam(missing){
        console.log(missing);
    }

    missingParam();

    var arr = [];
    console.log(arr.pop());        

Bien sûr, si vous décidez d'écrire var unitialised = null; ou renvoyer nul à partir d'une méthode vous-même, alors vous avez null se produisant dans d'autres situations. Mais cela devrait être assez évident.

Un troisième cas est celui où vous voulez accéder à une variable mais vous ne savez même pas si elle a été déclarée. Dans ce cas, utilisez typeof pour éviter une erreur de référence:

if(typeof unknown !== "undefined"){
    //use unknown
}

En résumé, vérifiez null lorsque vous manipulez le DOM, traitez avec Ajax ou utilisez certaines fonctionnalités ECMAScript 5. Pour tous les autres cas, il est sûr de vérifier non défini avec une égalité stricte:

if(value === undefined){
  // stuff
}

8

Comparaison de nombreuses vérifications nulles différentes en JavaScript:

http://jsfiddle.net/aaronhoffman/DdRHB/5/

// Variables to test
var myNull = null;
var myObject = {};
var myStringEmpty = "";
var myStringWhiteSpace = " ";
var myStringHello = "hello";
var myIntZero = 0;
var myIntOne = 1;
var myBoolTrue = true;
var myBoolFalse = false;
var myUndefined;

...trim...

http://aaron-hoffman.blogspot.com/2013/04/javascript-null-checking-undefined-and.html

Tableau de comparaison JavaScript Null Check


1
fait "var myUndefined;" définir la variable (comme une variable connue de type inconnu)?
Qi Fan

6

null et undefined sont tous deux faux pour l'égalité des valeurs (null == undefined): ils se réduisent tous les deux en booléens false. Ce ne sont pas le même objet (null! == non défini).

undefined est une propriété de l'objet global ("fenêtre" dans les navigateurs), mais est un type primitif et non un objet lui-même. Il s'agit de la valeur par défaut pour les variables et fonctions non initialisées se terminant sans instruction de retour.

null est une instance de Object. null est utilisé pour les méthodes DOM qui retournent des objets de collection pour indiquer un résultat vide, qui fournit une valeur fausse sans indiquer d'erreur.


5

Quelques précisions:

null et undefined sont deux valeurs différentes. L'un représente l'absence d'une valeur pour un nom et l'autre représente l'absence d'un nom.


Ce qui se passe dans un ifva comme suit pour if( o ):

L'expression entre parenthèses o est évaluée, puis les ifcoups de pied dans la contrainte de type sur la valeur de l'expression entre parenthèses - dans notre cas o.

Les valeurs fausses (qui seront forcées à être fausses) en JavaScript sont: '', null, indéfini, 0 et faux .


5

Pour ajouter à la réponse Quelle est la différence entre undefinedetnull , à partir de JavaScript Definitive Guide 6th Edition, p.41 sur cette page :

Vous pouvez envisager undefinedde représenter une nullabsence de valeur au niveau du système, inattendue ou semblable à une erreur et de représenter une absence de valeur au niveau du programme, normale ou attendue. Si vous devez affecter l'une de ces valeurs à une variable ou à une propriété ou passer l'une de ces valeurs à une fonction, nullc'est presque toujours le bon choix.


3

nullest un objet. Son type est nul. undefinedn'est pas un objet; son type n'est pas défini.


11
mal - les deux nullet undefinedsont des valeurs primitives - typeof null === 'object'est un bug de langue, carObject(null) !== null
Christoph

Non ce n'est pas. Object () transforme le travail de cette manière, voir ecma-international.org/publications/files/ECMA-ST/Ecma-262.pdf - 15.2.2.1 new Object ([value]) ... 8. (La valeur de l'argument n'a pas été fourni ou son type était nul ou non défini.) Créez un nouvel objet ECMAScript natif. La propriété [[Prototype]] de l'objet nouvellement construit est définie sur l'objet prototype Object. La propriété [[Class]] de l'objet nouvellement construit est définie sur "Object". L'objet nouvellement construit n'a pas de propriété [[Value]]. Renvoie l'objet natif nouvellement créé.
kentaromiura

3
@Christoph: Je veux dire, tu as raison. null doit être un type, ce que je veux dire, c'est que vous ne pouvez pas le vérifier de cette façon car: alert (new Object ()! == new Object ()); / * true, new istance n'est pas le même istance / alert (Object (null) .constructor == {} .constructor); / true comme dans spec / alert (Object (null) .prototype == {} .prototype); / true comme dans spec / alert (null instanceof Object); / évidemment faux, null signifie non instancié * / Mais fondamentalement, c'est un bug de spécification XD voir: uselesspickles.com/blog/2006/06/12/… et javascript.crockford.com/remedial.html
kentaromiura

2

La fonction suivante montre pourquoi et est capable de faire la différence:

function test() {
        var myObj = {};
        console.log(myObj.myProperty);
        myObj.myProperty = null;
        console.log(myObj.myProperty);
}

Si vous appelez

test();

Vous obtenez

indéfini

nul

Les premiers console.log(...)essais pour obtenir myPropertyde myObjalors qu'il n'a pas encore été défini - il revient « undefined ». Après lui avoir assigné null, le second console.log(...)retourne évidemment "null" car myPropertyexiste, mais il a la valeur qui nulllui est assignée.

Afin de pouvoir interroger cette différence, JavaScript a nullet undefined: Bien que null- tout comme dans d'autres langues un objet, undefinedne peut pas être un objet car il n'y a pas d'instance (même pas d' nullinstance) disponible.


2

Par exemple, window.someWeirdPropertyn'est pas défini, donc

"window.someWeirdProperty === null" évalue à faux tout

"window.someWeirdProperty === undefined" évalue à vrai.

De plus, checkif if (!o)n'est pas la même chose que vérifier if (o == null)pour oêtre false.


Pouvez-vous expliquer la différence entre les deux conditions
rahul

lire ma réponse, il signifie que si o est égal à 0, false ou "" la valeur booléenne est false: var undef, various = [0, "", null, false, undef]; for (var obj dans divers) {alert (! obj); // 4 fois faux dans IE, 5 dans FF;)}
kentaromiura

2

L'autre chose amusante à propos de null, par rapport à undefined, est qu'il peut être incrémenté.

x = undefined
x++
y = null
y++
console.log(x) // NaN
console.log(y) // 0

Ceci est utile pour définir des valeurs numériques par défaut pour les compteurs. Combien de fois avez-vous défini une variable sur -1 dans sa déclaration?


2

En Javascript, ce null n'est pas un objecttype, c'est un primitavetype.

Quelle est la différence? Undefined fait référence à un pointeur qui n'a pas été défini. Null fait référence au pointeur null, par exemple, quelque chose a défini manuellement une variable comme étant de typenull


2

Regarde ça:

   <script>
function f(a){
  alert(typeof(a));
  if (a==null) alert('null');
  a?alert(true):alert(false);
}
</script>
                                          //return:
<button onclick="f()">nothing</button>    //undefined    null    false
<button onclick="f(null)">null</button>   //object       null    false
<button onclick="f('')">empty</button>    //string               false
<button onclick="f(0)">zero</button>      //number               false
<button onclick="f(1)">int</button>       //number               true
<button onclick="f('x')">str</button>     //string               true

1

Extrait de "Les principes du Javascript orienté objet" par Nicholas C. Zakas

Mais pourquoi un objet quand le type est nul? (En fait, cela a été reconnu comme une erreur par TC39, le comité qui conçoit et maintient JavaScript. Vous pouvez penser que null est un pointeur d'objet vide, faisant de "object" une valeur de retour logique, mais cela prête toujours à confusion.)

Zakas, Nicholas C. (2014-02-07). Les principes du JavaScript orienté objet (emplacements Kindle 226-227). Pas de presse d'amidon. Édition Kindle.

Cela dit:

var game = null; //typeof(game) is "object"

game.score = 100;//null is not an object, what the heck!?
game instanceof Object; //false, so it's not an instance but it's type is object
//let's make this primitive variable an object;
game = {}; 
typeof(game);//it is an object
game instanceof Object; //true, yay!!!
game.score = 100;

Cas non défini:

var score; //at this point 'score' is undefined
typeof(score); //'undefined'
var score.player = "felix"; //'undefined' is not an object
score instanceof Object; //false, oh I already knew that.

1

La meilleure façon de penser à «null» est de rappeler comment le concept similaire est utilisé dans les bases de données, où il indique qu'un champ ne contient «aucune valeur du tout».

  • Oui, la valeur de l'article est connue; il est «défini». Il a été initialisé.
  • La valeur de l'article est: "il n'y a pas de valeur".

Il s'agit d'une technique très utile pour écrire des programmes qui sont plus facilement débogués. Une variable "non définie" peut être le résultat d'un bogue ... (comment le sauriez-vous?) ... mais si la variable contient la valeur "null", vous savez que "quelqu'un, quelque part dans ce programme, la définit sur 'null.' "Par conséquent, je suggère que, lorsque vous devez vous débarrasser de la valeur d'une variable, ne" supprimez "pas ... définissez-la sur 'null.' L'ancienne valeur sera orpheline et sera bientôt récupérée; la nouvelle valeur est "il n'y a pas de valeur (maintenant)". Dans les deux cas, l'état de la variable est certain: "il est évident, délibérément, qu'il en est ainsi"


1
  1. Non défini signifie qu'une variable a été déclarée mais qu'aucune valeur ne lui a été affectée tandis que Null peut être affecté à une variable représentant "aucune valeur" (Null est un opérateur d'affectation).

2.Undefined est un type lui-même tandis que Null est un objet.

3.Javascript peut lui-même initialiser toute variable non affectée à undefined mais il ne peut jamais définir la valeur d'une variable sur null. Cela doit être fait par programme.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.