about_Automatic_Variables

Kort beskrivning

Beskriver variabler som lagrar tillståndsinformation för PowerShell. Dessa variabler skapas och underhålls av PowerShell.

Lång beskrivning

Begreppsmässigt anses dessa variabler vara skrivskyddade. Även om de kan skrivas till , bör de inte skrivas till för bakåtkompatibilitet.

Här är en lista över de automatiska variablerna i PowerShell:

$$

Innehåller den sista token på den sista raden som togs emot av sessionen.

$?

Innehåller körningsstatus för det senaste kommandot. Den innehåller True om det senaste kommandot lyckades och False om det misslyckades.

För cmdletar och avancerade funktioner som körs i flera steg i en pipeline, till exempel i både process - och end -block, kommer anrop this.WriteError() eller $PSCmdlet.WriteError() vid vilken tidpunkt som helst att ställas in $?Falskt, liksom this.ThrowTerminatingError() och $PSCmdlet.ThrowTerminatingError().

Cmdleten Write-Error ställer alltid in $?Falskt direkt efter att den har körts, men kommer inte att anges $? till False för en funktion som anropar den:

function Test-WriteError
{
    Write-Error "Bad"
    $? # $false
}

Test-WriteError
$? # $true

För det senare ändamålet $PSCmdlet.WriteError() bör användas i stället.

För interna kommandon (körbara filer) $? anges till Sant när $LASTEXITCODE är 0 och anges till Falskt när $LASTEXITCODE är något annat värde.

Anteckning

Tills PowerShell 7, som innehåller en -instruktion inom parenteser (...), återställs $? underuttryckssyntaxen $(...) eller matrisuttrycket @(...) alltid till Sant, så det (Write-Error) visas $? som Sant. Detta har ändrats i PowerShell 7, så det $? återspeglar alltid den faktiska framgången för den senaste kommandokörningen i dessa uttryck.

$^

Innehåller den första token på den sista raden som togs emot av sessionen.

$_

Samma som $PSItem. Innehåller det aktuella objektet i pipelineobjektet. Du kan använda den här variabeln i kommandon som utför en åtgärd på varje objekt eller på valda objekt i en pipeline.

$args

Innehåller en matris med värden för odeklarerade parametrar som skickas till en funktion, ett skript eller ett skriptblock. När du skapar en funktion kan du deklarera parametrarna med hjälp av nyckelordet param eller genom att lägga till en kommaavgränsad lista med parametrar inom parentes efter funktionsnamnet.

I en händelseåtgärd innehåller variabeln $args objekt som representerar händelseargumenten för händelsen som bearbetas. Den här variabeln fylls endast i i blocket för Action ett händelseregistreringskommando. Värdet för den här variabeln finns också i egenskapen SourceArgs för PSEventArgs-objektet som Get-Event returneras.

$ConsoleFileName

Innehåller sökvägen till den konsolfil (.psc1) som senast användes i sessionen. Den här variabeln fylls i när du startar PowerShell med parametern PSConsoleFile eller när du använder cmdleten Export-Console för att exportera snapin-modulnamn till en konsolfil.

När du använder cmdleten Export-Console utan parametrar uppdateras automatiskt konsolfilen som senast användes i sessionen. Du kan använda den här automatiska variabeln för att avgöra vilken fil som ska uppdateras.

$Error

Innehåller en matris med felobjekt som representerar de senaste felen. Det senaste felet är det första felobjektet i matrisen $Error[0].

Om du vill förhindra att ett fel läggs till i matrisen $Error använder du den vanliga errorAction-parametern med värdet Ignorera. Mer information finns i about_CommonParameters.

$Event

Innehåller ett PSEventArgs-objekt som representerar händelsen som bearbetas. Den här variabeln fylls bara i i blocket för Action ett händelseregistreringskommando, till exempel Register-ObjectEvent. Värdet för den här variabeln är samma objekt som cmdleten Get-Event returnerar. Därför kan du använda egenskaperna för variabeln Event , till exempel $Event.TimeGenerated, i ett Action skriptblock.

$EventArgs

