Utilisation des listes

En Tcl, l'aquisition du fonctionnement des listes pour manipuler les chaines de charactère est indispensable.

Vous pouvez manipuler des listes de plusieurs manières :

lindex

La commande lindex permet de récuperer un des éléments d'une listes.

Syntaxe

lindex $variable <valeur>

Exemple

bind pub - !kiss pub:kiss
proc pub:kiss {nick host hand chan arg} {
   set cible [lindex $arg 0]
   if { $cible ne "" } {
      puthelp "PRIVMSG $chan :$nick fait un gros bisous a $cible"
      return 0
   } else {
      puthelp "PRIVMSG $chan :Il semblerai bien que $nick se fasse un bisou a lui même"
      return 0
   }
}

Comme vous l'avez sans doute deviné, ici, notre variable cible aura pour valeur ce que la personne aura écrit après !kiss (en l'occurence, un pseudo, normalement).

lrange

La commande lrange permet de récuperer plusieurs éléments d'une listes.

Contrairement a la méthode lindex donc, ont peut récuperer plusieurs choses.

Syntaxe

lrange $variable <debut> <fin>

debut et fin peuvent être des nombres ou une constante TCL comme end.

Exemple

bind pub - !kick pub:kick
proc pub:kick {nick host hand chan arg} {
   set arg [split $arg]
   set kick(pseudo) [lindex $arg 0]
   set kick(raison) [lrange $arg 1 end]
   if { $kick(pseudo) ne "" && $kick(raison) ne "" } {
      puthelp "KICK $chan $kick(pseudo) :$kick(raison) par $nick"
      return 0
   } else {
      puthelp "NOTICE $nick :Syntaxe : !kick <pseudo> <raison>"
      return 0
   }
}

Ce bout de code vous permet donc de kicker un pseudo. lrange intervient donc dans la variable kick(raison).

Astuce

