Discussion :

[topolino]

Bonjour,
toujours dans ma recherche de bonne pratique je voulais savoir ce que vous pensiez vis a vis de la maniere de construire des objets en Javascript.

Prototype

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
 function Person(name) {
        this.name = name;
    }
 
    Person.prototype.get_name = function() {
        return this.name;
    };
 
    Person.prototype.set_name = function(name) {
        this.name = name;
    };
 
    Person.prototype.set_name1 = function(name) {
        this.name = name;
    };
 
    Person.prototype.set_name2 = function(name) {
        this.name = name;
    };
 
    Person.prototype.set_name3 = function(name) {
        this.name = name;
    };
 
    Person.prototype.set_name4 = function(name) {
        this.name = name;
    };
 
    Person.prototype.set_name5 = function(name) {
        this.name = name;
    };

Ou Literal

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
var person = function(pname) {
        return {
                'get_name': function() {
                        return pname;
                },
                'set_name': function(name) {
                        pname = name;
                },
                'set_name1': function(name) {
                        pname = name;
                },
                'set_name2': function(name) {
                        pname = name;
                },
                'set_name3': function(name) {
                        pname = name;
                },
                'set_name4': function(name) {
                        pname = name;
                },
                'set_name5': function(name) {
                        pname = name;
                }
        };
    };

Code :

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

1
2
  var _p = new Person('John');
    var _c = person('John');

Merci pour votre experience

[SylvainPV]

Les objets partagent les méthodes et propriétés de leurs prototypes.
Dans le premier exemple, new Person() construit un objet Person et récupère les méthodes déclarées dans Person.prototype.
Tandis qu'avec la seconde méthode, person() renvoie un objet Object contenant les différentes méthodes. Chaque objet créé possède ses propres déclarations de ces fonctions, comme un tas de singletons en quelque-sorte.

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
function Person(name){        
    this.name = name;
}
 
Person.prototype.get_name = function() {
  return this.name;
 };
 
var person = function(pname) {
        return {
                'get_name': function() {
                        return pname;
                }
        };
    };
 
var a = new Person('John');
 
var b = new Person('Jack');
 
var c = person('Jim');
 
var d = person('Jeff');
 
console.log(person.get_name); //undefined
console.log(c.get_name()); // Jim
 
Person.prototype.get_name = function(){ return "My name is "+this.name; };
a.get_name(); //My name is John
b.get_name(); //My name is Jack

[Bovino]

Ta question n'a pas de sens parce que tu essayes d'opposer deux concepts qui n'ont rien à voir...
Donc avant les bonnes pratiques, ce sont surtout les fondamentaux qu'il faut approfondir.

La notion de littéral s'oppose habituellement à celle de constructeur pour créer un type natif de JavaScript. Exemples :

Code :

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

1
2
3
4
5
6
7
8
9
10
var bool = false;  // Littéral booléen
var bool = new Boolean(true); // Constructeur
var nb = 5; // Littéral
var nb = new Number(5); // Constructeur
var st = 'toto';
var st = new String('toto');
var tab = [];
var tab = new Array();
var obj = {};
var obj = new Obect();

Dans tes exemples, tu confonds aussi un constructeur avec une fonction renvoyant un objet.
Donc dans le premier cas, tu fais de la POO, pas dans le second.

Enfin, quant à l'utilisation de l'un ou de l'autre, cela dépend de l'utilisation que tu en as.
En général, un constructeur n'a d'utilité que si l'on est susceptible d'en utiliser plusieurs instances.

[topolino]

Comme je viens du Java et du C# je suis un peu perdu avec Javascript et la POO prototypal.
Effectivement je dois approfondir tout cela.

[SylvainPV]

Oui, pas facile de sortir du modèle de POO par classes quand on vient du monde Java. D'ailleurs, l'opérateur new a été ajouté à JavaScript pour essayer de rendre les choses plus claires pour les développeurs Java, mais ça n'a fait que rendre les choses encore plus confusantes.

[topolino]

Donc dans quel cas utilise t on l'un ou l'autre concept ?

[Kaamo]

En général, un constructeur n'a d'utilité que si l'on est susceptible d'en utiliser plusieurs instances.

Donc, quand tu veux créer plusieurs instances :

Code javascript :

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

1
2
3
4
5
6
7
function Person(name){        
    this.name = name;
}
 
Person.prototype.getName = function() {
  return this.name;
 };

La propriété prototype de l'objet Function permet de partager les méthodes entre plusieurs instances.

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
var personne1 = new Person('toto');
var personne2 = new Person('titi');
 
personne1.getName();  // toto 
personne2.getName(); // titi
 
// tu peux ajouter à la volée des méthodes au <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block"><span style="color: #0000ff;">prototype</span></span> de <span style="font-family: monospace; padding: 2px; background: #ddd; display: inline-block">Person</span> pour que toutes les instances en bénéficient :
 
Person.prototype.ditBonjour = function() {
  return "Salut de la part de " + this.name;
 };
 
personne1.ditBonjour();  // Salut de la part de toto
personne2.ditBonjour(); // Salut de la part de titi

On appelle ça le pattern constructor. Voici un post, et un autre, qui pourrait t'aider à mieux comprendre je pense.
Il faut faire attention avec new. Cf post récent de Sylvain

L'autre cas se passe si tu n'as qu'une et une seule instance, un singleton en somme (la gestion d'une base, gestion des logs, etc).