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

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?

(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.}

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

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

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

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.

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

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
}

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

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.

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 .

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.

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

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.

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.

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?

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

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

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.

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. 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.