Tableaux PowerShell, ArrayLists & Collections : Meilleures pratiques

Souvent, lors de l’écriture de scripts PowerShell, vous avez besoin d’un moyen de stocker un ensemble d’éléments. Une façon courante d’atteindre cela est avec un tableau ou un type spécifique appelé ArrayList. Mais qu’est-ce qu’un tableau de toute façon ? Un tableau est une structure de données conçue pour stocker une collection d’éléments. Cela peut inclure à la fois des éléments de même type et différents types.

Les tableaux sont utilisés dans de nombreux langages de programmation différents et PowerShell ne fait pas exception. Il existe de nombreuses façons de créer, manipuler et optimiser les tableaux. Dans cet article, vous apprendrez sur les ArrayLists, les tableaux et les collections ainsi que sur certaines bonnes pratiques lors de leur application avec PowerShell.

Prérequis/Exigences

Puisque vous travaillerez uniquement avec le langage PowerShell lui-même, il n’y a pas de prérequis environnementaux. Vous avez juste besoin d’un PC Windows avec PowerShell. Plus précisément :

  • Windows PowerShell 3 ou ultérieur
  • .NET Framework 4.5 ou ultérieur

Vous voulez plus de conseils comme celui-ci ? Consultez mon blog personnel sur PowerShell à l’adresse : https://nkasco.com/FriendsOfATA

Création de tableaux avec PowerShell

Il existe de nombreuses façons différentes de créer des tableaux avec PowerShell. Supposons que vous ayez une liste de noms que vous devez traiter d’une manière ou d’une autre comme indiqué ci-dessous.

John
Susie
Jim
Johnny
Carrie

Construction de tableaux via des éléments séparés par des virgules

La façon la plus basique de créer un tableau est simplement d’assigner des entrées connues, séparées par des virgules, à une variable comme indiqué ci-dessous.

$BasicArray = "John", "Susie", "Jim", "Johnny", "Carrie"

Si vous exécutez la méthode GetType() disponible sur tous les objets en PowerShell, vous verrez que vous avez créé avec succès un tableau comme indiqué par la propriété BaseType ci-dessous.

PS51> $BasicArray.GetType()

IsPublic IsSerial Name                                     BaseType                                                    
-------- -------- ----                                     --------                                                    
True     True     Object[]                                 System.Array

Utilisation de l’opérateur de sous-expression

Vous pouvez également créer des tableaux en PowerShell via un opérateur de sous-expression. Ce concept est couramment utilisé lorsque vous ne savez pas combien d’éléments seront ajoutés à votre tableau. Le résultat peut contenir zéro ou plusieurs éléments lorsqu’il est créé.

Remarquez ci-dessous qu’un tableau appelé $MyArray a été créé avec zéro élément à l’intérieur.

#Créer un tableau vide avec l'opérateur de sous-expression
PS51> $MyArray = @()
PS51> $MyArray.count
0

Utilisation de l’opérateur de plage

Les tableaux ne se limitent pas seulement au stockage de chaînes comme indiqué ci-dessus. Vous pouvez également créer des tableaux avec d’autres types d’objets comme des entiers.

Si vous avez besoin d’un tableau d’entiers dans l’ordre séquentiel, vous pouvez prendre un raccourci et utiliser l’opérateur de plage ... Ci-dessous, vous pouvez voir qu’un tableau a été créé avec les entiers de 2 à 5 avec une seule ligne de code.

PS51> $NumberedArray = 2..5
PS51> $NumberedArray
2
3
4
5

Création de collections ArrayList PowerShell

L’utilisation d’un ArrayList PowerShell est également un moyen de stocker une liste d’éléments avec PowerShell. La classe ArrayList fait partie de l’espace de noms System.Collections dans .NET. En créant un nouvel objet de ce type, vous pouvez ensuite stocker des objets dans un ArrayList.

Vous pouvez voir ci-dessous qu’il est nécessaire de créer explicitement un objet ArrayList en utilisant la cmdlet New-Object ou en convertissant un tableau standard en objet ArrayList.

