Discussion :

[topolino]

Bonjour,

Je suis en train de chercher la meilleur facon de faire pour mettre à jour un tableau d'object (cache) par rapport à un autre tableau d'objet contenant que les objets et proprietes mis à jour..
Cette operation est faite plusieurs fois par seconde.

Merci pour vos conseils

[SpaceFrog]

un opérateur magique

Code :

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

=

ou alors explicite mieux ta problématique

t0 A = objet , B= objet , A = B

t1 => modif A , ( A != B )

t2 => A=B , (A == B)


Tu ne dis pas si les deux objets ont la même strucutre au départ
Si ils ne l'ont pas il faudra boucler sur les propriété communes pour mettre a jour

[topolino]

Le premier tableau me sert de cache. le champ Id est ma cle primaire.

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
 
{"objets": [
        {
            "Id": 1,
            "champ2": "my valeur",
            "champ3": 2,
            "champ4": 3,
            "champ5": 4
        },
        {
            "Id": 2,
            "champ2": "my valeur2",
            "champ3": 22,
            "champ4": 32,
            "champ5": 42
 
        },
        {
            "Id": 3,
            "champ2": "my valeur3",
            "champ3": 23,
            "champ4": 33,
            "champ5": 43
 
        }
    ]
}

Plusieurs fois par seconde je recois les mis à jour que des champs modifiés avec toujours le champ Id pour savoir quel objet a ete modifié.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
{"objets": [
        {
            "Id": 1,
            "champ3": 2,
            "champ5": 4
        },
        {
            "Id": 3,
            "champ2": "my valeur3",
        }
    ]
}

Il faut que je mette à jour mon tableau de cache avec les nouvelles valeurs. Je cherche une autre methode plus efficace que de faire une iteration sur tous les objets et leurs champs respectifs.

[SpaceFrog]

je pense que tu peux chercher longtemps ...
sauf a faire des objets par référence, mais cela implique la mise à jour immédiate, la modification de A implique la modification par référence de B

[lysandro]

