Qu'est-ce qu'un mappage dans Solidity et comment stocke-t-il les paires clé-valeur ?

Comprendre les mappages dans Solidity

1. Un mappage dans Solidity est un type de référence utilisé pour stocker des données sous la forme de paires clé-valeur, similaires aux tables de hachage ou aux dictionnaires dans d'autres langages de programmation. Il permet aux développeurs d'associer une clé unique à une valeur spécifique, permettant ainsi des recherches et des mises à jour efficaces.

2. La syntaxe pour déclarer un mappage est mapping(keyType => valueType) , où keyType peut être presque n'importe quel type élémentaire tel que uint, adresse ou octets, mais pas de types de référence comme des tableaux ou d'autres mappages. Le valueType peut être n’importe quel type, y compris des structures, des tableaux ou même un autre mappage.

3. Les mappages sont déclarés dans les contrats et sont généralement utilisés pour gérer les variables d'état. Parce qu’ils sont stockés, leurs valeurs persistent dans les appels de fonction et les transactions.

4. L’une des caractéristiques déterminantes des mappages est qu’ils ne peuvent pas être itérés. Il n'existe aucun mécanisme intégré pour récupérer une liste de clés ou de valeurs. Cette limitation provient du fonctionnement du modèle de stockage d'Ethereum : les mappages sont conçus pour un accès rapide par clé, et non par énumération.

5. Lorsqu'un mappage est créé, toutes les clés possibles sont initialisées avec la valeur par défaut du valueType (par exemple, 0 pour les entiers, false pour les booléens). Cela signifie que l'accès à une clé inexistante renvoie la valeur par défaut plutôt que de générer une erreur.

Mécanisme de stockage derrière les mappages

1. Les mappages ne stockent pas les données dans un format de tableau traditionnel. Au lieu de cela, Solidity utilise la fonction de hachage keccak256 pour calculer dynamiquement les emplacements de stockage. Chaque clé est hachée à l'aide de keccak256 ainsi que la position de l'emplacement de stockage de la variable de mappage.

2. Pour un mappage de variable d'état situé dans l'emplacement de stockage n , la valeur associée à une clé donnée est stockée dans keccak256(key . slot) , où '.' désigne la concaténation. Cela garantit que chaque clé correspond à un emplacement de stockage unique et déterministe.

3. Étant donné que la fonction de hachage est à sens unique, il est informatiquement impossible de procéder à une ingénierie inverse des clés qui ont été définies. Cela contribue à l’incapacité d’itérer sur les mappages.

4. Les mappages imbriqués suivent le même principe. Dans un mappage comme mapping(address => mapping(uint => bool)), l'emplacement du mappage interne est déterminé en hachant la clé externe et l'emplacement du mappage externe, puis en utilisant ce résultat comme base pour la recherche de clé interne.

5. Cette disposition de stockage basée sur le hachage rend les mappages très efficaces pour les opérations de lecture et d'écriture, qui s'exécutent toutes deux en temps constant, quel que soit le nombre d'entrées.

Cas d'utilisation pratiques dans les contrats intelligents

1. Une utilisation courante des mappages consiste à suivre les soldes des utilisateurs dans les jetons ERC-20. Un mappage tel que mapping(address => uint256) private _balances permet une récupération et une mise à jour rapides des avoirs en jetons pour n'importe quelle adresse de portefeuille.

2. Les systèmes de contrôle d'accès utilisent souvent des mappages pour identifier les rôles ou les autorisations. Par exemple, mapping(address => bool) public isAdmin peut vérifier efficacement si une adresse dispose de privilèges administratifs.

3. Dans les bourses décentralisées ou les marchés NFT, les mappages lient les identifiants de commande ou les identifiants de jeton à des données structurées telles que le prix, le propriétaire ou le statut de cotation. Cela permet une recherche instantanée des détails des transactions sans analyser de grands ensembles de données.

4. Les mappages sont également utilisés pour empêcher les attaques de réentrance en marquant les adresses lors de l'exécution de la fonction. Un simple mapping(address => bool) private entré peut agir comme un mécanisme de verrouillage.

5. En raison de leurs modèles d'accès économes en gaz, les mappages sont préférés aux baies lorsque des recherches fréquentes par identifiant sont requises, en particulier dans les protocoles à haut débit.

Foire aux questions

Les mappages peuvent-ils être entièrement supprimés ? Oui, l'utilisation du mot-clé delete sur un mappage efface toutes les entrées en réinitialisant chaque emplacement écrit à sa valeur par défaut. Toutefois, étant donné que les mappages sont virtuellement initialisés avec des valeurs par défaut pour toutes les clés, cette opération n'affecte que les clés explicitement attribuées.

Est-il possible de renvoyer un mappage à partir d'une fonction ? Non, les mappages ne peuvent pas être renvoyés directement à partir des fonctions car ils ne sont pas des types de retour valides dans Solidity. Seules les valeurs spécifiques accessibles via une clé peuvent être renvoyées.

Des chaînes ou des tableaux dynamiques peuvent-ils être utilisés comme clés de mappage ? Les tableaux de chaînes et d’octets dynamiques ne peuvent pas être utilisés comme clés de mappage. Seuls les types de données de taille fixe tels que bytes32, uint et adresse sont autorisés. Les chaînes doivent être converties dans un format de taille fixe comme bytes32 si nécessaire.

Comment les cartographies affectent-elles les coûts du gaz ? La lecture d'un mappage avec une clé non initialisée consomme moins de gaz puisqu'elle renvoie la valeur par défaut sans modifier le stockage. L'écriture ou la mise à jour d'une valeur entraîne un gaz plus élevé, surtout si elle change une valeur nulle en une valeur non nulle, en raison des règles de coût de croissance de l'État d'Ethereum.