Remarquez que dans ce cas, le BaseType est un objet tandis que les exemples ci-dessus ont des BaseTypes de Tableaux qui montrent l’héritage de la classe Object. En fin de compte, PowerShell donne accès au système de types .NET.

PS51> $MyArrayList = New-Object -TypeName "System.Collections.ArrayList"
# Convertir un tableau en ArrayList est également une option viable
PS51> $MyArrayList = [System.Collections.ArrayList]@()
PS51> $MyArrayList.GetType()

IsPublic IsSerial Name                                     BaseType                                                    
-------- -------- ----                                     --------                                                    
True     True     ArrayList                                System.Object

Ajout d’éléments à un tableau

Lors de la création d’un tableau, vous pouvez soit définir tous les éléments au moment de la création, soit les ajouter de manière ad hoc.

Pour ajouter des éléments à une collection existante, vous pouvez utiliser l’opérateur += ou la méthode Add. Mais sachez qu’il y a des différences majeures dans leur fonctionnement.

Lorsque vous créez un tableau standard avec @(), vous utiliserez l’opérateur +=, mais pour ajouter des éléments à un ArrayList, vous utiliseriez la méthode Add. Ces méthodes diffèrent en ce que l’opérateur += détruit réellement le tableau existant et crée un nouveau avec le nouvel élément.

Pour illustrer, vous verrez ci-dessous que vous pouvez faire référence à la propriété IsFixedSize pour un tableau ou ArrayList pour savoir lequel est immuable et lequel ne l’est pas.

PS51> $BasicArray.IsFixedSize
True

PS51> $MyArrayList.IsFixedSize
False

Étant donné qu’un tableau de base est une collection de taille fixe, vous ne pouvez pas le modifier.

En essayant d’utiliser la méthode Add() avec un tableau de taille fixe, vous obtiendrez une erreur en raison de cette limitation de taille. Ci-dessous, vous pouvez voir quelques exemples dans lesquels vous pouvez ajouter des éléments à un tableau.

#Ne fonctionne PAS
$BasicArray.Add("Nate")

#Fonctionne
$BasicArray += "Nate"
$MyArrayList.Add("Nate")
$MyArrayList += "Nate"

Suppression d’éléments d’un tableau

Maintenant que vous avez une meilleure compréhension de la façon d’ajouter des éléments à un tableau, passons en revue quelques façons de supprimer des éléments d’un tableau.

Étant donné qu’un tableau de base est fixe, vous ne pouvez pas supprimer d’éléments directement. Au lieu de cela, vous devez créer un tout nouveau tableau. Par exemple, vous pouvez supprimer un seul élément d’un tableau en créant une condition qui ne correspond qu’aux éléments que vous souhaitez inclure. Un exemple est illustré ci-dessous.

$NewBasicArray = $BasicArray -ne "Nate"

Étant donné qu’un ArrayList n’est pas fixe, vous pouvez supprimer des éléments en utilisant la méthode Remove(). C’est un scénario dans lequel l’utilisation d’un ArrayList peut vous être bénéfique si vous prévoyez d’ajouter/supprimer fréquemment des éléments.

$MyArrayList.Remove("Nate")

Récupération d’éléments spécifiques d’un tableau ou d’un ArrayList

Pour récupérer des éléments spécifiques d’un tableau ou d’un ArrayList, vous pouvez utiliser différentes méthodes. Tout comme pour les autres objets en PowerShell, vous pouvez accéder à tous les éléments d’un tableau en appelant simplement l’objet.

PS51> $BasicArray
John
Susie
Jim
Johnny
Carrie

Peut-être avez-vous besoin de récupérer uniquement le premier élément ; les tableaux ont toujours un indice de départ de 0, représentant le premier élément du tableau. Pour récupérer le premier élément d’un tableau, spécifiez le numéro d’indice entre crochets comme illustré ci-dessous.

PS51> $BasicArray[0]
John

