Sobre variáveis automáticas
Descrição breve
Descreve variáveis que armazenam informações de estado para o PowerShell. Essas variáveis são criadas e mantidas pelo PowerShell.
Descrição longa
Conceitualmente, essas variáveis são consideradas somente leitura. Mesmo que eles possam ser escritos para, para compatibilidade com versões anteriores , eles não devem ser gravados.
Aqui está uma lista das variáveis automáticas no PowerShell:
$$
Contém o último token na última linha recebida pela sessão.
$?
Contém o status de execução do último comando. Ele conterá True se o último comando tiver sido bem-sucedido e False se tiver falhado.
Para cmdlets e funções avançadas que são executadas em vários estágios em um pipeline, por exemplo, em ambos e process
end
blocos, chamar this.WriteError()
ou $PSCmdlet.WriteError()
, respectivamente, em qualquer ponto, será definido $?
como False, como será this.ThrowTerminatingError()
e $PSCmdlet.ThrowTerminatingError()
.
O Write-Error
cmdlet sempre é definido $?
como False imediatamente após a execução, mas não será definido $?
como False para uma função que o chama:
function Test-WriteError
{
Write-Error "Bad"
$? # $false
}
Test-WriteError
$? # $true
Para a última finalidade, $PSCmdlet.WriteError()
deve ser usado em vez disso.
Para comandos nativos (executáveis), $?
é definido como True quando $LASTEXITCODE
é 0 e definido como False quando $LASTEXITCODE
é qualquer outro valor.
Observação
Até o PowerShell 7, contendo uma instrução dentro de parênteses, a sintaxe (...)
$(...)
de subexpressão ou a expressão @(...)
de matriz sempre são redefinidas $?
para True, de modo que (Write-Error)
seja exibido $?
como True.
Isso foi alterado no PowerShell 7, de modo que $?
sempre refletirá o sucesso real da última execução de comando nessas expressões.
$^
Contém o primeiro token na última linha recebida pela sessão.
$_
Mesmo que $PSItem
. Contém o objeto atual no objeto de pipeline. Você pode usar essa variável em comandos que executam uma ação em cada objeto ou em objetos selecionados em um pipeline.
$args
Contém uma matriz de valores para parâmetros não declarados que são passados para uma função, script ou bloco de script. Ao criar uma função, você pode declarar os parâmetros usando a param
palavra-chave ou adicionando uma lista separada por vírgulas de parâmetros em parênteses após o nome da função.
Em uma ação de evento, a $Args
variável contém objetos que representam os argumentos de evento do evento que está sendo processado. Essa variável é populada somente dentro do Action
bloco de um comando de registro de evento.
O valor dessa variável também pode ser encontrado na propriedade SourceArgs do objeto PSEventArgs que Get-Event
retorna.
$ConsoleFileName
Contém o caminho do arquivo de console (.psc1
) que foi usado mais recentemente na sessão. Essa variável é preenchida quando você inicia o PowerShell com o parâmetro PSConsoleFile ou quando você usa o Export-Console
cmdlet para exportar nomes snap-in para um arquivo de console.
Quando você usa o Export-Console
cmdlet sem parâmetros, ele atualiza automaticamente o arquivo de console que foi usado mais recentemente na sessão. Você pode usar essa variável automática para determinar qual arquivo será atualizado.
$Error
Contém uma matriz de objetos de erro que representam os erros mais recentes.
O erro mais recente é o primeiro objeto de erro na matriz $Error[0]
.
Para evitar que um erro seja adicionado à $Error
matriz, use o parâmetro comum ErrorAction com um valor de Ignorar. Para obter mais informações, confira about_CommonParameters.
$Event
Contém um objeto PSEventArgs que representa o evento que está sendo processado. Essa variável é populada somente dentro do Action
bloco de um comando de registro de evento, como Register-ObjectEvent
. O valor dessa variável é o mesmo objeto que o Get-Event
cmdlet retorna. Portanto, você pode usar as propriedades da Event
variável, como $Event.TimeGenerated
, em um Action
bloco de script.
$EventArgs
Contém um objeto que representa o primeiro argumento de evento que deriva de EventArgs do evento que está sendo processado. Essa variável é populada somente dentro do Action
bloco de um comando de registro de evento.
O valor dessa variável também pode ser encontrado na propriedade SourceEventArgs do objeto PSEventArgs que Get-Event
retorna.
$EventSubscriber
Contém um objeto PSEventSubscriber que representa o assinante do evento que está sendo processado. Essa variável é populada somente dentro do Action
bloco de um comando de registro de evento. O valor dessa variável é o mesmo objeto que o Get-EventSubscriber
cmdlet retorna.
$ExecutionContext
Contém um objeto EngineIntrinsics que representa o contexto de execução do host do PowerShell. Você pode usar essa variável para localizar os objetos de execução disponíveis para cmdlets.
$false
Contém False. Você pode usar essa variável para representar False em comandos e scripts em vez de usar a cadeia de caracteres "false". A cadeia de caracteres poderá ser interpretada como True se for convertida em uma cadeia de caracteres não vazia ou em um inteiro diferente de zero.
$foreach
Contém o enumerador (não os valores resultantes) de um loop ForEach . A $ForEach
variável existe somente enquanto o ForEach
loop está em execução; ele é excluído após a conclusão do loop.
Os enumeradores contêm propriedades e métodos que você pode usar para recuperar valores de loop e alterar a iteração de loop atual. Para obter mais informações, consulte Como usar enumeradores.
$HOME
Contém o caminho completo do diretório base do usuário. Essa variável é o equivalente às variáveis de ambiente do "$env:homedrive$env:homepath"
Windows, normalmente C:\Users\<UserName>
.
$Host
Contém um objeto que representa o aplicativo host atual do PowerShell. Você pode usar essa variável para representar o host atual em comandos ou para exibir ou alterar as propriedades do host, como $Host.version
ou $Host.CurrentCulture
, ou $host.ui.rawui.setbackgroundcolor("Red")
.
$input
Contém um enumerador que enumera todas as entradas passadas para uma função. A $input
variável está disponível apenas para funções e blocos de script (que são funções sem nome).
Em uma função sem um
Begin
,Process
ouEnd
bloco, a$input
variável enumera a coleção de todas as entradas para a função.Begin
No bloco, a$input
variável não contém dados.Process
No bloco, a$input
variável contém o objeto que está atualmente no pipeline.End
No bloco, a$input
variável enumera a coleção de todas as entradas para a função.Observação
Você não pode usar a
$input
variável dentro do bloco Processo e do bloco End na mesma função ou bloco de script.
Como $input
é um enumerador, acessar qualquer uma das propriedades faz com que elas $input
não estejam mais disponíveis. Você pode armazenar $input
em outra variável para reutilizar as $input
propriedades.
Os enumeradores contêm propriedades e métodos que você pode usar para recuperar valores de loop e alterar a iteração de loop atual. Para obter mais informações, consulte Como usar enumeradores.
$IsCoreCLR
Contém $True
se a sessão atual estiver em execução no CoreCLR (Runtime do .NET Core). Caso contrário, contém $False
.
$IsLinux
Contém $True
se a sessão atual estiver em execução em um sistema operacional Linux.
Caso contrário, contém $False
.
$IsMacOS
Contém $True
se a sessão atual estiver em execução em um sistema operacional MacOS.
Caso contrário, contém $False
.
$IsWindows
Contém $TRUE
se a sessão atual estiver em execução em um sistema operacional Windows. Caso contrário, contém $FALSE
.
$LastExitCode
Contém o código de saída do último programa baseado no Windows que foi executado.
$Matches
A Matches
variável funciona com os operadores e-notmatch
.-match
Quando você envia a entrada escalar para o -match
operador ou -notmatch
detecta uma correspondência, ela retorna um valor booliano e preenche a $Matches
variável automática com uma tabela de hash de todos os valores de cadeia de caracteres correspondentes. A $Matches
tabela de hash também pode ser preenchida com capturas quando você usa expressões regulares com o -match
operador.
Para obter mais informações sobre o -match
operador, consulte about_Comparison_Operators. Para obter mais informações sobre expressões regulares, consulte about_Regular_Expressions.
$MyInvocation
Contém informações sobre o comando atual, como o nome, parâmetros, valores de parâmetro e informações sobre como o comando foi iniciado, chamado ou invocado, como o nome do script que chamou o comando atual.
$MyInvocation
é populado somente para scripts, funções e blocos de script. Você pode usar as informações no objeto System.Management.Automation.InvocationInfo que $MyInvocation
retorna no script atual, como o caminho e o nome do arquivo do script ($MyInvocation.MyCommand.Path
) ou o nome de uma função ($MyInvocation.MyCommand.Name
) para identificar o comando atual. Isso é particularmente útil para localizar o nome do script atual.
A partir do PowerShell 3.0, MyInvocation
tem as novas propriedades a seguir.
Propriedade | Descrição |
---|---|
PSScriptRoot | Contém o caminho completo para o script que invocou |
o comando atual. O valor dessa propriedade é | |
populado somente quando o chamador é um script. | |
PSCommandPath | Contém o caminho completo e o nome do arquivo do script |
que invocou o comando atual. O valor disso | |
propriedade é populada somente quando o chamador é um | |
. |
Ao contrário das $PSScriptRoot
variáveis e $PSCommandPath
automáticas, as propriedades PSScriptRoot e PSCommandPath da $MyInvocation
variável automática contêm informações sobre o invocador ou o script de chamada, não o script atual.
$NestedPromptLevel
Contém o nível de prompt atual. Um valor 0 indica o nível de prompt original. O valor é incrementado quando você insere um nível aninhado e é decréscimo ao sair dele.
Por exemplo, o PowerShell apresenta um prompt de comando aninhado quando você usa o $Host.EnterNestedPrompt
método. O PowerShell também apresenta um prompt de comando aninhado quando você atinge um ponto de interrupção no depurador do PowerShell.
Quando você insere um prompt aninhado, o PowerShell pausa o comando atual, salva o contexto de execução e incrementa o valor da $NestedPromptLevel
variável. Para criar prompts de comando aninhados adicionais (até 128 níveis) ou retornar ao prompt de comando original, conclua o comando ou digite exit
.
A $NestedPromptLevel
variável ajuda você a acompanhar o nível de prompt. Você pode criar um prompt de comando alternativo do PowerShell que inclua esse valor para que ele fique sempre visível.
$null
$null
é uma variável automática que contém um valor nulo ou vazio. Você pode usar essa variável para representar um valor ausente ou indefinido em comandos e scripts.
O PowerShell trata $null
como um objeto com um valor, ou seja, como um espaço reservado explícito, para que você possa usar $null
para representar um valor vazio em uma série de valores.
Por exemplo, quando $null
está incluído em uma coleção, ele é contado como um dos objetos.
$a = "one", $null, "three"
$a.count
3
Se você canalizar a $null
variável para o ForEach-Object
cmdlet, ela gerará um valor para $null
, assim como faz para os outros objetos
"one", $null, "three" | ForEach-Object { "Hello " + $_}
Hello one
Hello
Hello three
Como resultado, você não pode usar $null
para significar nenhum valor de parâmetro. Um valor de parâmetro de $null
substitui o valor de parâmetro padrão.
No entanto, como o PowerShell trata a $null
variável como um espaço reservado, você pode usá-la em scripts como o seguinte, o que não funcionaria se $null
fosse ignorado.
$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
Contém o PID (identificador de processo) do processo que está hospedando a sessão atual do PowerShell.
$PROFILE
Contém o caminho completo do perfil do PowerShell para o usuário atual e o aplicativo host atual. Você pode usar essa variável para representar o perfil em comandos. Por exemplo, você pode usá-lo em um comando para determinar se um perfil foi criado:
Test-Path $PROFILE
Ou você pode usá-lo em um comando para criar um perfil:
New-Item -ItemType file -Path $PROFILE -Force
Você pode usá-lo em um comando para abrir o perfil no notepad.exe:
notepad.exe $PROFILE
$PSBoundParameters
Contém um dicionário dos parâmetros que são passados para um script ou função e seus valores atuais. Essa variável tem um valor somente em um escopo em que os parâmetros são declarados, como um script ou função. Você pode usá-lo para exibir ou alterar os valores atuais dos parâmetros ou passar valores de parâmetro para outro script ou função.
Neste exemplo, a função Test2 passa para $PSBoundParameters
a função Test1 . Elas $PSBoundParameters
são exibidas no formato chave e valor.
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
Contém um objeto que representa o cmdlet ou a função avançada que está sendo executada.
Você pode usar as propriedades e os métodos do objeto em seu cmdlet ou código de função para responder às condições de uso. Por exemplo, a propriedade ParameterSetName contém o nome do conjunto de parâmetros que está sendo usado e o método ShouldProcess adiciona os parâmetros WhatIf e Confirm ao cmdlet dinamicamente.
Para obter mais informações sobre a $PSCmdlet
variável automática, consulte about_Functions_CmdletBindingAttribute e about_Functions_Advanced.
$PSCommandPath
Contém o caminho completo e o nome do arquivo do script que está sendo executado. Essa variável é válida em todos os scripts.
$PSCulture
Contém o nome da cultura atualmente em uso no sistema operacional. A cultura determina o formato de exibição de itens como números, moeda e datas e é armazenada em um objeto System.Globalization.CultureInfo . Use Get-Culture
para exibir a cultura do computador. $PSCulture
contém o valor da propriedade Name .
$PSDebugContext
Durante a depuração, essa variável contém informações sobre o ambiente de depuração. Caso contrário, ele contém um valor nulo . Como resultado, você pode usá-lo para indicar se o depurador tem controle. Quando populado, ele contém um objeto PsDebugContext que tem propriedades Breakpoints e InvocationInfo . A propriedade InvocationInfo tem várias propriedades úteis, incluindo a propriedade Location . A propriedade Location indica o caminho do script que está sendo depurado.
$PSHOME
Contém o caminho completo do diretório de instalação do PowerShell, normalmente, $env:windir\System32\PowerShell\v1.0
em sistemas Windows. Você pode usar essa variável nos caminhos dos arquivos do PowerShell. Por exemplo, o comando a seguir pesquisa os tópicos conceituais da Ajuda para a variável de palavra:
Select-String -Pattern Variable -Path $pshome\*.txt
$PSItem
Mesmo que $_
. Contém o objeto atual no objeto pipeline. Você pode usar essa variável em comandos que executam uma ação em cada objeto ou em objetos selecionados em um pipeline.
$PSScriptRoot
Contém o diretório do qual um script está sendo executado.
No PowerShell 2.0, essa variável é válida somente em módulos de script (.psm1
).
A partir do PowerShell 3.0, ele é válido em todos os scripts.
$PSSenderInfo
Contém informações sobre o usuário que iniciou a PSSession, incluindo a identidade do usuário e o fuso horário do computador de origem. Essa variável está disponível apenas em PSSessionsions.
A $PSSenderInfo
variável inclui uma propriedade configurável pelo usuário, ApplicationArguments, que, por padrão, contém apenas a $PSVersionTable
da sessão de origem. Para adicionar dados à propriedade ApplicationArguments , use o parâmetro ApplicationArguments do New-PSSessionOption
cmdlet.
$PSUICulture
Contém o nome da cultura da interface do usuário que está em uso no sistema operacional no momento. A cultura da interface do usuário determina quais cadeias de caracteres de texto são usadas para elementos de interface do usuário, como menus e mensagens. Esse é o valor da propriedade System.Globalization.CultureInfo.CurrentUICulture.Name do sistema. Para obter o objeto System.Globalization.CultureInfo para o sistema, use o Get-UICulture
cmdlet.
$PSVersionTable
Contém uma tabela de hash somente leitura que exibe detalhes sobre a versão do PowerShell que está em execução na sessão atual. A tabela inclui os seguintes itens:
Propriedade | Descrição |
---|---|
PSVersion | O número da versão do PowerShell |
PSEdition | Essa propriedade tem o valor de 'Desktop' para |
PowerShell 4 e abaixo, bem como PowerShell | |
5.1 em edições completas do Windows. | |
Essa propriedade tem o valor de 'Core' para | |
PowerShell 6 e superior, bem como PowerShell | |
PowerShell 5.1 em edições de volume reduzido | |
como Windows Nano Server ou Windows IoT. | |
GitCommitId | A ID de confirmação dos arquivos de origem, no GitHub, |
SO | Descrição do sistema operacional que |
O PowerShell está em execução. | |
Plataforma | Plataforma que o sistema operacional está executando |
em. O valor no Linux e no macOS é Unix. | |
Veja $IsMacOs e $IsLinux . |
|
PSCompatibleVersions | Versões do PowerShell compatíveis |
com a versão atual | |
PSRemotingProtocolVersion | A versão do PowerShell remoto |
protocolo de gerenciamento. | |
SerializationVersion | A versão do método de serialização |
WSManStackVersion | O número de versão da pilha de WS-Management |
$PWD
Contém um objeto path que representa o caminho completo do diretório atual.
$Sender
Contém o objeto que gerou esse evento. Essa variável é populada somente no bloco Ação de um comando de registro de evento. O valor dessa variável também pode ser encontrado na propriedade Sender do objeto PSEventArgs que Get-Event
retorna.
$ShellId
Contém o identificador do shell atual.
$StackTrace
Contém um rastreamento de pilha para o erro mais recente.
$switch
Contém o enumerador e não os valores resultantes de uma Switch
instrução. A $switch
variável existe somente enquanto a Switch
instrução está em execução; ela é excluída quando a instrução conclui a switch
execução. Para obter mais informações, consulte about_Switch.
Os enumeradores contêm propriedades e métodos que você pode usar para recuperar valores de loop e alterar a iteração de loop atual. Para obter mais informações, consulte Como usar enumeradores.
$this
Em um bloco de script que define uma propriedade de script ou método de script, a $this
variável refere-se ao objeto que está sendo estendido.
Em uma classe personalizada, a $this
variável refere-se ao próprio objeto de classe que permite o acesso a propriedades e métodos definidos na classe.
$true
Contém True. Você pode usar essa variável para representar True em comandos e scripts.
Usando Enumeradores
As $input
variáveis , $foreach
e $switch
são todos os enumeradores usados para iterar por meio dos valores processados pelo bloco de código que contém.
Um enumerador contém propriedades e métodos que você pode usar para avançar ou redefinir a iteração ou recuperar valores de iteração. A manipulação direta de enumeradores não é considerada a melhor prática.
Em loops, as palavras-chave de controle de fluxo quebram e continuam devem ser preferenciais.
Dentro das funções que aceitam a entrada de pipeline, é melhor usar parâmetros com os atributos ValueFromPipeline ou ValueFromPipelineByPropertyName .
Para obter mais informações, consulte about_Functions_Advanced_Parameters.
MoveNext
O método MoveNext avança o enumerador para o próximo elemento da coleção. MoveNext retornará True se o enumerador tiver sido avançado com êxito, False se o enumerador tiver passado o final da coleção.
Observação
O valor booliano retornado meu MoveNext é enviado para o fluxo de saída.
Você pode suprimir a saída digitando-a [void]
ou canalizando-a para Out-Null.
$input.MoveNext() | Out-Null
[void]$input.MoveNext()
Redefinir
O método Reset define o enumerador como sua posição inicial, que é antes do primeiro elemento na coleção.
Current
A propriedade Current obtém o elemento na coleção, ou pipeline, na posição atual do enumerador.
A propriedade Current continua a retornar a mesma propriedade até que MoveNext seja chamado.
Exemplos
Exemplo 1: Usando a variável $input
No exemplo a seguir, acessar a $input
variável limpa a variável até a próxima vez que o bloco de processo for executado. O uso do método Reset redefine a $input
variável para o valor atual do pipeline.
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
O bloco de processo avança automaticamente a $input
variável mesmo que você não a acesse.
$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
Exemplo 2: Usando $input fora do bloco de processo
Fora do bloco de processo, a $input
variável representa todos os valores canalizados para a função.
- Acessar a
$input
variável limpa todos os valores. - O método Reset redefine toda a coleção.
- A propriedade Current nunca é preenchida.
- O método MoveNext retorna false porque a coleção não pode ser avançada.
- Chamar MoveNext limpa a
$input
variável.
- Chamar MoveNext limpa a
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:
Exemplo 3: usando o $input. Propriedade Atual
Usando a propriedade Current , o valor atual do pipeline pode ser acessado várias vezes sem usar o método Reset . O bloco de processo não chama automaticamente o método MoveNext .
A propriedade Current nunca será preenchida, a menos que você chame explicitamente MoveNext. A propriedade Current pode ser acessada várias vezes dentro do bloco de processo sem limpar seu valor.
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
Exemplo 4: Usando a variável $foreach
Ao contrário da $input
variável, a $foreach
variável sempre representa todos os itens da coleção quando acessados diretamente. Use a propriedade Current para acessar o elemento de coleção atual e os métodos Reset e MoveNext para alterar seu valor.
Observação
Cada iteração do foreach
loop chamará automaticamente o método MoveNext .
O loop a seguir é executado apenas duas vezes. Na segunda iteração, a coleção é movida para o terceiro elemento antes da iteração ser concluída. Após a segunda iteração, agora não há mais valores para iterar e o loop é encerrado.
A propriedade MoveNext não afeta a variável escolhida para iterar por meio da coleção ($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
O uso do método Reset redefine o elemento atual na coleção. O exemplo a seguir percorre os dois primeiros elementos duas vezes porque o método Reset é chamado. Após os dois primeiros loops, a instrução if
falha e o loop itera pelos três elementos normalmente.
Importante
Isso pode resultar em um loop infinito.
$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
Exemplo 5: Usando a variável $switch
A $switch
variável tem exatamente as mesmas regras que a $foreach
variável.
O exemplo a seguir demonstra todos os conceitos do enumerador.
Observação
Observe como o caso NotEvaluated nunca é executado, mesmo que não haja nenhuma break
instrução após o método 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
Confira também
about_Functions_Advanced_Methods
about_Functions_Advanced_Parameters
about_Functions_OutputTypeAttribute