Discussion :

[philoo91]

Bonjour,

Comment éviter qu'une boucle de type for (... in ...) restitue le nom de la fonction ajoutée dans un objet ?
Exemple (réalisé à la console Google):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
o={a:1,b:2,c:3}
// si j'écris :  
for (p in o){alert (p)}
// j'obtiens bien 3 boites de message, une pour chaque propriété a,b, et c ---- jusque la je suis ok
 
//mais si on fait :
o.constructor.prototype.message=function (m){alert(m)}
//puis 
for (p in o){alert (p)}
 
//Là cela ne va plus j'obtient une alerte avec "message" qui est une (ma) fonction

Question : Comment "MASQUER POUR LA COMMANDE FOR (...IN...)" la/les fonctions "rajoutées" dans l'objet ?

[headmax]

__proto__ est l'actuel object utilisé (préalablement créer) prototype est l'object qui permet de créer __proto__

Code javascript :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
( new Bar ).__proto__ === Bar.prototype
( new Bar ).prototype === undefined

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
 
o={a:1,b:2,c:3}
// si j'écris :
for (p in o){alert (p)}
// j'obtiens bien 3 boites de message, une pour chaque propriété a,b, et c ---- jusque la je suis ok
 
//mais si on fait :
o.constructor.__proto__.message= (function (m){alert(m)});
//puis
for (p in o){alert (p)}

[sekaijin]

tu peux pas un membre d'un objet est un membre d'un objet
et le for in parcours tous les membres.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
o={a:null};
o.a=1;  //la valeur 1 est affecté au membre a  (le membre a n'est pas modifié seule sa valeur a changée)
alert(o.a); //1
o.a = 'toto'; // la string 'toto' est crée et une référence à cette string est affecté au membre a (le membre a n'est pas modifié seule sa valeur a changée)
alert(o.a); //toto
o.a = {t:15}; // l'objet {t:15} est crée et une référence à cet objet est affecté au membre a (le membre a n'est pas modifié seule sa valeur a changée)
alert(o.a); //Object
o.a = function(){};// la fonction function(){}' est crée et une référence à cette fonction est affecté au membre a (le membre a n'est pas modifié seule sa valeur a changée)
alert(o.a); //function

le membre a de l'objet o n'a pas changé durant tout le script il est resté membre de o car c'est sa nature.
seule la valeur du membre à changé.
le for in parcourant tous les membres il n'y a pas de raison qu'il en ignore certain parce que leur valeur est une valeur comme une autre.

A+JYT

[NoSmoking]

Bonjour,
il te faut utiliser la méthode hasOwnProperty() pour tester si la propriété est définie sur l'objet lui même et non ajoutée via prototype ou autre.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
for( var p in o) {
    if( o.hasOwnProperty( p)) {
        alert( p);
    }
}

[philoo91]

Bonjour,

C'est encore moi.

Si au lieu de créer un objet quelconque comme dans l'exemple fourni à l'ouverture de la discussion, vous faites la démarche avec l'objet JavaScript standard "Object()"

En faisant ceci dans la console gogole :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for (p in Object()){alert(p)}

//Aucune alerte n'est affichée.

Et pourtant des fonctions sont bien évidemment présentes dans l'objet "Object":
(constructor, hasOwnProperty, ... pour n'en citer que quelques une...)

Maintenant si vous rajoutez une fonction à l'objet "Object()" pour l'enrichir d'une fonctionnalité comme par exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Object.prototype.valueIsIn=function (value){
	if (Array.isArray(this))return ($.inArray(value,this)!=-1);
	for (var prop in this){
		if (this[prop]==value)return true;
	}
	return false;
}

Qui renseigne si une propriété contient la valeur indiquée

On a bien avec l'IntelliSense de Google la fonction "valueIsIn" qui s'affiche avec les autres dans la boite lorsque l'on tape à la console :
Object. // suivi de contrôle espace//

En plus elle fonctionne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
x={a:1,b:2,c:3}
x.valueIsIn(2)// Affiche "true"
x.valueIsIn(5)//Affiche "false"

Par contre on a toujours le soucis avec :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for (prop in x){alert(prop)}
// Qui affiche certes 3 messages un pour chaque propriété a,b,c // La c'est OK
// Mais qui en affiche une quatrième avec le nom de la fonction  "valueIsIn"

D'où la question initiale :
Comment en rajoutant une fonction sur le propotype de Object() celle ci se comporte comme les autres
qui s'y trouvent "de base en standard" face à la commande for (..in..)

[sekaijin]

encore une fois un membre est un membre
c'est donc le comportement statndard

Ce que tu veux c'est un comportement NON standard.
le for in passe par tous les membres (les fonctions internes de JS ne sont pas des membres)

