about_Automatic_Variables
Description courte
Décrit les variables qui stockent des informations d’état pour et qui sont créées et gérées par PowerShell.
D’un point de vue conceptuel, la plupart de ces variables sont considérées comme en lecture seule. Bien qu’ils puissent être écrits dans, pour la compatibilité descendante, ils ne doivent pas être écrits dans.
Voici la liste des variables automatiques dans PowerShell :
- $$
- $?
- $^
- $_
- $args
- $ConsoleFileName
- $EnabledExperimentalFeatures
- $Error
- $Event
- $EventArgs
- $EventSubscriber
- $ExecutionContext
- $false
- $foreach
- $HOME
- $Host
- $input
- $IsCoreCLR
- $IsLinux
- $IsMacOS
- $IsWindows
- $LASTEXITCODE
- $Matches
- $MyInvocation
- $NestedPromptLevel
- $null
- $PID
- $PROFILE
- $PSBoundParameters
- $PSCmdlet
- $PSCommandPath
- $PSCulture
- $PSDebugContext
- $PSEdition
- $PSHOME
- $PSItem
- $PSScriptRoot
- $PSSenderInfo
- $PSUICulture
- $PSVersionTable
- $PWD
- $Sender
- $ShellId
- $StackTrace
- $switch
- $this
- $true
Description longue
$$
Contient le dernier jeton de la dernière ligne reçue par la session.
$?
Contient la status d’exécution de la dernière commande. Elle contient True si la dernière commande a réussi et False si elle a échoué.
Pour les applets de commande et les fonctions avancées qui sont exécutées à plusieurs étapes dans un pipeline, par exemple dans les process
blocs et end
, l’appel this.WriteError()
ou $PSCmdlet.WriteError()
à n’importe quel point a la valeur $?
False, comme le fait this.ThrowTerminatingError()
et $PSCmdlet.ThrowTerminatingError()
.
L’applet Write-Error
de commande définit $?
toujours la valeur False immédiatement après son exécution, mais n’a pas la valeur $?
False pour une fonction qui l’appelle :
function Test-WriteError
{
Write-Error "Bad"
"The `$? variable is: $?"
}
Test-WriteError
"Now the `$? variable is: $?"
Test-WriteError:
Line |
7 | Test-WriteError
| ~~~~~~~~~~~~~~~
| Bad
The $? variable is: False
Now the $? variable is: True
Dans ce dernier but, $PSCmdlet.WriteError()
doit être utilisé à la place.
Pour les commandes natives (exécutables), $?
est défini sur True quand $LASTEXITCODE
est 0 et défini sur False quand $LASTEXITCODE
est toute autre valeur.
Notes
Jusqu’à ce que PowerShell 7, l’encapsulation d’une instruction entre parenthèses (...)
, la syntaxe $(...)
de sous-expression ou une expression @(...)
de tableau soit toujours réinitialisée $?
à True. Par exemple, (Write-Error)
affiche $?
la valeur True. Ce comportement a changé dans PowerShell 7, de sorte qu’il $?
reflète toujours la réussite réelle de la dernière exécution de la commande dans ces expressions.
$^
Contient le premier jeton de la dernière ligne reçue par la session.
$_
Comme pour $PSItem
. Contient l’objet actuel dans l’objet pipeline. Vous pouvez utiliser cette variable dans les commandes qui effectuent une action sur chaque objet d’un pipeline.
Pour plus d’informations, consultez about_PSItem.
$args
Contient un tableau de valeurs pour les paramètres non déclarés qui sont passés à une fonction, un script ou un bloc de script. Lorsque vous créez une fonction, vous pouvez déclarer les paramètres avec le param
mot clé ou en ajoutant une liste de paramètres séparés par des virgules entre parenthèses après le nom de la fonction.
Dans une action d’événement, la $args
variable contient des objets qui représentent les arguments d’événement de l’événement en cours de traitement. Cette variable est remplie uniquement dans le Action
bloc d’une commande d’inscription d’événement. La valeur de cette variable se trouve également dans la propriété SourceArgs de l’objet PSEventArgs qui Get-Event
retourne.
$ConsoleFileName
Contient le chemin d’accès du fichier console (.psc1
) qui a été utilisé le plus récemment dans la session. Cette variable est remplie lorsque vous démarrez PowerShell avec le paramètre PSConsoleFile ou lorsque vous utilisez l’applet de commande pour exporter des Export-Console
noms de composants logiciels enfichables dans un fichier console.
Lorsque vous utilisez l’applet de Export-Console
commande sans paramètres, elle met automatiquement à jour le fichier de console qui a été utilisé le plus récemment dans la session. Vous pouvez utiliser cette variable automatique pour déterminer le fichier à mettre à jour.
$EnabledExperimentalFeatures
Contient la liste des noms des fonctionnalités expérimentales activées.
$Error
Contient un tableau d’objets d’erreur qui représentent les erreurs les plus récentes. L’erreur la plus récente est le premier objet d’erreur dans le tableau $Error[0]
.
Pour empêcher l’ajout d’une erreur au $Error
tableau, utilisez le paramètre commun ErrorAction avec la valeur Ignore. Pour plus d’informations, consultez about_CommonParameters.
$Event
Contient un objet PSEventArgs qui représente l’événement en cours de traitement. Cette variable est renseignée uniquement dans le Action
bloc d’une commande d’inscription d’événements, telle que Register-ObjectEvent
. La valeur de cette variable est le même objet que celui retourné par l’applet de Get-Event
commande. Vous pouvez utiliser les propriétés de la Event
variable, telles que $Event.TimeGenerated
, dans un bloc de Action
script.
$EventArgs
Contient un objet qui représente le premier argument d’événement dérivé d’EventArgs de l’événement en cours de traitement. Cette variable est remplie uniquement dans le Action
bloc d’une commande d’inscription d’événement. La valeur de cette variable se trouve également dans la propriété SourceEventArgs de l’objet PSEventArgs qui Get-Event
retourne.
$EventSubscriber
Contient un objet PSEventSubscriber qui représente l’abonné à l’événement en cours de traitement. Cette variable est remplie uniquement dans le Action
bloc d’une commande d’inscription d’événement. La valeur de cette variable est le même objet que celui retourné par l’applet de Get-EventSubscriber
commande.
$ExecutionContext
Contient un objet EngineIntrinsics qui représente le contexte d’exécution de l’hôte PowerShell. Vous pouvez utiliser cette variable pour rechercher les objets d’exécution disponibles pour les applets de commande.
$false
Contient false. Vous pouvez utiliser cette variable pour représenter False dans les commandes et les scripts au lieu d’utiliser la chaîne "false"
. La chaîne peut être interprétée comme true si elle est convertie en chaîne non vide ou en entier autre que zéro.
$foreach
Contient l’énumérateur (et non les valeurs résultantes) d’une boucle ForEach . La $ForEach
variable existe uniquement pendant l’exécution de la ForEach
boucle ; elle est supprimée une fois la boucle terminée.
Les énumérateurs contiennent des propriétés et des méthodes que vous pouvez utiliser pour récupérer des valeurs de boucle et modifier l’itération de boucle actuelle. Pour plus d’informations, consultez Utilisation d’énumérateurs.
$HOME
Contient le chemin d’accès complet du répertoire de base de l’utilisateur. Sur Windows, cette variable utilise la valeur de la "$env:USERPROFILE"
variable d’environnement Windows, généralement C:\Users\<UserName>
. Sur Unix, cette variable utilise la valeur de la variable d’environnement HOME
.
Important
Windows peut rediriger l’emplacement du profil de l’utilisateur. Cela signifie que $HOME
peut ne pas avoir la même valeur que "$env:HOMEDRIVE$env:HOMEPATH"
.
$Host
Contient un objet qui représente l’application hôte actuelle pour PowerShell.
Vous pouvez utiliser cette variable pour représenter l’hôte actuel dans les commandes ou pour afficher ou modifier les propriétés de l’hôte, telles que $Host.version
ou $Host.CurrentCulture
ou .$Host.UI.RawUI.BackGroundColor = "Red"
Notes
Les paramètres de couleur dans $Host.PrivateData
ont été remplacés par la variable de $PSStyle
préférence. Pour plus d’informations, consultez about_ANSI_Terminals.
$input
Contient un énumérateur qui énumère toutes les entrées passées à une fonction.
La $input
variable est disponible uniquement pour les fonctions, les blocs de script (qui sont des fonctions sans nom) et les fichiers de script (qui sont des blocs de script enregistrés).
Dans une fonction sans
begin
bloc ,process
ouend
, la$input
variable énumère la collection de toutes les entrées de la fonction.Dans le
begin
bloc, la$input
variable ne contient aucune donnée.Dans le
process
bloc, la$input
variable contient l’objet actuel dans le pipeline.Dans le
end
bloc, la$input
variable énumère la collection de toutes les entrées de la fonction.Notes
Vous ne pouvez pas utiliser la variable à l’intérieur
$input
duprocess
bloc et duend
bloc dans le même bloc de fonction ou de script.
Étant donné qu’il $input
s’agit d’un énumérateur, l’accès à l’une de ses propriétés entraîne $input
la non-disponibilité. Vous pouvez stocker $input
dans une autre variable pour réutiliser les $input
propriétés.
Les énumérateurs contiennent des propriétés et des méthodes que vous pouvez utiliser pour récupérer des valeurs de boucle et modifier l’itération de boucle actuelle. Pour plus d’informations, consultez Utilisation d’énumérateurs.
La $input
variable est également disponible pour la commande spécifiée par le -Command
paramètre de lorsqu’elle pwsh
est appelée à partir de la ligne de commande. L’exemple suivant est exécuté à partir de l’interpréteur de commandes Windows.
echo Hello | pwsh -Command """$input World!"""
$IsCoreCLR
Contient $True
si la session active s’exécute sur le runtime .NET Core (CoreCLR). Sinon, contient $False
.
$IsLinux
Contient $True
si la session active s’exécute sur un système d’exploitation Linux.
Sinon, contient $False
.
$IsMacOS
Contient $True
si la session active s’exécute sur un système d’exploitation MacOS.
Sinon, contient $False
.
$IsWindows
Contient $TRUE
si la session active s’exécute sur un système d’exploitation Windows. Sinon, contient $FALSE
.
$LASTEXITCODE
Contient le code de sortie du dernier programme natif ou script PowerShell qui a été exécuté.
Pour les scripts PowerShell, la valeur de dépend de $LASTEXITCODE
la façon dont le script a été appelé et si le exit
mot clé a été utilisé :
Lorsqu’un script utilise le
exit
mot clé :$LASTEXITCODE
est défini sur la valeur spécifiée par leexit
mot clé. Pour plus d’informations, consultez about_Language_Keywords.Lorsqu’un script est appelé directement, par exemple
./Test.ps1
, ou avec l’opérateur d’appel (&
) comme& ./Test.ps1
:La valeur de
$LASTEXITCODE
n’est pas modifiée, sauf si :- Le script appelle un autre script qui utilise le
exit
mot clé - Le script appelle une commande native
- Le script utilise le
exit
mot clé
- Le script appelle un autre script qui utilise le
Lorsqu’un script est appelé avec
pwsh
à l’aide du paramètre File ,$LASTEXITCODE
est défini sur :1
si le script s’est arrêté en raison d’une exception- Valeur spécifiée par le
exit
mot clé, si elle est utilisée dans le script 0
si le script s’est terminé avec succès
Lorsqu’un script est appelé avec
pwsh
à l’aide du paramètre Command ,$LASTEXITCODE
est défini sur :1
si le script s’est arrêté en raison d’une exception ou si le résultat de la dernière commande est défini sur$?
$false
0
si le script s’est terminé correctement et si le résultat de la dernière commande est défini sur$?
$true
Pour plus d’informations sur les paramètres File et Command , consultez about_Pwsh.
$Matches
La $Matches
variable fonctionne avec les -match
opérateurs et -notmatch
. Lorsque vous envoyez une entrée scalaire à l’opérateur -match
ou -notmatch
et que l’un ou l’autre détecte une correspondance, ils retournent une valeur booléenne et remplissent la $Matches
variable automatique avec une table de hachage de toutes les valeurs de chaîne qui ont été mises en correspondance. La $Matches
table de hachage peut également être remplie avec des captures lorsque vous utilisez des expressions régulières avec l’opérateur -match
.
Pour plus d’informations sur l’opérateur -match
, consultez about_Comparison_Operators. Pour plus d’informations sur les expressions régulières, consultez about_Regular_Expressions.
La $Matches
variable fonctionne également dans une switch
instruction avec le -Regex
paramètre . Il est rempli de la même façon que les -match
opérateurs et -notmatch
. Pour plus d’informations sur l’instruction switch
, consultez about_Switch.
Notes
Quand $Matches
est renseigné dans une session, il conserve la valeur correspondante jusqu’à ce qu’elle soit remplacée par une autre correspondance. Si -match
est à nouveau utilisé et qu’aucune correspondance n’est trouvée, elle ne se réinitialise $Matches
pas à $null
. La valeur précédemment correspondante est conservée dans jusqu’à ce qu’une $Matches
autre correspondance soit trouvée.
$MyInvocation
Contient des informations sur la commande active, telles que le nom, les paramètres, les valeurs de paramètre et des informations sur la façon dont la commande a été démarrée, appelée ou appelée, comme le nom du script qui a appelé la commande active.
$MyInvocation
est renseigné uniquement pour les scripts, les fonctions et les blocs de script. Vous pouvez utiliser les informations de l’objet System.Management.Automation.InvocationInfo qui $MyInvocation
retourne dans le script actif, comme le nom d’une fonction ($MyInvocation.MyCommand.Name
) pour identifier la commande active.
Cela est utile pour rechercher le nom du script actuel.
À partir de PowerShell 3.0, MyInvocation
possède les nouvelles propriétés suivantes.
- PSScriptRoot : contient le chemin d’accès complet au script qui a appelé la commande actuelle. La valeur de cette propriété est renseignée uniquement lorsque l’appelant est un script.
- PSCommandPath : contient le chemin d’accès complet et le nom du fichier du script qui a appelé la commande actuelle. La valeur de cette propriété est renseignée uniquement lorsque l’appelant est un script.
$PSScriptRoot
Contrairement aux variables automatiques et$PSCommandPath
, les propriétés PSScriptRoot et PSCommandPath de la $MyInvocation
variable automatique contiennent des informations sur l’appelant ou le script appelant, et non sur le script actuel.
$NestedPromptLevel
Contient le niveau d’invite actuel. La valeur 0 indique le niveau d’invite d’origine. La valeur est incrémentée lorsque vous entrez un niveau imbriqué et décrémentée lorsque vous le quittez.
Par exemple, PowerShell présente une invite de commandes imbriquée lorsque vous utilisez la $Host.EnterNestedPrompt
méthode . PowerShell présente également une invite de commandes imbriquée lorsque vous atteignez un point d’arrêt dans le débogueur PowerShell.
Lorsque vous entrez une invite imbriquée, PowerShell suspend la commande actuelle, enregistre le contexte d’exécution et incrémente la valeur de la $NestedPromptLevel
variable. Pour créer des invites de commandes imbriquées supplémentaires (jusqu’à 128 niveaux) ou pour revenir à l’invite de commandes d’origine, effectuez la commande ou tapez exit
.
La $NestedPromptLevel
variable vous aide à suivre le niveau d’invite. Vous pouvez créer une autre invite de commandes PowerShell qui inclut cette valeur afin qu’elle soit toujours visible.
$null
$null
est une variable automatique qui contient une valeur null ou vide. Vous pouvez utiliser cette variable pour représenter une valeur absente ou non définie dans les commandes et les scripts.
PowerShell traite $null
comme un objet avec une valeur ou un espace réservé. Vous pouvez donc l’utiliser $null
pour représenter une valeur vide dans une collection de valeurs.
Par exemple, quand $null
est inclus dans une collection, il est compté comme l’un des objets.
$a = "one", $null, "three"
$a.count
3
Si vous dirigez la $null
variable vers l’applet ForEach-Object
de commande, elle génère une valeur pour $null
, comme elle le fait pour les autres objets
"one", $null, "three" | ForEach-Object { "Hello " + $_}
Hello one
Hello
Hello three
Par conséquent, vous ne pouvez pas utiliser $null
pour signifier aucune valeur de paramètre. Une valeur de paramètre de $null
remplace la valeur de paramètre par défaut.
Toutefois, étant donné que PowerShell traite la $null
variable comme un espace réservé, vous pouvez l’utiliser dans des scripts comme le suivant, qui ne fonctionneraient pas si $null
elles étaient ignorées.
$calendar = @($null, $null, "Meeting", $null, $null, "Team Lunch", $null)
$days = "Sunday","Monday","Tuesday","Wednesday","Thursday",
"Friday","Saturday"
$currentDay = 0
foreach($day in $calendar)
{
if($day -ne $null)
{
"Appointment on $($days[$currentDay]): $day"
}
$currentDay++
}
Appointment on Tuesday: Meeting
Appointment on Friday: Team lunch
$PID
Contient l’identificateur de processus (PID) du processus qui héberge la session PowerShell actuelle.
$PROFILE
Contient le chemin d’accès complet du profil PowerShell pour l’utilisateur actuel et l’application hôte actuelle. Vous pouvez utiliser cette variable pour représenter le profil dans les commandes. Par exemple, vous pouvez l’utiliser dans une commande pour déterminer si un profil a été créé :
Test-Path $PROFILE
Vous pouvez également l’utiliser dans une commande pour créer un profil :
New-Item -ItemType file -Path $PROFILE -Force
Vous pouvez l’utiliser dans une commande pour ouvrir le profil dans notepad.exe:
notepad.exe $PROFILE
$PSBoundParameters
Contient un dictionnaire des paramètres passés à un script ou à une fonction et de leurs valeurs actuelles. Cette variable a une valeur uniquement dans une étendue où les paramètres sont déclarés, tels qu’un script ou une fonction. Vous pouvez l’utiliser pour afficher ou modifier les valeurs actuelles des paramètres ou pour passer des valeurs de paramètres à un autre script ou fonction.
Dans cet exemple, la fonction Test2 transmet le $PSBoundParameters
à la fonction Test1 . Les $PSBoundParameters
sont affichés au format Clé et Valeur.
function Test1 {
param($a, $b)
# Display the parameters in dictionary format.
$PSBoundParameters
}
function Test2 {
param($a, $b)
# Run the Test1 function with $a and $b.
Test1 @PSBoundParameters
}
Test2 -a Power -b Shell
Key Value
--- -----
a Power
b Shell
$PSCmdlet
Contient un objet qui représente l’applet de commande ou la fonction avancée en cours d’exécution.
Vous pouvez utiliser les propriétés et les méthodes de l’objet dans votre applet de commande ou votre code de fonction pour répondre aux conditions d’utilisation. Par exemple, la propriété ParameterSetName contient le nom du jeu de paramètres utilisé, et la méthode ShouldProcess ajoute dynamiquement les paramètres WhatIf et Confirm à l’applet de commande.
Pour plus d’informations sur la $PSCmdlet
variable automatique, consultez about_Functions_CmdletBindingAttribute et about_Functions_Advanced.
$PSCommandPath
Contient le chemin d’accès complet et le nom de fichier du script en cours d’exécution. Cette variable est valide dans tous les scripts.
$PSCulture
À partir de PowerShell 7, $PSCulture
reflète la culture de l’runspace PowerShell actuel (session). Si la culture est modifiée dans un runspace PowerShell, la $PSCulture
valeur de cet runspace est mise à jour.
La culture détermine le format d’affichage des éléments tels que les nombres, la devise et les dates, et est stockée dans un objet System.Globalization.CultureInfo . Permet Get-Culture
d’afficher la culture de l’ordinateur. $PSCulture
contient la valeur de la propriété Name .
$PSDebugContext
Lors du débogage, cette variable contient des informations sur l’environnement de débogage. Sinon, il contient une valeur null . Par conséquent, vous pouvez l’utiliser pour déterminer si le débogueur a le contrôle. Une fois renseigné, il contient un objet PsDebugContext qui a des propriétés Points d’arrêt et InvocationInfo . La propriété InvocationInfo possède plusieurs propriétés utiles, notamment la propriété Location . La propriété Location indique le chemin d’accès du script en cours de débogage.
$PSEdition
Contient la même valeur dans $PSVersionTable.PSEdition
. Cette variable est disponible pour une utilisation dans les fichiers manifeste de module, alors que $PSVersionTable
ce n’est pas le cas.
$PSHOME
Contient le chemin d’accès complet du répertoire d’installation de PowerShell, généralement, C:\Program Files\PowerShell\7
dans les systèmes Windows. Vous pouvez utiliser cette variable dans les chemins d’accès des fichiers PowerShell. Par exemple, la commande suivante recherche le mot Aide dans les rubriques d’aide conceptuelles :
Select-String -Pattern Help -Path $PSHOME\en-US\*.txt
$PSItem
Comme pour $_
. Contient l’objet actuel dans l’objet pipeline. Vous pouvez utiliser cette variable dans les commandes qui effectuent une action sur chaque objet d’un pipeline.
Pour plus d’informations, consultez about_PSItem.
$PSScriptRoot
Contient le chemin d’accès complet du répertoire parent du script en cours d’exécution.
Dans PowerShell 2.0, cette variable est valide uniquement dans les modules de script (.psm1
).
À compter de PowerShell 3.0, il est valide dans tous les scripts.
$PSSenderInfo
Contient des informations sur l’utilisateur qui a démarré la session PSSession, notamment l’identité de l’utilisateur et le fuseau horaire de l’ordinateur d’origine. Cette variable est disponible uniquement dans PSSessions.
La $PSSenderInfo
variable inclut une propriété configurable par l’utilisateur, ApplicationArguments, qui, par défaut, contient uniquement le $PSVersionTable
de la session d’origine. Pour ajouter des données à la propriété ApplicationArguments , utilisez le paramètre ApplicationArguments de l’applet New-PSSessionOption
de commande.
$PSUICulture
Contient le nom de la culture d’interface utilisateur configurée dans le système d’exploitation. La culture d'interface utilisateur détermine les chaînes de texte utilisées pour les éléments d'interface utilisateur, tels que les menus et les messages. Il s’agit de la valeur de System.Globalization.CultureInfo.CurrentUICulture.Name propriété du système. Pour obtenir l’objet System.Globalization.CultureInfo pour le système, utilisez l’applet de Get-UICulture
commande .
$PSVersionTable
Contient une table de hachage en lecture seule qui affiche des détails sur la version de PowerShell en cours d’exécution dans la session active. Le tableau comprend les éléments suivants :
- PSVersion : numéro de version de PowerShell
- PSEdition Cette propriété a la valeur « Desktop » pour PowerShell 4 et versions ultérieures, ainsi que PowerShell 5.1 sur les éditions Windows complètes. Cette propriété a la valeur de
Core
pour PowerShell 6 et versions ultérieures, ainsi que pour Windows PowerShell 5.1 sur les éditions à encombrement réduit comme Windows Nano Server ou Windows IoT. - GitCommitId : ID de validation des fichiers sources, dans GitHub,
- Système d’exploitation : description du système d’exploitation sur lequel PowerShell s’exécute.
- Plateforme : plateforme sur laquelle le système d’exploitation s’exécute. La valeur sur Linux et macOS est Unix. Localisez
$IsMacOs
et$IsLinux
. - PSCompatibleVersions : versions de PowerShell compatibles avec la version actuelle
- PSRemotingProtocolVersion : version du protocole de gestion à distance PowerShell.
- SérialisationVersion : version de la méthode de sérialisation
- WSManStackVersion : numéro de version de la pile WS-Management
$PWD
Contient un objet path qui représente le chemin d’accès complet de l’emplacement du répertoire actif pour l’instance d’exécution PowerShell actuelle.
Notes
PowerShell prend en charge plusieurs runspaces par processus. Chaque runspace a son propre répertoire actif. Ce n’est pas la même chose que le répertoire actif du processus : [System.Environment]::CurrentDirectory
.
$Sender
Contient l’objet qui a généré cet événement. Cette variable est remplie uniquement dans le bloc Action d’une commande d’inscription d’événement. La valeur de cette variable se trouve également dans la propriété Sender de l’objet PSEventArgs qui Get-Event
retourne.
$ShellId
Contient l’identificateur de l’interpréteur de commandes actuel.
$StackTrace
Contient une trace de pile pour l’erreur la plus récente.
$switch
Contient l’énumérateur et non les valeurs résultantes d’une Switch
instruction. La $switch
variable existe uniquement pendant l’exécution de l’instruction Switch
; elle est supprimée lorsque l’exécution de l’instruction switch
est terminée. Pour plus d’informations, consultez about_Switch.
Les énumérateurs contiennent des propriétés et des méthodes que vous pouvez utiliser pour récupérer des valeurs de boucle et modifier l’itération de boucle actuelle. Pour plus d’informations, consultez Utilisation d’énumérateurs.
$this
La $this
variable est utilisée dans les blocs de script qui étendent les classes pour faire référence à la instance de la classe elle-même.
Le système de type extensible (ETS) de PowerShell vous permet d’ajouter des propriétés aux classes à l’aide de blocs de script. Dans un bloc de script qui définit une propriété de script ou une méthode de script, la $this
variable fait référence à un instance d’objet de la classe en cours d’extension. Par exemple, PowerShell utilise ETS pour ajouter la propriété BaseName à la classe FileInfo .
PS> Get-ChildItem .\README.md | Get-Member BaseName | Format-List
TypeName : System.IO.FileInfo
Name : BaseName
MemberType : ScriptProperty
Definition : System.Object BaseName {get=if ($this.Extension.Length -gt 0)
{$this.Name.Remove($this.Name.Length - $this.Extension.Length
)}else{$this.Name};}
Pour plus d’informations, consultez about_Types.ps1xml.
Dans une classe PowerShell, la $this
variable fait référence à l’objet instance de la classe elle-même, ce qui autorise l’accès aux propriétés et méthodes définies dans la classe . Pour plus d’informations, consultez about_Classes.
La $this
variable est également utilisée par les classes d’événements .NET qui acceptent des blocs de script comme délégués pour le gestionnaire d’événements. Dans ce scénario, $this
représente l’objet à l’origine de l’événement, appelé expéditeur de l’événement.
$true
Contient la valeur True. Vous pouvez utiliser cette variable pour représenter True dans les commandes et les scripts.
Utilisation d’énumérateurs
Les $input
variables , $foreach
et $switch
sont tous des énumérateurs utilisés pour itérer au sein des valeurs traitées par leur bloc de code contenant.
Un énumérateur contient des propriétés et des méthodes que vous pouvez utiliser pour avancer ou réinitialiser l’itération, ou récupérer des valeurs d’itération. La manipulation directe des énumérateurs n’est pas considérée comme une bonne pratique.
Dans les boucles, les mots clés de contrôle de flux s’arrêtent et continuent doivent être préférés.
Dans les fonctions qui acceptent l’entrée de pipeline, il est recommandé d’utiliser des paramètres avec les attributs ValueFromPipeline ou ValueFromPipelineByPropertyName .
Pour plus d’informations, consultez about_Functions_Advanced_Parameters.
MoveNext
La méthode MoveNext avance l’énumérateur vers l’élément suivant de la collection. MoveNext retourne True
si l’énumérateur a été correctement avancé, False
si l’énumérateur a passé la fin de la collection.
Notes
La valeur booléenne retournée par MoveNext est envoyée au flux de sortie.
Vous pouvez supprimer la sortie en la tapant vers [void]
ou en la dirigeant vers Out-Null.
$input.MoveNext() | Out-Null
[void]$input.MoveNext()
Reset
La Reset méthode définit l’énumérateur sur sa position initiale, qui est avant le premier élément de la collection.
Current
La Current propriété obtient l’élément dans la collection, ou pipeline, à la position actuelle de l’énumérateur.
La Current propriété continue de retourner la même propriété jusqu’à ce que MoveNext soit appelé.
Exemples
Exemple 1 : utilisation de la variable $input
Dans l’exemple suivant, l’accès à la $input
variable efface la variable jusqu’à la prochaine exécution du bloc de processus. L’utilisation de la Reset méthode réinitialise la $input
variable à la valeur de pipeline actuelle.
function Test
{
begin
{
$i = 0
}
process
{
"Iteration: $i"
$i++
"`tInput: $input"
"`tAccess Again: $input"
$input.Reset()
"`tAfter Reset: $input"
}
}
"one","two" | Test
Iteration: 0
Input: one
Access Again:
After Reset: one
Iteration: 1
Input: two
Access Again:
After Reset: two
Le bloc de processus avance automatiquement la $input
variable même si vous n’y accédez pas.
$skip = $true
function Skip
{
begin
{
$i = 0
}
process
{
"Iteration: $i"
$i++
if ($skip)
{
"`tSkipping"
$skip = $false
}
else
{
"`tInput: $input"
}
}
}
"one","two" | Skip
Iteration: 0
Skipping
Iteration: 1
Input: two
Exemple 2 : utilisation de $input en dehors du bloc de processus
En dehors du bloc de processus, la $input
variable représente toutes les valeurs redirigées vers la fonction.
- L’accès à la
$input
variable efface toutes les valeurs. - La Reset méthode réinitialise l’ensemble de la collection.
- La Current propriété n’est jamais renseignée.
- La méthode MoveNext retourne false, car la collection ne peut pas être avancée.
- L’appel de MoveNext efface la
$input
variable.
- L’appel de MoveNext efface la
Function All
{
"All Values: $input"
"Access Again: $input"
$input.Reset()
"After Reset: $input"
$input.MoveNext() | Out-Null
"After MoveNext: $input"
}
"one","two","three" | All
All Values: one two three
Access Again:
After Reset: one two three
After MoveNext:
Exemple 3 : Utilisation de la $input.Current Propriété
Avec la Current propriété , la valeur actuelle du pipeline est accessible plusieurs fois sans utiliser la Reset méthode . Le bloc de processus n’appelle pas automatiquement la méthode MoveNext .
La Current propriété n’est jamais remplie, sauf si vous appelez explicitement MoveNext. La Current propriété est accessible plusieurs fois à l’intérieur du bloc de processus sans effacer sa valeur.
function Current
{
begin
{
$i = 0
}
process
{
"Iteration: $i"
$i++
"`tBefore MoveNext: $($input.Current)"
$input.MoveNext() | Out-Null
"`tAfter MoveNext: $($input.Current)"
"`tAccess Again: $($input.Current)"
}
}
"one","two" | Current
Iteration: 0
Before MoveNext:
After MoveNext: one
Access Again: one
Iteration: 1
Before MoveNext:
After MoveNext: two
Access Again: two
Exemple 4 : Utilisation de la variable $foreach
Contrairement à la $input
variable, la $foreach
variable représente toujours tous les éléments de la collection lorsqu’elle est consultée directement. Utilisez la Current propriété pour accéder à l’élément de collection actuel, et les Reset méthodes et MoveNext pour modifier sa valeur.
Notes
Chaque itération de la foreach
boucle appelle automatiquement la méthode MoveNext .
La boucle suivante ne s’exécute que deux fois. Dans la deuxième itération, la collection est déplacée vers le troisième élément avant la fin de l’itération. Après la deuxième itération, il n’y a plus de valeurs à itérer et la boucle se termine.
La propriété MoveNext n’affecte pas la variable choisie pour itérer dans la collection ($Num
).
$i = 0
foreach ($num in ("one","two","three"))
{
"Iteration: $i"
$i++
"`tNum: $num"
"`tCurrent: $($foreach.Current)"
if ($foreach.Current -eq "two")
{
"Before MoveNext (Current): $($foreach.Current)"
$foreach.MoveNext() | Out-Null
"After MoveNext (Current): $($foreach.Current)"
"Num hasn't changed: $num"
}
}
Iteration: 0
Num: one
Current: one
Iteration: 1
Num: two
Current: two
Before MoveNext (Current): two
After MoveNext (Current): three
Num hasn't changed: two
L’utilisation de la Reset méthode réinitialise l’élément actuel dans la collection. L’exemple suivant effectue deux boucles dans les deux premiers éléments, car la Reset méthode est appelée. Après les deux premières boucles, l’instruction if
échoue et la boucle itère normalement au sein des trois éléments.
Important
Cela peut entraîner une boucle infinie.
$stopLoop = 0
foreach ($num in ("one","two", "three"))
{
("`t" * $stopLoop) + "Current: $($foreach.Current)"
if ($num -eq "two" -and $stopLoop -lt 2)
{
$foreach.Reset()
("`t" * $stopLoop) + "Reset Loop: $stopLoop"
$stopLoop++
}
}
Current: one
Current: two
Reset Loop: 0
Current: one
Current: two
Reset Loop: 1
Current: one
Current: two
Current: three
Exemple 5 : Utilisation de la variable $switch
La $switch
variable a exactement les mêmes règles que la $foreach
variable. L’exemple suivant illustre tous les concepts de l’énumérateur.
Notes
Notez comment le cas NotEvaluated n’est jamais exécuté, même s’il n’existe aucune break
instruction après la méthode MoveNext .
$values = "Start", "MoveNext", "NotEvaluated", "Reset", "End"
$stopInfinite = $false
switch ($values)
{
"MoveNext" {
"`tMoveNext"
$switch.MoveNext() | Out-Null
"`tAfter MoveNext: $($switch.Current)"
}
# This case is never evaluated.
"NotEvaluated" {
"`tAfterMoveNext: $($switch.Current)"
}
"Reset" {
if (!$stopInfinite)
{
"`tReset"
$switch.Reset()
$stopInfinite = $true
}
}
default {
"Default (Current): $($switch.Current)"
}
}
Default (Current): Start
MoveNext
After MoveNext: NotEvaluated
Reset
Default (Current): Start
MoveNext
After MoveNext: NotEvaluated
Default (Current): End