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 ??

[scandinave]

cela me sert a simuler un héritage. en gros collision herite de interface,
mon but etant de fournir une api. je sais que je transforme le principe de javascript. Mais je vais devoir coder avec des gens venant de java et donc j'adapte au maximum le framework

cette structure fonctionne bien pour le reste de mon projet pourtant . je test des que j'ai le temps ton console.log(inter), je tiens au courant.

ce lien explique le pourquoi du comment j'utilise certain bout de code comme protype.constructor

http://stackoverflow.com/questions/5...ect-properties

[Kaamo]

Dans ce cas, je pense qu'il y a plus simple et moins brouillon pour simuler de l'héritage avec Javascript. Très simplement avec Object.create (ES5 donc il faut prévoir une solution de repli pour les navigateurs n'implémentant pas encore cette version ECMAScript).
Pourquoi s'embêter avec des .prototype, .constructor, etc. ? Qu'est-ce que ça apporte de plus ?

Dans le code simple suivant, il n'y a pas de notion de constructeur, d'assignation de prototype moche etc. (sauf pour reproduire ce que fait Object.create). Chaque objet pointe vers son prototype (__proto__) et a donc accès aux méthodes et propriétés de proto (parent) via le chainage des proto. On peut appeler ça de la délégation, plutôt que de l'héritage.

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
 /* Pour les navigateurs n'implémentant pas ES5 */
if (!Object.create) {
  Object.create = function(o) {
    function F() {}
    F.prototype = o;
    return new F();
  };
}
 
var personne = {};
personne.ditBonjour = function () {
  console.log("Bonjour !");
}
 
var geek = Object.create(personne);
geek.ditBonjourGeek = function() {
  console.log("Hello World !");
}
 
var monGeek = Object.create(geek);
 
monGeek.ditBonjourGeek(); // "Hello World !"
monGeek.ditBonjour(); // "Bonjour !"
 
console.log(personne.isPrototypeOf(monGeek)); // true
console.log(geek.isPrototypeOf(monGeek)); // true
console.log(geek.isPrototypeOf(personne)); // false

Javascript a des objets et quand on les lie (via leur proto respectif) entre eux on obtient un puissant système de délégation . Pas besoin d'ajouter des fioritures pour coller à des idées venant d'autres langages populaires. C'est dénaturer Javascript.
C'est mon avis, ça n'engage que moi, mais c'est la philosophie que j'utilise au quotidien et ça fonctionne plutôt bien.

(bien sûr cet exemple est très basique mais il démontre qu'on peut faire de "l'héritage" simplement).

[scandinave]

merci, je vais étudier ton code avec attention ^^.
Sinon tu as raison le console.log(inter.implementation) me retourne bien la valeur passé en paramètre au dessus.