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

Question

Pourquoi est-ce que null considéré comme un object en JavaScript ?

Est-ce que la vérification

if ( object == null )
      Do something

la même chose que

if ( !object )
      Do something

?

Et aussi :

Quelle est la différence entre null y undefined ?

Answer 1

(name is undefined)

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

name = null;

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

En bref ; undefined c'est là où il n'existe aucune notion de la chose ; elle n'a pas de type, et elle n'a jamais été référencée auparavant dans cette portée ; null c'est lorsque l'on sait que la chose existe, mais que l'on ne sait pas quelle est sa valeur.

Une chose à retenir est que null n'est pas, conceptuellement, la même chose que false o "" ou autre, même s'ils sont égaux après le moulage par type, c'est-à-dire

name = false;

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

name = '';

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

---

* : name Dans ce contexte, il s'agit d'une variable qui n'a jamais été définie. Il pourrait s'agir de n'importe quelle variable non définie, mais name est une propriété d'à peu près tous les éléments de formulaire HTML. Elle remonte à très loin et a été instituée bien avant id. Il est utile car les identifiants doivent être uniques, mais pas les noms.

Answer 2

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 de

object == null est différent pour vérifier if ( !object ) .

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

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

Donc si votre objet est non nul , mais faux o 0 o "" le chèque sera accepté car :

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

Answer 3

null es pas un objet il s'agit d'un 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 typeof null renvoie à "object" . Mais il s'agit en fait d'un bogue (qui pourrait même être corrigé dans ECMAScript 6).

La différence entre null y undefined est le suivant :

• 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 produit toutefois une exception :

  > unknownVariable
  ReferenceError: unknownVariable is not defined

• null : utilisé par les programmeurs pour indiquer "aucune valeur", par exemple en tant que 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 (== exécute toutes sortes de conversions qui peuvent produire des résultats inattendus). Le contrôle x == null est un cas limite, car il fonctionne à la fois pour les null y 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 est true . Cette conversion est effectuée par le if et l'opérateur booléen ! ("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 évaluent à false Il faut donc être prudent (par exemple, les vérifications ci-dessus ne peuvent pas faire la distinction entre les éléments suivants undefined y 0 ).

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

Vous pouvez tester la conversion en booléen en utilisant Boolean en tant que fonction (normalement, il s'agit d'un constructeur, à utiliser avec la fonction new ) :

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

Answer 4

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

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

Vous pouvez déclarer une variable, lui attribuer la valeur null, et le comportement est identique, à l'exception du fait que vous verrez "null" imprimé au lieu de "undefined". Vous pouvez même comparer une variable indéfinie à null ou vice versa, et la condition sera vraie :

 undefined == null
 null == undefined

Se référer à JavaScript Différence entre null et undefined pour plus de détails.

et avec votre nouvelle modifier oui

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

en testant si object est faux, ils ne remplissent tous deux la condition que lors du test si faux mais pas quand c'est vrai

Vérifiez ici : Javascript gotcha

Answer 5

Première partie de la question :

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

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

Deuxième partie de la question :

Est-ce que la vérification

if (object == null)
Do something

la même chose que

if (!object)
Do something

Les deux vérifications sont toujours toutes deux fausses, sauf pour :

• est indéfini ou nul : tous deux sont vrais.

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

Si l'objet n'est pas une primitive, mais un véritable objet, tel que new Number(0) , new String("") o new Boolean(false) alors les deux vérifications sont fausses.

Ainsi, si le terme "objet" est interprété comme signifiant un objet réel, les deux contrôles 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 jamais recommandé, utilisez === à la place.

Troisième partie de la question :

Et aussi :

Quelle est la différence entre null et undefined ?

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

En JavaScript, null==undefined est 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. Cela semble être une opinion arbitraire.

En JavaScript, null===undefined n'est pas vrai puisque le type doit être le même dans === .

En réalité, null et undefined sont identiques, puisqu'ils représentent tous deux la non-existence. Il en va de même pour 0, et "" pour cette question aussi, et peut-être les conteneurs vides [] y {} . Tant de types du même rien sont une recette pour les insectes. Il est préférable d'utiliser un seul type ou aucun. J'essaierais d'en utiliser le moins possible.

Les termes "faux", "vrai" et " !" sont un autre sac de vers qui pourrait être simplifié, par exemple, if(!x) y if(x) seuls sont suffisants, vous n'avez pas besoin de vrai et de faux.

A déclaré var x est de type indéfini si aucune valeur n'est donnée, mais il devrait être le même que si x n'avait 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 par exemple var x=1 .

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

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

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