Innehåller ett -objekt som representerar det första händelseargumentet som härleds från EventArgs för händelsen som bearbetas. Den här variabeln fylls endast i i blocket för Action ett händelseregistreringskommando. Värdet för den här variabeln finns också i egenskapen SourceEventArgs för PSEventArgs-objektet som Get-Event returneras.

$EventSubscriber

Innehåller ett PSEventSubscriber-objekt som representerar händelseprenumeranten för händelsen som bearbetas. Den här variabeln fylls endast i i blocket för Action ett händelseregistreringskommando. Värdet för den här variabeln är samma objekt som cmdleten Get-EventSubscriber returnerar.

$ExecutionContext

Innehåller ett EngineIntrinsics-objekt som representerar Körningskontexten för PowerShell-värden. Du kan använda den här variabeln för att hitta körningsobjekt som är tillgängliga för cmdletar.

$false

Innehåller False. Du kan använda den här variabeln för att representera False i kommandon och skript i stället för att använda strängen "false". Strängen kan tolkas som True om den konverteras till en icke-tom sträng eller till ett heltal som inte är noll.

$foreach

Innehåller uppräknaren (inte de resulterande värdena) för en ForEach-loop . Variabeln finns bara när loopen ForEach körs. Den $ForEach tas bort när loopen har slutförts.

Uppräknare innehåller egenskaper och metoder som du kan använda för att hämta loopvärden och ändra den aktuella loopiterationen. Mer information finns i Använda uppräknare.

$HOME

Innehåller den fullständiga sökvägen till användarens hemkatalog. Den här variabeln motsvarar "$env:homedrive$env:homepath" Windows-miljövariablerna, vanligtvis C:\Users\<UserName>.

$Host

Innehåller ett objekt som representerar det aktuella värdprogrammet för PowerShell. Du kan använda den här variabeln för att representera den aktuella värden i kommandon eller för att visa eller ändra värdens egenskaper, till exempel $Host.version eller $Host.CurrentCulture, eller $host.ui.rawui.setbackgroundcolor("Red").

$input

Innehåller en uppräknare som räknar upp alla indata som skickas till en funktion. Variabeln $input är endast tillgänglig för funktioner och skriptblock (som är namnlösa funktioner).

  • I en funktion utan ett Begin- eller ProcessEnd -block räknar variabeln $input upp samlingen med alla indata till funktionen.

  • Begin I blocket innehåller variabeln $input inga data.

  • Process I blocket innehåller variabeln $input objektet som för närvarande finns i pipelinen.

  • End I blocket räknar variabeln $input upp samlingen med alla indata till funktionen.

    Anteckning

    Du kan inte använda variabeln $input i både processblocket och slutblocket i samma funktion eller skriptblock.

Eftersom $input är en uppräknare blir $input åtkomst till någon av dess egenskaper inte längre tillgänglig. Du kan lagra $input i en annan variabel för att återanvända $input egenskaperna.

Uppräknare innehåller egenskaper och metoder som du kan använda för att hämta loopvärden och ändra den aktuella loopiterationen. Mer information finns i Använda uppräknare.

Variabeln $input är också tillgänglig för kommandot som anges av parametern -Commandpwsh för när den anropas från kommandoraden. Följande exempel körs från Windows-kommandogränssnittet.

echo Hello | pwsh -Command """$input World!"""

$IsCoreCLR

Innehåller $True om den aktuella sessionen körs på .NET Core Runtime (CoreCLR). Annars innehåller $False.

$IsLinux

Innehåller $True om den aktuella sessionen körs på ett Linux-operativsystem. Annars innehåller $False.

$IsMacOS

Innehåller $True om den aktuella sessionen körs på ett MacOS-operativsystem. Annars innehåller $False.

$IsWindows

Innehåller $TRUE om den aktuella sessionen körs på ett Windows-operativsystem. Annars innehåller $FALSE.

$LastExitCode

Innehåller slutkoden för det senaste interna programmet som kördes.

$Matches

Variabeln $Matches fungerar med operatorerna -match och -notmatch . När du skickar skalära indata till operatorn -match eller -notmatch och någon av dem identifierar en matchning returnerar de ett booleskt värde och fyller i den $Matches automatiska variabeln med en hash-tabell med alla strängvärden som matchades. Hash-tabellen $Matches kan också fyllas med avbildningar när du använder reguljära uttryck med operatorn -match .

