3. Concepts de base

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 sur : 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.

3.1 Fournisseurs et lecteurs

Un fournisseur autorise l’accès aux données et aux composants qui ne seraient pas facilement accessibles dans la ligne de commande. Les données sont présentées dans un format cohérent qui ressemble à un lecteur de système de fichiers.

Les données exposées par un fournisseur s’affichent sur un lecteur et les données sont accessibles via un chemin d’accès comme avec un lecteur de disque. Les applets de commande intégrées pour chaque fournisseur gèrent les données sur le lecteur du fournisseur.

PowerShell inclut l’ensemble suivant de fournisseurs intégrés pour accéder aux différents types de magasins de données :

Fournisseur	Nom du lecteur	Description	Ref.
Pseudonyme	Alias:	Alias PowerShell	§3.1.1
Environnement	Env:	Variables d'environnement	§3.1.2
Système de fichiers	A :, B :, C :, ...	Lecteurs de disque, répertoires et fichiers	§3.1.3
Fonction	Fonction:	Fonctions PowerShell	§3.1.4
Variable	Variable:	Variables PowerShell	§3.1.5

Windows PowerShell :

Fournisseur	Nom du lecteur	Description
Certificat	Cert:	Certificats x509 pour les signatures numériques
Registre	HKLM : (HKEY_LOCAL_MACHINE), HKCU : (HKEY_CURRENT_USER)	Registre Windows
WSMan	WSMan :	WS-Management informations de configuration

Les applets de commande suivantes traitent des fournisseurs et des lecteurs :

• Get-PSProvider : obtient des informations sur un ou plusieurs fournisseurs
• Get-PSDrive : obtient des informations sur un ou plusieurs lecteurs

Le type d’un objet qui représente un fournisseur est décrit dans le §4.5.1. Le type d’un objet qui représente un lecteur est décrit dans le §4.5.2.

3.1.1 Alias

Un alias est un autre nom pour une commande. Une commande peut avoir plusieurs alias, et le nom d’origine et tous ses alias peuvent être utilisés de manière interchangeable. Un alias peut être réaffecté. Un alias est un élément (§3.3).

Un alias peut être affecté à un autre alias ; Toutefois, le nouvel alias n’est pas un alias de la commande d’origine.

L’alias du fournisseur est un espace de noms plat qui contient uniquement des objets qui représentent les alias. Les variables n'ont pas d'éléments enfants.

PowerShell est fourni avec un ensemble d’alias intégrés.

Les applets de commande suivantes traitent des alias :

• New-Alias : crée un alias
• Set-Alias : crée ou modifie un ou plusieurs alias
• Get-Alias : obtient des informations sur un ou plusieurs alias
• Export-Alias : exporte un ou plusieurs alias vers un fichier

Lorsqu’un alias est créé pour une commande à l’aide New-Aliasd’une commande, les paramètres de cette commande ne peuvent pas être inclus dans cet alias. Toutefois, l’affectation directe à une variable dans l’espace de noms Alias : l’espace de noms autorise l’inclusion des paramètres.

Remarque

Toutefois, il s’agit d’une question simple de créer une fonction qui ne contient rien de plus que l’appel de cette commande avec tous les paramètres souhaités et d’affecter un alias à cette fonction.

Le type d’un objet qui représente un alias est décrit dans le §4.5.4.

Les objets d’alias sont stockés sur l’alias de lecteur : (§3.1).

3.1.2 Variables d’environnement

Le fournisseur d’environnement PowerShell permet aux variables d’environnement du système d’exploitation d’être récupérées, ajoutées, modifiées, effacées et supprimées.

L’environnement fournisseur est un espace de noms plat qui contient uniquement des objets qui représentent les variables d’environnement. Les variables n'ont pas d'éléments enfants.

Le nom d’une variable d’environnement ne peut pas inclure le signe égal (=).

Les modifications apportées aux variables d’environnement affectent uniquement la session active.

Une variable d’environnement est un élément (§3.3).

Le type d’un objet qui représente une variable d’environnement est décrit dans le §4.5.6.

Les objets de variable d’environnement sont stockés sur le lecteur Env : (§3.1).

3.1.3 Système de fichiers

Le fournisseur PowerShell FileSystem permet de créer, d’ouvrir, de modifier et de supprimer des répertoires et des fichiers.

Le fournisseur FileSystem est un espace de noms hiérarchique qui contient des objets qui représentent le système de fichiers sous-jacent.

Les fichiers sont stockés sur des lecteurs avec des noms tels que A :, B :, C :, etc. (§3.1). Les répertoires et les fichiers sont accessibles à l’aide de la notation de chemin d’accès (§3.4).

Un répertoire ou un fichier est un élément (§3.3).

3.1.4 Fonctions

Le fournisseur de fonctions PowerShell permet aux fonctions (§8.10) et aux filtres (§8.10.1) d’être récupérés, ajoutés, modifiés, effacés et supprimés.

La fonction fournisseur est un espace de noms plat qui contient uniquement les objets de fonction et de filtre. Ni les fonctions ni les filtres n'ont des éléments enfants.

Les modifications apportées aux fonctions affectent uniquement la session active.

Une fonction est un élément (§3.3).

Le type d’un objet qui représente une fonction est décrit dans le §4.5.10. Le type d’un objet qui représente un filtre est décrit dans le §4.5.11.

Les objets de fonction sont stockés sur la fonction de lecteur : (§3.1).

3.1.5 Variables

Les variables peuvent être définies et manipulées directement dans le langage PowerShell.

La variable fournisseur est un espace de noms plat qui contient uniquement des objets qui représentent les variables. Les variables n'ont pas d'éléments enfants.

Les applets de commande suivantes traitent également des variables :

• New-Variable : crée une variable
• Set-Variable : crée ou modifie les caractéristiques d’une ou plusieurs variables
• Get-Variable : obtient des informations sur une ou plusieurs variables
• Clear-Variable : supprime la valeur d’une ou plusieurs variables
• Remove-Variable : supprime une ou plusieurs variables