Toi, ce que tu veux, c'est passer en revue les membres et en fonction de la nature de leur valeur agir différemment.

Je ne vois pas ce qui t'empêche de le faire.
Tu fais ça.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
var prop1 = 15;
alert(prop1);
var prop2 = function(){};
alert(prop2);

alors que tu veux faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
var prop1 = 15;
if ('function' != typeof prop1) {
  alert(prop1);
}var prop2 = function(){};
if ('function' != typeof prop2) {
  alert(prop2);
}

Je ne vois vraiment pas ce qui t'empêche de le faire.

IL faut que tu te mettes dans la tête qu'un membre d'un objet peut avoir n'importe quel type et que parmi ces types il y a le type fonction. C’est dans la structure du langage.
Pour ce qui est du noyau de l'interprète, ce n'est pas un membre.

Tu peux considérer qu'en JavaScript tout est objet. que chaque nom est en fait une référence à un objet
Ainsi quand tu écris

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

var o = {a:12,b:'test',c:function(){}};

tu crées un symbole o qui référence un objet
cet objet est constitué de 3 membres ayant chacun un symbole et une valeur
le premier a pour symbole a et référence un objet de type Inetger dont le contenu est 12
le second a pour symbole b et référence un objet de type String dont le contenu est 'test'
Le dernier a pour symbole c et référence un objet de type fonction dont le contenu est une fonction anonyme vide.

Tout est donc parfaitement homogène. Il n'y a donc aucune raison que for in se comporte différemment avec certains membres.
Cela fait partie du langage.

Si tu as déjà travaillé avec d'autres langages à objet tu connais probablement la structure Map (java, C++ etc) ou Tableau associatif de PHP.

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

o = new HashMap<String, Object>();

tu à l'a une Map dont les clefs sont des string et les valeurs des objets.
Tu peux donc à priori y mettre ce que tu veux. Toute classe dérivant de Object peut être ajoutée à ta Map.

maintenant, imagine une classe

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
Class Function{
...
}

N'importe quelle instance de cette classe peut être ajoutée à ta Map.
si tu fais

Code java :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
for(Entry<String, Object> entry : o.entrySet()) {
    object p = entry.getValue();
    ...
}

Dis-moi pourquoi le for devrait ne pas te retourner les entrées don la valeur est une instance de la classe Fonction ?

C'est pourtant ce que tu demandes.
Et tu dis Oui, mais les fonctions internes elles ...

Dans ce code Java la méthode entrySet ou la propriété length font-elles partie de la liste des valeurs de ta Map ?

Le For in parcours tous les membres et que les membres sans aucune distinction de valeurs.
Si tu veux faire des actions différentes en fonction du type de valeur libre à toi de le faire.

A+JYT

[javatwister]

d'accord avec No Smok en tout cas!

[philoo91]

Merci de ta longue réponse.

Mon besoin de "cacher" la/les fonctions rajoutées est motivé par un code qui bug du fait de l'utilisation de cette commande for .. in.. avec (avant) un ajout dans le prototype de "Object"
Il ne m'est pas possible d'y apporter un correctif, (de par sa nature, et son utilisation dans le groupe entreprise).
Tant pis.
Enfin je reste sur ma fin. Je tire peut être une conclusion qui va fâcher.
Mais je constate qu'il n'est pas fini le langage.
La boucle for avec IN devrait passer en revu les "Vraies" propriétés (tout ce qui n'est pas du type "function")
Car en définitive dans un objet quel qu'il soit il y a deux sorte d'informations :
les données (scalaires , vectorielles, objets(pourvu que ce ne soit pas des fonctions)) et du code(les fonctions)
Aussi il serai bien que le langage rajoute comme un paramètre sur le IN permettant de récupérer tout, uniquement les données ou uniquement les fonctions.

Mais,
Reste les "class"
J'ai constaté que :

si l'on écrit (dans un js) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
"use strict"
class Polygone {
  constructor(hauteur, largeur) {
    this.nom = 'Polygone';
    this.hauteur = hauteur;
    this.largeur = largeur;
  }
  truc(m){console.log(m);}
}

On fait tourner
, et dans la console on fait :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for (p in new Polygone()){alert (p)} //le new est obligatoire parce que Polygone est construit avec "Class"

// pas de message avec "truc"

Alors une réflexion vers la piste d'une redéfinition de la classe Object en "class Object" avec de nouvelle(s) fonctions

Effet de bord potentiel : le code qui citerait ainsi : "mavarobj=Objet" ou "mavarobj=Objet()" // sans le mot clé new devant Objet
Et Quid avec IE de micro mous ?