Mer information om operatorn finns i -matchabout_Comparison_Operators. Mer information om reguljära uttryck finns i about_Regular_Expressions.

Variabeln $Matches fungerar också i en switch -instruktion med parametern -Regex . Den fylls i på samma sätt som operatorerna -match och -notmatch . Mer information om -instruktionen finns i switchabout_Switch.

Anteckning

När $Matches fylls i i en session behåller den det matchade värdet tills det skrivs över av en annan matchning. Om -match används igen och ingen matchning hittas återställs $Matches den inte till $null. Det tidigare matchade värdet sparas tills $Matches en annan matchning hittas.

$MyInvocation

Innehåller information om det aktuella kommandot, till exempel namn, parametrar, parametervärden och information om hur kommandot startades, anropades eller anropades, till exempel namnet på skriptet som anropade det aktuella kommandot.

$MyInvocation fylls endast i för skript, funktioner och skriptblock. Du kan använda informationen i objektet System.Management.Automation.InvocationInfo som returneras i det $MyInvocation aktuella skriptet, till exempel sökvägen och filnamnet för skriptet ($MyInvocation.MyCommand.Path) eller namnet på en funktion ($MyInvocation.MyCommand.Name) för att identifiera det aktuella kommandot. Detta är särskilt användbart för att hitta namnet på det aktuella skriptet.

Från och med PowerShell 3.0 MyInvocation har följande nya egenskaper.

  • PSScriptRoot – innehåller den fullständiga sökvägen till skriptet som anropade det aktuella kommandot. Värdet för den här egenskapen fylls bara i när anroparen är ett skript.
  • PSCommandPath – innehåller den fullständiga sökvägen och filnamnet för skriptet som anropade det aktuella kommandot. Värdet för den här egenskapen fylls bara i när anroparen är ett skript.

$PSScriptRoot Till skillnad från de automatiska variablerna och $PSCommandPath innehåller egenskaperna PSScriptRoot och PSCommandPath för den $MyInvocation automatiska variabeln information om anroparen eller det anropande skriptet, inte det aktuella skriptet.

$NestedPromptLevel

Innehåller den aktuella promptnivån. Värdet 0 anger den ursprungliga promptnivån. Värdet ökas när du anger en kapslad nivå och minskar när du avslutar den.

PowerShell visar till exempel en kapslad kommandotolk när du använder $Host.EnterNestedPrompt metoden . PowerShell visar också en kapslad kommandotolk när du når en brytpunkt i PowerShell-felsökningsprogrammet.

När du anger en kapslad prompt pausar PowerShell det aktuella kommandot, sparar körningskontexten och ökar värdet för variabeln $NestedPromptLevel . Om du vill skapa ytterligare kapslade kommandotolks (upp till 128 nivåer) eller återgå till den ursprungliga kommandotolken slutför du kommandot eller skriver exit.

Variabeln $NestedPromptLevel hjälper dig att spåra promptnivån. Du kan skapa en alternativ PowerShell-kommandotolk som innehåller det här värdet så att det alltid visas.

$null

$null är en automatisk variabel som innehåller ett null - eller tomt värde. Du kan använda den här variabeln för att representera ett saknat eller odefinierat värde i kommandon och skript.

PowerShell behandlar $null som ett objekt med ett värde, det vill sa att det är en explicit platshållare, så du kan använda $null för att representera ett tomt värde i en serie med värden.

När ingår i en samling räknas det till exempel $null som ett av objekten.

$a = "one", $null, "three"
$a.count
3

Om du skickar variabeln $null till cmdleten ForEach-Object genereras ett värde för $null, precis som för de andra objekten

"one", $null, "three" | ForEach-Object { "Hello " + $_}
Hello one
Hello
Hello three

Därför kan du inte använda $null för att ange något parametervärde. Parametervärdet $null åsidosätter standardparametervärdet.

Men eftersom PowerShell behandlar variabeln $null som en platshållare kan du använda den i skript som följande, vilket inte skulle fungera om $null de ignorerades.

$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

Innehåller processidentifieraren (PID) för den process som är värd för den aktuella PowerShell-sessionen.

$PROFILE

