5. Variables

Note éditoriale

Important

La spécification du langage Windows PowerShell 3.0 a été publiée en décembre 2012 et est basée sur Windows PowerShell 3.0. Cette spécification ne reflète pas l’état actuel de PowerShell. Il n’existe aucun plan de mise à jour de cette documentation pour refléter l’état actuel. Cette documentation est présentée ici pour référence historique.

Le document de spécification est disponible en tant que document Microsoft Word à partir du Centre de téléchargement Microsoft à l’adresse : https://www.microsoft.com/download/details.aspx?id=36389 ce document Word a été converti pour présentation ici sur Microsoft Learn. Pendant la conversion, certaines modifications éditoriales ont été apportées pour prendre en charge la mise en forme de la plateforme Docs. Certaines fautes de frappe et erreurs mineures ont été corrigées.

Une variable représente un emplacement de stockage pour une valeur et cette valeur a un type. Les langages de programmation procédural traditionnels sont typés statiquement ; autrement dit, le type d’exécution d’une variable est celui avec lequel elle a été déclarée au moment de la compilation. Les langages orientés objet ajoutent l’idée d’héritage, ce qui permet au type d’exécution d’une variable d’être celle avec laquelle elle a été déclarée au moment de la compilation ou d’un type dérivé de ce type. Étant un langage typé dynamiquement, les variables de PowerShell n’ont pas de types, par défaut. En fait, les variables ne sont pas définies ; ils viennent simplement en être lorsqu’ils sont d’abord attribués une valeur. Et si une variable peut être contrainte (§5.3) de conserver une valeur d’un type donné, les informations de type dans une affectation ne peuvent pas toujours être vérifiées statiquement.

À différents moments, une variable peut être associée à des valeurs de différents types par affectation (§7.11) ou à l’utilisation des opérateurs ++ et ‑‑ (§7.1.5, §7.2.6). Lorsque la valeur associée à une variable est modifiée, le type de cette valeur peut changer. Par exemple

$i = "abc"        # $i holds a value of type string
$i = 2147483647   # $i holds a value of type int
++$i              # $i now holds a value of type double because
                  # 2147483648 is too big to fit in type int

Toute utilisation d’une variable qui n’a pas été créée génère la valeur $null. Pour voir si une variable a été définie, utilisez l’applet de commande Test-Path.

5.1 Emplacement accessible en écriture

Un emplacement accessible en écriture est une expression qui désigne une ressource à laquelle une commande a accès en lecture et en écriture. Un emplacement accessible en écriture peut être une variable (§5), un élément de tableau (§9), une valeur associée dans une table de hachage accessible via un indice (§10), une propriété (§7.1.2) ou un stockage géré par un fournisseur (§3.1).

5.2 Catégories de variables

PowerShell définit les catégories de variables suivantes : les variables statiques, les variables d’instance, les éléments de tableau, les paires clé/valeur de la table de hachage, les paramètres, les variables ordinaires et les variables situées sur les lecteurs de fournisseur. Les sous-sections qui suivent décrivent chacune de ces catégories.

Dans l’exemple suivant

function F ($p1, $p2) {
    $radius = 2.45
    $circumference = 2 * ([Math]::PI) * $radius

    $date = Get-Date -Date "2010-2-1 10:12:14 pm"
    $month = $date.Month

    $values = 10, 55, 93, 102
    $value = $values[2]

    $h1 = @{ FirstName = "James"; LastName = "Anderson" }
    $h1.FirstName = "Smith"

    $Alias:A = "Help"
    $Env:MyPath = "E:\Temp"
    ${E:output.txt} = 123
    $Function:F = { "Hello there" }
    $Variable:v = 10
}

• [Math::PI] est une variable statique
• $date.Month est une variable d’instance
• $values[2] est un élément de tableau
• $h1.FirstName est une clé Hashtable dont la valeur correspondante est $h 1['FirstName']'
• $p1 et $p2 sont des paramètres
• $radius, $circumference, $date, $month, $values, $valueet $h1 sont des variables ordinaires
• $Alias:A, $Env:MyPath, ${E:output.txt}et $Function:F sont des variables sur les lecteurs de fournisseur correspondants.
• $Variable:v est une variable ordinaire écrite avec le nom complet de son lecteur de fournisseur.

5.2.1 Variables statiques

Un membre de données d’un objet qui appartient au type de l’objet plutôt qu’à cette instance particulière du type est appelé une variable statique . Consultez §4.2.3, §4.2.4.1et §4.3.8 pour obtenir des exemples.

PowerShell ne permet pas de créer de nouveaux types qui contiennent des variables statiques ; toutefois, les objets de ces types peuvent être fournis par l’environnement hôte.