Inversement, vous pouvez également faire référence aux index à l’envers en utilisant un tiret (indicateur négatif) pour appeler les X derniers éléments du tableau. Une manière courante de trouver le dernier élément dans un tableau est d’utiliser -1 comme indiqué ci-dessous.

PS51> $BasicArray[-1]
Carrie

L’opérateur de plage que vous avez appris ci-dessus peut également être utilisé pour récupérer des objets d’un tableau en suivant la même méthode d’appel des éléments. Disons que vous voulez récupérer les quatre premiers noms dans le tableau $BasicArray.

Vous pouvez voir ci-dessous que vous pouvez spécifier une plage d’index de 0 à 3 qui renverra les quatre premiers éléments.

PS51> $BasicArray[0..3]
John
Susie
Jim
Johnny

Optimisation des tableaux avec PowerShell

Maintenant que vous avez une bonne base sur la manière de créer et de manipuler des tableaux, lequel devriez-vous utiliser ? Pour répondre à cela, parcourons quelques exemples avec la commande Measure-Command. En utilisant la commande Measure-Command, vous comprendrez mieux combien de temps les commandes prennent pour traiter les éléments lorsqu’ils sont transmis dans le pipeline.

En règle générale, si vous avez une petite collection d’objets, vous ne remarquerez probablement pas beaucoup de différence dans la manière dont vous manipulez vos tableaux. Cependant, si vous avez une grande collection d’objets, il est important de comprendre les différences pour obtenir des résultats optimaux.

Appliquons ce que vous venez d’apprendre dans la section précédente sur la différence entre += et l’utilisation de la méthode Add() avec une boucle de 50 000 éléments.

Tout d’abord, créez un tableau vide et une ArrayList vide comme indiqué ci-dessous.

PS51> $MyArray = @()
PS51> $MyArrayList = [System.Collections.ArrayList]@()

Ensuite, peuplez 50 000 éléments dans chaque collection en utilisant l’opérateur de plage et une boucle foreach comme indiqué ci-dessous.

@(0..50000).foreach({$MyArray += $_})
@(0..50000).foreach({$MyArrayList.Add($_)})

Enfin, enveloppez vos commandes dans une expression et passez cette expression à la cmdlet Measure-Command. En exécutant l’expression avec Measure-Command, vous pouvez voir combien de temps chaque processus prend réellement à s’exécuter.

N’oubliez pas qu’comme vous l’avez appris auparavant, += crée en fait un nouveau tableau plutôt que d’ajouter à un tableau fixe.

PS51> Measure-Command -Expression {@(0..50000).foreach({$MyArray += $_})}
Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 59
Milliseconds      : 58
Ticks             : 590585963
TotalDays         : 0.000683548568287037
TotalHours        : 0.0164051656388889
TotalMinutes      : 0.984309938333333
TotalSeconds      : 59.0585963
TotalMilliseconds : 59058.5963

PS51> Measure-Command -Expression {@(0..50000).foreach({$MyArrayList.Add($_)})}
Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 0
Milliseconds      : 139
Ticks             : 1399989
TotalDays         : 1.62035763888889E-06
TotalHours        : 3.88885833333333E-05
TotalMinutes      : 0.002333315
TotalSeconds      : 0.1399989
TotalMilliseconds : 139.9989

Le résultat ? Près de 60 secondes contre 139 millisecondes!

Comme vous pouvez le constater, il est beaucoup plus rapide de tirer parti d’une ArrayList pour de grandes collections plutôt que d’utiliser un tableau de taille fixe.

Bien que ce soit un exemple de base, cela souligne l’importance de comprendre ce que votre code fait pendant le traitement. S’il n’est pas correctement compris, cela peut entraîner une mauvaise expérience utilisateur.

Si vous avez un script existant qui pourrait bénéficier de l’utilisation d’une ArrayList plutôt que d’un tableau, cela présenterait une excellente opportunité d’apporter une amélioration rapide !

Lecture complémentaire

Vous voulez plus de conseils comme celui-ci ? Consultez mon blog personnel PowerShell à l’adresse : https://nkasco.com/FriendsOfATA.

Source:
https://adamtheautomator.com/powershell-array/