about_Return

Article
05/09/2024

Description courte

Quitte l'étendue active (fonction, script ou bloc de script).

Description longue

Le return mot clé quitte une fonction, un script ou un bloc de script. Il peut être utilisé pour quitter une étendue à un point spécifique, pour retourner une valeur ou pour indiquer que la fin de l’étendue a été atteinte.

Les utilisateurs qui sont familiarisés avec des langages comme C ou C# peuvent vouloir utiliser le return mot clé pour rendre explicite la logique de laisser une étendue explicite.

Dans PowerShell, les résultats de chaque instruction sont retournés en tant que sortie, même sans instruction contenant l’mot clé Return. Les langages comme C ou C# retournent uniquement la ou les valeurs spécifiées par le return mot clé.

Notes

À compter de PowerShell 5.0, PowerShell a ajouté le langage pour définir des classes à l’aide de la syntaxe formelle. Dans le contexte d’une classe PowerShell, rien n’est généré à partir d’une méthode, sauf ce que vous spécifiez à l’aide d’une return instruction. Vous pouvez en savoir plus sur les classes PowerShell dans about_Classes.

Syntax

La syntaxe de l’mot clé return est la suivante :

return [<expression>]

Le return mot clé peut apparaître seul, ou il peut être suivi d’une valeur ou d’une expression, comme suit :

return
return $a
return (2 + $a)

Exemples

L’exemple suivant utilise le return mot clé pour quitter une fonction à un point spécifique si une condition est remplie. Les nombres impairs ne sont pas multipliés, car l’instruction return se termine avant que cette instruction ne puisse s’exécuter.

function MultiplyEven
{
    param($number)

    if ($number % 2) { return "$number is not even" }
    $number * 2
}

1..10 | ForEach-Object {MultiplyEven -Number $_}

1 is not even
4
3 is not even
8
5 is not even
12
7 is not even
16
9 is not even
20

Dans PowerShell, les valeurs peuvent être retournées même si le return mot clé n’est pas utilisé. Les résultats de chaque instruction sont retournés. Par exemple, les instructions suivantes retournent la valeur de la $a variable :

$a
return

L’instruction suivante retourne également la valeur de $a:

return $a

L’exemple suivant inclut une instruction destinée à informer l’utilisateur que la fonction effectue un calcul :

function calculation {
    param ($value)

    "Please wait. Working on calculation..."
    $value += 73
    return $value
}

$a = calculation 14

Le « S’il vous plaît attendre. Travailler sur le calcul..." la chaîne n’est pas affichée. Au lieu de cela, elle est affectée à la $a variable, comme dans l’exemple suivant :

PS> $a
Please wait. Working on calculation...
87

La chaîne d’information et le résultat du calcul sont retournés par la fonction et affectés à la $a variable.

Si vous souhaitez afficher un message dans votre fonction, à partir de PowerShell 5.0, vous pouvez utiliser le Information flux. Le code ci-dessous corrige l’exemple ci-dessus à l’aide de l’applet Write-Information de commande avec un InformationAction de Continue.

function calculation {
    param ($value)

    Write-Information "Please wait. Working on calculation..." -InformationAction Continue
    $value += 73
    return $value
}

$a = calculation 14

Please wait. Working on calculation...
C:\PS> $a
87

Valeurs de retour et pipeline

Lorsque vous retournez une collection à partir de votre bloc ou fonction de script, PowerShell déroule automatiquement les membres et les transmet un par un dans le pipeline. Cela est dû au traitement un à la fois de PowerShell. Pour plus d’informations, consultez about_pipelines.

Ce concept est illustré par l’exemple de fonction suivant qui retourne un tableau de nombres. La sortie de la fonction est redirigée vers l’applet Measure-Object de commande qui compte le nombre d’objets dans le pipeline.

function Test-Return
{
    $array = 1,2,3
    return $array
}
Test-Return | Measure-Object

Count    : 3
Average  :
Sum      :
Maximum  :
Minimum  :
Property :

Pour forcer un bloc ou une fonction de script à retourner une collection en tant qu’objet unique au pipeline, utilisez l’une des deux méthodes suivantes :

Expression de tableau unaire

En utilisant une expression unaire, vous pouvez envoyer votre valeur de retour dans le pipeline en tant qu’objet unique, comme illustré dans l’exemple suivant.
```
function Test-Return
{
    $array = 1,2,3
    return (, $array)
}
Test-Return | Measure-Object
```
```
Count    : 1
Average  :
Sum      :
Maximum  :
Minimum  :
Property :
```
Write-Output avec le paramètre NoEnumerate .

Vous pouvez également utiliser l’applet de Write-Output commande avec le paramètre NoEnumerate . L’exemple ci-dessous utilise l’applet Measure-Object de commande pour compter les objets envoyés au pipeline à partir de l’exemple de fonction par le return mot clé.
```
function Test-Return
{
    $array = 1, 2, 3
    return Write-Output -NoEnumerate $array
}

Test-Return | Measure-Object
```
```
Count    : 1
Average  :
Sum      :
Maximum  :
Minimum  :
Property :
```

Share via