Discussion :

[Pandapi]

Bonjour,

J'aurais besoin de transformer un tableau classique tab[0], tab[1], etc... En tableau associatif tab['key1'], tab['key2'], etc...
Pour ça je vais sûrement utiliser une boucle qui parcourt le tableau, mais j'aurais aimé savoir s'il y avait besoin de créer un second tableau ou s'il était possible d'ajouter des clés à un tableau classique.
En gros je voudrais une fonction ou quelque chose comme : tab[0].addKey('key') qui transformerait le tableau afin que tab[0] et tab['key'] pointent au même endroit.

Voilà, j'ai cherché un peu mais le net fourmille de forums/pages qui parlent de la déclaration de tableaux associatifs et ça pollue la recherche, du coup j'ai du mal à trouver quelqu'un ayant déjà posé laquestion.

Petite précision, j'utilise jQuery, donc s'il n'existe pas de solution basique mais que jQuery en fournit une, ça me va également.

Merci d'avance pour votre aide.

[NoSmoking]

Bonjour,
sujet traité, entre autres, dans cette discussion.

[Pandapi]

Merci pour la réponse rapide.

D'après ce que je lis dans ce sujet, la personne ne transformait pas un tablau en tableau associatif mais elle avait besoin de transformer un tableau à deux dimensions en tableau d'objets.
Du coup ce n'est pas vraiment la même chose, moi je ne veux rien ajouter au tableau, toutes mes données sont là, je veux juste y accéder par des clés plutôt que par des numéros.
Je comptais faire comme ce qui est indiqué dans ce sujet, créer un nouveau tableau et lui ajouter les données avec des clés en parcourant l'ancien tableau, je me demandais juste s'il n'y avait pas une solution "clé en main" pour uniquement ajouter des clés.

[NoSmoking]

Tu récupères les clés où ?
Pourquoi ne pas passer par un objet JSON dans ce cas ?

Quoiqu'il arrive il te faudra parcourir le tableau, bien que tu puisses aissi passer par la méthode map() des Arrays.

As tu un exemple de données en entrée et la sortie que tu souhaites, pas sûr d'avoir bien saisi le but !

[Pandapi]

Bonjour à toi,

Alors en effet, le parcours du tableau sera là dans tous les cas, ce que je gagnerais en ayant une fonction permettant d'intégrer directement des clés, c'est de ne pas avoir à créer un tableau supplémentaire.

Pour expliquer plus en détail, j'ai une fonction qui me renvoie un tableau d'éléments, donc de la forme :

Code :

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

tab = ['x','y','z']

Ensuite j'ai une autre fonction qui me construit mes éléments <select> à partir d'un tableau associatif donc de la forme :

Code :

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

1
2
3
4
5
tab = {
key1: 'elem1',
key2: 'elem2',
key3: 'elem3'
}

qui donnera donc :

Code :

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

1
2
3
4
5
<select>
<option value='elem1'>key1</option>
<option value='elem2'>key2</option>
<option value='elem3'>key3</option>
</select>

J'aimerais donner en argument à la seconde fonction les données qui proviennent de la première, mais pour ce faire il faut les transformer car le tableau n'est pas associatif.
De plus, dans mon cas précis je vais utiliser les éléments comme clés (car la BD avec laquelle je travaille a des soucis de conception).
Donc il me faudrait à partir du tableau venant de la première fonction :

Code :

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

1
2
3
4
5
tab = {
x: 'x',
y: 'y',
z: 'z'
}

Alors je pourrais faire quelque chose qui ressemble à ce qui est fait dans le code du lien que tu m'a donné :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
var dataTab = fonction1();
var finalTab = new array();
tabLength = dataTab .length;
for(i = 0; i < tabLength ; i++)
{
    finalTab[dataTab[i]] = dataTab[i];
}
 
var mySelect = fonction2(finalTab);

Mais je voulais savoir pour mon information personnelle, et pour éviter des choses inutiles (même si elle ne pèse pas forcément beaucoup) s'il existait quelque chose du type :

Code :

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

1
2
3
4
5
6
7
8
9
 
var dataTab = fonction1();
tabLength = dataTab .length;
for(i = 0; i < tabLength ; i++)
{
    dataTab[i].addKey(dataTab[i]);
}
 
var mySelect = fonction2(dataTab);

Je ne sais pas s'il existe quelque chose qui s'apparenterait à une fonction addKey ou une opération d'insertion de clé, qui permet uniquement d'ajouter une clé à un élément du tableau. J'y gagne pas grand chose, juste la création d'un second tableau et j'évite l'affectation des couples key/data alors que j'ai déjà un tableau avec les data et que je veux seulement y ajouter des keys.

