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

https://stackoverflow.com/questions/801032

03-07-2019
|

Question

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

vérifie

if ( object == null )
      Do something

identique à

if ( !object )
      Do something

Et aussi:

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

La solution

(name is undefined)

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

name = null;

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

En bref; undefined est 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 étendue; null est l'endroit où l'existence de la chose est connue, mais la valeur de celle-ci est inconnue.

Une chose à garder à l'esprit est que null n'est pas, conceptuellement, la même chose que false ou "quot ", ou autre, même si ils assimilent après la conversion de type, à savoir

name = false;

Vous: Qu'est-ce que nom ?
JavaScript: Boolean false.

name = '';

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

^{*: nom désigne dans ce contexte une variable qui n'a jamais été définie. Ce peut être n'importe quelle variable non définie, cependant, le nom est une propriété de presque n'importe quel élément de formulaire HTML. Cela remonte à longtemps et a été institué bien avant l’identification. C'est utile car les identifiants doivent être uniques mais les noms ne doivent pas nécessairement l'être.}

Autres conseils

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 == null est différent pour vérifier si (! object) .

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

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

Ainsi, si votre objet n'est pas null , mais faux ou 0 ou "&" ; , le chèque sera accepté parce que:

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

null 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 typeof null renvoie " objet " <. Mais c’est en fait un bug (qui pourrait même être corrigé dans ECMAScript 6).



 La différence entre  null  et  indéfini  est la suivante: 


   undefined : utilisé par JavaScript et signifie & # 8220; pas de valeur & # 8221 ;. 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 génère cependant une exception: 

> unknownVariable
ReferenceError: unknownVariable is not defined
 
   null : utilisé par les programmeurs pour indiquer & # 8220; pas de valeur & # 8221 ;, ex. 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 devriez toujours utiliser === et jamais == en JavaScript (== effectue  toutes sortes de conversions  pouvant produire des résultats inattendus). La vérification  x == null  est une casse car elle fonctionne à la fois pour  null  et pour  undefined : 

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


 Une manière courante de vérifier si une variable a une valeur consiste à la convertir en booléen et à voir si elle est  true . Cette conversion est effectuée par l'instruction  if  et l'opérateur booléen! (& # 8220; pas & # 8221;). 

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 ont pour valeur  false . Vous devez donc être prudent (par exemple, les vérifications ci-dessus ne peuvent pas faire la distinction entre  undefined  et  0 ). 


  indéfini ,  null  
 Booléens:  false  
 Numéros:  +0 ,  -0 ,  NaN  
 Chaînes:  ""  


 Vous pouvez tester la conversion en booléen en utilisant la fonction  Boolean  (il s'agit généralement d'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é quand 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". indéfini n'est pas un objet, son type est indéfini. 

 Vous pouvez déclarer une variable, lui attribuer la valeur null. Le comportement est identique à la différence près que vous verrez " null " imprimé par rapport à "non défini". Vous pouvez même comparer une variable non définie à null ou vice versa, et la condition sera vraie: 

 undefined == null
 null == undefined


 Voir  JavaScript. Différence entre null et indéfini  pour plus de détails. 

 et avec votre nouvelle  modification   oui  

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


 lorsqu'ils testent si l'objet est false, ils remplissent tous les deux la condition requise si  false  est testé, mais pas si true 

 Vérifiez ici:  Javascript gotcha  
	


	
		
	
	
			 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 corriger maintenant. Il aurait dû être de type null, pas d'objet de type, 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 bugs. 

 Deuxième partie de la question: 


   vérifie 

  
 

   if (object == null)  

   Faire quelque chose  

  

  le même que 

  

   if (! object)  

   Faire quelque chose  
 


 Les deux vérifications sont toujours fausses sauf pour: 


  objet n'est pas défini ou null: les deux sont vrais. 
 
  l'objet est primitif et 0,  "" ou false: vérifiez d'abord la valeur false, la deuxième la valeur true. 
 


 Si l'objet n'est pas une primitive, mais un objet réel, tel que  nouveau numéro (0) ,  nouveau chaîne (")  ou . new Boolean (false) , les deux vérifications sont alors fausses. 

 Donc, si "objet" est interprété comme désignant un objet réel, les deux vérifications sont toujours les mêmes. Si les primitives sont autorisées, les vérifications sont différentes pour 0,  "" " et false. 

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

 Troisième partie de la question: 


   Et aussi: 

  

  Quelle est la difference entre null et undefined? 
 


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

 En JavaScript,  null == undefined  est true et considéré comme égal si le type est ignoré. Pourquoi ils ont décidé cela, mais 0,  "  et false ne sont pas égaux, je ne sais pas. Cela semble être un avis arbitraire. 

 En JavaScript,  null === undefined  n'est pas vrai, car le type doit être identique dans  === . 

 En réalité, null et indéfini sont identiques, car ils représentent tous deux la non-existence. Faites donc 0, et  "" " également, 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'essayerais d'en utiliser le moins possible. 

 'faux', 'vrai' et '!' Un autre paquet de vers pouvant être simplifié, par exemple,  si (! x)  et  si (x)  seuls suffisent, vous n'avez pas besoin de vrai et de faux. 

 Un  var x  déclaré est de type non défini si aucune valeur n'est donnée, mais il devrait être identique à si x n'avait jamais été déclaré. Une autre source de bogue est un conteneur vide rien. 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 pour essayer de comprendre tous ces types de rien, mais c'est la même chose dans des vêtements compliqués. La réalité est 

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


 Et peut-être que tous devraient lancer 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 qui interrogent le DOM 

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



    {
      name: "Bob",
      address: null
    }



   RegEx.exec . 
 
  Nouvelle fonctionnalité en pleine mutation. Les éléments suivants renvoient null: 
 



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

       // But this returns undefined:

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


 Tous les autres cas de non-existence sont signalés par undefined (comme noté par @Axel). Chacune des impressions suivantes "" non défini ": 

    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 null à partir d'une méthode vous-même, alors vous avez null dans d'autres situations. Mais cela devrait être assez évident. 

 Un troisième cas se présente lorsque vous souhaitez accéder à une variable mais que 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é, recherchez la valeur null lorsque vous manipulez le DOM, utilisez Ajax ou utilisez certaines fonctions ECMAScript 5. Dans tous les autres cas, il est prudent de rechercher non défini avec une égalité stricte: 

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


	
		
	
	
			 Comparaison de nombreux contrôles Null différents 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 les deux faux pour l'égalité de valeur (null == undefined): ils sont tous deux réduits à boolean false. Ils 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. C'est la valeur par défaut pour les variables et fonctions non initialisées se terminant sans instruction return. 

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


	
		
	
	
			 Quelques précisions: 

 null et indéfini  sont  deux valeurs différentes. L’un représente l’absence de valeur pour un nom et l’autre représente l’absence d’un nom. 



 Que se passe-t-il dans un  si  se déroule comme suit pour  si (o) : 

 L'expression entre les parenthèses o est évaluée, puis le  si  entame le type en forçant la valeur de l'expression entre parenthèses - dans notre cas  o . 

Les valeurs  de Falsy (qui seront forcées à false) en JavaScript sont les suivantes:  '', null, undefined, 0 et false . 
	


	
		
	
	
			 Pour ajouter à la réponse de  Quelle est la différence entre  undefined  et  null  , à partir de JavaScript Definitive Guide  sur cette page : 


   Vous pourriez considérer que  non défini  représente des événements inattendus au niveau système.
  ou une erreur de type absense de valeur et  null  pour représenter le niveau du programme,
  absence normale ou attendue de valeur. Si vous devez attribuer l’un des
  ces valeurs à une variable ou une propriété ou passer l'une de ces valeurs à
  une fonction,  null  est presque toujours le bon choix. 
	


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

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


 Si vous appelez 

test();


 Vous obtenez 


   non défini 
  
   null 


 Le premier  console.log (...)  tente d'obtenir  myProperty  à partir de  myObj  tant qu'il n'est pas encore défini. retour "non défini". Après lui avoir attribué la valeur null, le second  console.log (...)  renvoie évidemment "null". parce que  myProperty  existe, mais que la valeur  null  lui est attribuée. 

 Pour pouvoir interroger cette différence, JavaScript a  null  et  undefined : Alors que  null  est - comme dans d'autres langues un object,  undefined  ne peut pas être un objet car il n'y a pas d'instance disponible (même pas une instance  null ). 
	


	
		
	
	
			  null  est un objet. Son type est nul.  undefined  n'est pas un objet; son type n'est pas défini. 
	


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

  & window; window.someWeirdProperty === null "  a la valeur false alors que 

  & window; window.someWeirdProperty === non défini "  est évalué à true. 

 De plus, vérifier si  si (! o)  est différent de vérifier  si (o == null)  pour  o  étant  faux . 
	


	
		
	
	
			 L’autre chose intéressante à propos de null, comparé à undefined, est qu’elle peut être incrémentée.
 

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? 
	


	
		
	
	
			 Dans  Javascript   null  n'est pas un type  objet , il s'agit d'un type  primitave . 

  Quelle est la différence? 
 Non défini  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 de type  null  
.	


	
		
	
	
			 Regardez ceci: 

   <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 "Principes de 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 en déduire que null est un pointeur d'objet vide, ce qui fait de "objet" une valeur de retour logique, mais cela reste inchangé. déroutant.) 


 Zakas, Nicholas C. (2014-02-07). Principes du JavaScript orienté objet (Emplacements Kindle 226-227). Aucune 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. 


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


 C’est une technique très utile pour écrire des programmes plus faciles à déboguer. 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,  définissez-le  sur "null". Par conséquent, je suggère que, lorsque vous avez besoin de vous débarrasser de la valeur d'une variable, n'effectuez pas de "suppression". ... Réglez-le sur 'null'. L'ancienne valeur sera orpheline et sera bientôt ramassée. la nouvelle valeur est, "il n’ya pas de valeur (maintenant)". Dans les deux cas, l'état de la variable est certain: "il est évident, délibérément, obtenu de cette façon". 
	


	
		
	
	
			
 Undefined signifie qu'une variable a été déclarée mais qu'aucune valeur ne lui a été attribuée, alors que Null peut être affecté à une variable représentant "aucune valeur". (Null est un opérateur d'assignation) 


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

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



	
		
			Licencié sous: CC-BY-SA avec attribution
			Non affilié à StackOverflow