Comme une variable est un élément (§3.3), il peut être manipulé par la plupart des applets de commande liées à l’élément.

Le type d’un objet qui représente une variable est décrit dans le §4.5.3.

Les objets variables sont stockés sur la variable de lecteur : (§3.1).

3.2 Emplacements de travail

L’emplacement de travail actuel est l’emplacement par défaut auquel les commandes pointent. Il s’agit de l’emplacement utilisé si un chemin explicite (§3.4) n’est pas fourni lorsqu’une commande est appelée. Cet emplacement inclut le lecteur actuel.

Un hôte PowerShell peut avoir plusieurs lecteurs, auquel cas, chaque lecteur a son propre emplacement actuel.

Lorsqu’un nom de lecteur est spécifié sans répertoire, l’emplacement actuel de ce lecteur est implicite.

L’emplacement de travail actuel peut être enregistré sur une pile, puis défini sur un nouvel emplacement. Plus tard, cet emplacement enregistré peut être restauré à partir de cette pile et a rendu l’emplacement de travail actuel. Il existe deux types de piles d’emplacements : la pile d’emplacements de travail par défaut et zéro ou plusieurs piles d’emplacements de travail nommées définies par l’utilisateur. Lorsqu’une session commence, la pile d’emplacements de travail par défaut est également la pile d’emplacements de travail actuelle. Toutefois, toute pile d’emplacements de travail nommée peut être effectuée dans la pile d’emplacements de travail actuelle.

Les applets de commande suivantes traitent des emplacements :

• Set-Location : établit l’emplacement de travail actuel
• Get-Location : détermine l’emplacement de travail actuel du ou des lecteurs spécifiés ou les emplacements de travail de la ou des piles spécifiées
• Emplacement push : enregistre l’emplacement de travail actuel en haut d’une pile spécifiée d’emplacements
• Emplacement contextuel : restaure l’emplacement de travail actuel à partir du haut d’une pile d’emplacements spécifiée

Les types d’objets qui représentent un emplacement de travail et une pile d’emplacements de travail sont décrits dans le §4.5.5.

3.3 Éléments

Un élément est un alias (§3.1.1), une variable (§3.1.5), une fonction (§3.1.4), une variable d’environnement (§3.1.2) ou un fichier ou un répertoire dans un système de fichiers (§3.1.3).

Les applets de commande suivantes traitent des éléments :

