Pourquoi est null
considéré comme un object
code JavaScript?
Vérifie
if ( object == null )
Do something
le même que
if ( !object )
Do something
?
Et aussi:
Quelle est la difference entre null
et undefined
?
Pourquoi est null
considéré comme un object
code JavaScript?
Vérifie
if ( object == null )
Do something
le même que
if ( !object )
Do something
?
Et aussi:
Quelle est la difference entre null
et undefined
?
Réponses:
(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é name
auparavant. 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; undefined
c'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; null
est l'endroit où la chose est connue pour exister, mais on ne sait pas quelle est la valeur.
Une chose à retenir est que ce null
n'est pas, conceptuellement, la même chose que false
ou ""
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
*: name
dans 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.
null
est «rien». Null est précisément défini comme aucune valeur. Néant, nul, nada. Rien.
name
auparavant» est vrai. Cependant, déclarer une variable sans lui attribuer une valeur ( var somevar;
) entraînera encore assez étonnamment undefined
.
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 à 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
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.
typeof
est 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);
.
null
n'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 null
revient "object"
. Mais c'est en fait un bogue (qui pourrait même être corrigé dans ECMAScript 6).
La différence entre null
et undefined
est 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 == null
est un cas de bord, car il fonctionne pour les deux null
et 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' if
instruction 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 undefined
et 0
).
undefined
, null
false
+0
, -0
,NaN
""
Vous pouvez tester la conversion en booléen en utilisant Boolean
comme fonction (normalement c'est un constructeur, à utiliser avec new
):
> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true
+0
et -0
séparément si +0 === -0
?
+0
et -0
: 1/+0 !== 1/-0
.
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
null
n'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).
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==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. Il semble que ce soit une opinion arbitraire.
En JavaScript, ce null===undefined
n'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 x
est 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.
[]
a naturellement une .push()
fonction , il n'y a donc pas de bon argument pour que [] soit nul. 0,02 $.
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
}
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 if
va comme suit pour if( o )
:
L'expression entre parenthèses o est évaluée, puis les if
coups 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 undefined
etnull
, à partir de JavaScript Definitive Guide 6th Edition, p.41 sur cette page :
Vous pouvez envisager
undefined
de représenter unenull
absence 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,null
c'est presque toujours le bon choix.
null
est un objet. Son type est nul. undefined
n'est pas un objet; son type n'est pas défini.
null
et undefined
sont des valeurs primitives - typeof null === 'object'
est un bug de langue, carObject(null) !== null
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 myProperty
de myObj
alors 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 myProperty
existe, mais il a la valeur qui null
lui est assignée.
Afin de pouvoir interroger cette différence, JavaScript a null
et undefined
: Bien que null
- tout comme dans d'autres langues un objet, undefined
ne peut pas être un objet car il n'y a pas d'instance (même pas d' null
instance) disponible.
Par exemple, window.someWeirdProperty
n'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 object
type, c'est un primitave
type.
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».
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"
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.