Voilà, j'ai détaillé en espérant que cela soit plus clair, mais en tous cas merci de l'aide.

[NoSmoking]

Tout d'abord on va arrêter de parler de tableaux associatifs pour parler d'objet.

...c'est de ne pas avoir à créer un tableau supplémentaire.

tu peux réutiliser le même il suffit d'une réaffectation par exemple

Code :

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

1
2
3
4
5
function transformeTableau( tableau){
   // du code pour un profond changement
  return new_Array;
}
monTableau = transformeTableau( monTableau);

le tout sachant que les Array sont passés par adresse tu peux tout à fait faire

Code :

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

1
2
3
4
5
6
7
8
var tab = ['un', 'deux', 'trois'];
function modifTableau( tableau){
  for( var i=0; i < tableau.length; i++){
    tableau[i] += ' après passage dans la fonction';
  }
}
modifTableau( tab);
// tab : >> un après passage dans la fonction,deux après passage dans la fonction,trois après passage dans la fonction

d'autres méthodes existent également map() notamment


Si en entrée on dispose de

Code :

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

1
2
3
4
5
6
var tabIndice = ['x','y','z'];
var tabObjet = {
    key1: 'elem1',
    key2: 'elem2',
    key3: 'elem3'
};

il est nécessaire de savoir exactement ce que l'on veut en retour car

• option #1 (sans grand intérêt)

Code :

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

1
2
3
4
5
6
7
8
var monObjet = {
    'key1': 'elem1',
    'key2': 'elem2',
    'key3': 'elem3'
    'x'   : 'x',
    'y'   : 'y',
    'z'   : 'z',
};

ou cette version
• option #2

Code :

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

1
2
3
4
5
var monObjet = {
    'key1' : { 'value' : 'elemen1', 'indice' : 'x' },
    'key2' : { 'value' : 'elemen2', 'indice' : 'y' },
    'key3' : { 'value' : 'elemen3', 'indice' : 'z' }
};

la démarche n'est pas la même.

Je ne sais pas s'il existe quelque chose qui s'apparenterait à une fonction addKey ou une opération d'insertion de clé, qui permet uniquement d'ajouter une clé à un élément du tableau.

dans ce cas on change la nature du tableau de départ, Array donc, en le faisant devenir un objet.

J'y gagne pas grand chose,

la manipulation d'un objet plutôt que d'un tableau, bien souvent plus clair dans le code.


Pour finir et sur base de l'option #2 voila une solution de code

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
var monObjet = {
  key1: 'elem1',
  key2: 'elem2',
  key3: 'elem3',
  key4: 'elem4'
}
var tabInd = ['x','y','z'];
 
/* transformation en obj de la forme
{
  'key1' : { 'value' : 'elemen1', 'indice' : 'x' },
  'key2' : { 'value' : 'elemen2', 'indice' : 'y' },
  'key3' : { 'value' : 'elemen3', 'indice' : 'z' },
  'key4' : { 'value' : 'elemen4', 'indice' : null}
};
*/
function objetAddKey( obj, tab, label){
  var objTmp = {},
      indice,
      valeur,
      key,
      count = 0;
 
  for( key in obj){
    // lecture valeur de la key
    valeur = obj[key];
    // lecture valeur à affecter
    // si on déborde vaudra undefined
    indice = tabInd[count++];
    // donc mis à null
    indice = indice ? indice : null;
    // si déjà un objet on ajoute la new key
    if( typeof obj[key] === 'object'){
      // copy de l'objet (ce n'est pas une copie en profondeur !)
      objTmp[key] = JSON.parse( JSON.stringify( obj[key]));
    }
    else{
      // sinon on crée le nouvel objet
      objTmp[key] = {};
      // affectation des key/value
      objTmp[key]['value'] = valeur;
    }
    // ajout nouvelle entrée
    objTmp[key][label] = indice;
  }
  return objTmp;
}
// ajout dans monObjet de la clé 'indice' associée à la valeur contenue dans tabInd (ordre des index)
monObjet = objetAddKey( monObjet, tabInd, 'indice');
 
console.log( monObjet);

[Pandapi]

Ok je vois, je ne pensais pas que la structure entre les deux types d'objets était si différente.
Du coup ce que je voulais faire n'est pas possible, merci pour les idées de solutions, je verrai celle que je préfère en temps voulu.
Et sinon, quand je disais que je n'y gagne pas grand chose, c'était dans l'exemple donné ici, car en réalité les pages sur lesquelles je travaille ont des soucis de temps de chargement, certaines peuvent mettre plusieurs minutes à se charger. C'est pour ça que je chipote même pour des coûts qui ne semblent pas forcément énormes.
Je passe le sujet en résolu.