Innehåller den fullständiga sökvägen till PowerShell-profilen för den aktuella användaren och det aktuella värdprogrammet. Du kan använda den här variabeln för att representera profilen i kommandon. Du kan till exempel använda den i ett kommando för att avgöra om en profil har skapats:

Test-Path $PROFILE

Eller så kan du använda det i ett kommando för att skapa en profil:

New-Item -ItemType file -Path $PROFILE -Force

Du kan använda den i ett kommando för att öppna profilen i notepad.exe:

notepad.exe $PROFILE

$PSBoundParameters

Innehåller en ordlista med de parametrar som skickas till ett skript eller en funktion och deras aktuella värden. Den här variabeln har endast ett värde i ett omfång där parametrar deklareras, till exempel ett skript eller en funktion. Du kan använda den för att visa eller ändra aktuella värden för parametrar eller för att skicka parametervärden till ett annat skript eller en annan funktion.

I det här exemplet skickar $PSBoundParameters funktionen Test2 till funktionen Test1. $PSBoundParameters visas i formatet Nyckel och Värde.

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

Innehåller ett objekt som representerar cmdleten eller den avancerade funktion som körs.

Du kan använda egenskaperna och metoderna för objektet i din cmdlet eller funktionskod för att svara på användningsvillkoren. Egenskapen ParameterSetName innehåller till exempel namnet på parameteruppsättningen som används, och metoden ShouldProcess lägger till parametrarna WhatIf och Confirm i cmdleten dynamiskt.

Mer information om den $PSCmdlet automatiska variabeln finns i about_Functions_CmdletBindingAttribute och about_Functions_Advanced.

$PSCommandPath

Innehåller den fullständiga sökvägen och filnamnet för skriptet som körs. Den här variabeln är giltig i alla skript.

$PSCulture

Från och med PowerShell 7 $PSCulture återspeglar kulturen i det aktuella PowerShell-körningsutrymmet (session). Om kulturen ändras i en PowerShell-runspace $PSCulture uppdateras värdet för det runspacet.

Kulturen avgör visningsformatet för objekt som tal, valuta och datum och lagras i ett System.Globalization.CultureInfo-objekt . Använd Get-Culture för att visa datorns kultur. $PSCulture innehåller namnegenskapens värde.

$PSDebugContext

Under felsökningen innehåller den här variabeln information om felsökningsmiljön. Annars innehåller den ett null-värde . Därför kan du använda den för att ange om felsökaren har kontroll. När det är ifyllt innehåller det ett PsDebugContext-objekt som har egenskaper för Brytpunkter och InvocationInfo . Egenskapen InvocationInfo har flera användbara egenskaper, inklusive egenskapen Plats . Egenskapen Plats anger sökvägen till skriptet som felsöks.

$PSHOME

Innehåller den fullständiga sökvägen till installationskatalogen för PowerShell, vanligtvis $env:windir\System32\PowerShell\v1.0 i Windows-system. Du kan använda den här variabeln i sökvägarna för PowerShell-filer. Följande kommando söker till exempel i begreppsmässiga hjälpavsnitt efter ordvariabeln:

Select-String -Pattern Variable -Path $pshome\*.txt

$PSItem

Samma som $_. Innehåller det aktuella objektet i pipelineobjektet. Du kan använda den här variabeln i kommandon som utför en åtgärd på varje objekt eller på valda objekt i en pipeline.

$PSScriptRoot

Innehåller den fullständiga sökvägen till det körande skriptets överordnade katalog.

I PowerShell 2.0 är den här variabeln endast giltig i skriptmoduler (.psm1). Från och med PowerShell 3.0 är det giltigt i alla skript.

$PSSenderInfo

Innehåller information om användaren som startade PSSessionen, inklusive användaridentiteten och tidszonen för den ursprungliga datorn. Den här variabeln är endast tillgänglig i PSSessioner.

Variabeln $PSSenderInfo innehåller en användarkonfigurerbar egenskap, ApplicationArguments, som som standard endast $PSVersionTable innehåller från den ursprungliga sessionen. Om du vill lägga till data i egenskapen ApplicationArguments använder du parametern ApplicationArguments för cmdleten New-PSSessionOption .

