Discussion :

[chok371]

Bonjour,

J'aimerais savoir si il y a une différence entre ces 3 techniques de création d'objet :

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
var unObj = function() {
   this.prop1 = valeur1;
   this.prop2 = valeur2;
   this.method1 = function() { ... }
}
var useObj = new unObj();
 
-----
 
var unObj = {
   prop1 : valeur1,
   propr2 : valeur2.
   method1 : function() { ... }
}
 
-----
 
var unObj = new Object();
unObj.prop1 = valeur1;
unObj.prop2 = valeur2;
unObj.method1 = function() { ... };

Merci.

[SpaceFrog]

la différence réside dans le type d'objet

teste avec typeOf ...

Chacun des type pouvant avoir des propriétés ou methodes propres différentes

[Willpower]

la différence réside dans le type d'objet

teste avec typeOf ...

Chacun des type pouvant avoir des propriétés ou methodes propres différentes

Les 3 typeof donneront des "object"

Pour moi, les 3 sont identiques, mais :

la première est plus pratique si tu comptes définir plusieurs objets avec le même prototype. (structure)

La deuxième solution si tu ne fais qu'un seul objet de ce prototype.

La troisième permet de rajouter des méthodes/propriétés. (par exemple sous certaines conditions.) mais ne doit pas servir de déclaration car le "new Object" est moche et pas très esthétique(selon moi) et devrait donc être remplacé/couplé à un des 2 exemples précédent avec un constructeur pauvre ou vide si tu le désires comme par exemple :

Code :

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

var unObj = {};

[SpaceFrog]

Code :

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

Les 3 typeof donneront des "object"

biensur ... la preuve ...

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
var valeur1
var valeur2
var unObj1 = function() {
   this.prop1 = valeur1;
   this.prop2 = valeur2;
   this.method1 = function() { alert('') }
}
var useObj = new unObj1();
 
 
var unObj2 = {
   prop1 : valeur1,
   propr2 : valeur2,
   method1 : function() { void(0) }
}
 
 
 
var unObj3 = new Object();
unObj3.prop1 = valeur1;
unObj3.prop2 = valeur2;
unObj3.method1 = function() {  };
 
 
alert(typeof unObj1)
alert(typeof unObj2)
alert(typeof unObj3)

[Willpower]

Code :

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

Les 3 typeof donneront des "object"

biensur ... la preuve ...

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
var valeur1
var valeur2
var unObj1 = function() {
   this.prop1 = valeur1;
   this.prop2 = valeur2;
   this.method1 = function() { alert('') }
}
var useObj = new unObj1();
 
 
var unObj2 = {
   prop1 : valeur1,
   propr2 : valeur2,
   method1 : function() { void(0) }
}
 
 
 
var unObj3 = new Object();
unObj3.prop1 = valeur1;
unObj3.prop2 = valeur2;
unObj3.method1 = function() {  };
 
 
alert(typeof unObj1)
alert(typeof unObj2)
alert(typeof unObj3)

Evidement, il a mal écrit son code, mais on peut déviner que ce qu'il voulait écrire c'était :

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
var makeObj = function() {
   this.prop1 = 1;
   this.prop2 = 2;
   //this.method1 = function() {  };
};
var unObj = new makeObj();
alert(typeof(unObj));
 
//-----
 
var unObj = {
   prop1 : 1,
   propr2 : 2
}
 
alert(typeof(unObj));
//-----
 
var unObj = new Object();
unObj.prop1 = 1;
unObj.prop2 = 2;
 
alert(typeof(unObj));

il a juste appelé le premier "useObj" au lieu de "unObj" à qui il avait déjà donné le nom de la fonction servant à le construire ... toi-même tu as changé les noms pour les appeler "unObj1" et "unObj2".

[nault]

Code :

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

1
2
3
4
5
6
 
var unObj = function(){...};
// ou
var unObj = new Object();
// ou
var unObj = {};

revien au même ; attache un objet vide a unObj
nb: pour le premier utiliser avec fonction(),
cré un object seulement si il est utilisé avec new comme dans ton exemple

pour :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
var unObj = new Object();
unObj.prop1 = 'valeur1'; // ou unObj['prop1'] = 'valeur1';
 
// ou
 
var unObj = {'prop1':'valeur1'};
 
//ou
 
var unObj = function() {
   this.prop1 = 'valeur1';
}

cest 3 methodes font pratiquement la meme choses comme la bien expliquer Willpower.

mais tu peux les mixer a ta guise

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
var humain = function(){
     this.planete = 'terre';
     this.age = 1;
 
    this.livreFavori = function(titre){
        this.livreFavori = titre
    }
}
var nault = new humain();
     nault.profession = 'programmeur'
     nault['couleurYeux'] = 'bleu'
     nault.livreFavori('c++ pour les null')

donc y a t'il une différence entre ces 3 facons de creer des objets

Oui la façon dont tu les déclare seulement, et par la suite comment tu va t'en servir, bien c'est à ta guise selon l'utilisé/fonctionnment qu'ils auronts

[Willpower]

Code :

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

1
2
3
4
5
6
 
var unObj = function(){...};
// ou
var unObj = new Object();
// ou
var unObj = {};

...

je dirai même plus (pour être précis et supprimer l’ambiguïté entre objet et fonction qui traîne depuis le début du thread)

Code :

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

1
2
3
4
5
6
var unObj = new(function(){})();
// ou
var unObj = new Object();
// ou
var unObj = {};

revient au même, attache un objet vide à unObj.

[Willpower]

je dirai même plus (pour être précis et supprimer l’ambiguïté entre objet et fonction qui traîne depuis le début du thread)

Code :

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

1
2
3
4
5
6
var unObj = new(function(){})();
// ou
var unObj = {};
// ou
var unObj = new Object();

revient au même, attache un objet vide à unObj.

Pour me citer moi-même, la différence entre la première et les 2 suivantes, c'est qu'en plus de pouvoir ré-instancier des objets ayant le même constructeur, dans la première ont peut executer du code dans la création de l'objet alors que la 2ème n'est qu'une série d'assignations de propriétés et de méthodes. (la 3ème étant moche car pareil que la 2 s'écrivant avec plus de caractères et aucune assignation directe n'est possible.)

Voila, tout est résumé ici.

ps:RomainVALERI, je ne vois pas de quoi tu parles. t'as recopié la première façon.


edit:

il existe aussi les trucs farfelus pour créer/copier (plus ou moins partiellement) les objets :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
var unObj1 = new (function(){this.prop1="auto";})();
alert(unObj1.prop1);
 
//-----
 
var unObj4 = new unObj1.constructor();
alert(unObj4.prop1)
 
 
makeObj5 = function(){};
makeObj5.prototype = unObj1;
var unObj5 = new makeObj5();
alert(unObj5.prop1);

[RomainVALERI]

ces 3 4 techniques de création d'objet :

Code javascript :

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

1
2
3
4
5
6
function unObj(valeur1, valeur2) {
   this.prop1 = valeur1;
   this.prop2 = valeur2;
   this.method1 = function() { /* code */ };
}
var useObj = new unObj();

...qui revient au même que la première de tes syntaxes, en l'occurrence : un constructeur, donc un objet Function.
D'où la nécessité de l'utilisation du "new" dont Willpower a déjà parlé.