Comme valeurs sur lindex et sur lrange, vous pouvez utilisez end, end-1 (l'avant dernier élément), ...

llength

La commande llength permet de retourner le nombre d'élément d'une liste.

Syntaxe

llength $variable

Exemple

bind pub - !compte pub:compte
proc pub:compte {nick host hand chan arg} {
   set chaine [lrange [split $arg] 0 end]
   if { $chaine ne "" } {
      puthelp "PRIVMSG $chan :Je compte [llength $chaine] mot dans la chaine \"$chaine\""
      return 0
   } else {
      puthelp "NOTICE $nick :Syntaxe incorrecte : !compte <phrase>"
      puthelp "NOTICE $nick :Cette commande permet de compter le nombre de mot dans une phrase (elle compte aussi les signes de ponctuactions."
      return 0
   }
}

Ce script tcl permet donc de compter le nombre de mot dans une chaine de charactère.

lappend

La commande lappend permet d'ajouter un élément à une liste.

Syntaxe

lappend <variable> <chaine>

Exemple

set machin [list "salut" "ca"]
lappend machin "va ?"
putlog $machin

$machin aura pour valeur "salut ca {va ?}". L'utilisation de cette commande est très simple, mais peut s'avérer utile lorsque que vous manipulez de longues chaines.
Attention : "lappend machin" et non "lappend $machin".

linsert

La commande linsert permet d'insérer dans une variable contenant une chaine de charactère un/des valeur qui peuvent être des mots, des nombres ...

Syntaxe

linsert <variable> <position> <chaine>

Exemple

set variable "salut ca va ?"
linsert $variable 1 "est-ce-que"
putlog $variable

Donc $variable aura au finant comme valeur "salut est-ce-que ca va ?".

list

La commande list permet d'enregistrer dans une variable plusieurs informations sous forme de liste (organisée).

Syntaxe

set <variable> [list <arguments>]

Exemple

set machin [list {salut} {ca} {va}]

Si vous essayer d'afficher $machin, il vous affichera "salut ca va". En revanche, si vous l'utilisez dans une boucle, ce qui est préférable, il vous traitera les valeurs de la variable les unes après les autres.

lsort

La commande lsort permet de classer une liste par ordre alphabetique.

Syntaxe 1 :

lsort $variable

Exemple :

set bidule [list {z} {y} {x} {w} {v} {u} {t} {s} {r} {q} {p} {o} {n} {m} {l} {k} {j} {i} {h} {g} {f} {e} {d} {c} {b} {a}]
set bidule [lsort $bidule]
putlog $bidule

Ce code tcl vous remet la liste des lettres de l'alphabet dans l'ordre.

Exemple 2 :

bind pub - !ordre pub:ordre
proc pub:ordre {nick host hand chan arg} {
   set phrase [lrange $arg 0 end]
   set phrase [split $phrase " "]
   set phrase [lsort $phrase]
   if { $phrase ne "" } {
      puthelp "PRIVMSG $chan :Voici votre phrase organiser dans l'ordre alphrabetique :"
      puthelp "PRIVMSG $chan :$phrase"
      return 0  
   } else {
      puthelp "NOTICE $nick :Syntaxe : !ordre <phrase>"
      return 0
   }
}

Ce code permet de vous retranscrire se que vous lui avez donner dans l'ordre alphabétique. La source est facilement optimisable, les trois lignes peuvent être remplacé par un seule soit :

set phrase [lsort [split [lrange $arg 0 end] " "]]

Bien que le lrange soi quelque peut inutile, étant donnée que $arg contient la phrase.

lsearch

La commande lsearch permet de chercher dans une chaine de charactere un mot.

Syntaxe

lsearch $variable test

Exemple

set liste_admin "DaV34 Crazy_Cat"
bind pub - !isadmin pub:isadmin
proc pub:isadmin {nick host hand chan arg} {
   set cible [lindex $arg 0]
   if { $cible ne "" } {
      if { [lsearch $::liste_admin $cible] eq 0 } {
         puthelp "PRIVMSG $chan :$cible fait bien partit des administrateurs du bot."
         return 0
      } else {
         puthelp "PRIVMSG $chan :$cible ne fait pas partit des administrateurs du bot."
         return 0
      }
   } else {
      puthelp "NOTICE $nick :Syntaxe : !isadmin <pseudo>"
      puthelp "NOTICE $nick :Permet de vérifier si pseudo est un administrateur du robot."
      return 0
   }
}

Ce tcl permet de vérifier par le biais d'une commande si une personne est administrateur du robot. Adminstrateur du robot est vaste, en vérité, c'est de vérifier si la personne se trouve dans la variable $liste_admin, que vous pouvez donc ensuite utilisée comme liste des access.

join

La commande join permet de joindre les éléments d'une liste.

Syntaxe

join $variable <arguments>

Exemple

set data "1 2 3 4 5 6 7 8 9 10"
join $data ", "
putlog $data

Retourne :

$data = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Bien qu'il soit rare d'utiliser join, cette commande reste importante. Attention : Vous remarquerez que j'ai mit un espace dans la deuxieme ligne du code de l'exemple, vous remarquerez donc ce que cela retourne, ne vous y trompez pas, faite attention aux éventuelles erreurs stupide.

Shuffle

La fonction pour mélanger une liste n'existe pas en tcl, mais elle est facilement implémentable.

Source

# Shuffle d'une liste
proc shuffle { list } {
   set slist {}
   while {[llength $list]>0} {
      expr {srand([clock clicks])}
      set j [expr {int(rand()*[llength $list])}]
      lappend slist [lindex $list $j]
      set list [lreplace $list $j $j]
   }
   return $slist
}

Utilisation

set orig { 1 2 3 4 5 6 7 8 9 }
putlog $orig
putlog [shuffle $orig]

Voir également

list, llength, lindex, lrange, linsert, lreplace, lappend, lsearch, concat, split, join, lsort, lrepeat, lset, lassign, ldiff, A propos des listes