web-dev-qa-db-fra.com

Tableau d'objets vs objet d'objets

La question est de décider des compromis entre les notations suivantes:

Basé sur JSON:

"users": {
    "id1": {
        "id": "id1",
        "firstname": "firstname1",
        "lastname": "lastname1"
    },
    "id2": {
        "id": "id2",
        "firstaame": "firstname2",
        "lastname": "lastname2"
    }
}

Basé sur les tableaux:

users: [
    {
        "id": "id",
        "key2": "value2",
        "key3": "value3"
    },
    {
        "id": "id",
        "key2": "value2",
        "key3": "value3"
    }
]

En ce qui concerne this post sur le même problème, j’ai décidé (sur le front-end) d’utiliser la notation objet JSON au lieu d’un tableau d’objets, car cela convient à mes besoins, à de meilleures performances et à moins de code dans le navigateur.

Mais le problème est que la liste elle-même n'est pas statique. J'entends par là que la liste est générée, c'est-à-dire récupérée/stockée depuis la base de données (NoSQL) et créée pour les nouvelles entrées via une API Java sur le serveur. Je ne suis pas en mesure de décider de la notation à utiliser en bout de chaîne (ce qui finira par affecter également l'interface utilisateur). 

Toute pensée/suggestion sur les performances, la maintenabilité ou l’évolutivité est appréciée.

javaarraysjsonperformancemaintainability
46
me_digvijay

C'est une question d'opinion totale. Il pourrait y avoir beaucoup d'autres points, mais je peux préciser que ci-dessous.

Approche basée sur JSON: Si je ne me trompe pas, elle sera implémentée en utilisant Map du côté serveur.

Avantage: En JavaScript, vous pouvez directement utiliser users.id1, ​​users.id2, c.-à-d. Pas besoin d'itération

Inconvénient: Côté client, vous aurez besoin des identifiants présents dans votre JSON, c’est-à-dire soit en les codant en dur, soit en utilisant une approche dynamique qui vous indiquera quel identifiant est présent dans votre JSON.

Approche basée sur les tableaux: Si je ne me trompe pas, cela sera implémenté en utilisant Array/List du côté serveur.

Avantage:

  1. Du côté du client, vous pouvez parcourir directement un tableau, sans Vous inquiéter à l’avance quant à quel identifiant y est présent, c’est-à-dire sans codage dur
  2. Comme indiqué par @JBNizet , une approche basée sur les tableaux maintiendra l'ordre.

Inconvénient: Si vous voulez récupérer un identifiant unique, vous devrez parcourir le tableau.

En général, nous n'envoyons pas beaucoup d'informations côté client. Une approche basée sur les baies ne créera donc aucun problème. Et transformer un tableau en carte est possible à la fois du côté du serveur et du client si vous voulez une approche basée sur un id.

18
Naman Gala

Du côté du serveur, les tableaux sont stockés sous forme de listes simples: ArrayList<Content>, tandis que les objets sont stockés sous forme de cartes: HashMap<String, Content> ou, le plus souvent, sous forme d'objets Java.

Pour convertir des entités Java en JSON, vous pouvez jeter un coup d'œil au projet Jackson qui fait tout cela pour vous.

Je ne m'inquiéterais pas des différences de performance entre ces deux variantes. Il est plus important de disposer d'une API sémantique compréhensible. Vous devez donc vous baser sur l'analyse de rentabilisation plutôt que sur les performances.

En regardant votre exemple, je pense qu'un Array est la meilleure approche, car vous voulez renvoyer une liste d'utilisateurs qui sont tous égaux. Envoyer l'ID deux fois n'a aucun sens et augmente la quantité de données à transmettre.

De plus, étant donné que les noms Arrays sont beaucoup plus simples à stocker et à itérer en Java, ils devraient également offrir de meilleures performances que les objets.

Quelques différences générales:

  • Les tableaux préservent l'ordre
  • Les tableaux peuvent contenir des entrées en double
  • Les objets ont souvent une surcharge de stockage/réseau
  • Les tableaux sont plus rapides à itérer (côté serveur)
6
maja

Un des gros inconvénients de votre première notation "basée sur JSON" est que certains frameworks ont des problèmes avec la (dé) sérialisation de ce problème. Par exemple, DataContractSerializer (C # .NET) attend que les champs id1 et id2 soient définis (codés en dur) dans la classe de vos objets users. Je ne sais pas si cela s'applique également à certains frameworks Java. Peut-être que le framework que vous utiliserez pourra le désérialiser sous forme de HashMap.

Globalement, je trouverais la notation de tableau beaucoup plus intuitive pour travailler avec itération, etc.

1
Sebastian

Vous pouvez utiliser object[property]notation pour accéder aux propriétés d'un objet en JavaScript ou les définir.

Choisissez l’approche basée sur un tableau au niveau du serveur principal et convertissez le tableau en une carte (basé sur JSON comme vous l’appelez) au début du processus.

var list = [{id: "id1", value: "One"}, {id: "id2", value: "Two"}]
var map = {};
list.forEach(function (item) { map[item.id] = item });
map.get("id1")

Si votre liste change, vous pouvez obtenir la nouvelle liste depuis le backend et mettre à jour votre carte dans l'interface utilisateur.

De cette façon, votre système est plus rapide à répondre car il n’est pas nécessaire de convertir une liste en carte. Votre interface effectuera une O(n) itération une fois sur la liste pour la convertir en carte. Mais c’est un petit prix comparé à O(n), que vous devrez payer chaque fois que vous effectuez une recherche dans une liste.

Si vous voulez récupérer principalement vos données à l’arrière, utilisez basé sur JSON sur le système proprement dit (vous pouvez utiliser LinkedHashMap pour préserver l’ordre).

0
Foxx

Les deux approches ont leurs avantages et inconvénients et dépendent de ce que vous regardez.

L'approche de type array est facile à sérialiser et est plus conviviale pour le framework (vous pouvez ajouter des beans à une liste et sérialiser la liste et vous avez terminé). Cela permet, par exemple, à un conteneur Web de renvoyer la réponse sans nécessiter de personnalisation. Cela sera probablement pris en charge immédiatement par la plupart des frameworks.

D'autre part, l'approche basée sur les objets est plus difficile à générer (en termes relatifs), mais elle est plus facile à rechercher étant donné que la clé est connue.

Donc, pour faciliter l'implémentation (par producteur), optez pour l'approche basée sur les tableaux. Pour la facilité d'utilisation (consommée par les clients), optez pour une approche basée sur les objets.

0
Ravindra HV