$PSUICulture

Innehåller namnet på användargränssnittskulturen (UI) som för närvarande används i operativsystemet. Användargränssnittskulturen avgör vilka textsträngar som används för användargränssnittselement, till exempel menyer och meddelanden. Det här är värdet för System.Globalization.CultureInfo.Current UICulture.Name systemets egenskap. Använd cmdleten Get-UICulture för att hämta objektet System.Globalization.CultureInfo för systemet.

$PSVersionTable

Innehåller en skrivskyddad hash-tabell som visar information om den version av PowerShell som körs i den aktuella sessionen. Tabellen innehåller följande objekt:

  • PSVersion – PowerShell-versionsnumret
  • PSEdition Den här egenskapen har värdet "Desktop" för PowerShell 4 och nedan samt PowerShell 5.1 på fullständiga Windows-utgåvor. Den här egenskapen har värdet Core för för PowerShell 6 och senare samt PowerShell PowerShell 5.1 på utgåvor med reducerat fotavtryck som Windows Nano Server eller Windows IoT.
  • GitCommitId – inchecknings-ID för källfilerna i GitHub,
  • OS – Beskrivning av operativsystemet som PowerShell körs på.
  • Plattform – plattform som operativsystemet körs på. Värdet på Linux och macOS är Unix. Se $IsMacOs och $IsLinux.
  • PSCompatibleVersions – Versioner av PowerShell som är kompatibla med den aktuella versionen
  • PSRemotingProtocolVersion – versionen av PowerShell-protokollet för fjärrhantering.
  • SerializationVersion – serialiseringsmetodens version
  • WSManStackVersion – versionsnumret för WS-Management stacken

$PWD

Innehåller ett sökvägsobjekt som representerar den fullständiga sökvägen till den aktuella katalogplatsen för den aktuella PowerShell-körningen.

Anteckning

PowerShell stöder flera runspaces per process. Varje runspace har en egen aktuell katalog. Detta är inte samma som den aktuella katalogen i processen: [System.Environment]::CurrentDirectory.

$Sender

Innehåller objektet som genererade den här händelsen. Den här variabeln fylls endast i i åtgärdsblocket för ett händelseregistreringskommando. Värdet för den här variabeln finns också i egenskapen Sender för PSEventArgs-objektet som Get-Event returneras.

$ShellId

Innehåller identifieraren för det aktuella gränssnittet.

$StackTrace

Innehåller en stackspårning för det senaste felet.

$switch

Innehåller uppräknaren, inte de resulterande värdena för en Switch -instruktion. Variabeln finns bara när -instruktionen Switch körs. Den $switch tas bort när -instruktionen slutför körningenswitch. Mer information finns i about_Switch.

Uppräknare innehåller egenskaper och metoder som du kan använda för att hämta loopvärden och ändra den aktuella loop-iterationen. Mer information finns i Använda uppräknare.

$this

Variabeln $this används i skriptblock som utökar klasser för att referera till instansen av själva klassen.

Med ETS (Extensible Type System) i PowerShell kan du lägga till egenskaper i klasser med hjälp av skriptblock. I ett skriptblock som definierar en skriptegenskap eller skriptmetod refererar variabeln $this till en instans av objektet för klassen som utökas. PowerShell använder till exempel ETS för att lägga till egenskapen BaseName i klassen 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};}

Mer information finns i about_Types.ps1xml.

I en PowerShell-klass refererar variabeln $this till instansobjektet för själva klassen, vilket ger åtkomst till egenskaper och metoder som definierats i klassen. Mer information finns i about_Classes.

Variabeln $this används också av .NET-händelseklasser som tar skriptblock som ombud för händelsehanteraren. I det här scenariot $this representerar objektet som kommer från händelsen, som kallas händelsesändare.

$true

Innehåller Sant. Du kan använda den här variabeln för att representera True i kommandon och skript.

Använda uppräknare

Variablerna $input, $foreachoch $switch är alla uppräkningar som används för att iterera genom de värden som bearbetas av deras innehållande kodblock.

