Pourquoi null est un objet et quelle est la différence entre null et indéfini?
Pourquoi null est-il considéré comme un object en JavaScript?
Est en train de vérifier
if ( object == null )
Do something
le même que
if ( !object )
Do something
?
Et aussi:
Quelle est la différence entre null et undefined?
(name is undefined)
You: Qu'est-ce que name? (*)
JavaScript:name? Qu'est-ce qu'un name? Je ne sais pas de quoi tu parles. Vous n'avez jamais mentionné de name auparavant. Voyez-vous un autre langage de script du côté (client)?
name = null;
You: Qu'est-ce que name?
JavaScript: Je ne sais pas.
En bref; undefined est l'endroit 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ù la chose est connue pour exister, mais on ignore quelle est sa valeur.
Une chose à garder à l’esprit est que null n’est pas, conceptuellement, identique à false ou "" ou similaire, même s’ils correspondent à une transtypage, c.-à-d.
name = false;
You: Qu'est-ce que name?
JavaScript: Boolean false.
name = '';
You: Qu'est-ce que name?
JavaScript: Chaîne vide
*: name dans ce contexte est 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.
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 if ( !object ).
Ce dernier est égal à ! Boolean(object), car l'opérateur unaire ! transforme automatiquement l'opérande de droite en booléen.
Puisque Boolean(null) est égal à false, alors !false === true.
Donc, si votre objet est non null, mais false ou = ou "", le contrôle échouera 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, parce que 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 et undefined est la suivante:
undefined: utilisé par JavaScript et signifie “pas de 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) undefinedL'accès à des variables inconnues, cependant, génère une exception:
> unknownVariable ReferenceError: unknownVariable is not definednull: utilisé par les programmeurs pour indiquer “pas de valeur”, par ex. en tant que paramètre d'une fonction.
Examiner 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 pouvant produire des résultats inattendus). Le contrôle x == null est un cas Edge, car il fonctionne à la fois pour null et undefined:
> null == null
true
> undefined == null
true
Un moyen courant de vérifier si une variable a une valeur consiste à la convertir en booléen et à voir s'il s'agit de true. Cette conversion est effectuée par l'instruction if et par 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 comme false, vous devez donc être prudent (par exemple, les vérifications ci-dessus ne permettent pas de distinguer undefined de 0).
undefined,null- Booléens:
false - Numéros:
+0,-0,NaN - Chaînes:
""
Vous pouvez tester la conversion en booléen en utilisant la fonction Boolean (normalement, il s'agit d'un constructeur, à utiliser avec new):
> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true
Quelle est la difference 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 "pas de valeur. indéfini 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, sauf 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
Reportez-vous à Différence JavaScript entre null et undefined pour plus de détails.
et avec votre nouveau edit yes
if (object == null) does mean the same if(!object)
lorsqu’ils testent si objet est faux, ils répondent tous les deux à la condition lorsqu’ils testent si false , mais pas quand 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:
Est en train de vérifier
if (object == null)Do something
le même queif (!object)Do something
Les deux contrôles sont toujours faux, sauf pour:
object est indéfini ou null: les deux sont vrais.
objet est primitif et 0,
""ou faux: vérifiez d'abord faux, deuxième vrai.
Si l'objet n'est pas une primitive, mais un objet réel, tel que new Number(0), new String("") ou new Boolean(false), les deux vérifications sont 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 contrôles sont différents pour 0, "" et false.
Dans des cas comme object==null, les résultats non évidents pourraient être une source de bogues. L'utilisation de == n'est pas recommandée, 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 objet et indéfini est de type indéfini.
En JavaScript, null==undefined est true et est considéré comme égal si le type est ignoré. Pourquoi ils ont décidé ça, mais 0, "" et false ne sont pas égaux, je ne sais pas. Cela semble être une opinion 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, puisqu'ils représentent tous deux la non-existence. Faites de même 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'essayerais d'en utiliser le moins possible.
'faux', 'vrai' et '!' Un autre sac de vers pouvant être simplifié. Par exemple, if(!x) et if(x) suffisent à eux seuls. Vous n'avez pas besoin de true et de false.
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 jeter 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
Comparaison de nombreux contrôles nuls 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
Une façon de donner un sens à zéro et non dé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: nullRéponses JSON reçues d'une requête Ajax
{
name: "Bob",
address: null
}
Nouvelle fonctionnalité en pleine mutation. Les valeurs suivantes sont nulles:
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 sans savoir 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 fonctionnalités ECMAScript 5. Dans tous les autres cas, il est prudent de rechercher non défini avec une égalité stricte:
if(value === undefined){
// stuff
}
null et undefined sont les deux valeurs fausses pour l'égalité des valeurs (null == undefined): elles sont toutes deux réduites à une valeur booléenne false. Ils ne sont pas le même objet (null! == non défini).
indéfini 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.
Pour ajouter à la réponse de Quelle est la différence entre undefined et null, à partir de JavaScript Definitive Guide on cette page :
Vous pouvez considérer que
undefinedreprésente une valeur absente de valeur au niveau du système, inattendue ou semblable à une erreur, etnullreprésente une valeur absente au niveau du programme, normale ou attendue. Si vous devez affecter l'une de ces valeurs à une variable ou à une propriété ou transmettre l'une de ces valeurs à une fonction,nullest presque toujours le bon choix.
Quelques précisions:
null et undefined are 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 se déroule comme suit pour if( o ):
L'expression entre les parenthèses o est évaluée, puis le if lance le type en forçant la valeur de l'expression entre les parenthèses - dans notre cas o.
Les valeurs de Falsy (qui seront forcées à false) en JavaScript sont les suivantes: '', null, indéfini, 0 et false.
null est un objet. Son type est nul. undefined n'est pas un objet; son type est indéfini.
Par exemple, window.someWeirdProperty n'est pas défini, donc
"window.someWeirdProperty === null" est évalué à false alors que
"window.someWeirdProperty === undefined" est évalué à true.
De plus, checkif if (!o) n'est pas la même chose que vérifier if (o == null) pour o étant 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) // 0Ceci 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?
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
Dans Javascriptnull n'est pas un type object c'est 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
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
undefined
nul
La première console.log(...) essaie d'obtenir myProperty de myObj tant qu'elle n'est pas encore définie. Elle est donc restituée "indéfinie". Après lui avoir attribué la valeur null, la seconde console.log(...) renvoie évidemment "null", car myProperty existe, mais la valeur null lui est affectée.
Pour pouvoir interroger cette différence, JavaScript a null et undefined: Bien que null soit - comme dans d'autres langages, un objet, undefined ne peut pas être un objet car il n'y a pas d'instance (même pas une instance null) disponible.
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 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 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, définissez-le sur 'null.' "Par conséquent, je suggère que, lorsque vous devez supprimer la valeur d'une variable, ne" supprimez "pas ... définissez-le sur 'nul.' L'ancienne valeur sera orpheline et sera bientôt ramassé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, que c'est ainsi".
De "Les principes du Javascript orienté objet" de 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 prête à confusion.)
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.
- Non défini signifie qu'une variable a été déclarée mais qu'aucune valeur n'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, alors que Null est un objet.
3.Javascript peut lui-même initialiser une variable non affectée sur non définie, mais ne peut jamais définir la valeur d'une variable sur null. Cela doit être fait par programme.