Discussion :

[Benjamin Delespierre]

Merci à toi Willpower.

J'y vois nettement plus clair dans l'héritage par prototypes maintenant. Je ne sais toujours pas pourquoi certains types natifs comme String posent problème alors que d'autres comme Array sont plus coopératifs. Mais avec cette classe j'ai tout ce qu'il me faut et je n'ai pas envie de creuser dans la norme ECMA.

De toute façon, hériter de la classe String n'a pas beaucoup de sens d'un point de vue sémantique Hériter de Array en revanche à des application bien pratiques.

Pour ceux qui se poseraient la question de la façon dont JavaScript effectue le chainage de prototypes, j'ai trouvé cet article qui y répond assez bien: http://dosimple.ch/articles/Javascri...type-heritage/.

[Willpower]

c'est résolu, mais j'apporte encore un dernier élément.


dans mon implémentation, j'utilise array.map qui n'existe pas sous les vieilles versions d'IE. j'ai donc remplacer par myArray.map que je défini également dans mes prototypes et qui renvoit un myArray.

ceci m'a permis de constater un bug, c'est que

Code :

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

1
2
3
 
var myArr = new myArray();
myArr[2] = "lalal";

ne fonctionne pas vraiment bien, le string "lalal" est ajouté à la partie "objet" de notre myArr et non à la partie "array". il n'est dont pas affiché lors d'un toString et n'augmente pas la "length" de notre myArr qui est restée à 0.

pour palier à ça, on peut (tout comme pour l'objet natif array) faire comme ceci :

Code :

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

1
2
var myArr = new myArray(4); // s'il n'y a qu'un seul paramètre et que c'est un "number", ça défini alors la longueur plutot qu'un unique élément.
myArr[2] = "lalal"; // ça fonctionne nickel.

j'ai donc aussi ajouté ce constructor d'un paramètre "len" dans mon code, ce qui donne au final : (exemple compris)

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
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
// constructor par défaut prenant des éléments ou la longueur
// exemple d'utilisation :
// var myArr = new myArray(1,2,3); -> [1,2,3]
// var myArr = new myArray(4); -> [,,,]
function myArray(len){
	if(arguments.length==1 && typeof(len)=='number')
		this.push.apply(this,(new Array(len)));
	else
		this.push.apply(this,arguments);
}
 
// ajout des méthodes de array en écrassant le prototype (~héritage)
myArray.prototype = new Array();
 
// [INUTILE] correction de l'attribut "constructor" (qui a été écrasé à la ligne au dessus)
myArray.prototype.constructor = myArray;
 
// création d'une méthode "toArray"
myArray.prototype.toArray = function(){
	return this.slice();
};
 
// correction de la méthode "toString" (qui plantait sous certains navigateurs comme chrome)
myArray.prototype.toString = function(){
	return this.toArray().toString();
};
 
// ajout d'un "init" qui ajoute les éléments d'un array à l'objet courant
// exemple d'utilisation : 
// var myArr = (new myArray()).init([1,2,3]);
myArray.prototype.init = function(array){
	this.push.apply(this,array);
	return this;
};
// correction de la méthode "concat" (qui renvoyait un array au lieu d'un myArray)
myArray.prototype.concat = function(){
	var a = this.map.call(arguments,function(e){return e.toArray?e.toArray():e;});
	return (new myArray()).init([].concat.apply(this.toArray(),a.toArray()));
};
//------------------------------------
// https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Array/map
//if(!myArray.prototype.map){  
  myArray.prototype.map = function(callback, thisArg) {  
    var T, A, k;  
    if (this == null) {  
      throw new TypeError(" this is null or not defined");  
    }  
    var O = Object(this);  
    var len = O.length >>> 0;  
    if ({}.toString.call(callback) != "[object Function]") {  
      throw new TypeError(callback + " is not a function");  
    }  
    if (thisArg) {  
      T = thisArg;  
    }   
    A = new myArray(len);  
    k = 0;   
    while(k < len) {  
      var kValue, mappedValue;  
      if (k in O) {   
        kValue = O[ k ];  
        mappedValue = callback.call(T, kValue, k, O);  
        A[ k ] = mappedValue;  
	  }  
      k++;  
    }  
    return A;  
  };        
//}  
//------------------------------------
 
 
function dump(e){
	document.write(e,'<br/>');
}
 
var a = new myArray(1,2,3);
var b = a.concat([4,5,6],[7,8,9,0],a);
 
for(var i in b)
	dump(i+" : "+b[i]);
dump('---');
for(var i in a)
	dump(i+" : "+a[i]);

edit: leçon à retenir: ne jamais essayé de surcharger/hériter des classes natives en javascript.


edit: je ne sais pas si j'ai été clair dans mes explications, mais en gros, tu ne peux pas utiliser les crochets pour ajouter des éléments. tu peux les utiliser uniquement pour écraser des éléments. d'où l'intêret de définir une taille dans le constructeur. autrement ces référence seront accesibles en tant qu'objet mais non pas en tant qu'array. (je pourrais éventuellement faire une fonction de reconstruction de l'array(myArray) après utilisation des crochets si tu le désires).