Discussion :

[scandinave]

Bonjour, je fais appel à vous car je ne voit pas du tout d’où peu venir le problème. Dans le code ci-dessous. Ma variable this.implementation est bien renseigné. Le premier console.log() affiche bien le contenu.

Par contre dans la méthode validMethod(), je ne peux pas y accéder.
le console.log me retourne undefined

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
function Interface(implementation){
	this.implementation = implementation;
	console.log(this.implementation);
}
 
Interface.prototype.constructor = Interface;
Interface.prototype.validMethodCount = function(){
	return this.length !== this.implementation.length
};
 
Interface.prototype.validMethod = function(){
	for(var i in this){
		console.log(this.implementation);
		if(i !== "validMethodCount" && i !== "validMethod "){
			if(this.implementation[i] == undefined){
				throw "Method " + i + " is missing. You must implement it;";
			}
		}
    }
};

Quelqu'un saurait me dire pourquoi?

Seconde question, en utilisant le même structure( prototype) est-il possible d'utiliser des accesseurs pour les variables de classe? en passant les variables comme implementation en

Code :

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

var implementation;

au lien de

Code :

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

this.implementation

merci d'avance.

[Kaamo]

Des pistes :

Pourquoi fais - tu Interface.prototype.constructor = Interface; ?
Comment créées- tu ton objet à partir de Interface(implementation) ?

en utilisant le même structure( prototype) est-il possible d'utiliser des accesseurs pour les variables de classe?

Prototype et classe dans la même phrase, c'est contradictoire. Ce sont deux "catégories" de langage objet différentes.

Javascript est un langage objet orienté prototype. Il n'y a pas de classes alors pourquoi vouloir implémenter la notion d'interface ? Je ne comprends pas ...
Il faut bien comprendre que la notion d'interface dans les langages objet orientés classe sont là uniquement pour pallier un problème de transversalité que n'offre pas ce type de langage objet.
En Javascript, il suffit simplement de tester si tel ou tel objet a telle ou telle méthode. Si elle n'existe pas, tu la crées à la volée, sinon tu la retournes.

Il y a quand même plusieurs moyens de simuler cela. Voici un cas ultra basique. On check si l'objet courant possède les propriétés imposées par l'interface qui est en réalité un objet bidon recensant les types de propriétés attendues. Attention, si l'objet courant contient plus de propriétés, ce bout de code ne le détecte pas. Bref, c'est simplement pour imager la chose :

Code javascript :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// l'objet implémente - t - il l'interface ?
Object.prototype.Implemente = function(interface){ 
  for(var prop in interface) if (interface.hasOwnProperty(prop)) {
    if(typeof this[prop] != interface[prop] || this[prop] === undefined)
      return false;
  }
  return true;
};
 
 
var InterfaceTest = {
  prop1: "number",
  prop2: "function",
  prop3: "object"
}; 
 
var InterfaceTest2 = {
  prop1: "number",
  prop2: "function"
}; 
 
var ObjetTest = {
  prop1: 1,
  prop2: function() { console.log('coucou'); }
}
 
console.log(ObjetTest.Implemente(InterfaceTest)); // false, il manque la prop3
console.log(ObjetTest.Implemente(InterfaceTest2)); // true

Mais ça n'a pas de sens car c'est un langage dynamique. A la création de l'objet, peut-être que ObjetTest se pliera aux exigences d'une interface quelconque. Mais quid de modifier ensuite l'interface ? Bim, ton objet ainsi créé ne correspond plus.
Renseigne toi également sur ce qu'on appelle le "Duck typing". C'est exactement ce qu'utilise Javascript.

[scandinave]

voici les éléments l'utilisant :

Collision.js

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
function Collision(implementatation){
	Interface.call(this, implementatation);
	this.parent.validMethod();
}
 
Collision.prototype = new Interface();
Collision.prototype.constructor = Interface;
Collision.prototype.parent = Interface.prototype;
 
Collision.prototype.touch = function(item1, item2){
	this.implementation.touch(item1, item2);
};
 
 
Collision.prototype.test = function(){
	throw "Not implemented";
};

AABBCollision.js

Code :

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

1
2
3
4
5
6
7
8
 
function AABBCollision(){
 
}
 
AABBCollision.prototype.touch = function(item1, item2){
	console.log("toto");
};

l'appel à l'interface :

Code :

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

var inter = new Collision(new AABBCollision());

La manière de faire l'appel est moche mais cela est juste pour test ^^.
concernant le :

Code :

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

Interface.prototype.constructor = Interface;

j'avoue ne pas mettre trop posé la question de son intérêt. Il me semble qu'il rajoute un attribut

name="Interface"

dans l'objet.

J'ai bien compris la différence entre les deux langages ^^. j'essaye juste de voir jusqu’où je peux allez dans la simulation des des mécanismes objets.

[Kaamo]

j'essaye juste de voir jusqu’où je peux allez dans la simulation des des mécanismes objets.

Selon moi, cela n'a pas de sens que de vouloir faire faire à Javascript des choses qui lui sont "contre-nature".
Si on utilise Javascript, il faut se défaire du paradigme que l'on connait bien, oublier ce qu'on nous a appris et appréhender ce concept qu'on ne comprend pas assez au final.
A mon avis, tu vas droit dans le mur à vouloir créer des interfaces en Javascript.

[scandinave]

je prend en compte ton avis, mais je tiens quand même a savoir pourquoi mon this.implementation retourne undefined . j'utilise le même mécanisme sans problème d'en d'autre fonction js.

[Kaamo]

Parce que tu assignes au prototype de Collision un nouvel objet construit à partir d'Interface :

Code javascript :

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

Collision.prototype = new Interface();

Or, en faisant ce simple new Interface(); sans aucun paramètre, this.implementation est donc undefined.

De plus que fait Interface.call(this, implementation); ? Ça exécute la fonction Interface qui fait quoi ? Applique implementation à this. Or, qui est this au moment de l'appel de la fonction ? L'objet inter ... Fais un console.log(inter) et tu t'apercevras que ton implementation n'est pas undefined. Tu ne l'attendais pas au bon endroit voilà tout.

Sinon, tout ça m'a l'air bien compliqué. Je ne vois pas trop l'utilité de tout ça. A quoi ça sert ??