> For the complete documentation index, see [llms.txt](https://docs.augelab.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.augelab.com/french/function-blocks/blocks-reference/data-logic/data-operations/dictionary-operations.md).

# Dictionary Operations

Ce bloc de fonction fournit une interface flexible pour créer, modifier, interroger et convertir des données de type dictionnaire pendant votre scénario. Sélectionnez une méthode depuis les contrôles et le bloc adaptera dynamiquement ses entrées et sorties pour correspondre à l'opération choisie.

## 📥 Inputs

Les entrées disponibles dépendent de la méthode sélectionnée. Le bloc change dynamiquement les sockets lorsque vous choisissez une méthode. Noms d'entrée courants que vous pouvez voir :

* `Dict` — Données du dictionnaire sur lesquelles opérer (lorsque requis)
* `Keys` — Clé unique (string) ou liste de clés pour la création
* `Values` — Valeur unique ou liste de valeurs pour la création
* `Input Dict` — Dictionnaire source pour les opérations update/remove/extend/get/copy
* `Key` — Chaîne clé utilisée pour update/remove/get
* `Value` — Valeur utilisée pour l'opération update
* `New Dict` — Dictionnaire à fusionner dans un dictionnaire existant (extend)
* `Text` — Texte JSON à parser (parse)
* `Dict` (pour conversion) — Dictionnaire à convertir en chaîne texte

## 📤 Outputs

Les sorties dépendent également de la méthode sélectionnée. Sorties typiques :

* `Dict` — Dictionnaire résultant après create/update/remove/extend/copy
* `Text` — Chaîne JSON résultante lors de la conversion en texte ou après parsing

Lorsque l'on utilise un get pour une clé unique, la sortie peut renvoyer directement la valeur demandée.

## 🕹️ Controls

`Select Method` Choisissez l'opération de dictionnaire souhaitée. Méthodes disponibles :

* `create`
* `update`
* `remove`
* `extend`
* `get`
* `copy`
* `parse`
* `to_string`

`Info` Zone de texte contextuelle affichant de l'aide et des exemples d'utilisation pour la méthode actuellement sélectionnée.

Remarque : changer `Select Method` mettra immédiatement à jour les sockets du bloc pour correspondre à l'opération choisie.

## 🎨 Features

* Sockets dynamiques : les entrées et sorties se mettent à jour automatiquement selon la méthode choisie pour afficher uniquement les champs pertinents.
* Gestion JSON rapide : parser du texte JSON en dictionnaire et convertir des dictionnaires en chaînes JSON avec des méthodes dédiées.
* Support de fusion et d'édition : mettre à jour des clés individuelles, supprimer des clés ou étendre un dictionnaire existant avec un autre dictionnaire.
* Support de copie : créer des copies sûres pour éviter des modifications involontaires en aval.
* Aide intégrée : des indications spécifiques à chaque méthode sont affichées dans la zone Info pour réduire les tâtonnements.

## ⚙️ Running mechanism

* Sélectionnez une méthode avec `Select Method` puis connectez les sockets qui apparaissent.
* Lorsque le scénario s'exécute, le bloc réalise l'opération sélectionnée sur les entrées fournies et renvoie les données résultantes sur les sockets de sortie correspondants.
* Si des entrées sont invalides pour l'opération choisie (par exemple longueurs de listes incompatibles pour create, clé manquante pour get/remove, ou chaîne JSON invalide pour parse), le bloc affichera un message d'erreur pour vous aider à corriger la configuration.

## 📝 Usage instructions

1. Ajoutez le bloc et cliquez sur `Select Method` pour choisir l'opération appropriée.
2. Connectez les sources aux sockets qui apparaissent (par exemple, connectez `Keys` et `Values` lors de l'utilisation de `create`).
3. Utilisez la zone `Info` pour des exemples rapides et des notes spécifiques à la méthode sélectionnée.
4. Exécutez le scénario et vérifiez les sorties sur les sockets correspondants.

## 💡 Tips and Tricks

* Persistance des valeurs : combinez avec `Data Memory` ou `Data Write Local` / `Data Write Global` pour garder les dictionnaires accessibles tout au long du scénario ou entre les exécutions.
* Débogage : utilisez `Debug Input` pour inspecter le contenu du dictionnaire pendant le développement.
* Flux JSON : associez `parse` à un `String Input` (pour du JSON manuel) ou à un bloc produisant du texte, puis utilisez le dictionnaire résultant en aval. Utilisez `to_string` avant de sauvegarder ou publier.
* Sauvegarde/export : après `to_string`, envoyez le texte vers `CSV Export` ou `File/Folder Operations` si vous devez stocker les résultats.
* Utilisation conditionnelle : vérifiez l'absence de clé en utilisant `Is None` après un `get` pour éviter les erreurs dans les blocs suivants.
* Mises à jour progressives : pour construire une configuration pas à pas, utilisez `extend` conjointement avec des lectures/écritures périodiques (`Data Read Local` / `Data Write Local`) pour conserver un dictionnaire maître.
* Manipulation de chaînes : utilisez `String Merge` ou `Find Substring` pour construire ou valider les clés/valeurs avant de les transmettre aux opérations update/create.

## 🛠️ Troubleshooting

* Mismatched lists on creation
  * Cause : `Keys` et `Values` ont des longueurs de liste différentes.
  * Solution : Assurez-vous que les longueurs des listes correspondent ou fournissez des paires clé/valeur uniques.
* Key not found on get/remove
  * Cause : La `Key` demandée n'existe pas dans l’`Input Dict` fourni.
  * Solution : Confirmez les clés à l'aide d'un affichage de debug ou effectuez une vérification sûre (par ex. vérifier l'existence avant d'appeler get/remove).
* Invalid JSON when using parse
  * Cause : Le `Text` fourni n'est pas du JSON valide (les guillemets doubles sont requis pour les clés/chaînes).
  * Solution : Validez votre texte JSON (utilisez `String Input` ou copiez depuis une source JSON valide). La zone `Info` montre un exemple de format.
* Unexpected shared changes
  * Cause : Les modifications en aval d'une référence de dictionnaire affectent d'autres blocs.
  * Solution : Utilisez `copy` ou combinez avec `Data Memory` pour contrôler si vous travaillez sur une copie ou sur l'original.

Si vous avez besoin de visualiser ou d'inspecter des images intermédiaires ou des valeurs lors du travail avec une logique pilotée par dictionnaires, pensez à connecter des blocs visuels ou d'export appropriés (par exemple `Show Image` pour des sorties image ou `CSV Export` pour des résultats journaux).