Propriété dynamique de l'objet JavaScript?

Je me demande si cela est possible en JavaScript, je veux avoir un objet qui puisse contenir des propriétés dynamiques.

Donne un exemple:

function MyObject() { } var myobj = new MyObject(); myobj.property1 = "something"; alert(myobj.property1); // something alert(myobj.property2); // this should never report error, instead the property should be evaluated to null, as it has never been set.

Existe-t-il un moyen d'intercepter des appels de propriété en JavaScript afin que je puisse définir de façon proactive une propriété sans valeur comme nulle?

Merci.

C'est à peu près aussi près que vous pouvez atteindre votre objectif.

Code:

 var obj = {}; alert("prop: " + obj.prop); obj.prop = "something"; alert("prop: " + obj.prop); delete obj.prop; alert("prop: " + obj.prop);

Comportement:

 Alerte: "prop: undefined"
 Alerte: "prop: quelque chose"
 Alerte: "prop: undefined"

«Proxy» peut faire cela

 var myobj = new Object(); var handler = { get:function (obj, name, proxyed){ if(obj[name] !== undefined) // if obj[name] exist return obj[name]; // then return obj[name] return null; // if obj[name] is not exist then return null; } }; var obj = new Proxy(myobj, handler); obj.property1 = "something"; alert(myobj.property1); // something alert(myobj.property2); // undefined alert(obj.property1); // something alert(obj.property2); // null

Oui, mais seulement dans la version 2.0 et supérieure. La syntaxe exacte est encore à déterminer, mais il semble que ce sera get * () {...} pour les littératures objet au moins.

Nan. JavaScript n'est pas Smalltalk.

Il n'y a aucun moyen d'intercepter les accès aux propriétés directes en JavaScript. Lorsqu'une propriété est récupérée qui n'a pas été définie, le résultat sera undefined . Bien que null et undefined soit habituellement considéré comme la même chose, ils sont en fait des entités différentes.

En JavaScript undefined , aucune valeur et null signifie une valeur nulle. Dans certains cas, vous pouvez mixer indéfini et nul. Par exemple, lorsque vous utilisez l'opérateur == , ils sont équivalents ( (null == undefined) === true ). En utilisant l'opérateur sans contrainte, === , ils sont différents ( (null === undefined) === false ).

Vous pouvez utiliser cela à votre avantage. Bien que la plupart des gens affirment que vous devriez utiliser l'opérateur non-coercitif ( === ), il est préférable de mettre de façon null et undefined dans le même seau, en moins, bien sûr, vous vous souciez vraiment de la différence entre les deux. Là où il devient difficile, c'est undefined qui est une propriété de l'objet global et peut donc être affecté à une nouvelle valeur.

Si quelqu'un devait dire undefined = 'donkey' alors null == undefined commencerait à renvoyer false . Dans la pratique, ce n'est presque jamais un problème, car la plupart des gens ne sont pas assez sots pour réaffecter la valeur de l'indéfini.

Donc, de manière indirecte, vous n'avez pas besoin de piéger les accès aux propriétés pour renvoyer le null pour les propriétés qui n'ont pas été définies tant que vous comparez le résultat à null utilisant == .

Non, sauf si vous manipulez un objet contrôlé par un plugin NPAPI, auquel cas vous pouvez implémenter le comportement prévu.

En d'autres termes, grâce à un plugin NPAPI, vous pouvez implémenter le comportement que vous recherchez.

Consultez les prototypes de javascript. Je pense que cela vous donnera au moins une partie de ce que vous recherchez. Juste google "prototype javascript".

Dans votre exemple, la deuxième alerte ne générera pas d'erreur. Il va juste alerter undefined . L'accès aux propriétés des propriétés générera une erreur:

 myobj.property2.property3