La mémoire permettant de créer et de supprimer des objets contenant des variables statiques est gérée par l’environnement hôte et le système de garbage collection.

Consultez §7.1.2 pour plus d’informations sur l’accès à une variable statique.

Un membre de données statique peut être un champ ou une propriété.

5.2.2 Variables d’instance

Un membre de données d’un objet qui appartient à une instance particulière du type de l’objet plutôt qu’au type lui-même est appelé une variable d’instance . Consultez §4.3.1, §4.3.2et §4.3.3 pour obtenir des exemples.

Un environnement hôte PowerShell peut fournir un moyen de créer de nouveaux types qui contiennent des variables d’instance ou d’ajouter de nouvelles variables d’instance à des types existants.

La mémoire permettant de créer et de supprimer des objets contenant des variables statiques est gérée par l’environnement hôte et le système de garbage collection.

Consultez §7.1.2 pour plus d’informations sur l’accès à une variable d’instance.

Un membre de données d’instance peut être un champ ou une propriété.

5.2.3 Éléments de tableau

Un tableau peut être créé via un opérateur de virgule unaire (§7.2.1), sous-expression (§7.1.6), tableau-expression (§7.1.7), opérateur de virgule binaire (§7.3), opérateur de plage (§7.4) ou applet de commande New-Object .

La mémoire pour la création et la suppression de tableaux est gérée par l’environnement hôte et le système de collecte de déchets.

Les tableaux et les éléments de tableau sont abordés dans §9.

5.2.4 Paires clé-valeur de table de hachage

Une table de hachage est créée à l’aide d’un littéral de hachage (§2.3.5.6) ou de l’applet de commande New-Object. Une nouvelle paire clé/valeur peut être ajoutée via l’opérateur [] (§7.1.4.3).

La mémoire permettant de créer et de supprimer des tables de hachage est gérée par l’environnement hôte et le système de ramasse-miettes.

Les tables de hachage sont abordées au paragraphe §10.

5.2.5 Paramètres

Un paramètre est créé lorsque sa commande parente est appelée et qu’elle est initialisée avec la valeur de l’argument fourni dans l’appel ou par l’environnement hôte. Un paramètre cesse d’exister lorsque sa commande parente se termine.

Les paramètres sont abordés dans §8.10.

5.2.6 Variables ordinaires

Une variable ordinaire est définie par une expression d’assignation (§7.11) ou une instruction foreach (§8.4.4). Certaines variables ordinaires sont prédéfinies par l’environnement hôte, tandis que d’autres sont temporaires, à venir et à passer selon les besoins au moment de l’exécution.

La durée de vie d’une variable ordinaire est la partie de l’exécution du programme durant laquelle il est garanti que le stockage lui est réservé. Cette durée de vie commence au moment de l'entrée dans la portée avec laquelle elle est associée et ne se termine pas avant la fin de l'exécution de cette portée. Si l’étendue parente est entrée de manière récursive ou itérative, une nouvelle instance de la variable locale est créée à chaque fois.

Le stockage référencé par une variable ordinaire est récupéré indépendamment de la durée de vie de cette variable.

Une variable ordinaire peut être nommée explicitement avec une variable : préfixe d’espace de noms (§5.2.7).

5.2.7 Variables situées sur les lecteurs de fournisseur

Les concepts de fournisseurs et de lecteurs sont expliqués au paragraphe §3.1. Chaque fournisseur est capable de fournir ses propres lecteurs d’espace de noms. Cela permet aux ressources sur ces lecteurs d’être accessibles comme si elles étaient des variables ordinaires (§5.2.6). En fait, une variable ordinaire est stockée sur le lecteur fournisseur du système de fichiers Variable : (§3.1.5) et est accessible par son nom ordinaire ou par son nom d'espace de noms entièrement qualifié.

Certains types de variables d’espace de noms sont contraints implicitement (§5.3).

5.3 Variables contraintes

Par défaut, une variable peut désigner une valeur de n’importe quel type. Toutefois, une variable peut être contrainte à désigner des valeurs d’un type donné en spécifiant ce type sous forme de littéral avant son nom dans une affectation ou un paramètre. Par exemple

[int]$i = 10   # constrains $i to designating ints only
$i = "Hello"   # error, no conversion to int
$i = "0x10"    # ok, conversion to int
$i = $true     # ok, conversion to int

function F ([int]$p1, [switch]$p2, [regex]$p3) { ... }

Toute variable appartenant à l’espace de noms Env :, Alias :, ou à l’espace de noms du système de fichiers (§2.3.2, §3.1) est contrainte implicitement au type string. Toute variable appartenant à l’espace de noms Fonction : (§2.3.2, §3.1) est contrainte implicitement au type scriptblock.