Terminando um script no PowerShell

Eu estava procurando uma maneira de finalizar um script do PowerShell (PS1) quando ocorre um erro irrecuperável dentro de uma função. Por exemplo:

function foo() {
    # Do stuff that causes an error
    $host.Exit()
}

Claro que não existe $host.Exit(). Existe $host.SetShouldExit(), mas isso realmente fecha a janela do console, que não é o que eu quero. O que eu preciso é de algo equivalente ao Python sys.exit()que simplesmente pare a execução do script atual sem mais delongas.

Edit: Sim, é apenas exit. Duh.

Você deve usar a exitpalavra-chave .

Percebo que este é um post antigo, mas me vejo voltando muito a esse tópico, pois é um dos principais resultados de pesquisa ao pesquisar esse tópico. No entanto, sempre deixo mais confuso do que quando cheguei devido às informações conflitantes. Em última análise, eu sempre tenho que realizar meus próprios testes para descobrir isso. Então desta vez vou postar minhas descobertas.

TL; DR A maioria das pessoas desejará usar Exitpara finalizar os scripts em execução. No entanto, se seu script estiver apenas declarando funções para serem usadas posteriormente em um shell, você desejará usarReturn nas definições dessas funções.

Saída x Retorno x Ruptura

• Saída: Isso "sairá" do contexto em execução no momento. Se você chamar esse comando a partir de um script, ele sairá do script. Se você chamar esse comando do shell, ele sairá do shell.

  Se uma função chamar o comando Exit, ela sairá do contexto em que estiver sendo executada. Portanto, se essa função for chamada apenas de dentro de um script em execução, ela será encerrada. No entanto, se o seu script apenas declarar a função para que possa ser usada no shell atual e você a executar a partir do shell, ele sairá do shell porque o shell é o contexto no qual a função que contém o Exitcomando está sendo executada.

  Nota: Por padrão, se você clicar com o botão direito do mouse em um script para executá-lo no PowerShell, assim que o script for executado, o PowerShell será fechado automaticamente. Isso não tem nada a ver com o Exitcomando ou qualquer outra coisa no seu script. É apenas um comportamento padrão do PowerShell para scripts sendo executados usando este método específico de execução de um script. O mesmo vale para arquivos em lotes e para a janela Linha de Comando.

• Retorno: Isso retornará ao ponto de chamada anterior. Se você chamar esse comando a partir de um script (fora de qualquer função), ele retornará ao shell. Se você chamar esse comando do shell, ele retornará ao shell (que é o ponto de chamada anterior para um único comando executado no shell). Se você chamar esse comando de uma função, ele retornará para onde quer que a função tenha sido chamada.

  A execução de qualquer comando após o ponto de chamada para o qual ele é retornado continuará a partir desse ponto. Se um script for chamado a partir do shell e ele contiver o Returncomando fora de qualquer função, quando retornar ao shell, não haverá mais comandos a serem executados, fazendo com que o Returnusado dessa maneira seja essencialmente o mesmo que Exit.

• Interromper: Isso interrompe os loops e alterna os casos. Se você chamar esse comando enquanto não estiver em loop ou alternar entre maiúsculas e minúsculas, o script será interrompido. Se você chamar Breakdentro de um loop aninhado dentro de um loop, ele sairá apenas do loop no qual foi chamado.

  Há também um recurso interessante de Breakonde você pode prefixar um loop com um rótulo e, em seguida, pode interromper esse loop rotulado, mesmo que o Breakcomando seja chamado dentro de vários grupos aninhados dentro desse loop rotulado.

  While ($true) {
      # Code here will run
  
      :myLabel While ($true) {
          # Code here will run
  
          While ($true) {
              # Code here will run
  
              While ($true) {
                  # Code here will run
                  Break myLabel
                  # Code here will not run
              }
  
              # Code here will not run
          }
  
          # Code here will not run
      }
  
      # Code here will run
  }

Exittambém sairá do PowerShell. Se você deseja "quebrar" apenas a função ou script atual - use Break:)

If ($Breakout -eq $true)
{
     Write-Host "Break Out!"
     Break
}
ElseIf ($Breakout -eq $false)
{
     Write-Host "No Breakout for you!"
}
Else
{
    Write-Host "Breakout wasn't defined..."
}

Write-Error é para erros sem finalização e throw é para erros com finalização

O cmdlet Write-Error declara um erro sem fim. Por padrão, os erros são enviados no fluxo de erros para o programa host a ser exibido, juntamente com a saída.

Erros que não terminam gravam um erro no fluxo de erros, mas não param o processamento do comando. Se um erro sem finalização for declarado em um item em uma coleção de itens de entrada, o comando continuará processando os outros itens na coleção.

Para declarar um erro de encerramento, use a palavra-chave Throw. Para obter mais informações, consulte about_Throw ( http://go.microsoft.com/fwlink/?LinkID=145153 ).

Finaliza esse processo e fornece ao sistema operacional subjacente o código de saída especificado.

https://msdn.microsoft.com/en-us/library/system.environment.exit%28v=vs.110%29.aspx

[Environment]::Exit(1)

Isso permitirá que você saia com um código de saída específico, que pode ser retirado do chamador.

Eu acho que você está procurando em Returnvez de Break. A quebra é normalmente usada para loops e apenas quebra do bloco de código mais interno. Use Return para sair de uma função ou script.

Lançar uma exceção será bom, especialmente se você desejar esclarecer o motivo do erro:

throw "Error Message"

Isso irá gerar um erro de finalização.

Pode ser que seja melhor usar "trap". Uma interceptação do PowerShell especifica um bloqueio de código a ser executado quando ocorrer um erro ou finalização. Tipo

Get-Help about_trap

para saber mais sobre a declaração de armadilha.

Por coincidência, descobri que (por exemplo , simplesmente , onde o rótulo não existe ) parece romper o script inteiro (mesmo de dentro de uma função) e mantém o host vivo. Dessa forma, você pode criar uma função que quebre o script de qualquer lugar (por exemplo, um loop recursivo) sem conhecer o escopo atual (e criar rótulos):Break <UnknownLabel>Break ScriptScript

Function Quit($Text) {
    Write-Host "Quiting because: " $Text
    Break Script
} 

Eu usei isso para uma reexecução de um programa. Não sei se isso ajudaria, mas é uma instrução if simples que requer apenas duas entradas diferentes. Funcionou em PowerShell para mim.

$rerun = Read-Host "Rerun report (y/n)?"

if($rerun -eq "y") { Show-MemoryReport }
if($rerun -eq "n") { Exit }

Não sei se isso ajuda, mas acredito que isso seria ao longo das linhas de finalizar um programa depois de executá-lo. No entanto, neste caso, toda entrada definida requer uma saída listada e categorizada. Você também pode solicitar que a saída chame uma nova linha de prompt e encerre o programa dessa maneira.