Discussion :

[Trebly]

Bonjour,

Quelle méthode, quelle pratique utiliser pour effectuer, au mieux l'opération suivante :
- Construire un objet global (objet hiérarchisé et tableaux (array) d'objets), à partir de l'appel répété à des fonctions.

Explication du problème :

• Un objet global contient en particulier des tableaux d'objets.
• Des fonctions construisent les objets qui seront des éléments des tableaux.
• Les appels répétés aux différentes fonctions construisent l'objet global

Note : Le mieux est (sera) d'utiliser un (des) constructeurs inclus dans l'objet. Cependant la conception d'origine, plus éclatée, fait appel à des fonctions séparées. Une mise en ordre doit précéder la construction de l'objet global (une API comprenant une trentaine de fonctions, 1500 lignes de code).

Il serait, me semble-t-il, assez adapté d'utiliser une structure du type :

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 myfunction = function () {
     var local_obj = new Obj();
 
     local_obj.data = "toto"; // Valeur provenant d'une source quelconque
     local_obj.ref_obj2 = a_ref_to_an_obj2; // Une référence à un objet externe (connu de manière externe ou objet-paramètre
     ...
 
     // Quand la construction de local_obj est terminée on va assigner local_obj à l'objet global
     // Nous supposons qu'il existe un tableau "global_obj.les_obj[]" qui contient des objets Obj()
     // on écrirait alors en fin de procédure :
     global_obj.mes_obj.push(new Obj());
     global_obj.mes_obj[global_obj.les_obj.length -1] = Object.assign({},local_obj);
}
myfunction();

Note : lorsque local_obj est assigné les valeurs sont copiées pendant que les références sont aussi copiées , mais pas leur contenu (ce qui est recherché)

Une autre manière de procéder serait d'utiliser le passage de l'objet à renseigner en paramètre :

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 myfunction = function (local_obj) {
 
     local_obj.data = "toto"; // Valeur provenant d'une source quelconque
     local_obj.ref_obj2 = a_ref_to_an_obj2; // Une référence à un objet externe (connu de manière externe ou objet-paramètre
     ...
}
 
 
     // Nous supposons qu'il existe un tableau "global_obj.mes_obj[]" qui contient des Obj()
    // Le corps de l'appelant est alors :
 
     global_obj.mes_obj.push(new Obj());
 
     myfunction(global_obj.mes_obj[global_obj.mes_obj.length -1]);

Mon point de vue :
La seconde forme peut paraitre plus simple, mais dans le cas où une gestion d'erreur est nécessaire, la première forme est plus ouverte, plus souple, plus sure, plus fiable.
La première forme utilise des variables locales pour les calculs alors que la deuxième utilise l'objet global.
Dans la première forme il est possible d'effectuer après construction de l'objet des test de cohérence des données générées avant l'assignation à l'objet global.

Qu'en pensez-vous ?(il y a-t-il des erreurs dans le code type proposé ?)

Merci d'avance

Trebly

[SpaceFrog]

As tu regardé du coté des fonction arrows ?

[danielhagnoul]

Sous réserve d'avoir compris la question (j'ai un vrai doute), je pense au code suivant :

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
let
  ObjGlobal = {
    arObjs : [],
    insertObj( obj ){
      ObjGlobal.arObjs.push( Object.assign( {}, obj ) );
    }
  },
  ObjExistant = {
    data : "Hello",
    value : 4
  };
 
// debug
console.log( Reflect.ownKeys( ObjExistant ) );
console.log( Reflect.getOwnPropertyDescriptor( ObjExistant, "data") );
 
// création de NouvelObj
let NouvelObj = {
  data : "Bonjour",
  refVersObjExistant : ObjExistant
}
 
// debug
console.log( Reflect.ownKeys( NouvelObj ) );
console.log( Reflect.getOwnPropertyDescriptor( NouvelObj, "refVersObjExistant") );
 
// insertion de NouvelObj
ObjGlobal.insertObj( NouvelObj );
 
//debug
console.log( Reflect.ownKeys( ObjGlobal ) );
console.log( Reflect.getOwnPropertyDescriptor( ObjGlobal, "arObjs") );

[Trebly]

Bonjour,

Merci des réponses.

Désolé j'étais absent.

danielhagnoul semble bien répondre à la question pour l'intégration de l'opération dans le prototype.

Je suis en cours de test, mais plusieurs plats sur le feu.

Le sujet n'est pas clos je reviens.

cordialement;

Trebly