Pourquoi existe-t-il une valeur «nulle» en JavaScript?

En JavaScript, il existe deux valeurs qui disent essentiellement «je n'existe pas» – undefined et null .

Une propriété à laquelle un programmeur n'a pas affecté quelque chose sera undefined , mais pour qu'une propriété redevienne null , null doit l'être explicitement.

  • Comment ajouter du contenu au corps html à l'aide de JS?
  • Télécharger le contenu du texte / csv en tant que fichiers du serveur en Angulaire
  • Supprimez la balise <script> spécifique dans la balise <head> par l'événement onclick
  • JSON.stringify convertir Infinity en null
  • Comment créer un commutateur marche / arrêt avec Javascript / CSS?
  • Comment puis-je observer les changements de tableau et voir quel nouvel élément est ajouté?
  • Une fois, j'ai pensé qu'il y avait un besoin de null car undefined est une valeur primitive et null un objet. Ce n'est pas, même si typeof null produira un 'object' : en fait, les deux sont des valeurs primitives – ce qui signifie que ni undefined ni null ne peut être renvoyé à partir d'une fonction de constructeur, car les deux seront converties en un objet vide (il faut lancer une erreur Proclamer l'échec dans les constructeurs).

    Ils évaluent également à false dans des contextes booléens. La seule vraie différence que je peux penser est que l'on évalue à NaN , l'autre à 0 dans les contextes numériques.

    Alors, pourquoi est-il à la fois undefined et null si cela confond les programmeurs qui vérifient de manière incorrecte la valeur null lorsqu'ils tentent de savoir si une propriété a été définie ou non?

    Edit: Ce que je voudrais savoir, c'est si quelqu'un a un exemple raisonnable où il est nécessaire d'utiliser null qui ne peut pas être exprimé en utilisant undefined place.

    Edit2 + 3 : Donc, le consensus général semble être que undefined signifie «il n'y a pas de propriété de ce genre» alors que null signifie «la propriété n'existe pas, mais ne contient aucune valeur».

    Je pourrais vivre avec cela si les implémentations JavaScript impliquaient effectivement ce comportement – mais undefined est une valeur primitive parfaitement valide, de sorte qu'il peut être facilement attribué aux propriétés existantes pour rompre ce contrat. Par conséquent, si vous voulez vous assurer que si une propriété existe, vous devez utiliser l'opérateur ou hasOwnProperty() toute façon. Alors encore une fois: quelle est l'utilisation pratique pour des valeurs distinctes pour undefined et null ?

    En fait, j'utilise undefined quand je veux désélectionner les valeurs des propriétés qui ne sont plus utilisées mais que je ne veux pas delete . Dois-je utiliser null place?

  • Différence entre les guillemets simples et les guillemets doubles en Javascript
  • Remplacer la fonction d'analyse de la colonne vertébrale
  • Comment analyser une URL dans hostname and path in javascript?
  • Comment puis-je ajouter des bibliothèques de JavaScript tierces à une application Meteor?
  • Empêchez l'iPhone de zoomer sur `select` dans l'application Web
  • Comment fonctionne l'émulateur Linux en Javascript par Fabrice Bellard?
  • 11 Solutions collect form web for “Pourquoi existe-t-il une valeur «nulle» en JavaScript?”

    La question n'est pas vraiment «pourquoi existe-t-il une valeur nulle dans JS» – il existe une valeur nulle dans la plupart des langues et il est généralement considéré comme très utile.

    La question est: "pourquoi existe-t-il une valeur indéfinie dans JS"? Principaux endroits où il est utilisé:

    1. Lorsque vous déclarez 'var x;' Mais ne l'assignez pas, x détient indéfini;
    2. Lorsque votre fonction obtient moins d'arguments qu'il ne le déclare;
    3. Lorsque vous accédez à une propriété d'objet inexistante.

    «Null» aurait certainement fonctionné aussi bien pour (1) et (2) *. (3) devrait vraiment jeter une exception tout de suite, et le fait qu'il ne soit pas, au lieu de renvoyer cet étrange 'indéfini' qui échouera plus tard, est une grande source de difficulté de débogage.

    *: Vous pourriez également argumenter que (2) devrait jeter une exception, mais il faudrait fournir un mécanisme meilleur et plus explicite pour les arguments par défaut / variables.

    Cependant, JavaScript n'avait pas à l'origine des exceptions, ni aucune façon de demander un objet s'il avait un membre sous un certain nom – la seule façon était (et parfois encore) d'accéder au membre et de voir ce que vous obtenez. Étant donné que «null» avait déjà un but et que vous pourriez vouloir créer un membre, une valeur différente de la bande était nécessaire. Donc, nous avons «indéfini», il est problématique comme vous le signalez, et c'est une autre excellente fonctionnalité de JavaScript que nous ne pourrons jamais nous débarrasser.

    En fait, j'utilise indéfiniment quand je veux désélectionner les valeurs des propriétés qui ne sont plus utilisées mais que je ne veux pas supprimer. Dois-je utiliser null à la place?

    Oui. Gardez «indéfini» comme une valeur spéciale pour la signalisation lorsque d'autres langues peuvent plutôt lancer une exception.

    «Null» est généralement mieux, sauf sur certaines interfaces IE DOM où le réglage de quelque chose pour «null» peut vous donner une erreur. Souvent, dans ce cas, le réglage sur la chaîne vide tend à fonctionner.

    Le mieux décrit ici , mais en résumé:

    Indéfini est le manque de type et de valeur, et null est le manque de valeur.

    En outre, si vous faites des comparaisons simples '==', vous avez raison, elles sortent de la même façon. Mais essayez ===, qui compare le type et la valeur, et vous remarquerez la différence.

    Je ne pense pas qu'il y ait aucune raison d'avoir à la fois null et undefined , car la seule raison que plusieurs personnes ont suggérée (" undefined signifie qu'il n'y a pas de telle variable / propriété") n'est pas valide, du moins en JavaScript. undefined ne peut pas vous dire si la variable / propriété existe ou non.

     console.log(foo); // "ReferenceError: foo is not defined" // foo does not exist var foo; console.log(foo); // "undefined", a different response console.log(foo === undefined); // "true", but it does exist var obj = {}; console.log(obj.hasOwnProperty("foo")); // "false", no such property obj.foo = undefined; console.log(obj.hasOwnProperty("foo")); // "true", it exists and has the value "undefined" console.log(obj.foo === undefined); // "true", but it does exist obj.bar = "delete me"; obj.bar = undefined; console.log(obj.hasOwnProperty("bar")); // "true", not actually deleted delete obj.bar; console.log(obj.hasOwnProperty("bar")); // "false", deleted 

    Comme vous pouvez le voir, vérifier foo === undefined ne vous indique pas si foo existe et le réglage obj.bar = undefined ne supprime pas la bar .

    C'est peut-être l'intention originale de l'auteur JavaScript que l' undefined devrait représenter "inexistence". Cependant, la mise en œuvre ne s'est pas déroulée de cette façon.

    Il est tout à fait possible d'en avoir besoin. Par exemple, si vous interrogez WMI, il est tout à fait possible d'avoir des propriétés de retour de classe qui ont une valeur nulle. Ils sont définis, ils se révèlent nuls à l'époque.

    Je pense que votre conclusion selon laquelle JavaScript définit undefined comme "il n'y a pas de propriété de ce type" et null comme "la propriété n'a aucune valeur" est parfaitement correct. Et dans une langue aussi dynamique que JavaScript, c'est une distinction très importante. L'utilisation de la typage de canard signifie que nous devons pouvoir différencier une propriété qui n'existe pas et n'ayant pas de valeur. C'est notre principal moyen de dériver des informations de type. Dans un langage statiquement typé, il existe une distinction définie entre un champ nul et un champ qui n'existe pas. En JavaScript, ceci n'est pas différent. Cependant, il est vérifié au moment de l'exécution, et peut être modifié jusqu'à ce moment.

    Je vais devoir convenir que la mise en œuvre est étrange car beaucoup de temps la distinction est floue. Cependant, je pense que, en JavaScript, la distinction est importante. Et être capable d'assigner un undefined est essentiel.

    Je me souviens de lire un article sur le blog d'un RPG en ligne écrit en JavaScript. Il a utilisé des exemples où des objets ont été créés en tant que copies d'instances existantes plutôt que de prototypes (classes, fonctions, autres) et ont ensuite été modifiés. Cela m'a vraiment permis de comprendre à quel point il était puissant que l'on ne pouvait pas définir lors de la modification des objets existants, mais je ne me souviens pas de l'avoir écrit.

    Sémantiquement, ils signifient des choses différentes. Le type null a exactement une valeur dans son domaine, null et une propriété peut être attribuée à cette valeur spécifique. Undefined représente un manque distinct de valeur attribuée.

    En tant que programmeur Java, je vois une énorme différence entre indéfini et nul. Codage de JavaScript, pas tellement, car JavaScript n'est pas fortement typé et les différences entre indéfinis et nuls sont floues par les conversions automatiques effectuées fréquemment par l'exécution. BTW, je profite fréquemment de ces conversions; Ils rendent mon code JS plus compact et lisible.

    Pour répondre à votre question, indéfini signifie qu'une valeur n'a jamais été définie. Pratiquement parlant, cela indique généralement un bug. Si yourObject.property est indéfini, cela signifie que vous n'avez pas configuré la propriété pour une raison quelconque, ou je recherche quelque chose qui n'existe pas du tout. C'est un problème réel lorsque vous travaillez sur un projet avec plus d'un codeur.

    Null signifie que "aucune valeur" a été définie explicitement. Pratiquement parlant, vous me dites quelque chose à propos de la propriété, peut-être qu'elle n'est pas utilisée dans ce contexte, ou qu'une valeur n'a pas encore été déterminée.

    En Java, les tentatives d'accès à un champ indéfini entraîneront toujours une exception. En fait, le compilateur peut être fait pour vous avertir à propos de cela dans votre code.

    Essayez cet exemple:

     <html> <head> <script type="text/javascript"> function ShowObjProperties(obj) { var property, propCollection = ""; for(property in obj) { propCollection += (property + ": " + obj[property] + "\n"); } alert(propCollection); } var obj = { userid: 3, name: 'me!', speak: function() { alert('Hi! My name is ' + this.name + ' and my ID is ' + this.userid + '.'); } } //Shows all properties ShowObjProperties(obj); //The Speak function is no longer in the list! delete obj.speak; alert(typeof obj.speak); ShowObjProperties(obj); //The UserID is still listed, it just has no value! obj.userid = null; ShowObjProperties(obj); </script> </head> <body> </body> </html> 

    Je pense qu'il existe une utilisation très réelle pour 2 types différents ici.

    À quoi cela aboutit-t-il à la nature dynamique javascripts.

    Les choses peuvent être indéfinies afin qu'elles puissent être ajoutées ultérieurement. C'est sans doute pourquoi javascript est si puissant et extensible.

    Null is beautiful

    Tout comme tous les autres types de script en direct.

    Citer: en JavaScript, il existe deux valeurs qui disent essentiellement «je n'existe pas» – indéfini et nul.

    Pourquoi voudriez-vous dire des choses incorrectes?

    "Null" est "Object vide" comme "0" est un "numéro vide" . 0, n'est rien, mais il existe comme type de chose Numéro. Null est bien sûr également vide, mais "c'est" et c'est une chose bien définie d'un type d'objet .

    Il est courant de parler de ces choses comme des "types", quand ils ne le sont pas. En fait, ce sont des "catégories". Mais c'est fini maintenant.

    Ainsi, il faudra dire que «null» est un type d'objet sans type. Et "nul" dit "J'existe beaucoup [,] mais je n'ai pas le contenu de mon genre".

    Alors que indéfini manque à la fois le type et le type où indéfini se trouve également sa définition de type. Un type indéfini d'un type devient sa typologie distinctive. Une sorte de [existe "rien" et comment définissez-vous «rien»?].

    Cité: undefined ou null peut être renvoyé à partir d'une fonction de constructeur, car les deux seront convertisseurs vers un objet vide

    Vous avez réussi à répéter une chose incorrecte. Bien sûr que non, le "indéfini" n'est pas un objet, c'est un jeton simple que nous, les humains, comprenons; Mais contrairement à ce null est – et il vous dit que: son Type est correct, mais le genre que vous recherchez n'est pas contenu, ou du moins – pas à l'heure actuelle. Venez nous rendre visite plus tard lorsque nous mettons \ assigner un objet dans \ à celui-ci.

    Cite: La seule différence réelle que je peux penser est que l'on évalue à NaN, l'autre à 0 dans les contextes numériques.

    Cela fait tout le point de leur distinction de base, comme mentionné: undefined est un jeton simple et puisqu'il est composé du même matériau «génétique» que ses parents éloignés: les chaînes, l'opération [+ non définie] va le convertir en pates NaN, de manière similaire nulle, évidemment, se transformera en un bon type 0 \ Number à la place, et par opposition à undefined qui se transformera en une chaîne (! Qui n'est pas vide!) Et c'est exactement pourquoi elle produit NaN à la place. Où: + indéfini >> + "indéfini" >> NaN. Étant donné que le contexte numérique s'attend à une valeur explicite.

    Alors que le contexte booléen s'attend à une référence – ne trouve rien à convertir et donne «faux».

    Passons maintenant …

    Citer: Donc encore une fois: quel est l'usage pratique pour des valeurs séparées pour indéfini et nul?

    Je vais essayer de vous donner seulement deux exemples empiriques et j'espère suffire

     oElement.onclick >> null 

    // signifie -la propriété existe; Sa valeur attendue est de Type: Object , et que oElement prend en charge l'événement "onclick"!

     oElement.innerText >> "" 

    // signifie – la propriété existe; Sa valeur attendue est de Type: String , ce qui signifie que oElement prend en charge la propriété "innerText".

    Sur les deux cas – si vous recevez "indéfini", cela signifie que la propriété n'existe pas; N'est pas pris en charge ou a une mauvaise implantation (fournisseur ua).

    Restez froid et amusez-vous.

    C'est une fonctionnalité de langue importante si vous enveloppez votre programme autour du paradigme évité de javascript.

     // a key exists as a placeholder for something if(obj[name] === null) // no key exists int eh hashtable that is in this object if(obj[name] === undefined) 

    Ceci est très utile si vous rencontrez un ensemble de données qui a besoin d'une valeur pour représenter 'rien' pour indiquer une action différente de l'utilisation de 'rien' pour indiquer l'action par défaut.

     filter_func_pt = { date:function(d){ return Math.round(d.getTime()/1000);}, user: null, } function transform(obj){ var ret = {}; for( var prop in obj){ var f = filter_func_pt[prop]; if(f) ret[prop] = f(obj); else if(filter_func_pt[prop] === null) continue; else ret[prop] == obj; } return ret; } var a = { date: new Date(), user: 'sam' votes: [23, 41, 55] }; var b = transform(a); /* b = { * date: 1298582417 * votes: [23, 41, 55] * } */ 

    Dans le code ci-dessus, le mot-clé null et le serveur indéfini sont très clairs et différents. La recherche qui ne se trouve pas dans l'objet filter_func_pt qui renvoie des moyens non définis pour ajouter la propriété à l'objet de retour, alors qu'une valeur nulle indique que la valeur doit être retenue et non ajoutée, et la présence de toute valeur réelle dans cette Case représente une fonction utilisée pour transformer la valeur avant de l'ajouter à l'objet ret .

    JavaScript rend le site Web intelligent, beauté et facile à utiliser.