Pourquoi null est un objet et quelle est la différence entre null et undefined?
-
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
}
-
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
.
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 etnull
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.