Optimisation POO et sécurité en JS
Bonjour,
Pour la réalisation d'un futur projet, je vais devoir (ré)apprendre à coder en javascript. Les "best-practices" et le langage ayant évolués avec les années, je dois me (re)mettre à niveau.
Le web ne manque pas d'informations valables, mais... il est facile de tomber également sur des informations erronées/désuètes/ou tout simplement fausses. Ci-dessous quelques classes que j'ai écrite pour me faire un petit exercice. Je sollicite donc l'avis des plus expérimentés qui découvriront au fil des commentaires de mon code les questions que je me pose.
Mes 2 principaux objectifs sont les suivants :
- La sécurité
- L'optimisation (par exemple : éviter les objets "closures")
Voici mes classes :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/* CLASS caracteristiques
* Comportes des variables et méthodes utiles à d'autres CLASS
* (cf. CLASS humain et CLASS animal
*/
var caracteristiques = function() {
this.attaque = 0;
this.defense = 0;
};
caracteristiques.prototype.setAttaque = function(attaque) {
this.attaque = attaque;
};
caracteristiques.prototype.setDefense = function(defense) {
this.defense = defense;
}; |
Code:
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
|
/* CLASS animal
* C'est une CLASS parente
* (cf. CLASS animalOurs ou animalLoup)
*/
var animal = function(nom) {
this.nom = nom;
this.niveau = 1;
this.caracteristiques = new caracteristiques();
/*QUESTION : a chaque nouvel objet enfant hérité de la CLASS "animal", comment se comporte la variable "this.caracteristiques"? contiendra-t-elle un objet "closure" ? Y a-t-il une meilleure manière de faire en terme de mémoire ? */
};
animal.prototype.toString = function() {
return(this.nom);
};
/* CLASS animalOurs
*
*/
var animalOurs = function(nom) {
animal.call(this, nom?nom:"Ours");
this.caracteristiques.setDefense(3);
};
animalOurs.prototype = new animal();
animalOurs.prototype.constructor = animalOurs;
/* CLASS animalOurs
*
*/
var animalLoup = function(nom) {
animal.call(this, nom?nom:"Loup");
this.caracteristiques.setDefense(1);
};
animalLoup.prototype = new animal();
animalLoup.prototype.constructor = animalLoup; |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/* CLASS humain
*
*/
var humain = function(nom, prenom) {
this.nom = nom;
this.prenom = prenom;
this.caracteristiques = new caracteristiques();
this.animauxInvoques=[];
/*QUESTION : "this.animauxInvoques" est un tableau d'objet. Comment javascript s'en sort-il ? Stock-t-il juste un pointer vers les objets ou copie-t-il l'objet au total ? Y a-t-il une meilleure manière de faire en terme de mémoire/performance ? */
};
/* cette méthode permet d'ajouter un animal à un humain */
humain.prototype.invoqueAnimal = function(animalClassName) {
var newAnimal = new window[animalClassName]();
this.animauxInvoques.push(newAnimal);
return newAnimal;
}; |
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
/* programme principal */
var game = function()
{
var gameName = "Game name";
var humain1 = new humain("Smith", "John");
var humain2 = new humain("Hollande", "Angella");
humain1.caracteristiques.setAttaque(2);
var newAnimal = humain2.invoqueAnimal("animalOurs");
newAnimal.caracteristiques.setAttaque(5);
var newAnimal = humain2.invoqueAnimal("animalLoup");
newAnimal.caracteristiques.setAttaque(1);
};
(function() {
var g = new game();
/* QUESTION : En procédant de cette manière, est-ce que j'empêche l'appel et l’exécution de mes objets depuis un script externe ?*/
})(); |
Je remercie d'avance ceux qui auront eu la gentillesse de lire mon poste.
Cordialement,
Greg
