Comment retourner plusieurs éléments d'une fonction PowerShell

1. Utiliser un tableau pour retourner plusieurs éléments d’une fonction PowerShell
2. Utiliser [PSCustomObject] pour retourner plusieurs éléments d’une fonction PowerShell
3. Utiliser des tables de hachage pour retourner plusieurs éléments d’une fonction PowerShell
4. Utiliser des objets personnalisés pour retourner plusieurs éléments d’une fonction PowerShell
5. Conclusion

Lorsque vous travaillez avec des fonctions PowerShell, il y a souvent un besoin de retourner plusieurs valeurs de manière efficace. Une approche efficace consiste à utiliser des tableaux, [PSCustomObject], des tables de hachage ou des objets personnalisés pour encapsuler et présenter ces valeurs.

Dans cet article, nous allons examiner comment utiliser les méthodes mentionnées pour retourner plusieurs éléments d’une fonction PowerShell. Nous décrirons des procédures étape par étape pour chaque méthode et fournirons des exemples de code pour illustrer leur mise en œuvre et présenter leurs résultats.

Utiliser un tableau pour retourner plusieurs éléments d’une fonction PowerShell

Pour retourner plusieurs valeurs d’une fonction PowerShell à l’aide d’un tableau, suivez ces étapes :

Créons une simple fonction PowerShell qui retourne plusieurs valeurs en utilisant un tableau.

function Get-MultipleValues {
    $values = @()

    $values += "Value1"
    $values += "Value2"
    $values += "Value3"

    return $values
}

$resultArray = Get-MultipleValues

Write-Output "Values returned from the function:"
foreach ($value in $resultArray) {
    Write-Output $value
}

Sortie :

Values returned from the function:
Value1
Value2
Value3

Dans cet exemple, nous avons une fonction nommée Get-MultipleValues. Dans la fonction, nous déclarons une variable de tableau $values.

Nous remplissons ensuite ce tableau avec trois valeurs : "Value1", "Value2" et "Value3". Enfin, nous retournons le tableau rempli comme sortie de la fonction.

Lors de l’appel de la fonction, nous stockons le résultat dans une variable ($resultArray) et affichons les valeurs dans le tableau à l’aide d’une boucle.

Utiliser [PSCustomObject] pour retourner plusieurs éléments d’une fonction PowerShell

Vous pouvez également utiliser [PSCustomObject] pour créer des objets personnalisés dans PowerShell. Cela vous permet de définir des propriétés et des valeurs pour un objet, ce qui en fait un choix approprié pour retourner plusieurs valeurs d’une fonction.

Pour créer un objet personnalisé en utilisant [PSCustomObject], vous définissez simplement les propriétés et leurs valeurs correspondantes comme ceci :

$customObject = [PSCustomObject]@{
    Property1 = 'Value1'
    Property2 = 'Value2'
    ...
}

Pour retourner plusieurs valeurs à l’aide de [PSCustomObject] dans une fonction PowerShell, commencez par définir la fonction PowerShell et créer une instance de [PSCustomObject]. Définissez les propriétés et les valeurs que vous souhaitez retourner dans l’objet personnalisé.

function Get-MultipleValues {
    [CmdletBinding()]
    param (
        [string]$Value1,
        [int]$Value2,
        [string]$Value3
    )

    $resultObject = [PSCustomObject]@{
        Name    = $Value1
        Age     = $Value2
        Address = $Value3
    }

    return $resultObject
}

Maintenant, vous pouvez appeler la fonction et récupérer l’objet personnalisé contenant plusieurs valeurs.

$result = Get-MultipleValues -Value1 'Rohan' -Value2 21 -Value3 'UK'

Write-Output "Values returned from the function:"
foreach ($value in $result) {
    Write-Output $value
}

Sortie :

Values returned from the function:
Name  Age Address
----  --- -------
Rohan  21 UK

Comme nous pouvons le voir, le code PowerShell ci-dessus introduit une fonction nommée Get-MultipleValues. Cette fonction, marquée avec [CmdletBinding()], indique sa capacité à utiliser des paramètres de cmdlet communs.

Au sein de la fonction, trois paramètres sont définis : $Value1 (une chaîne), $Value2 (un entier) et $Value3 (une chaîne). La fonction construit un objet personnalisé nommé $resultObject à l’aide de ces paramètres, les attribuant aux propriétés Name, Age et Address dans l’objet personnalisé.

L’instruction return $resultObject garantit que cet objet personnalisé est retourné comme sortie de la fonction Get-MultipleValues.

Après cela, le script appelle la fonction Get-MultipleValues, en spécifiant des valeurs pour chaque paramètre : $Value1 est défini sur 'Rohan', $Value2 est défini sur 21, et $Value3 est défini sur 'UK'. L’objet personnalisé résultant, incorporant les valeurs des paramètres fournis, est stocké dans la variable $result.

Par la suite, le script utilise Write-Output pour présenter un message sur la console et initie une boucle, parcourant les propriétés de l’objet personnalisé contenu dans $result. Pour chaque propriété, le script affiche à la fois le nom de la propriété et sa valeur respective sur la console.

Utiliser des tables de hachage pour retourner plusieurs éléments d’une fonction PowerShell

Une table de hachage dans PowerShell est une collection non ordonnée de paires clé-valeur. Chaque clé doit être unique, et la valeur associée peut être de n’importe quel type de données.

Elle est également appelée dictionnaire ou tableau associatif. Les tables de hachage sont particulièrement utiles lorsque vous devez stocker et récupérer des données en fonction de clés spécifiques, offrant une manière structurée d’organiser l’information.

Pour retourner plusieurs valeurs d’une fonction PowerShell en utilisant des tables de hachage, suivez ces étapes :