• Nouvel élément : crée un élément
• Set-Item : Modifie la valeur d’un ou plusieurs éléments
• Get-Item : obtient les éléments à l’emplacement spécifié
• Get-ChildItem : obtient les éléments et les éléments enfants à l’emplacement spécifié
• Copier-élément : copie un ou plusieurs éléments d’un emplacement vers un autre
• Move-Item : déplace un ou plusieurs éléments d’un emplacement vers un autre
• Renommer l’élément : renomme un élément
• Invoke-Item : effectue l’action par défaut sur un ou plusieurs éléments
• Effacer l’élément : supprime le contenu d’un ou plusieurs éléments, mais ne supprime pas les éléments (voir
• Remove-Item : supprime les éléments spécifiés

Les applets de commande suivantes traitent du contenu des éléments :

• Get-Content : obtient le contenu de l’élément
• Complément : ajoute du contenu aux éléments spécifiés
• Set-Content : écrit ou remplace le contenu d’un élément
• Effacer le contenu : supprime le contenu d’un élément

Le type d’un objet qui représente un répertoire est décrit dans le §4.5.17. Le type d’un objet qui représente un fichier est décrit dans le §4.5.18.

3.4 Noms de chemins

Tous les éléments d’un magasin de données accessibles via un fournisseur PowerShell peuvent être identifiés de manière unique par leurs noms de chemin d’accès. Un nom de chemin est une combinaison du nom de l’élément, du conteneur et des sous-conteneurs dans lesquels se trouve l’élément et du lecteur PowerShell via lequel les conteneurs sont accessibles.

Les noms de chemins sont divisés en deux types : qualifiés et relatifs complets. Un nom de chemin complet se compose de tous les éléments qui composent un chemin d’accès. La syntaxe suivante affiche les éléments dans un nom de chemin d’accès complet :

Conseil / Astuce

La ~opt~ notation dans les définitions de syntaxe indique que l’entité lexicale est facultative dans la syntaxe.

path:
    provider~opt~   drive~opt~   containers~opt~   item

provider:
    module~opt~   provider   ::

module:
    module-name   \

drive:
    drive-name   :

containers:
    container   \
    containers container   \

le nom du module fait référence au module parent.

le fournisseur fait référence au fournisseur PowerShell via lequel le magasin de données est accessible.

le lecteur fait référence au lecteur PowerShell pris en charge par un fournisseur PowerShell particulier.

Un conteneur peut contenir d’autres conteneurs, qui peuvent contenir d’autres conteneurs, et ainsi de suite, avec le conteneur final contenant un élément. Les conteneurs doivent être spécifiés dans l’ordre hiérarchique dans lequel ils existent dans le magasin de données.

Voici un exemple de nom de chemin d’accès :

E:\Accounting\InvoiceSystem\Production\MasterAccount\MasterFile.dat

Si l’élément final d’un chemin d’accès contient d’autres éléments, il s’agit d’un élément conteneur ; sinon, il s’agit d’un élément feuille.

Dans certains cas, un nom de chemin complet n’est pas nécessaire ; un nom de chemin relatif suffit. Un nom de chemin relatif est basé sur l’emplacement de travail actuel. PowerShell permet à un élément d’être identifié en fonction de son emplacement par rapport à l’emplacement de travail actuel. Un nom de chemin relatif implique l’utilisation de certains caractères spéciaux. Le tableau suivant décrit chacun de ces caractères et fournit des exemples de noms de chemin d’accès relatifs et de noms de chemin d’accès complets. Les exemples de la table sont basés sur le répertoire de travail actuel défini sur C :\Windows :

Symbole	Description	Chemin relatif	Chemin complet
.	Emplacement de travail actuel	.\System	C:\Windows\System
..	Parent de l’emplacement de travail actuel	..\Program Files	C:\Program Files
\	Racine du lecteur de l’emplacement de travail actuel	\Program Files	C:\Program Files
Aucune	Pas de caractères spéciaux	System	C:\Windows\System

Pour utiliser un nom de chemin d’accès dans une commande, entrez ce nom en tant que nom de chemin complet ou relatif.

Les applets de commande suivantes traitent des chemins d’accès :

• Convert-Path : convertit un chemin d’accès à partir d’un chemin PowerShell en chemin d’accès du fournisseur PowerShell
• Join-Path : combine un chemin d’accès et un chemin enfant dans un seul chemin d’accès
• Resolve-Path : résout les caractères génériques d’un chemin d’accès
• Split-Path : retourne la partie spécifiée d’un chemin d’accès
• Test-Path : détermine si les éléments d’un chemin existent ou si un chemin d’accès est bien formé

Certaines applets de commande (telles que Add-Content et Copy-Item utilisent des filtres de fichiers). Un filtre de fichier est un mécanisme permettant de spécifier les critères de sélection à partir d’un ensemble de chemins d’accès.

Le type d’objet qui représente un chemin résolu est décrit dans §4.5.5. Les chemins d’accès sont souvent manipulés en tant que chaînes.

3.5 Étendues

3.5.1 Introduction

Un nom peut désigner une variable, une fonction, un alias, une variable d’environnement ou un lecteur. Le même nom peut indiquer différents éléments à différents endroits dans un script. Pour chaque élément différent qu’un nom désigne, ce nom n’est visible que dans la région du texte de script appelé sa portée. Différents éléments indiqués par le même nom ont des étendues différentes ou se trouvent dans des espaces de noms différents.

Les étendues peuvent imbriquer, auquel cas, une étendue externe est appelée étendue parente, et toutes les étendues imbriquées sont des étendues enfants de ce parent. L’étendue d’un nom est l’étendue dans laquelle elle est définie et toutes les étendues enfants, sauf si elle est rendue privée. Dans une étendue enfant, un nom défini masque tous les éléments définis avec le même nom dans les étendues parentes.

Sauf si la notation source par point (§3.5.5) est utilisée, chacune des sections suivantes crée une nouvelle étendue :

• Fichier de script
• Bloc de script
• Fonction ou filtre

Prenons l’exemple suivant :

# Start of script
$x = 2; $y = 3
Get-Power $x $y

# Function defined in script
function Get-Power([int]$x, [int]$y) {
    if ($y -gt 0) {
        return $x * (Get-Power $x (--$y))
    } else {
        return 1
    }
}
# End of script

L’étendue des variables $x et $y créée dans le script est le corps de ce script, y compris la fonction définie à l’intérieur. La fonction Get-Power définit deux paramètres avec ces mêmes noms. Comme chaque fonction a sa propre étendue, ces variables sont différentes de celles définies dans l’étendue parente, et elles masquent celles de l’étendue parente. L’étendue de la fonction est imbriquée à l’intérieur de l’étendue du script.

Notez que la fonction s’appelle de manière récursive. Chaque fois qu’il le fait, il crée une autre étendue imbriquée, chacune avec ses propres variables $x et $y.

Voici un exemple plus complexe qui montre également les étendues imbriquées et la réutilisation des noms :

# start of script scope
$x = 2              # top-level script-scope $x created
                    # $x is 2
F1                  # create nested scope with call to function F1
                    # $x is 2
F3                  # create nested scope with call to function F3
                    # $x is 2

function F1 {       # start of function scope
                    # $x is 2
    $x = $true      # function-scope $x created
                    # $x is $true

    & {             # create nested scope with script block
                    # $x is $true
        $x = 12.345 # scriptblock-scope $x created
                    # $x is 12.345
    }               # end of scriptblock scope, local $x goes away

                    # $x is $true
    F2              # create nested scope with call to function F2
                    # $x is $true
}                   # end of function scope, local $x goes away

function F2 {       # start of function scope
                    # $x is $true
    $x = "red"      # function-scope $x created
                    # $x is "red"
}                   # end of function scope, local $x goes away

function F3 {       # start of function scope
                    # $x is 2
    if ($x -gt 0) {
                    # $x is 2
        $x = "green"
                    # $x is "green"
    }               # end of block, but not end of any scope
                    # $x is still "green"
}                   # end of function scope, local $x goes away
# end of script scope

3.5.2 Noms et nombres d’étendues

PowerShell prend en charge les étendues suivantes :

• Global : il s’agit de l’étendue la plus haut niveau. Toutes les variables automatiques et de préférence sont définies dans cette étendue. L’étendue globale est l’étendue parente de toutes les autres étendues, et toutes les autres étendues sont des étendues enfants de l’étendue globale.

• Local : il s’agit de l’étendue actuelle à n’importe quel point d’exécution au sein d’un script, d’un bloc de script ou d’une fonction. Toute étendue peut être l’étendue locale.

• Script : cette étendue existe pour chaque fichier de script exécuté. L’étendue du script est l’étendue parente de toutes les étendues créées à partir de celle-ci. Un bloc de script n’a pas sa propre étendue de script ; Au lieu de cela, son étendue de script est celle de son fichier de script ancêtre le plus proche. Bien qu’il n’existe aucune étendue de module, l’étendue de script fournit l’équivalent.

Les noms peuvent être déclarés privés, auquel cas, ils ne sont pas visibles en dehors de leur étendue parente, pas même aux étendues enfants. Le concept de privé n’est pas une étendue distincte ; il s’agit d’un alias pour l’étendue locale avec l’ajout de masquage du nom s’il est utilisé comme emplacement accessible en écriture.

Les étendues peuvent être référencées par un nombre, qui décrit la position relative d’une étendue à une autre. L’étendue 0 indique l’étendue locale, l’étendue 1 désigne une étendue ancêtre de 1 génération, l’étendue 2 indique une étendue ancêtre de 2 générations, et ainsi de suite. (Les numéros d’étendue sont utilisés par les applets de commande qui manipulent des variables.)

3.5.3 Étendue du nom de variable

Comme le montre la production suivante, un nom de variable peut être spécifié avec l’une des six étendues différentes :

variable-scope:
    Global:
    Local:
    Private:
    Script:
    Using:
    Workflow:
    variable-namespace

L’étendue est facultative. Le tableau suivant indique la signification de chacun dans tous les contextes possibles. Elle affiche également l’étendue lorsqu’aucune étendue n’est spécifiée explicitement :

Modificateur d’étendue	Dans un fichier de script	Dans un bloc de script	Dans une fonction
Mondial	Étendue globale	Étendue globale	Étendue globale
Scénario	Étendue du fichier de script ancêtre le plus proche ou Global s’il n’existe aucun fichier de script ancêtre le plus proche	Étendue du fichier de script ancêtre le plus proche ou Global s’il n’existe aucun fichier de script ancêtre le plus proche	Étendue du fichier de script ancêtre le plus proche ou Global s’il n’existe aucun fichier de script ancêtre le plus proche
Privé	Étendue globale/script/locale	Étendue locale	Étendue locale
Local	Étendue globale/script/locale	Étendue locale	Étendue locale
Using	Implémentation définie	Implémentation définie	Implémentation définie
Flux de travail	Implémentation définie	Implémentation définie	Implémentation définie
Aucun	Étendue globale/script/locale	Étendue locale	Étendue locale

Les informations d’étendue de variable peuvent également être spécifiées lors de l’utilisation de la famille d’applets de commande répertoriées dans (§3.1.5). En particulier, reportez-vous au paramètre Scope, ainsi qu’aux paramètres Option Private et Option AllScope pour plus d’informations.

Le Using: modificateur d’étendue est utilisé pour accéder aux variables définies dans une autre étendue lors de l’exécution de scripts via des applets de commande telles que Start-Job, Invoke-Commandou dans une instruction inlinescript-. Par exemple:

$a = 42
Invoke-Command --ComputerName RemoteServer { $Using:a } # returns 42
workflow foo
{
    $b = "Hello"
    inlinescript { $Using:b }
}
foo # returns "Hello"

Le flux de travail d’étendue est utilisé avec une instruction parallèle ou une instruction de séquence pour accéder à une variable définie dans le flux de travail.

3.5.4 Étendue du nom de la fonction

Un nom de fonction peut également avoir l’une des quatre étendues différentes, et la visibilité de ce nom est la même que pour les variables (§3.5.3).

3.5.5 Notation source point

Lorsqu’un fichier de script, un bloc de script ou une fonction est exécuté à partir d’un autre fichier de script, d’un bloc de script ou d’une fonction, le fichier de script exécuté crée une nouvelle étendue imbriquée. Par exemple,

Script1.ps1
& "Script1.ps1"
& { ... }
FunctionA

Toutefois, lorsque la notation source de point est utilisée, aucune nouvelle étendue n’est créée avant l’exécution de la commande. Par conséquent, les ajouts/modifications qu’il aurait apportés à sa propre étendue locale sont apportés à l’étendue actuelle à la place. Par exemple,

. Script2.ps1
. "Script2.ps1"
. { ... }
. FunctionA

3.5.6 Modules

Tout comme un fichier de script de niveau supérieur se trouve à la racine d’une arborescence d’étendue imbriquée hiérarchique, chaque module est également (§3.14). Toutefois, par défaut, seuls les noms exportés par un module sont disponibles par nom dans le contexte d’importation. Le paramètre global de l’applet de commande Import-Module permet aux noms exportés d’avoir une visibilité accrue.

3.6 Propriétés readOnly et constante

Les variables et les alias sont décrits par les objets qui contiennent un certain nombre de propriétés. Ces propriétés sont définies et manipulées par deux familles d’applets de commande (§3.1.5, §3.1.1). Une de ces propriétés est Options, qui peut être définie sur ReadOnly ou Constante (à l’aide du paramètre Option). Une variable ou un alias marqué ReadOnly peut être supprimé et ses propriétés peuvent être modifiées à condition que le paramètre Force soit spécifié. Toutefois, une variable ou un alias marqué Constante ne peut pas être supprimé ni ses propriétés ont changé.

3.7 Surcharges de méthode et résolution des appels

3.7.1 Introduction

Comme indiqué dans le §1, une procédure externe rendue disponible par l’environnement d’exécution (et écrite dans un langage autre que PowerShell) est appelée méthode.

Le nom d’une méthode ainsi que le nombre et les types de ses paramètres sont collectivement appelés signature de cette méthode. (Notez que la signature n’inclut pas le type de retour de la méthode.) L’environnement d’exécution peut permettre à un type d’avoir plusieurs méthodes portant le même nom que chacun a une signature différente. Lorsque plusieurs versions de certaines méthodes sont définies, cette méthode est dite surchargée. Par exemple, le type Math (§4.3.8) contient un ensemble de méthodes appelées Abs, qui calcule la valeur absolue d’un nombre spécifié, où le nombre spécifié peut avoir l’un des types. Les méthodes de ce jeu ont les signatures suivantes :

Abs(decimal)
Abs(float)
Abs(double)
Abs(int)
Abs(long)
Abs(SByte)
Abs(Int16)

Dans ce cas, toutes les méthodes ont le même nombre d’arguments ; leurs signatures diffèrent uniquement par type d’argument.

Un autre exemple implique le type Array (§4.3.2), qui contient un ensemble de méthodes appelées Copy qui copie une plage d’éléments d’un tableau à un autre, en commençant au début de chaque tableau (par défaut) ou à un élément désigné. Les méthodes de ce jeu ont les signatures suivantes :

Copy(Array, Array, int)
Copy(Array, Array, long)
Copy(Array, int, Array, int, int)
Copy(Array, long, Array, long, long)

Dans ce cas, les signatures diffèrent par type d’argument et, dans certains cas, par nombre d’arguments.

Dans la plupart des appels aux méthodes surchargées, le nombre et le type des arguments passés correspondent exactement à l’une des surcharges, et la méthode sélectionnée est évidente. Toutefois, si ce n’est pas le cas, il doit y avoir un moyen de résoudre la version surchargée à appeler, le cas échéant. Par exemple,

[Math]::Abs([byte]10) # no overload takes type byte
[array]::Copy($source, 3, $dest, 5L, 4) # both int and long indexes

D’autres exemples incluent la chaîne de type (c.-à-d. ; System.String), qui a de nombreuses méthodes surchargées.

Bien que PowerShell ait des règles pour résoudre les appels de méthode qui ne correspondent pas exactement à une signature surchargée, PowerShell ne fournit pas lui-même un moyen de définir des méthodes surchargées.

Remarque

Remarque de l’éditeur : PowerShell 5.0 a ajouté la possibilité de définir des classes basées sur des scripts. Ces classes peuvent contenir des méthodes surchargées.

3.7.2 Résolution de surcharge de méthode

Étant donné un appel de méthode (§7.1.3) ayant une liste d’expressions d’argument et un ensemble de méthodes candidates(c’est-à-dire ces méthodes qui peuvent être appelées), le mécanisme de sélection de la meilleure méthode est appelé résolution de surcharge.

Étant donné l’ensemble des méthodes candidates applicables (§3.7.3), la meilleure méthode dans cet ensemble est sélectionnée. Si l’ensemble contient une seule méthode, cette méthode est la meilleure méthode. Sinon, la meilleure méthode est celle qui est meilleure que toutes les autres méthodes en ce qui concerne la liste d’arguments donnée à l’aide des règles indiquées dans le §3.7.4. S’il n’existe pas exactement une méthode qui est meilleure que toutes les autres méthodes, l’appel de méthode est ambigu et une erreur est signalée.

La meilleure méthode doit être accessible dans le contexte dans lequel elle est appelée. Par exemple, un script PowerShell ne peut pas appeler une méthode privée ou protégée.

La meilleure méthode pour un appel à une méthode statique doit être une méthode statique, et la meilleure méthode pour un appel à une méthode d’instance doit être une méthode d’instance.

3.7.3 Méthode applicable

Une méthode est considérée comme applicable par rapport à une liste d’arguments A lorsque l’une des valeurs suivantes est vraie :

• Le nombre d’arguments dans A est identique au nombre de paramètres acceptés par la méthode.
• La méthode a des paramètres obligatoires M et des paramètres facultatifs N, et le nombre d’arguments dans A est supérieur ou égal à M, mais inférieur à N.
• La méthode accepte un nombre variable d’arguments et le nombre d’arguments dans A est supérieur au nombre de paramètres acceptés par la méthode.

En plus d’avoir un nombre approprié d’arguments, chaque argument dans A doit correspondre au mode de passage de paramètre de l’argument, et le type d’argument doit correspondre au type de paramètre, ou il doit y avoir une conversion du type d’argument vers le type de paramètre.

Si le type d’argument est ref (§4.3.6), le paramètre correspondant doit également être ref, et le type d’argument à des fins de conversion est le type de la valeur de propriété de l’argument ref.

Si le type d’argument est ref, le paramètre correspondant peut être out au lieu de ref.

Si la méthode accepte un nombre variable d’arguments, la méthode peut s’appliquer sous forme normale ou sous forme développée. Si le nombre d’arguments dans A est identique au nombre de paramètres acceptés par la méthode et que le dernier paramètre est un tableau, le formulaire dépend du rang d’une des deux conversions possibles :

• Classement de la conversion du type du dernier argument dans A vers le type de tableau du dernier paramètre.
• Rang de la conversion du type du dernier argument dans A au type d’élément du type de tableau pour le dernier paramètre.

Si la première conversion (en type de tableau) est meilleure que la deuxième conversion (vers le type d’élément du tableau), la méthode est applicable sous forme normale, sinon elle est applicable sous forme développée.

S’il existe plus d’arguments que de paramètres, la méthode peut être applicable sous forme développée uniquement. Pour être applicable sous forme développée, le dernier paramètre doit avoir un type de tableau. La méthode est remplacée par une méthode équivalente dont le dernier paramètre a été remplacé par des paramètres suffisants pour tenir compte de chaque argument sans correspondance dans A. Chaque type de paramètre supplémentaire est le type d’élément du type de tableau pour le dernier paramètre de la méthode d’origine. Les règles ci-dessus pour une méthode applicable sont appliquées à cette nouvelle méthode et à cette nouvelle liste d’arguments A.

3.7.4 Meilleure méthode

Étant donné une liste d’arguments A avec un ensemble d’expressions { E~1~, E~2~, ..., E~N~ } d’arguments et deux méthodes M~P~ d’application et M~Q~ avec des types { P~1~, P~2~, ..., P~N~ } de paramètres et { Q~1~, Q~2~, ..., Q~N~ }, M~P~ est défini pour être une meilleure méthode que M~Q~ si le classement cumulatif des conversions pour M~P~ est meilleur que celui pour M~Q~.

Le classement cumulé des conversions est calculé comme suit. Chaque conversion vaut une valeur différente en fonction du nombre de paramètres, avec la conversion de E~1~ valeur N, E~2~ valeur N-1, jusqu’à E~N~ 1. Si la conversion de E~X~ vers P~X~ est meilleure que celle de E~X~ vers Q~X~, l’accumulation M~P~ N-X+1 ; sinon, M~Q~ accumule N-X+1. Si M~P~ et M~Q~ ont la même valeur, les règles de rupture de lien suivantes sont utilisées, appliquées dans l’ordre :

• Le classement cumulé des conversions entre les types de paramètres (ignorant les types d’arguments) est calculé de manière similaire au classement précédent. Par conséquentP~1~, il est comparé à , P~2~ contre Q~1~Q~2~, ... et P~N~ contre Q~N~. La comparaison est ignorée si l’argument était $nullou si les types de paramètres ne sont pas des types numériques. La comparaison est également ignorée si la conversion E~X~ d’argument perd des informations en cas P~X~ de conversion, mais ne perd pas d’informations lorsqu’elle Q~X~est convertie en , ou inversement. Si les types de conversion de paramètre sont comparés, si la conversion de P~X~ vers Q~X~ est meilleure que celle de Q~X~ vers P~X~, les M~P~ cumuls N-X+1 ; sinon, M~Q~ accumule N-X+1. Cette règle de rupture de lien est destinée à préférer la méthode la plus spécifique (c’est-à-dire la méthode avec les paramètres ayant les plus petits types de données) si aucune information n’est perdue dans les conversions, ou pour préférer la méthode la plus générale (c’est-à-dire la méthode avec les paramètres avec les plus grands types de données) si les conversions entraînent une perte d’informations.
• Si les deux méthodes utilisent leur formulaire développé, la méthode avec plus de paramètres est la meilleure méthode.
• Si une méthode utilise le formulaire développé et l’autre utilise un formulaire normal, la méthode utilisant un formulaire normal est la meilleure méthode.

3.7.5 Meilleure conversion

Le texte ci-dessous marqué comme celui-ci est spécifique à Windows PowerShell.

Les conversions sont classées de la manière suivante, de la plus basse à la plus élevée :

• T~1~[] vers T~2~[] l’emplacement où aucune conversion assignable entre T~1~ et T~2~ existe
• T à chaîne où T est n’importe quel type
• T~1~ vers T~2~ l’emplacement T~1~ ou T~2~ la définition d’une conversion personnalisée de manière définie par l’implémentation
• T~1~ T~1~ où T~2~ implémente IConvertible
• T~1~où T~2~ ou T~2~ implémente T~1~ la méthodeT~2~ op_Implicit(T1)
• T~1~où T~2~ ou T~2~ implémente T~1~ la méthodeT~2~ op_Explicit(T1)
• T~1~ T~2~ où T~2~ implémente un constructeur prenant un seul argument de typeT~1~
• L’une des conversions suivantes :
  • chaîne à l’endroit T où T implémente une méthode T Parse(string) statique ou T Parse(string, IFormatProvider)
  • T~1~ T~2~ où T~2~ se trouve n’importe quelle énumération et T~1~ est une chaîne ou une collection d’objets qui peuvent être convertis en chaîne
• T vers PSObject où T se trouve n’importe quel type
• L’une des conversions suivantes : Language
  • T pour bool où T est n’importe quel type numérique
  • chaîne à T l’endroit où T est regex, , wmisearcherwmi, wmiclass, adsi, adsisearcheroutype
  • T à bool
  • T~1~ vers Nullable[T~2~] l’endroit où une conversion vers T~1~T~2~ existe
  • T à vider
  • T~1~[] vers T~2~[] l’emplacement où une conversion assignable entre T~1~ et T~2~ existe
  • T~1~ T~1~ où T~2~[] se trouve une collection
  • IDictionary à Hashtable
  • T à ref
  • T à xml
  • scriptblock à delegate
  • T~1~ T~1~ où T~2~ est un type entier et T~2~ est une énumération
• $null T où T se trouve n’importe quel type de valeur
• $null T où T se trouve n’importe quel type de référence
• L’une des conversions suivantes :

  • octet vers l’emplacement TT où se trouve SByte

  • UInt16 à T l’endroit où T est SByte, byteou Int16

  • Int16à l’emplacement ou à T l’emplacement TSBytebyte

  • UInt32 à T l’endroit où T est SByte, byte, Int16, UInt16, ou int

  • int à T l’emplacement TSByte, byte, Int16ou UInt16

  • UInt64à T l’endroit où T est SByte, , byteInt16, UInt16, int, UInt32oulong

  • longà T l’emplacement T où est SByte, , byteInt16, UInt16, int, ouUInt32

  • float T où T est n’importe quel type entier oudecimal

  • double T où T est n’importe quel type entier oudecimal

  • decimal T où T est n’importe quel type entier

• L’une des conversions suivantes :
  • SByte à T l’emplacement Tbyte, uint6, UInt32ou UInt64
  • Int16 à T l’endroit où T est UInt16, UInt32ou UInt64
  • intà l’emplacement ou à T l’emplacement TUInt32UInt64
  • long à UInt64
  • decimalà l’emplacement ou à T l’emplacement Tfloatdouble
• L’une des conversions suivantes :
  • T T où string se trouve n’importe quel type numérique
  • T T où char se trouve n’importe quel type numérique
  • string T où T se trouve n’importe quel type numérique
• Toutes les conversions suivantes sont considérées comme des conversions assignables :
  • byteoù T est Int16, , UInt16int, UInt32, singlelongUInt64, ou doubleTdecimal
  • SByteoù T est Int16, , UInt16int, UInt32, singlelongUInt64, ou doubleTdecimal
  • UInt16 à T l’endroit où T est int, UInt32, long, ou UInt64, single, doubleou decimal
  • Int16 à T l’endroit où T est int, UInt32, long, ou UInt64, single, doubleou decimal
  • UInt32 à T l’emplacement T où est long, ou UInt64, single, , doubleou decimal
  • int à T l’endroit où T est long, UInt64, single, double, ou decimal
  • single à double
• T~1~ T~2~ où T~2~ est une classe de base ou une interface de T~1~. Cette conversion est considérée comme une conversion assignable.
• string à char[]
• T en T -- Cette conversion est considérée comme une conversion assignable.

Pour chaque conversion du formulaire T~1~ vers l’endroit T~1~ où n’est pas un tableau et aucune autre conversion ne s’applique, s’il existe une conversion à partir T~1~T~2~de , le rang de la conversion est pire que la conversion vers T~1~T~2~, mais mieux que toute conversion classée inférieure à la conversion de T~1~ vers T~2~[]T~2~

3.8 Recherche de noms

Il est possible d’avoir des commandes de différentes sortes qui ont le même nom. L’ordre dans lequel la recherche de noms est effectuée dans ce cas est l’alias, la fonction, l’applet de commande et la commande externe.

3.9 Recherche de nom de type

§7.1.10 contient l’instruction « Un littéral de type est représenté dans une implémentation par un type sous-jacent non spécifié. Par conséquent, un nom de type est un synonyme de son type sous-jacent. Voici des exemples de types : int, double, long[]et Hashtable.

Les noms de types sont mis en correspondance comme suit : comparez un nom de type donné à la liste des accélérateurs de type intégrés, tels que int, long, double. Si une correspondance est trouvée, il s’agit du type. Sinon, présumez que le nom du type est complet et vérifiez si ce type existe sur le système hôte. Si une correspondance est trouvée, il s’agit du type. Sinon, ajoutez le préfixe System.d’espace de noms . Si une correspondance est trouvée, il s’agit du type. Sinon, le nom du type est en erreur. Cet algorithme est appliqué pour chaque argument de type pour les types génériques. Toutefois, il n’est pas nécessaire de spécifier l’arité (nombre d’arguments ou d’opérandes pris par une fonction ou un opérateur).

3.10 Gestion automatique de la mémoire

Différents opérateurs et applets de commande entraînent l’allocation de mémoire pour les objets de type référence, tels que les chaînes et les tableaux. L’allocation et la libération de cette mémoire sont gérées par le système d’exécution PowerShell. Autrement dit, PowerShell fournit un garbage collection automatique.

3.11 Ordre d’exécution

Un effet secondaire est une modification de l’état de l’environnement d’exécution d’une commande. Une modification de la valeur d’une variable (via les opérateurs d’affectation ou les opérateurs de pré-incrémentation et de décrémentation) est un effet secondaire, car il s’agit d’une modification du contenu d’un fichier.

Sauf indication contraire, les instructions sont exécutées dans l’ordre lexical.

À l’exception de certains opérateurs, l’ordre d’évaluation des termes dans une expression et l’ordre dans lequel les effets secondaires ont lieu ne sont pas spécifiés.

Une expression qui appelle une commande implique l’expression qui désigne la commande, et zéro ou plusieurs expressions qui désignent les arguments dont les valeurs doivent être passées à cette commande. L’ordre dans lequel ces expressions sont évaluées par rapport aux autres n’est pas spécifié.

3.12 Gestion des erreurs

Lorsqu’une commande échoue, elle est considérée comme une erreur et des informations sur cette erreur sont enregistrées dans un enregistrement d’erreur, dont le type n’est pas spécifié (§4.5.15) ; toutefois, ce type prend en charge l’indice.

Une erreur se situe dans l’une des deux catégories. Soit il met fin à l’opération (une erreur de fin) soit elle ne l’arrête pas ( une erreur non terminée). Avec une erreur de fin, l’erreur est enregistrée et l’opération s’arrête. Avec une erreur sans fin, l’erreur est enregistrée et l’opération se poursuit.

Les erreurs sans fin sont écrites dans le flux d’erreurs. Bien que ces informations puissent être redirigées vers un fichier, les objets d’erreur sont d’abord convertis en chaînes et des informations importantes dans ces objets ne seraient pas capturés en rendant le diagnostic difficile s’il n’est pas impossible. Au lieu de cela, le texte d’erreur peut être redirigé (§7.12) et l’objet d’erreur enregistré dans une variable, comme dans $Error1 = command 2>&1.

La variable $Error automatique contient une collection d’enregistrements d’erreurs qui représentent des erreurs récentes, et l’erreur la plus récente se trouve dans $Error[0]. Cette collection est conservée dans une mémoire tampon de sorte que les anciens enregistrements soient ignorés à mesure que de nouveaux enregistrements sont ajoutés. La variable $MaximumErrorCount automatique contrôle le nombre d’enregistrements pouvant être stockés.

$Error contient toutes les erreurs de toutes les commandes mélangées dans une collection. Pour collecter les erreurs à partir d’une commande spécifique, utilisez le paramètre common ErrorVariable, qui permet à une variable définie par l’utilisateur d’être spécifiée pour contenir la collection.

3.13 Pipelines

Un pipeline est une série d’une ou plusieurs commandes chacune séparées par l’opérateur | de canal (U+007C). Chaque commande reçoit l’entrée de son prédécesseur et écrit la sortie dans son successeur. Sauf si la sortie à la fin du pipeline est ignorée ou redirigée vers un fichier, elle est envoyée à l’environnement hôte, qui peut choisir de l’écrire dans la sortie standard. Les commandes d’un pipeline peuvent également recevoir une entrée à partir d’arguments. Par exemple, considérez l’utilisation suivante des commandes Get-ChildItem, Sort-Objectet Process-File, qui créent une liste de noms de fichiers dans un répertoire de système de fichiers donné, trient un ensemble d’enregistrements de texte et effectuent un traitement sur un enregistrement de texte, respectivement :

Get-ChildItem
Get-ChildItem E:*.txt | Sort-Object -CaseSensitive | Process-File >results.txt

Dans le premier cas, Get-ChildItem crée une collection de noms des fichiers dans le répertoire actif/par défaut. Cette collection est envoyée à l’environnement hôte, qui écrit par défaut la valeur de chaque élément dans la sortie standard.

Dans le deuxième cas, Get-ChildItem crée une collection de noms des fichiers dans le répertoire spécifié, à l’aide de l’argument E:*.txt. Cette collection est écrite dans la commande Sort-Object, qui, par défaut, les trie dans l’ordre croissant, sensibles à la casse (en vertu de l’argument CaseSensitive ). La collection résultante est ensuite écrite en commande Process-File, qui effectue un traitement (inconnu). La sortie de cette commande est ensuite redirigée vers le fichier results.txt.

Si une commande écrit un seul objet, son successeur reçoit cet objet, puis se termine après avoir écrit son propre objet dans son successeur. Toutefois, si une commande écrit plusieurs objets, elles sont remises une à la fois à la commande successeur, qui s’exécute une fois par objet. Ce comportement est appelé streaming. Dans le traitement de flux, les objets sont écrits le long du pipeline dès qu’ils sont disponibles, et non lorsque la collection entière a été produite.

Lors du traitement d’une collection, une commande peut être écrite de telle sorte qu’elle puisse effectuer un traitement spécial avant l’élément initial et après l’élément final.

3.14 Modules

Un module est une unité réutilisable autonome qui permet au code PowerShell d’être partitionné, organisé et abstrait. Un module peut contenir des commandes (telles que des applets de commande et des fonctions) et des éléments (tels que des variables et des alias) qui peuvent être utilisés en tant qu’unité unique.

Une fois qu’un module a été créé, il doit être importé dans une session avant que les commandes et les éléments qu’il puisse utiliser. Une fois importés, les commandes et les éléments se comportent comme s’ils étaient définis localement. Un module est importé explicitement avec la Import-Module commande. Un module peut également être importé automatiquement comme déterminé de manière définie par l’implémentation.

Le type d’un objet qui représente un module est décrit dans le §4.5.12.

Les modules sont abordés en détail dans le §11.

3.15 Expressions génériques

Une expression générique peut contenir zéro ou plusieurs des éléments suivants :

Élément	Descriptif
Caractère autre que *, ?, ou [	Correspond à ce caractère
*	Correspond à zéro ou plusieurs caractères. Pour faire correspondre un caractère *, utilisez [*].
?	Correspond à n’importe quel caractère. Pour faire correspondre un ? character, use [ ?].
[set]	Correspond à n’importe quel caractère du jeu, qui ne peut pas être vide. Si l’ensemble commence par ], ce crochet droit est considéré comme faisant partie du jeu et le crochet droit suivant met fin à l’ensemble ; sinon, le premier crochet droit met fin à l’ensemble. Si le jeu commence ou se termine par -, ce trait d’union-moins est considéré comme faisant partie de l’ensemble ; sinon, il indique une plage de points de code Unicode consécutifs avec les caractères de chaque côté du trait d’union-moins étant les délimiteurs de plages inclusives. Par exemple, A-Z indique les 26 lettres anglaises majuscules, et 0-9 indique les 10 chiffres décimaux.

Remarque

Pour plus d’informations, consultez les spécifications de base open group : critères de correspondance de modèle », IEEE Std 1003.1, 2004 Edition.. Toutefois, dans PowerShell, le caractère d’échappement est backtick, pas la barre oblique inverse.

3.16 Expressions régulières

Une expression régulière peut contenir zéro ou plusieurs des éléments suivants :

Élément	Descriptif
Caractère autre que ., [, ^, *, $ou \	Correspond à ce caractère
.	Correspond à n’importe quel caractère. Pour faire correspondre un . character, use \..
[set] [^set]	Le formulaire [set] correspond à n’importe quel caractère de l’ensemble. Le formulaire [^set] ne correspond à aucun caractère du jeu. set ne peut pas être vide. Si le jeu commence par ] ou ^], ce crochet droit est considéré comme faisant partie du jeu et le crochet droit suivant met fin à l’ensemble ; sinon, le premier crochet droit met fin à l’ensemble. Si l’ensemble commence par - ou ^-, ou se termine par -, ce trait d’union-moins est considéré comme faisant partie de l’ensemble ; sinon, il indique une plage de points de code Unicode consécutifs avec les caractères de chaque côté du trait d’union-moins étant les délimiteurs de plages inclusives. Par exemple, A-Z indique les 26 lettres anglaises majuscules, et 0-9 indique les 10 chiffres décimaux.
*	Correspond à zéro d’occurrences supplémentaires de l’élément précédent.
+	Correspond à l’une des occurrences de l’élément précédent.
?	Correspond à zéro d’une occurrence de l’élément précédent.
^	Correspond au début de la chaîne. Pour faire correspondre un caractère ^, utilisez \^.
$	Correspond à la fin de la chaîne. Pour faire correspondre un caractère $, utilisez $.
\ c	Échappe le caractère c, de sorte qu’il n’est pas reconnu comme un élément d’expression régulière.