Deux options auxquelles je pense (pour la mise à jour globale) :
1- utiliser une table de références croisées (grossiérement le principe, aucun controle) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 // après avoir constitué le tableau des objets en cache (= cache)
var xref = new Object();
cache.forEach(function(object,rank){
  xref[object.id]=rank;
}
...
// à la mise à jour (tableau des objets à mettre à jour = maj)
maj.forEach(function(changed_object,k,o){
  var cached_objet = cache[xref[changed_object.id]];
  // mettre à jour
});

Supporte la suppression, et l'insertion à condition à mettre à jour les références croisées

2- Il est aussi possible de trier le tableau de cache sur les ids, et d'implémenter une recherche dichotomique pour la mise à jour

[SpaceFrog]

Je cherche une autre methode plus efficace que de faire une iteration

foreach ...
si c'est pas de l'itération

[lysandro]

Euh pas d'itération sur les éléments à mettre à jour ? Là ça devient compliqué - je n'avais pas compris ça désolé

[SpaceFrog]

complique ou comique ^^
donc à par le partage de référence ...

[lysandro]

Je pensais qu'il recevait ses màj par json (pure spéculation de ma part) dans ce cas le partage de référence c'est possible ?

[SpaceFrog]

a partir du moment ou les objets sont construits avec un système de référence, la modif de l'objet de base implqiue la mise à jour simultanée de tous les autres

[topolino]

Je recois effectivement les mise à jour en Json.

• Peux tu m'en dire plus sur les references croisé ? Je ne connais pas.
• SpaceFrog, par le partage de reference ? c'est a dire. As tu un petit example.

Vous m'avez perdu la !!!

Sinon le code proposé m'a l'air pas mal

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
// après avoir constitué le tableau des objets en cache (= cache)
var xref = new Object();
cache.forEach(function(object,rank){
  xref[object.id]=rank;
}
...
// à la mise à jour (tableau des objets à mettre à jour = maj)
maj.forEach(function(changed_object,k,o){
  var cached_objet = cache[xref[changed_object.id]];
  // mettre à jour

[SpaceFrog]

en parlant de référence, je pensais a un truc dans ce genre là
http://snook.ca/archives/javascript/javascript_pass
ou
http://stackoverflow.com/questions/7...-in-javascript

[lysandro]

@SpaceFrog: J'aime assez le deuxième lien ça me rappelle un discussion sur le passage par référence ou par valeur ...
Je me suis creusé la tête, je pensais que tu voulais parler de truc comme DDO ...

@topolino: Bin pas trop, j'ai oublié tout ça, il ne m'en reste guère que ce que je t'ai montré, simplement utiliser un objet comme table faisant le lien entre Id et rang dans le tableau.

Cela étant, l'idée de références de SpaceFrog, enfin telle que je la comprends, est sans doute plus intéressante. La vision que j'en ai serait de centraliser tes objets dans une structure comme ton cache, mais pas comme un tableau, comme objet pour avoir un accés par Id. Et d'utiliser cette structure pour accéder à tes objets. Un peu comme le 'document.getElementById' du DOM. Cela reviendrai à avoir un objet simple var tousMesObjets = Object.create(null); dans le quel tu stockerais tes objets juste aprés leur création tousMesObjets[monObjet.Id] = monObjet; et ce serait le point central pour lire ou écrire un objet. Si l'objet n'existe pas dans la structure !(monObjet.Id in tousMesObjets), tu le crée et tu le stockes. Sinon tu le mets à jour. Et quand tu as besoin d'un objet, tu viens le lire dans la structure monObjet = tousMesObjets[Id];. Le point important est qu'une fois créé, tu ne changes jamais la référence de l'objet. Pour un Id existant dans tousMesObjets ne jamais faire tousMesObjets[monObjet.Id] = nouvelObjet;. Comme ça tu ne mets à jour qu'une fois ton objet, et toutes les références sont à jour aussi puisque tu travailles sur le même objet au final.

Enfin, c'est ce que j'ai compris ...

[SylvainPV]

D'après moi, le problème vient du JSON de base. Si "Id" représente un champ unique pour chaque objet, pourquoi utiliser une Array et pas une hashmap ? Ceci me paraît à la fois plus court et plus simple :

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
{  "objets": {
    1: {        
        "champ2": "my valeur",
        "champ3": 2,
        "champ4": 3,
        "champ5": 4
    },
    2: {       
        "champ2": "my valeur2",
        "champ3": 22,
        "champ4": 32,
        "champ5": 42
    },
    3:   {
		"champ2": "my valeur3",
        "champ3": 23,
        "champ4": 33,
        "champ5": 43
    }
  }
}

[topolino]

Tu penses que cela est beaucoup plus performant ?

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
var cache = {
	"1": {        
		"champ2": "my valeur",
		"champ3": 2,
		"champ4": 3,
		"champ5": 4
	},
	"2": {       
		"champ2": "my valeur2",
		"champ3": 22,
		"champ4": 32,
		"champ5": 42
	},
	"3":   {
		"champ2": "my valeur3",
		"champ3": 23,
		"champ4": 33,
		"champ5": 43
	}
};

Les mises à jour concernent que les champs et id à changer.

Les JSON entrant peuvent ressembler à ca:

Code :

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

1
2
3
4
5
6
7
8
9
var newData = {
	"2": {       
		"champ2": "new my valeur2"
	},
	"3":   {
		"champ4": 333333,
		"champ5": 333343
	}
};

Les mises à jour

Code :

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

1
2
3
4
5
6
7
Object.keys(newData).forEach(function(key) {
    	Object.keys(newData[key]).forEach(function(key2) {
		console.log(cache[key][key2]);
		cache[key][key2] = newData[key][key2];
		console.log(cache[key][key2]);
    	});
});

C'est bien ta logique ?

[topolino]

Est ce optimisé a votre avis ?

[lysandro]

Je n'ai pas fait de bench sur ES5, mais en ES3 pour les moteurs que j'avais testé, applicable à ton code :
- l'appel de fonction est couteux, si on peu s'en passer c'est mieux
- maintenir une référence est mieux que de la recalculer à chaque fois
Ca dépend des implémentations et des optimisations.

Comme je n'ai pas peur des comparaisons capillotractées, je dirais que la programmation connait aussi son principe d'incertitude : passé un certain seuil, il n'est pas possible d'optimiser à la fois la taille et la vitesse du code. Dans ton cas, ce n'est pas la taille qui compte.

[SylvainPV]

Je pensais à un jQuery.extend ou similaire. J'utilise cette fonction pour merger des objets sans passer par Object.keys :

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
function merge(base, ext){
    if(ext instanceof Object){
        for(var p in ext){
            if(ext.hasOwnProperty(p)){
                if(base.hasOwnProperty(p)){
                    if(base[p] instanceof Object){
                        merge(base[p], ext[p]);
                    }
                } else {
                    base[p] = ext[p];
                }
            }
        }
    }
    return base
}
 
merge(cache, newData);

C'est assez rapide pour moi, mais on doit sans doute pouvoir faire mieux si tu tiens à avoir une formule 1

[topolino]

Dans ce projet je n'utilise pas Jquery (enfin au minimum), je fais de l'angularJS.
Il me faut une formule1, c'est pour ca que j'essaye d'optimiser le JSON et le javascript (raw).

[SylvainPV]

Euh à mon avis si AngularJS te convient en performances, alors cette fonction devrait parfaitement faire l'affaire également.