Prenons un exemple qui utilise la table de hachage pour retourner plusieurs valeurs d’une fonction nommée user.

Code :

function user() {
    $hash = @{ Name = 'Rohan'; Age = 21; Address = 'UK' }
    return $hash
}

$a = user
Write-Host "$($a.Name) is $($a.Age) and lives in $($a.Address)."

Sortie :

Rohan is 21 and lives in UK.

Comme nous pouvons le voir, ce code définit une fonction nommée user() en utilisant le mot-clé function. Au sein de cette fonction, une table de hachage nommée $hash est créée en utilisant la syntaxe @{}, contenant trois paires clé-valeur : Name avec la valeur 'Rohan', Age avec la valeur 21, et Address avec la valeur 'UK'.

L’instruction return $hash garantit que cette table de hachage est la sortie de la fonction user().

Subséquemment, le script appelle la fonction user() et attribue la table de hachage résultante à la variable $a. Cela signifie que $a contient désormais la table de hachage retournée par la fonction user().

Enfin, le cmdlet Write-Host est utilisé pour afficher un message sur la console. Le message incorpore les valeurs de la table de hachage stockée dans $a, récupérées à l’aide de $($a.Name), $($a.Age) et $($a.Address) pour accéder respectivement aux valeurs Name, Age et Address.

Maintenant, créons une autre fonction PowerShell qui calcule la somme et le produit de deux nombres et retourne les résultats en utilisant une table de hachage.

function Calculate-SumAndProduct {
    param(
        [int]$num1,
        [int]$num2
    )

    $resultHashTable = @{
        Sum     = $num1 + $num2
        Product = $num1 * $num2
    }

    return $resultHashTable
}

$inputNum1 = 5
$inputNum2 = 7

$result = Calculate-SumAndProduct -num1 $inputNum1 -num2 $inputNum2

Write-Output "Sum: $($result['Sum'])"
Write-Output "Product: $($result['Product'])"

Sortie :

Sum: 12
Product: 35

Ce code commence par définir une fonction appelée Calculate-SumAndProduct, qui accepte deux paramètres int, $num1 et $num2. À l’intérieur de la fonction, une table de hachage nommée $resultHashTable est créée en utilisant la syntaxe @{}.

Cette table de hachage contient deux paires clé-valeur : Sum avec une valeur égale à la somme de $num1 et $num2, et Product avec une valeur égale au produit de $num1 et $num2. La fonction retourne ensuite cette table de hachage, la rendant sortie de la fonction Calculate-SumAndProduct.

En continuant dans le script, deux nombres d’entrée sont définis : $inputNum1 avec une valeur de 5 et $inputNum2 avec une valeur de 7. La fonction Calculate-SumAndProduct est appelée avec ces nombres d’entrée, et la table de hachage résultante est stockée dans une variable nommée $result.

Enfin, le script utilise le cmdlet Write-Output pour afficher les valeurs de la somme et du produit en accédant aux valeurs correspondantes dans la table de hachage stockée dans $result.

Utiliser des objets personnalisés pour retourner plusieurs éléments d’une fonction PowerShell

Un objet personnalisé dans PowerShell est une instance de la classe System.Management.Automation.PSCustomObject. Il vous permet de définir des propriétés et des valeurs associées à ces propriétés, imitant un objet du monde réel.

Les objets personnalisés sont flexibles et permettent d’organiser et de récupérer des données de manière structurée.

Pour retourner plusieurs valeurs d’une fonction PowerShell en utilisant des objets personnalisés, suivez ces étapes :

Créons une fonction PowerShell qui calcule la somme et le produit de deux nombres et retourne les résultats en utilisant un objet personnalisé.

function Calculate-SumAndProduct {
    param(
        [int]$num1,
        [int]$num2
    )

    $resultObject = New-Object PSObject
    $resultObject | Add-Member -MemberType NoteProperty -Name "Sum" -Value ($num1 + $num2)
    $resultObject | Add-Member -MemberType NoteProperty -Name "Product" -Value ($num1 * $num2)

    return $resultObject
}

$inputNum1 = 5
$inputNum2 = 7

$result = Calculate-SumAndProduct -num1 $inputNum1 -num2 $inputNum2

Write-Output "Sum: $($result.Sum)"
Write-Output "Product: $($result.Product)"

Sortie :

Sum: 12
Product: 35

Dans cet exemple, nous avons défini une fonction nommée Calculate-SumAndProduct qui prend deux nombres d’entrée ($num1 et $num2). À l’intérieur de la fonction, nous avons créé un objet personnalisé nommé $resultObject et ajouté des propriétés (Sum et Product) à celui-ci, en attribuant les valeurs calculées respectives.

Lorsque nous appelons la fonction avec des nombres d’entrée (5 et 7), nous stockons le résultat dans une variable ($result). Nous affichons ensuite la somme et le produit en accédant aux propriétés de l’objet personnalisé résultant.

Conclusion

Cet article a exploré diverses techniques pour retourner plusieurs valeurs d’une fonction, y compris l’utilisation de tableaux, [PSCustomObject], de tables de hachage et d’objets personnalisés. Chaque méthode offre ses avantages et peut être choisie en fonction des exigences spécifiques de votre script.

Les tableaux offrent un moyen simple de retourner plusieurs valeurs, en particulier lorsque les éléments de données partagent un type ou une structure similaire. [PSCustomObject] vous permet de créer des objets personnalisés avec des propriétés nommées, offrant une approche structurée pour retourner des données.

Les tables de hachage excellent dans les situations où la récupération des données est basée sur des clés spécifiques, fournissant une solution organisée et efficace. Les objets personnalisés, construits à l’aide de la classe [System.Management.Automation.PSCustomObject], offrent flexibilité et imitent des objets du monde réel.