Remarque

Pour plus d’informations, consultez Les spécifications de base open group : Expressions régulières, IEEE Std 1003.1, édition 2004..

Windows PowerShell : Les classes de caractères disponibles dans les expressions régulières microsoft .NET Framework sont prises en charge, comme suit :

Élément	Descriptif
\p{name}	Correspond à n’importe quel caractère dans la classe de caractères nommée spécifiée par son nom. Les noms pris en charge sont des groupes Unicode et des plages de blocs telles que Ll, Nd, Z, IsGreek et IsBoxDrawing.
\P{name}	Correspond au texte non inclus dans les groupes et plages de blocs spécifiées dans le nom.
\w	Correspond à n’importe quel caractère de mot. Équivalent aux catégories [\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]de caractères Unicode . Si le comportement conforme à ECMAScript est spécifié avec l’option ECMAScript, \w est équivalent à [a-zA-Z_0-9].
\W	Correspond à n’importe quel caractère non word. Équivalent aux catégories [\^\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}\p{Pc}]Unicode .
\s	Correspond à n’importe quel espace blanc. Équivalent aux catégories [\f\n\r\t\v\x85\p{Z}] de caractères Unicode.
\S	Correspond à n’importe quel caractère d’espace non blanc. Équivalent aux catégories [\^\f\n\r\t\v\x85\p{Z}]de caractères Unicode .
\d	Correspond à n’importe quel chiffre décimal. Équivalent à \p{Nd} Unicode et [0-9] pour le comportement non-Unicode.
\D	Correspond à n’importe quel chiffre. Équivalent à \P{Nd} Unicode et [\^0-9] pour le comportement non-Unicode.

Les quantificateurs disponibles dans les expressions régulières microsoft .NET Framework sont pris en charge, comme suit :

Élément	Descriptif
*	Spécifie zéro ou plusieurs correspondances ; par exemple, \w* ou (abc)*. équivalent à {0,}.
+	Correspond aux instances répétées des caractères précédents.
?	Spécifie zéro ou une correspondance ; par exemple, \w? ou (abc)?. Équivalent à {0,1}.
{n}	Spécifie exactement n correspondances ; par exemple, (pizza){2}.
{n,}	Spécifie au moins n correspondances ; par exemple, (abc){2,}.
{n,m}	Spécifie au moins n, mais pas plus de m, correspond.