Terminer un script en PowerShell

je me rends compte que c'est un vieux post mais je me retrouve à revenir à ce fil beaucoup comme il est l'un des résultats de recherche haut lors de la recherche de ce sujet. Cependant, je laisse toujours plus confus que lorsque je suis venu à cause des informations contradictoires. En fin de compte, je dois toujours faire mes propres tests pour le comprendre. Donc cette fois je vais poster mes résultats.

TL; DR la plupart des gens voudront utiliser Exit pour terminer une course script. Cependant, si votre script est simplement en train de déclarer des fonctions à utiliser plus tard dans un shell, alors vous voudrez utiliser Return dans les définitions de ces fonctions.

Sortie vs Retour vs Pause

• Exit: ceci "exit" le contexte en cours d'exécution. Si vous appelez cette commande à partir d'un script, il va quitter le script. Si vous appelez cette commande depuis le shell, il sortira du 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 que depuis un script en cours d'exécution, il sortira de ce script. Cependant, si votre script déclare simplement la fonction pour qu'elle puisse être utilisée à partir du shell actuel et que vous exécutez cette fonction à partir du shell, il sortira du shell parce que le shell est le contexte dans lequel la fonction contenant la commande Exit est en cours d'exécution.

  Note: par défaut, si vous cliquez avec le bouton droit de la souris sur un script pour l'exécuter dans PowerShell, une fois le script exécuté, PowerShell se ferme automatiquement. Cela n'a rien à voir avec la commande Exit 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 en utilisant cette méthode spécifique d'exécution d'un script. Il en va de même pour les fichiers par lots et la fenêtre de ligne de commande.

• de Retour: Ce sera de retour à l'appel précédent point. Si vous appelez cette commande à partir d'un script (en dehors de toute fonction), elle retournera dans le shell. Si vous appelez cette commande depuis le shell, elle retournera vers le shell (qui est le point d'appel précédent pour une seule commande lancée depuis le shell). Si vous appelez cette commande à partir d'une fonction, elle retournera là où la fonction a été appelée.

  exécution de toute commande après la le point d'appel auquel il est retourné continuera à partir de ce point. Si un script est appelé à partir de l'interpréteur de commandes et qu'il contient la commande Return en dehors de toute fonction, alors quand il retourne dans l'interpréteur de commandes, il n'y a plus de commandes à exécuter, ce qui fait qu'un Return utilisé de cette façon est essentiellement le même que Exit .

• Pause": Cela va casser les boucles et le commutateur cas. Si vous appelez cette commande alors que pas dans un boucle ou cas de commutation, il se détachera du script. Si vous appelez Break à l'intérieur d'une boucle imbriquée à l'intérieur d'une boucle, il va seulement sortir de la boucle, il avait été appelé.

  il y a aussi une caractéristique intéressante de Break où vous pouvez préfixer une boucle avec un label et puis vous pouvez sortir de cette boucle étiquetée même si la commande Break 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
  }
  

Exit quittera PowerShell aussi. Si vous souhaitez "sortir" de la fonction ou du script courant-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 la non-terminaison d'erreurs et de jeter est pour mettre fin à des erreurs

le cmdlet Write-Error déclare une erreur non terminante. Par défaut, les erreurs sont envoyées dans le flux d'erreur pour le programme hôte pour être affiché, avec la sortie.

Non-terminaison des erreurs d'écriture une erreur dans le flux d'erreur, mais ils n'arrêtent pas le traitement des commandes. Si un l'erreur de non-terminaison est déclaré sur un élément dans une collection d'éléments d'entrée, la commande continue à traiter les autres de la collection.

pour déclarer un la résiliation d'erreur, utilisez le mot clé Jeter. Pour plus d'informations, voir à propos de_throw ( http://go.microsoft.com/fwlink/?LinkID=145153 ).

je pense que vous cherchez Return au lieu de Break . Break est généralement utilisé pour les boucles et ne se brise du bloc de code le plus interne. Utilisez Return pour quitter une fonction ou un script.

termine 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 sortir avec un code de sortie, qui peuvent être ramassés à partir de l'appelant.

lancer une exception sera bon surtout si vous voulez clarifier la raison de l'erreur:

throw "Error Message"

cela générera une erreur de terminaison.

peut-être est-il préférable d'utiliser"trap". Un piège PowerShell spécifie un codeblock à exécuter en cas de terminaison ou d'erreur. Type

Get-Help about_trap

pour en savoir plus sur la déclaration trap.

j'ai utilisé ceci pour une rediffusion d'un programme. Je ne sais pas si cela pourrait aider, mais c'est un simple si déclaration exigeant seulement deux entrées différentes. Ça a marché à 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 crois que ce serait dans le sens de mettre fin à un programme après l'avoir exécuté. Toutefois, dans ce cas, chaque entrée définie nécessite une sortie listée et catégorisée. Vous pourriez également avoir le quitter appeler une nouvelle invite de ligne et mettre fin au programme de cette façon.

je l'ai trouvée par hasard que Break <UnknownLabel> (par exemple, tout simplement Break Script , où l'étiquette Script n'existe pas ) semble sortir de l'intégralité du script (même à partir d'une fonction) et maintient l'hôte vivant.

De cette façon, vous pouvez créer une fonction qui casse le script de n'importe où (par exemple une boucle récursive) sans connaître la portée actuelle (et créer des étiquettes):

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