Comment utiliser les tableaux Powershell

Introduction

Un tableau est une structure de données qui peut contenir plusieurs valeurs à la fois. Considérez-le comme une collection ou une liste d'éléments de même type ou de types de données différents. Les tableaux sont utilisés dans de nombreux langages de script et de programmation, y compris Windows PowerShell.

Plongeons dans la manière de créer et d'utiliser un array in PowerShell.

Création d'un tableau d'objets

Par défaut, chaque élément d'un tableau est un objet, plutôt qu'un autre type de données tel qu'une chaîne de caractères ou un entier. Voici un exemple de la façon de créer un tableau d'objets en ajoutant explicitement des objets :

      $people = @(

    [PSCustomObject]@{Name='Alice'; Age=30},

    [PSCustomObject]@{Name='Bob'; Age=25}
      

Création d'un tableau avec un seul élément

Si vous mettez juste une valeur dans une variable, alors PowerShell ne créera pas de tableau. Pour confirmer cela, utilisons deux scripts et affichons leurs types de données.

Tout d'abord, nous allons créer un tableau en PowerShell avec cinq éléments :

      $array = @(1, 2, 3, 4, 5)

$array1.GetType()
      

Maintenant, essayons d'utiliser un script similaire pour créer un tableau avec un seul élément :

      $array1 = 1

$array1.GetType()
      

Comme vous pouvez le voir dans le résultat ci-dessous, PowerShell a créé un tableau (System.Array) pour le premier script d'exemple mais pas pour le second.

Ce comportement est particulièrement préoccupant si vous souhaitez créer un tableau en récupérant des objets en exécutant une commande spécifique, car vous ne savez pas à l'avance combien d'objets seront retournés dans les résultats.

Pour contourner ce problème, vous pouvez utiliser l'opérateur , (virgule). Si une virgule est utilisée comme opérateur binaire, alors un tableau normal est créé ; si elle est utilisée comme opérateur unaire, le tableau n'a qu'un seul élément.

Par exemple, voici comment nous pouvons obtenir un tableau composé d'un seul élément :

      $array1 = ,1

$array1.GetType()
      

Nous pouvons confirmer la création du tableau avec le résultat affiché ci-dessous :

Création d'un tableau vide

Dans PowerShell, vous pouvez également créer un tableau — y compris un tableau vide — en utilisant l'opérateur @. Si vous spécifiez @(), vous obtenez un tableau sans aucun objet, vous pouvez créer un. C'est un moyen pratique d'initialiser des variables en tant que tableaux et d'ajouter plus tard des objets aux tableaux sans se soucier de leur nombre.

      $array3 = @()

$array3.GetType()
      

Création d'un tableau fortement typé

Par défaut, les éléments d'un tableau peuvent avoir différents types de données. Mais vous pouvez également créer des tableaux qui n'acceptent que des valeurs d'un type désigné unique. Essayer d'ajouter une valeur d'un type différent produira une erreur. Voici comment créer les tableaux fortement typés les plus courants :

Entier :

      [int[]]$intArray = 1, 2, 3
      

Chaîne :

      [string[]]$strArray = "one", "two", "three"
      

Date/Heure :

[datetime[]]$dateArray = (Get-Date), (Get-Date).AddDays(1)

Création d'un tableau multidimensionnel (matrice)

En imbriquant des tableaux à l'aide de virgules, vous pouvez créer un arrangement structuré de données en lignes ou en colonnes. Ici, nous créons une matrice 3×3 :

$twoDArray = @(

@(1, 2, 3),

@(4, 5, 6),

@(7, 8, 9)

)

Comparaison, regroupement, sélection et tri de tableaux

Parmi les autres cmdlets PowerShell utiles pour travailler avec des tableaux, on trouve :

• Compare-Object — Compare deux tableaux et retourne les différences.
• Group-Object — Regroupe les éléments d'un tableau en fonction des valeurs des propriétés.
• Select-Object — Sélectionne des propriétés spécifiées d'un objet ou d'un ensemble d'objets, et peut également être utilisé pour sélectionner un nombre spécifique d'éléments dans un tableau.
• Sort-Object — Utilisé pour trier des tableaux qui contiennent uniquement un type de données, comme indiqué ci-dessous :

      $array = @(3, 1, 4, 2)
$sortedArray = $array | Sort-Object
      

Parcourir un tableau

Pour traiter chaque élément d'un tableau l'un après l'autre, nous devons créer une boucle en utilisant l'opérateur foreach. Par exemple, si nous déclarons un tableau de chaînes de caractères et voulons compter la longueur de chaque mot dans le tableau, nous devrions exécuter le script suivant :

      $array8 = @("Earth","Mercury","Venus","Jupiter","Saturn","Mars", "Neptune", "Pluto")
foreach ($array in $array8) {
 "$array = " + $array.length
}
      

Le résultat ressemblera à ceci :

Utilisation d'un Pipeline

Le pipeline est utilisé dans PowerShell pour passer la sortie d'une commande comme entrée à une autre. Lorsque vous travaillez avec des tableaux, vous pouvez utiliser le pipeline pour traiter et manipuler les données dans le tableau et assigner les résultats à un nouveau tableau ou modifier le tableau existant.

Ici, nous allons multiplier chaque élément du tableau par 2 :

      $numbers = 1,2,3,4,5

$doubled = $numbers | ForEach-Object { $_ * 2 }
      

Ajout à un tableau

La taille d'un tableau dans PowerShell est immuable une fois qu'il est défini. Cependant, l'opérateur += vous permet de créer un nouveau tableau en ajoutant des éléments à un tableau existant — créant essentiellement un nouveau tableau combiné.

      $array = @(1, 2, 3)
$array += 4
      

Création d'une ArrayList

Pour les grands tableaux ou les ajouts fréquents, l'utilisation de += peut être une préoccupation en termes de performance, car à chaque fois que vous l'utilisez, un nouveau tableau est créé, les anciens éléments sont copiés et le nouvel élément est ajouté à la fin. Dans ces cas, vous pourriez vouloir utiliser une ArrayList.

La taille d'une ArrayList est modifiable, vous pouvez donc ajouter ou retirer des éléments sans avoir à recréer la collection entière. Comme un tableau standard, une ArrayList peut contenir des éléments de différents types de données.

Voici le cmdlet pour créer une ArrayList :

      $array3 = New-Object System.Collections.ArrayList

      

Suppression d'un élément d'un tableau

Maintenant, utilisons une ArrayList pour retirer un élément d'un tableau. Commençons par créer un tableau.

      $array5 = "one", "two", "three", "four", "five"
$array5.gettype()
      

Maintenant, nous allons l'ajouter à une ArrayList afin de pouvoir le modifier facilement.

      [System.Collections.ArrayList]$ArrayList1 = $array5

$ArrayList1.GetType()
      

Nous utiliserons ensuite la commande .Remove.

      $ArrayList1.Remove("three")

      

Vider un tableau

Il n'existe pas de méthode définie pour supprimer un tableau, mais il y a plusieurs façons de se débarrasser du contenu d'un tableau (le vider). L'une d'elles consiste à assigner la variable $null au tableau :

      $array7 = $null
$array7
      

Voici une autre méthode pour vider un tableau :

      $array = @("element1", "element2", "element3")

$array = @()
      

Voici comment vider une ArrayList :

      $arrayList = New-Object System.Collections.ArrayList
$arrayList.Add("element1")
$arrayList.Add("element2")
$arrayList.Clear()
      

Impression d'un tableau

La manière la plus simple d'afficher le contenu d'un tableau est de simplement faire référence à la variable du tableau. L'exemple ci-dessous montre comment inclure le texte « Élément : » avant chaque élément dans le tableau :

Pour écrire dans un fichier .txt, utilisez la commande Out-File :

      $var5 | Out-File C:scriptsarray.txt

      

Pour exporter vers un fichier .csv, utilisez la commande Export-Csv :

      $var6 | Export-Csv -Path C:scriptsarray.csv

      

Filtrer un tableau

Nous pouvons utiliser le cmdlet Where-Object pour récupérer uniquement les nombres pairs d'un tableau :

      $numbers = 1,2,3,4,5,6

$evenNumbers = $numbers | Where-Object { $_ % 2 -eq 0 }

$evenNumbers
      

Alternativement, nous pouvons utiliser la méthode .Where() qui ne nécessite pas de pipeline :

      $numbers = 1,2,3,4,5,6

$evenNumbers = $numbers.Where({ $_ % 2 -eq 0 })

$evenNumbers

      

Vérification de la longueur d'un tableau

Pour retourner le nombre d'éléments dans un tableau, utilisez le paramètre .length :

      $array6 = 1,2,3,4,5,6
echo $array6.Length
      

Vérifier si un tableau contient une valeur particulière

Si vous souhaitez vérifier si l'un des éléments d'un tableau contient une valeur particulière, utilisez la méthode Contains. Ce code indiquera si un tableau contient un 2 ou un 12 :

      $array7 = 1,2,5,8,3,4,5
$array7.Contains(2)
$array7.Contains(12)
      

Accéder aux éléments en utilisant l'indice du tableau

Comme avec la plupart des langages de programmation, chaque élément individuel dans un tableau PowerShell peut être accédé par un indice. L'indice d'un tableau commence à zéro, donc dans un tableau de trois éléments, le premier élément est à l'indice 0, le second est à l'indice 1, et le troisième est à l'indice 2.

Pour accéder aux éléments en utilisant l'indice du tableau, vous devez fournir l'indice entre crochets après la variable du tableau. Voici un exemple montrant comment créer un tableau et afficher le deuxième élément :

      $colors = "Red", "Green", "Blue", "Yellow"

$secondColor = $colors[1]

Write-Output $secondColor
      

Vous pouvez accéder aux éléments depuis la fin d'un tableau en utilisant un indice négatif. -1 fait référence au dernier élément, -2 fait référence à l'avant-dernier élément, etc.

Utilisation de l'opérateur Join et de l'opérateur Split

Dans PowerShell, l'opérateur join est utilisé pour concaténer un tableau de chaînes de caractères en une seule chaîne, en utilisant éventuellement un délimiteur spécifié. Voici un exemple sans délimiteur.

      $array = "Power", "Shell"

$joined = $array -join ""

# Output: "PowerShell"
      

Voici ce que cela donnerait avec un délimiteur :

L'opérateur split fait essentiellement l'inverse de l'opérateur join, comme le montre l'exemple ci-dessous :

      $string = "apple,banana,grape"
$fruits = $string -split ","
      

Utilisation de l'opérateur Replace

L'opérateur replace est utilisé pour remplacer une chaîne par une autre. Voici la structure de l'applet de commande :

      <originalString> -replace <patternToFind>, <replacementString>

      

Voici un exemple qui remplacera « Hello World » par « PowerShell » :

      $string = "Hello World"

$newString = $string -replace "World", "PowerShell"

      

Découper un tableau

Vous pouvez créer un sous-tableau en spécifiant une plage, comme montré ici :

      $array = 1,2,3,4,5,6,7,8,9

$subset = $array[3..6]

      

Inverser un tableau

Voici un exemple de la manière d'inverser l'ordre des éléments dans un tableau :

      $numbers = 1..5

[Array]::Reverse($numbers)
      

Conclusion

Les tableaux sont une structure de données fondamentale dans la plupart des langages de script et de programmation car ils vous permettent de stocker, récupérer et manipuler une collection d'éléments de divers types de données. Comprendre les tableaux améliorera votre capacité à automatiser des tâches en utilisant PowerShell.

Maintenant, Netwrix peut aider

Besoin de sécuriser votre Active Directory et l'environnement Entra ID (Azure AD) de manière plus efficace et efficiente ? Envisagez Netwrix Directory Manager. Ses capacités de gestion automatisée des groupes et des utilisateurs réduisent le risque de violations de données tout en éliminant les tâches administratives manuelles qui font perdre du temps.

Netwrix Directory Manager vous permet de :

• Automatisez la provision et la déprovision des utilisateurs de votre système d'information RH (HRIS) vers Active Directory, Entra ID et les applications compatibles SCIM, permettant ainsi aux nouveaux employés d'être rapidement productifs et réduisant le risque que des adversaires prennent le contrôle d'identités obsolètes.
• Mettez à jour automatiquement les groupes d'annuaires en fonction des changements tels que la promotion d'un employé ou son passage à un autre rôle, tel qu'enregistré dans votre système d'information sur les ressources humaines (HRIS). Cette automatisation maintient les droits d'accès à jour en temps quasi réel comme requis pour la sécurité et la conformité, tout en faisant gagner du temps à votre équipe informatique.
• Déléguez la gestion des groupes et des utilisateurs aux personnes qui savent qui devrait avoir accès à quoi. Des workflows simples permettent aux responsables des lignes de métier de réviser leurs groupes et d'approuver ou de refuser les demandes d'accès des utilisateurs, réduisant ainsi le risque d'avoir des groupes et des utilisateurs sur-privilégiés dans votre annuaire.
• Gardez l'annuaire propre et plus facile à gérer avec la création, l'expiration et la suppression automatiques des utilisateurs.
• Maintenez et prouvez la conformité avec les réglementations et normes grâce à une analyse approfondie, une automatisation efficace et des rapports clairs sur les groupes et les membres.