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


Pourquoi est-ce null considéré comme object en JavaScript?

Vérifie

if ( object == null )
      Do something

le même que

if ( !object )
      Do something

?

Et aussi:

Quelle est la différence entre null et undefined?


819
2018-04-29 05:47


origine


Réponses:


(name is undefined)

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

name = null;

Toi: Quel est name?
JavaScript: Je ne sais pas.

En bref; undefined est où aucune notion de la chose n'existe; il n'a aucun 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 null n'est pas, conceptuellement, le même que false ou "" ou tels, même s'ils sont équivalents après le moulage de type, c'est-à-dire

name = false;

Toi: Quel est name?
JavaScript: Booléen faux.

name = '';

Toi: Quel est name?
JavaScript: Chaîne vide


*: name dans ce contexte, on entend une variable qui n'a jamais été définie. Cela pourrait être n'importe quelle variable indéfinie. Cependant, name est une propriété de n'importe quel élément de formulaire HTML. Il va bien, très loin 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.


1439
2018-04-29 13:31



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 de vérifier if ( !object ).

Ce dernier est égal à ! Boolean(object), parce que l'unaire ! l'opérateur transpose automatiquement l'opérande droit en un booléen.

Depuis Boolean(null) est égal à faux alors !false === true.

Donc, si votre objet est non nul, mais  faux ou 0 ou "", le chèque passera car:

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

137
2018-04-29 06:44



null est pas un objet, c'est un valeur primitive. Par exemple, vous ne pouvez pas ajouter de propriétés. Parfois, les gens supposent à tort que c'est un objet, parce que typeof null résultats "object". Mais c'est en fait un bug (qui pourrait même être corrigé dans ECMAScript 6).

La différence entre null et undefined est comme suit:

  • 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
    

    Toutefois, l'accès aux variables inconnues génère une exception:

    > unknownVariable
    ReferenceError: unknownVariable is not defined
    
  • null: utilisé par les programmeurs pour indiquer "aucune valeur", par ex. en tant que paramètre à 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 devriez toujours utiliser === et jamais == en JavaScript (== effectue toutes sortes de conversions cela peut produire des résultats inattendus). Le cheque x == null est un cas de bord, parce que cela fonctionne à la fois 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 est true. Cette conversion est effectuée par le if déclaration 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 évaluent false, donc vous devez être prudent (par exemple, les contrôles ci-dessus ne peuvent pas distinguer entre undefined et 0).

  • undefined, null
  • Booléens: false
  • Nombres: +0, -0, NaN
  • Cordes: ""

Vous pouvez tester la conversion en booléen en utilisant Boolean en tant que fonction (normalement c'est un constructeur, à utiliser avec new):

> Boolean(null)
false
> Boolean("")
false
> Boolean(3-3)
false
> Boolean({})
true
> Boolean([])
true

113
2017-11-01 15:06



Quelle est la difference entre null et indéfini ??

Une propriété lorsqu'elle n'a pas de définition est indé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 est indéfini.

Vous pouvez déclarer une variable, la définir sur 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

Faire référence à Différence JavaScript entre null et indéfini pour plus de détails.

et avec votre nouveau modifier  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 lors du test si fauxmais pas quand c'est vrai

Vérifier ici: Javascript gotcha


23
2018-04-29 05:52



Première partie de la question:

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

C'est une erreur de conception JavaScript qu'ils ne peuvent pas corriger maintenant. Il aurait dû être de type null, pas de type objet, ou ne pas l'avoir du tout. Cela nécessite un contrôle supplémentaire (parfois oublié) lors de la détection d'objets réels et est la source de bugs.

Deuxième partie de la question:

Vérifie


if (object == null) 
Do something 

  le même que

if (!object) 
Do something 





Les deux contrôles sont toujours faux tous les deux sauf pour:

  • l'objet est indéfini ou null: les deux sont vrais.

  • l'objet est primitif, et 0, ""ou false: cochez d'abord false, second true.

Si l'objet n'est pas un primitif, mais un objet réel, comme new Number(0), new String(""), ou new Boolean(false), alors les deux vérifications sont fausses.

Donc, si 'objet' est interprété comme signifiant 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 faux.

Dans des cas comme object==null, les résultats non évidents pourraient être une source de bugs. Utilisation de == n'est jamais recommandé, utilisez === au lieu.

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 object 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. Cela semble être une opinion arbitraire.

En JavaScript, null===undefined n'est pas vrai puisque le type doit être le même ===.

En réalité, nul et indéfini sont identiques, puisqu'ils représentent tous les deux la non-existence. Alors faites 0, et "" d'ailleurs aussi, et peut-être les conteneurs vides [] et {}. Tant de types du même rien sont une recette pour les bugs. Un type ou aucun n'est meilleur. J'essaierais d'en utiliser le moins possible.

'faux', 'vrai' et '!' sont un autre sac de vers qui pourrait être simplifié, 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 un type indéfini si aucune valeur n'est donnée, mais il doit être le même que si x n'a jamais été déclaré. Une autre source de bogue est un conteneur de 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 types de rien, mais c'est tout 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 jeter des exceptions.


18
2017-07-14 22:15



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


10
2018-04-29 05:56



Une façon de donner un sens à null et indéfini est de comprendre où chacun se produit.

Attendez 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 perpétuelle évolution Le résultat suivant est nul:


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

       // But this returns undefined:

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

Tous les autres cas de non-existence sont notés par undefined (comme noté par @Axel). Chacune des impressions suivantes "indé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 renvoyez null d'une méthode vous-même alors vous avez null se produire dans d'autres situations. Mais cela devrait être assez évident.

Un troisième cas est lorsque 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, que vous utilisez Ajax ou que vous utilisez certaines fonctionnalités d'ECMAScript 5. Pour tous les autres cas, il est sûr de vérifier pour indéfini avec une égalité stricte:

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

7
2018-05-07 10:06