Terminer un script dans PowerShell

J'ai cherché un moyen de terminer un script PowerShell (PS1) lorsqu'une erreur irrécupérable se produit dans une fonction. Par exemple:

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

Bien sûr, il n'y a rien de tel $host.Exit(). Oui $host.SetShouldExit(), mais cela ferme la fenêtre de la console, ce qui n'est pas ce que je veux. Ce dont j'ai besoin est quelque chose d'équivalent à Python sys.exit()qui arrêtera simplement l'exécution du script actuel sans plus tarder.

Edit: Ouais, c'est juste exit. Duh.

Vous devez utiliser le exitmot - clé .

Je me rends compte que c'est un ancien post mais je me retrouve à revenir sur ce sujet car c'est l'un des meilleurs résultats de recherche lorsque vous recherchez ce sujet. Cependant, je laisse toujours plus confus que quand je suis venu en raison des informations contradictoires. En fin de compte, je dois toujours effectuer mes propres tests pour le comprendre. Cette fois, je vais donc publier mes résultats.

TL; DR La plupart des gens voudront utiliser Exitpour terminer un script en cours d'exécution. Cependant, si votre script déclare simplement des fonctions à utiliser ultérieurement dans un shell, alors vous voudrez les utiliser Returndans les définitions desdites fonctions.

Sortie vs retour vs pause

• Quitter: cela "quittera" le contexte en cours d'exécution. Si vous appelez cette commande à partir d'un script, elle quittera le script. Si vous appelez cette commande à partir du shell, elle quittera le shell.

  Si une fonction appelle la commande Exit, elle quittera le contexte dans lequel elle s'exécute. Ainsi, si cette fonction n'est appelée qu'à partir d'un script en cours d'exécution, elle quittera ce script. Cependant, si votre script déclare simplement la fonction afin qu'elle puisse être utilisée à partir du shell actuel et que vous exécutez cette fonction à partir du shell, il quittera le shell car le shell est le contexte dans lequel la fonction contenant la Exitcommande s'exécute.

  Remarque: Par défaut, si vous cliquez avec le bouton droit sur un script pour l'exécuter dans PowerShell, une fois le script exécuté, PowerShell se fermera automatiquement. Cela n'a rien à voir avec la Exitcommande ou quoi que ce soit d'autre dans votre script. Il s'agit simplement d'un comportement PowerShell par défaut pour les scripts exécutés à l'aide de cette méthode spécifique d'exécution d'un script. Il en va de même pour les fichiers batch et la fenêtre de ligne de commande.

• Revenir: Cela reviendra au point d'appel précédent. Si vous appelez cette commande à partir d'un script (en dehors de toute fonction), elle reviendra au shell. Si vous appelez cette commande à partir du shell, elle reviendra au shell (qui est le point d'appel précédent pour une seule commande exécutée à partir du shell). Si vous appelez cette commande à partir d'une fonction, elle retournera à l'endroit où la fonction a été appelée.

  L'exécution de toutes les commandes après le point d'appel auquel il est renvoyé se poursuivra à partir de ce point. Si un script est appelé à partir du shell et qu'il contient la Returncommande en dehors de toute fonction, alors quand il revient au shell, il n'y a plus de commandes à exécuter, rendant ainsi un Returnutilisé de cette manière essentiellement identique à Exit.

• Break: Cela va sortir des boucles et changer les boîtiers. Si vous appelez cette commande alors qu'elle n'est pas dans une boucle ou un commutateur, elle sortira du script. Si vous appelez à l' Breakintérieur d'une boucle imbriquée dans une boucle, elle ne sortira que de la boucle dans laquelle elle a été appelée.

  Il y a aussi une fonctionnalité intéressante Breakoù vous pouvez préfixer une boucle avec une étiquette et ensuite vous pouvez sortir de cette boucle étiquetée même si la Breakcommande est appelée dans plusieurs groupes imbriqués dans cette boucle étiquetée.

  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
  }

Exitquittera également PowerShell. Si vous souhaitez "sortir" de la fonction ou du script en cours, utilisez 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 est pour les erreurs qui ne se terminent pas et throw est pour les erreurs qui se terminent

L'applet de commande Write-Error déclare une erreur sans fin. Par défaut, les erreurs sont envoyées dans le flux d'erreurs au programme hôte à afficher, avec la sortie.

Les erreurs qui ne se terminent pas écrivent une erreur dans le flux d'erreurs, mais elles n'arrêtent pas le traitement des commandes. Si une erreur sans fin est déclarée sur un élément d'une collection d'éléments d'entrée, la commande continue de traiter les autres éléments de la collection.

Pour déclarer une erreur de fin, utilisez le mot clé Throw. Pour plus d'informations, consultez about_Throw ( http://go.microsoft.com/fwlink/?LinkID=145153 ).

Met fin à ce processus et donne au système d'exploitation sous-jacent le code de sortie spécifié.

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

[Environment]::Exit(1)

Cela vous permettra de quitter avec un code de sortie spécifique, qui peut être récupéré auprès de l'appelant.

Je pense que vous cherchez au Returnlieu de Break. La rupture est généralement utilisée pour les boucles et uniquement les ruptures du bloc de code le plus interne. Utilisez Retour pour quitter une fonction ou un script.

Lancer une exception sera utile, surtout si vous souhaitez clarifier la raison de l'erreur:

throw "Error Message"

Cela générera une erreur de terminaison.

Peut-être vaut-il mieux utiliser "trap". Un déroutement PowerShell spécifie un bloc de code à exécuter en cas d'arrêt ou d'erreur. Type

Get-Help about_trap

pour en savoir plus sur l'instruction trap.

Je trouve par hasard que (par exemple simplement , où l'étiquette n'existe pas ) semble sortir du script entier (même à l' intérieur d' une fonction) et maintient l'hôte vivant. De cette façon, vous pouvez créer une fonction qui rompt le script de n'importe où (par exemple une boucle récursive) sans connaître la portée actuelle (et créer des étiquettes):Break <UnknownLabel>Break ScriptScript

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

Je l'ai utilisé pour une nouvelle exécution d'un programme. Je ne sais pas si cela aiderait, mais c'est une simple instruction if ne nécessitant que deux entrées différentes. Cela a fonctionné en PowerShell pour moi.

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

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

Je ne sais pas si cela aide, mais je pense que ce serait dans le sens de terminer un programme après l'avoir exécuté. Cependant, dans ce cas, chaque entrée définie nécessite une sortie répertoriée et catégorisée. Vous pouvez également demander à la sortie d'appeler une nouvelle ligne d'invite et de terminer le programme de cette façon.