Manipule les dictionnaires

dict append dictionaryVariable key ?string ...? 
dict create ?key value ...? 
dict exists dictionaryValue key ?key ...? 
dict filter dictionaryValue filterType arg ?arg ...?
   dict filter dictionaryValue key ?globPattern ...? 
   dict filter dictionaryValue script {keyVariable valueVariable} script 
   dict filter dictionaryValue value ?globPattern ...? 
dict for {keyVariable valueVariable} dictionaryValue body 
dict get dictionaryValue ?key ...? 
dict incr dictionaryVariable key ?increment? 
dict info dictionaryValue 
dict keys dictionaryValue ?globPattern? 
dict lappend dictionaryVariable key ?value ...? 
dict map {keyVariable valueVariable} dictionaryValue body 
dict merge ?dictionaryValue ...? 
dict remove dictionaryValue ?key ...? 
dict replace dictionaryValue ?key value ...? 
dict set dictionaryVariable key ?key ...? value 
dict size dictionaryValue 
dict unset dictionaryVariable key ?key ...? 
dict update dictionaryVariable key varName ?key varName ...? body 
dict values dictionaryValue ?globPattern? 
dict with dictionaryVariable ?key ...? body 

Cette commande permet de créer des dictionnaires, sortes de tableaux associatifs (array) sans nom, mais avec des fonctionnalités supplémentaires.

dict append dictionaryVariable key ?string ...?

Cette opération ajoute la chaîne (ou les chaînes) donnée(s) à la valeur de la clé donnée dans la valeur du dictionnaire contenue dans la variable donnée, en écrivant la valeur du dictionnaire résultante dans cette variable. Les clés inexistantes sont traitées comme si elles correspondaient à une chaîne vide. La valeur mise à jour du dictionnaire est renvoyée.

dict create ?key value ...?

Renvoie un nouveau dictionnaire contenant chacune des correspondances clé/valeur énumérées en tant qu'arguments (clés et valeurs alternées, chaque clé étant suivie de la valeur qui lui est associée).

dict exists dictionaryValue key ?key ...?

Cette fonction renvoie une valeur booléenne indiquant si la clé donnée (ou le chemin des clés à travers un ensemble de dictionnaires imbriqués) existe dans la valeur donnée du dictionnaire.

dict filter dictionaryValue filterType arg ?arg ...?

Cette fonction prend une valeur de dictionnaire et renvoie un nouveau dictionnaire qui contient uniquement les paires clé/valeur qui correspondent au type de filtre spécifié (qui peut être abrégé.) Les types de filtres pris en charge sont les suivants:

• dict filter dictionaryValue key ?globPattern …? La règle des clés ne s'applique qu'aux paires clé/valeur dont les clés correspondent à l'un des motifs donnés (à la manière de string match).
• dict filter dictionaryValue script {keyVariable valueVariable} script La règle de script teste la correspondance en affectant la clé à la variable clé et la valeur à la variable valeur, puis en évaluant le script donné, ce qui devrait donner une valeur booléenne (la paire clé/valeur n'étant incluse dans le résultat du filtre dict que lorsqu'une valeur vraie est renvoyée). Notez que le premier argument après le mot de sélection de la règle est une liste à deux éléments. Si le script renvoie une condition TCL_BREAK, aucune autre paire clé/valeur n'est prise en compte pour être incluse dans le dictionnaire résultant, et une condition TCL_CONTINUE équivaut à un résultat faux. Les paires clé/valeur sont testées dans l'ordre dans lequel les clés ont été insérées dans le dictionnaire.
• dict filter dictionaryValue value ?globPattern …? La règle de valeur ne s'applique qu'aux paires clé/valeur dont les valeurs correspondent à l'un des motifs donnés (à la manière de string match).

dict for {keyVariable valueVariable} dictionaryValue body

Cette commande prend trois arguments, le premier étant une liste de noms de variables à deux éléments (pour la clé et la valeur respectivement de chaque correspondance dans le dictionnaire), le deuxième étant la valeur du dictionnaire à parcourir et le troisième étant un script à évaluer pour chaque correspondance avec les variables clé et valeur définies de manière appropriée (à la manière de foreach.) Le résultat de la commande est une chaîne vide. Si une évaluation du corps génère un résultat TCL_BREAK, aucune autre paire du dictionnaire ne sera itérée et la commande dict for se terminera immédiatement avec succès. Si une évaluation du corps génère un résultat TCL_CONTINUE, celui-ci sera traité exactement comme un résultat TCL_OK normal. L'ordre d'itération est l'ordre dans lequel les clés ont été insérées dans le dictionnaire.

dict get dictionaryValue ?key ...?

Étant donné une valeur de dictionnaire (premier argument) et une clé (deuxième argument), cette commande récupère la valeur de cette clé. Lorsque plusieurs clés sont fournies, la commande se comporte comme si le résultat de dict get $dictVal $key était transmis comme premier argument à dict get, les autres arguments étant les deuxièmes (et éventuellement les suivants). Cela facilite les recherches dans les dictionnaires imbriqués. Par exemple, les deux commandes suivantes sont équivalentes :

dict get $dict foo bar spong
dict get [dict get [dict get $dict foo] bar] spong

Si aucune clé n'est fournie, le dict get renverra une liste contenant des paires d'éléments de la même manière que pour array get. En d'autres termes, le premier élément de chaque paire sera la clé et le second élément sera la valeur de cette clé.

Tenter de récupérer une valeur pour une clé qui n'est pas présente dans le dictionnaire est une erreur.

Création d'un dictionnaire :

set le_dico [dict create k1 v1 k2 v2 k3 v3]

Faute de dictionnaire, on aurait dû créer un tableau au moyen de la commande

array set le_tableau {k1 v1 k2 v2 k3 v3}

Récupération de la valeur “v2” associée à la clé “k2” :

puts [dict get $le_dico k2]   ;# -> v2

Ajout de la clé k4 associée à la valeur v4 dans le dictionnaire :

dict set le_dico k4 v4        ;# k1 v1 k2 v2 k3 v3 k4 v4

Modification le la valeur associée à la clé k3 :

dict set le_dico k3 v3n       ;# k1 v1 k2 v2 k3 v3n k4 v4

Suppression de la clé k2 (et de sa valeur associée)

dict unset le_dico k2        ;# k1 v1 k3 v3n k4 v4

Liste des clés

puts [dict keys $le_dico]    ;# -> k1 k3 k4
puts [dict keys $le_dico *3] ;# -> k3

Une valeur-liste

dict lappend k5 v5           ;# k1 v1 k3 v3n k4 v4 k5 v5
dict lappend k5 v5a v5b      ;# k1 v1 k3 v3n k4 v4 k5 {v5 v5a v5b}

Si une procédure doit accéder à un dictionnaire sans le modifier, on peut passer sa valeur. Avec un tableau, il faut toujours passer le nom :

proc get_val_dico {dico k} {return [dict get $dico $k]}
proc get_val_array {arrayName k} {upvar $arrayName array; return $array($k)}
puts [get_val_dico $le_dico k3]     ;# -> v3n
puts [get_val_array le_tableau k3]  ;# -> v3

array