En uppräkning innehåller egenskaper och metoder som du kan använda för att avancera eller återställa iteration eller hämta iterationsvärden. Direkt manipulering av uppräknare anses inte vara bästa praxis.

  • Inom loopar bryts nyckelorden för flödeskontroll och fortsätter bör föredras.

  • I funktioner som accepterar pipelineindata är det bästa praxis att använda parametrar med attributen ValueFromPipeline eller ValueFromPipelineByPropertyName .

    Mer information finns i about_Functions_Advanced_Parameters.

FlyttaNästa

Metoden MoveNext flyttar uppräknaren till nästa element i samlingen. MoveNext returnerar True om uppräknaren har avancerats, False om uppräknaren har passerat slutet av samlingen.

Anteckning

Det booleska värdet som returneras av MoveNext skickas till utdataströmmen. Du kan ignorera utdata genom att skriva den till [void] eller skicka den till Out-Null.

$input.MoveNext() | Out-Null
[void]$input.MoveNext()

Reset

Metoden Reset ställer in uppräknaren till sin ursprungliga position, vilket är före det första elementet i samlingen.

Current

Egenskapen Current hämtar elementet i samlingen, eller pipelinen, på den aktuella positionen för uppräknaren.

Egenskapen Current fortsätter att returnera samma egenskap tills MoveNext anropas.

Exempel

Exempel 1: Använda variabeln $input

I följande exempel rensar åtkomst till variabeln $input variabeln till nästa gång processblocket körs. Med hjälp av Reset metoden återställs variabeln $input till det aktuella pipelinevärdet.

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

Processblocket flyttar automatiskt fram variabeln $input även om du inte kommer åt den.

$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

Exempel 2: Använda $input utanför processblocket

Utanför processblocket representerar variabeln $input alla värden som skickas till funktionen.

  • Åtkomst till variabeln $input rensar alla värden.
  • Metoden Reset återställer hela samlingen.
  • Egenskapen Current fylls aldrig i.
  • Metoden MoveNext returnerar false eftersom samlingen inte kan avanceras.
    • Om du anropar MoveNext rensas variabeln $input .
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:

Exempel 3: Använda $input.Current egenskap

Med hjälp av Current egenskapen kan det aktuella pipelinevärdet nås flera gånger utan att metoden används Reset . Processblocket anropar inte metoden MoveNext automatiskt.

Egenskapen Current fylls aldrig i om du inte uttryckligen anropar MoveNext. Egenskapen Current kan nås flera gånger i processblocket utan att rensa dess värde.

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

Exempel 4: Använda variabeln $foreach

Till skillnad från variabeln $input representerar variabeln $foreach alltid alla objekt i samlingen när den används direkt. Current Använd egenskapen för att komma åt det aktuella samlingselementet och Reset metoderna och MoveNext för att ändra dess värde.

Anteckning

Varje iteration av loopen foreach anropar automatiskt metoden MoveNext .

Följande loop körs bara två gånger. I den andra iterationen flyttas samlingen till det tredje elementet innan iterationen är klar. Efter den andra iterationen finns det nu inga fler värden att iterera och loopen avslutas.

Egenskapen MoveNext påverkar inte variabeln som valts för att iterera genom samlingen ($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 has not changed: $num"
    }
}
Iteration: 0
        Num: one
        Current: one
Iteration: 1
        Num: two
        Current: two
Before MoveNext (Current): two
After MoveNext (Current): three
Num has not changed: two

Med hjälp av Reset metoden återställs det aktuella elementet i samlingen. I följande exempel loopas de två första elementen Resettvå gånger eftersom metoden anropas. Efter de två första looparna misslyckas -instruktionen if och loopen itererar igenom alla tre elementen normalt.

Viktigt

Detta kan resultera i en oändlig loop.

$stopLoop = 0
foreach ($num in ("one","two", "three"))
{
    ("`t" * $stopLoop) + "Current: $($foreach.Current)"

    if ($num -eq "two" -and $stopLoop -lt 2)
    {
        $foreach.Reset() | Out-Null
        ("`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

Exempel 5: Använda variabeln $switch

Variabeln $switch har exakt samma regler som variabeln $foreach . I följande exempel visas alla uppräkningsbegrepp.

Anteckning

Observera att det NotEvaluated-ärendet aldrig körs, även om det inte finns någon break -instruktion efter metoden 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

Se även