Terminar um programa em 'PowerShell'

Eu percebo que este é um post antigo, mas eu me encontro voltando muito a este tópico, uma vez que é um dos resultados de pesquisa de topo ao procurar por este tópico. No entanto, eu sempre deixo mais confuso quando eu vim devido à informação conflitante. Em última análise, tenho sempre de fazer os meus próprios testes para descobrir. Então desta vez vou postar minhas descobertas.

TL; DR a maioria das pessoas irá querer usar Exit para terminar um programa em execução. No entanto, se o seu script é meramente declarando funções para mais tarde ser usado em uma shell, então você vai querer usar Return nas definições das referidas Funções.

Exit vs Return vs Break

• Saída: isto irá "sair" do contexto actual. Se você ligar para este comando a partir de um script ele irá sair do script. Se você chamar este comando a partir da shell ele vai sair da shell.

  Se uma função chama o comando Exit, sai do contexto em que está a correr. Portanto, se essa função é apenas chamado de dentro de um script em execução que irá sair desse script. No entanto, se o seu programa apenas declarar a função para que possa ser usada a partir da linha de comandos actual e executar essa função a partir da linha de comandos, irá sair da linha de comandos porque a linha de comandos é o contexto em que a função que contigua o comando Exit está a correr.

  Nota:, Por padrão, se você clicar em um script para executá-lo no PowerShell, uma vez que o script é feito em execução, o PowerShell irá fechar automaticamente. Isto não tem nada a ver com o comando Exit ou qualquer outra coisa no seu script. É apenas um comportamento PowerShell padrão para scripts sendo executado usando este método específico de executar um script. O mesmo se aplica aos ficheiros em lote e à janela da linha de comandos.

• Retorno: Isto irá retornar ao ponto de chamada anterior. Se você chamar este comando a partir de um script (fora de quaisquer funções) ele retornará à shell. Se você chamar este comando a partir da shell ele vai voltar para o shell (que é o ponto de chamada anterior para um único comando executado a partir do shell). Se você chamar este comando a partir de uma função, ele retornará para onde a função foi chamada.

  A execução de quaisquer comandos após o ponto de chamada para o qual é devolvido continuará a partir desse ponto. Se um script é chamado a partir da linha de comandos e ele contém o comando Return fora de quaisquer funções, então quando ele retorna para a linha de comandos não existem mais comandos para executar assim fazendo um Return usado desta forma essencialmente o mesmo que Exit.

• Break: isto vai sair de loops e mudar de caixas. Se você chamar este comando enquanto não estiver em um loop ou mudar de caso, ele vai sair do script. Se você chamar Break dentro de um loop que é aninhado dentro de um loop ele só vai quebrar fora do loop que foi chamado para dentro.

  Existe também uma característica interessante de Break onde você pode prefixar um laço com um rótulo e então você pode sair desse laço marcado mesmo que o Break o comando é chamado dentro de vários grupos aninhados dentro desse loop.

  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
  }
  

Exit vai sair PowerShell também. Se você deseja "sair" apenas da função atual ou uso de script 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 terminação e throw é para erros de terminação

O erro de Escrita cmdlet declara um erro de não-terminação. Por omissão, os erros são enviados na sequência de erros para o programa de máquina a ser apresentado, juntamente com a saída.

Erros de não-terminação escrevem um erro na sequência de erros, mas eles não param o processamento de comandos. Se um erro de não-terminação for declarado num item de uma colecção de itens de entrada, comando continua a processar os outros itens da coleção.

Declarar a a terminar o erro, use a palavra-chave. Para mais informações, consulte sobre o futuro ( http://go.microsoft.com/fwlink/?LinkID=145153).

Termina este processo e dá ao sistema operativo 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)

Abrir uma excepção será bom especialmente se quiser esclarecer a razão do erro:

throw "Error Message"

Isto irá gerar um erro de terminação.

Get-Help about_trap

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

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

Por coincidência descobri que Break <UnknownLabel> (por exemplo, simplesmente Break Script, onde o rótulo Script não existe) parece sair de todo o script (mesmo dentro de uma função) e mantém a máquina viva.
Desta forma, poderá criar uma função que quebra o programa de qualquer lugar (por exemplo, um ciclo recursivo) sem conhecer o âmbito actual (e criar legendas):

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