====== namespace ======
Crée et manipule des contextes pour les commandes et variables
===== Syntaxe =====
<code tcl>namespace ?option? ?arg ...?</code>
===== Description =====
La commande **namespace** vous permet de créer, d’accéder, et de détruire des contextes séparés pour les commandes et variables.
==== children ====
<code tcl>namespace children ?namespace? ?pattern?</code>
 Renvoie une liste de tous les namespaces enfants qui appartiennent à namespace. Si namespace n'est pas spécifié, alors les enfants sont renvoyés pour le namespace courant. Cette commande retourne des noms pleinement qualifiés, qui commencent avec ::. Si l'option //pattern// est donnée, alors cette commande retourne seulement les noms qui correspond au modèle glob-style. Le modèle actuel utilisé est déterminé comme suit: un modèle qui commence avec :: est utilisé directement, autrement le namespace //namespace// (ou le nom pleinement qualifié du namespace courant) est ajouté au modèle.
==== code ====
<code tcl>namespace code script</code>
Capture le contexte namespace courant pour une exécution ultérieure du script script. Retourne un nouveau script dans lequel script aura été englobé dans une commande namespace code. Le nouveau script a deux propriétés importantes. D'abord, il peut être évalué dans tout namespace et provoquera l'évaluation de script dans le namespace courant (celui où la commande namespace code a été appelée). Deuxièmement, des arguments supplémentaires peuvent être ajoutés au script résultant et ils seront transmis à script comme arguments additionnels. Par exemple, supposez que la commande `set script [namespace code {foo bar}]` est appelée dans le namespace //::a::b//. Ensuite `eval "$script x y"` peut être exécuté dans tout namespace (en supposant que la valeur de script lui ait été transmise correctement) et aura le même effet que la commande `namespace eval ::a::b {foo bar x y}`.
==== current ====
<code tcl>namespace current</code>
Renvoie le nom pleinement qualifié pour le namespace courant. Le nom actuel du namespace global est "" (ex., une chaîne vide), mais cette commande retourne :: pour le namespace global par convénience pour les programmeurs.
==== delete ====
<code tcl>namespace delete ?namespace namespace ...?</code>
Chaque namespace //namespace// est effacé et toutes variables, fonctions, et namespaces enfants contenus dans le namespace sont effacés. Si une fonction est en cours d'exécution dans le namespace, le namespace sera maintenu jusqu'à ce que la fonction retourne; néanmoins, le namespace est marqué pour empêcher tout autre code de le rechercher par son nom. Si un namespace n'existe pas, cette commande retourne une erreur. Si aucuns noms de namespace ne sont donnés, cette commande ne fait rien.
==== eval ====
<code tcl>namespace eval namespace arg ?arg ...?</code>
Active un namespace appelé //namespace// et évalue tout code dans ce contexte. Si le namespace n'existe pas déjà, il est créé. Si plus d'un argument //arg// est spécifié, les arguments sont concaténés, séparés par des espaces de la même façon qu'avec la commande [[:tcl:eval]], et le résultat est évalué. Si namespace a des quantificateurs //namespace// en tête et que les namespaces en tête n'existent pas, ils sont automatiquement créés.
==== export ====
<code tcl>namespace export ?-clear? ?pattern pattern ...?</code>
Spécifie quelles commandes sont exportées par un namespace. Le commandes exportées sont celles qui peuvent être plus tard importées dans un autre namespace en utilisant une commande namespace import. L’ensemble des commandes définies dans un namespace et des commandes que le namespace a précédemment importé peut être exporté par un namespace. La commandes n'ont pas à être définies à l'instant où la commande namespace export est exécutée. Chaque pattern peut contenir des caractères spéciaux glob-style, mais il ne peut pas inclure quelconque quantificateurs namespace. Ainsi, le modèle peut seulement spécifier des commandes dans le namespace courant (exportant). Chaque pattern est ajouté à la liste de modèles d'export du namespace. Si le flag //-clear// est donné, la liste de modèles d'export du namespace est réinitialisée en chaîne vide avant que quelconques pattern arguments soient ajoutés. Si aucuns patterns ne sont donnés et que le flag -clear n'est pas fourni, cette commande retourne la liste d'export du namespace courant.
<code tcl>namespace forget ?pattern pattern ...?</code>
==== forget ====
Re-déplace les commandes précédemment importées d'un namespace. Chaque pattern est un nom qualifié tel que foo::x ou a::b::p*. Les noms qualifiés contiennent des ::s et qualifient un nom avec le nom d'un ou plusieurs namespaces. Chaque pattern est qualifié avec le nom d'un namespace exportant et peut avoir des caractères spéciaux glob-style dans le nom de commande à la fin du nom qualifié. Les caractères glob ne peuvent pas apparaître dans un nom de namespace. Cette commande trouve en premier les commandes exportées correspondantes. Elle vérifie ensuite si une ou plusieurs de ces commandes ont été précédemment importées par le namespace courant. Si c'est le cas, cette commande efface les commandes importées correspondantes. Ceci annule effectivement l'action d'une commande namespace import.
==== import ====
<code tcl>namespace import ?-force? ?pattern pattern ...?</code>
Importe des commandes dans un namespace. Chaque pattern est un nom qualifié comme foo::x ou a::p*. Ainsi, elle inclut le nom d'un namespace exportant et peut avoir des caractères spéciaux glob-style dans le nom de commande à la fin du nom qualifié. Les caractères glob ne peuvent pas apparaître dans un nom de namespace. Toutes les commandes qui correspondent à une chaîne pattern et qui sont couramment exportées de leurs namespace sont ajoutées au namespace courant. Ceci est fait par création d'une nouvelle commande dans le namespace courant qui pointe vers la commande exportée dans son namespace original; quand la nouvelle commande importée est appelée, elle appelle la commande exportée. Cette commande normalement retourne une erreur si une commande importée rentre en conflit avec une commande existante. Néanmoins, si l'option -force est donnée, les commandes importées remplaceront silencieusement les commandes existantes. La commande namespace import a une sémantique photographique: ainsi, seulement les commandes requises couramment définies dans le namespace exportant sont importées. En d'autres mots, vous pouvez importer seulement les commandes qui sont dans un namespace à l'instant où la commande namespace import est exécutée. Si une autre commande est définie et exportée dans ce namespace plus tard, elle ne sera pas importée.
== inscope ====
<code tcl>namespace inscope namespace arg ?arg ...?</code>
Exécute un script dans le contexte d'un namespace particulier. Cette commande n'est pas sensée être utilisé directement par les programmeurs; des appels sont générés implicitement quand les applications utilisent la commande namespace code pour créer scripts callback que l’application alors enregistre avec, par ex., des widgets Tk. La commande namespace inscope ressemble plus à la commande namespace eval excepté qu'elle a une sémantique lappend et que le namespace doit déjà exister. Elle traite le premier argument comme une liste, et ajoute tout argument après le premier jusqu'à la fin comme des éléments de liste correcte. `namespace inscope ::foo a x y z` est équivalent à `namespace eval ::foo [concat a [list x y z]]` Cette sémantique lappend est importante parce que de nombreux scripts callback sont actuellement des préfixes.
==== origin ====
<code tcl>namespace origin command</code>
Renvoie le nom pleinement qualifié de la commande originale à laquelle la commande importée command se réfère. Quand une commande est importée dans un namespace, une nouvelle commande est créée dans ce namespace qui pointe vers la commande actuelle dans le namespace exportant. Si une commande est importée dans une séquence de namespaces a, b,...,n où chaque namespace successif importe juste la commande du précédent namespace, cette commande retourne le nom pleinement qualifié de la commande originale dans le premier namespace, a. Si command ne se réfère pas à une commande importée, le propre nom pleinement qualifié de la commande est renvoyé.
==== parent ====
<code tcl>namespace parent ?namespace?</code>
Renvoie le nom pleinement qualifié du namespace parent de namespace. Si namespace n'est pas spécifié, le nom pleinement qualifié du parent du namespace courant est renvoyé.
==== qualifiers ====
<code tcl>namespace qualifiers string</code> Renvoie tous les quantificateurs namespace en tête de string. Les quantificateurs sont les noms de namespace séparées par ::. Pour la string ::foo::bar::x, cette commande retourne ::foo::bar, et pour :: elle retourne une chaîne vide. Cette commande est le complément de la commande namespace tail. Notez qu'elle ne vérifie pas si les noms de namespace sont, en fait, les noms des namespaces couramment définis.
==== tail ====
<code tcl>namespace tail string</code>
Renvoie le simple nom à la fin d'une chaîne qualifiée. Les quantificateurs sont les noms de namespace séparées par ::. Pour la string ::foo::bar::x, cette commande retourne x, et for :: elle retourne une chaîne vide. Cette commande est le complément de la commande namespace qualifiers. Elle ne vérifie pas si les noms de namespace sont, en fait, les noms des namespaces couramment définis.
==== which ====
<code tcl>namespace which ?-command? ?-variable? name</code>
Recherche name soit comme commande ou variable et retourne son nom pleinement qualifié. Par exemple, si name n'existe pas dans le namespace courant mais existe dans le namespace global, cette commande retourne un nom pleinement qualifié dans le namespace global. Si la commande ou variable n'existe pas, cette commande retourne une chaîne vide. Si la variable a été créée mais non définie, tel qu'avec la commande variable ou au travers d'une trace sur la variable, cette commande renverra le nom pleinement qualifié de la variable. Si aucun flag n'est donné, name est traité comme un nom de commande. Voir la section RÉSOLUTION DE NOM ci-dessous pour une explication des règles concernant la résolution de nom.
===== Exemples =====
Dans la plupart des scripts, il est intéressant de ne pas utiliser le nom du namespace en dur((hard-coded)). On utilise donc souvent `[namespace current]` pour accéder au nom du namespace en cours, par exemple pour appeler une procédure de ce namespace dans un [[:tcl:tcl_eggdrop:bind]].

Pour récupérer la valeur d'une variable dans le namespace, `$::[namespace current]::variable` ne marche pas, il faut utiliser la particularité de [[:tcl:set]] qui retourne la valeur de l'élément visé si on ne lui passe pas d'argument:
<code tcl>namespace eval myns {

   variable v

   proc doit {} {
      incr [namespace current]::v 1
   }

   proc readit {handle idx text} {
      [namespace current]::doit
      putlog "v is now [set [namespace current]::v]"
      # Notez bien l'utilisation de set
   }

   bind dcc - readme [namespace current]::readit
}</code>
===== Voir aussi =====
{{tag>tcl Namespace incomplete}}