Les tableaux sont une composante essentielle de PowerShell. Ils permettent d’ingérer des données, de les manipuler et de produire de véritables structures de données (plutôt que de simples chaînes de caractères brutes). Cette capacité distingue PowerShell des autres langages de script et le rend particulièrement utile.
Dans cet article, nous allons vous présenter les tableaux et vous expliquer comment les utiliser dans PowerShell. Nous allons d’abord vous montrer comment créer des tableaux dans PowerShell, puis vous découvrirez comment utiliser les fonctions de base pour les manipuler. Nous explorerons ensuite plusieurs types de tableaux, ainsi que certaines de leurs fonctionnalités plus subtiles.
Obtenir le cours vidéo gratuit sur PowerShell et Active Directory
L’objectif est de vous donner les bonnes bases pour utiliser des tableaux dans PowerShell. Une fois ces bases maîtrisées, vous pourrez consulter notre cours sur PowerShell pour en savoir plus.
- Fondamentaux des tableaux
- Tableaux d’objets
- Opérateurs pour les tableaux
- Comment ajouter des valeurs dans un tableau
- Types de tableaux
- Fonctions de tableau avancées
Tableaux PowerShell
Les tableaux sont une fonctionnalité courante de la plupart des langages de programmation. Il s’agit de structures de données qui permettent de collecter plusieurs éléments de données. Dans un tableau, vous pouvez utiliser la même commande pour exécuter une fonction particulière sur chaque élément qui y figure, ou vous pouvez accéder aux éléments individuels et les manipuler à l’aide d’un indice.
Dans PowerShell, les tableaux peuvent contenir un ou plusieurs éléments. Ces éléments peuvent être une chaîne de caractères, un nombre entier, un objet, voire un autre tableau. Un même tableau peut contenir n'importe quelle combinaison de ces éléments. Chaque élément comporte un index qui commence toujours par 0 (ce qui peut être source de confusion). Le premier élément du tableau reçoit l'index 0, le second l'index 1, etc.
Les tableaux sont tellement fondamentaux dans PowerShell que tout tutoriel sur PowerShell y fait référence. Il est donc essentiel de bien comprendre comment ils fonctionnent pour maîtriser de nombreux aspects de PowerShell, qu’il s’agisse de configurer Office 365 ou d’utiliser PowerShell pour réaliser des tests d’intrusion.
Exemple de tableau PowerShell
Le moyen le plus simple d’illustrer le fonctionnement d’un tableau est d’en montrer un exemple. Créons un tableau représentant un bol de fruits.
Il existe plusieurs méthodes pour créer des tableaux dans PowerShell, mais le plus simple est d'exécuter cette commande :
@()
Cette commande crée un tableau vide. Un tel tableau n’ayant que peu d’utilité, nous allons y ajouter quelques fruits. Ils seront représentés par des chaînes de texte. Pour ce faire, exécutez cette commande
$fruits = @('Pommes','Oranges','Bananes')
Cette commande nomme le tableau « fruits » et lui ajoute trois éléments. Pour voir si cela a fonctionné, vous pouvez lire le tableau à l'aide de cette commande :
PS /Utilisateurs/votrenom> $fruits
Et cette commande renvoie :
Pommes Oranges Bananes
Comme vous le voyez, ce tableau est un groupe d'éléments de données individuels. PowerShell va automatiquement les indexer comme nous l'avons expliqué plus haut : « Pommes » aura l'index 0, « Oranges » l'index 1 et « Bananes » l'index 2.
Cet exemple peut laisser entendre que les tableaux sont des objets très simples, ce qui d’une certaine manière est vrai. Cette simplicité leur confère toutefois une grande flexibilité et beaucoup de puissance. Dans le reste de ce guide, nous allons vous donner un avant-goût de ce que vous pouvez faire avec les tableaux.
Fondamentaux des tableaux
Dans cette section, nous allons découvrir les moyens les plus simples de créer et d’utiliser des tableaux dans PowerShell.
Créer un tableau
Nous allons commencer par créer un tableau. La méthode standard consiste à utiliser @(), mais il en existe d’autres.
Pour le moment, créons un tableau intitulé « données ». Pour ce faire, exécutez la commande suivante :
$données = @()
Pour le moment, ce tableau est vide, car nous n’avons spécifié aucune donnée. Pour vérifier le nombre d’éléments qu’il contient, nous pouvons utiliser la fonction count :
$données.count
Pour l’instant, elle retourne 0, car notre tableau ne contient aucun élément. Pour y intégrer des données, il faut les mettre entre parenthèses après le @ :
$données = @('Zéro','Un','Deux','Trois')
Exécutez de nouveau la fonction count, qui indique désormais la présence de 4 éléments. Pour revoir ces éléments, il suffit d’appeler le tableau :
$données
Cela permet d’afficher les éléments inclus dans le tableau.
Accéder aux éléments
Maintenant que nous avons notre tableau, il s’agit de savoir comment accéder aux éléments qui s’y trouvent. Il existe plusieurs méthodes. La première consiste à utiliser l’index des éléments du tableau. Comme nous l’avons déjà indiqué, les indices commencent à 0. Par conséquent, pour récupérer le premier élément de notre tableau, nous devons demander à PowerShell de rechercher l’élément dont l’indice est zéro. Exécutons la commande suivante :
$données[0]
Cette commande retourne « Zéro », car il s’agit de la première chaîne que nous avons entrée dans notre tableau.
Nous pouvons également étendre cette syntaxe pour renvoyer plusieurs éléments du même tableau, simplement en ajoutant des indices dans la même commande. Exécutez par exemple la commande suivante :
$données[0,2,3]
Cette commande renvoie le résultat « Zéro Deux Trois ». Les éléments sont renvoyés dans le même ordre que les indices saisis. Vous pouvez modifier la syntaxe pour renvoyer des ensembles d’éléments d’un tableau. Par exemple :
$données[1..3]
Cette commande renvoie tous les éléments avec un indice compris entre 1 et 3 (inclus). Et :
$données[-1]
Cette commande renvoie le dernier élément du tableau : le nombre négatif indique à PowerShell de compter à l’envers à partir de la fin du tableau. Dans ce cas, la commande retourne « Trois », soit le dernier élément de notre tableau de test.
Modifier des éléments
La même méthode peut être utilisée pour mettre à jour les éléments d’un tableau. Par exemple, pour mettre à jour l’élément dont l’indice est 2 (souvenez-vous qu’il s’agit du 3e élément du tableau), nous pouvons exécuter la commande suivante :
$données[2] = 'second'
Cette commande nous donne un accès direct aux éléments d’un tableau.
Actions itérées
L’une des fonctionnalités les plus puissantes de PowerShell (et d’ailleurs, de toutes les interfaces de ligne de commande), c’est la possibilité d’exécuter la même action sur tous les éléments d’un tableau. Vous pouvez pour ce faire utiliser plusieurs méthodes.
La plus simple consiste à utiliser un pipeline, c’est-à-dire le caractère |. Lorsque vous passez un tableau dans un pipeline, chaque élément de ce tableau est traité individuellement. Comme nous l’avons souligné dans notre article Objets PowerShell et pipelines de données, il s’agit souvent du moyen le plus simple d’effectuer des actions itérées.
Par exemple, pour ajouter une description à chaque élément de notre tableau, nous pouvons utiliser cette commande :
$données | ForEach-Object {"Élément : [$PSItem]"}
Cette commande indique à PowerShell de prendre les éléments dans $données un par un et de les faire précéder de la mention « Élément : », qui sera suivie de la valeur d'origine.
D’autres méthodes permettent d’effectuer des actions itérées dans PowerShell, qui ne vous seront pas inconnues si vous avez déjà utilisé d’autres langages de programmation : PowerShell inclut des boucles ForEach, des boucles For et des boucles Switch. Pour en savoir plus sur ces dernières, consultez la documentation Microsoft.
Tableaux d’objets
Jusqu’à présent, nous avons travaillé avec un tableau contenant des données basiques : une chaîne. Toutefois, les tableaux peuvent également contenir des objets, et nombre des utilisations les plus courantes de PowerShell, comme la configuration d’Office 365, nécessitent que vous sachiez comment les utiliser. Découvrons quelques commandes de base.
Créer un tableau d’objets
Nous pouvons créer un tableau d’objets de la même manière qu’avec des chaînes, en utilisant la fonction @(). Par exemple, pour créer une liste test d’employés, nous pouvons utiliser la commande suivante :
$données = @(
[pscustomobject]@{FirstName='Mathieu';LastName='Richard'}
[pscustomobject]@{FirstName='Jean'; LastName='Imbert'}
)
La plupart des cmdlets renvoient un tableau de ce type lorsque vous leur attribuez une variable à utiliser.
Accéder aux objets des tableaux
Le processus que nous avons exécuté ci-dessus pour accéder aux éléments de données individuels peut également être utilisé sur des tableaux contenant des objets. Par exemple, la commande :
$données[0]
Renvoie :
FirstName LastName ----- ---- Mathieu Richard
Vous pouvez également accéder aux propriétés des objets individuels en spécifiant la propriété souhaitée dans la même commande :
$données[0].FirstName
Cette commande renvoie « Mathieu ».
Mettre à jour les propriétés des objets dans les tableaux
En outre, la même syntaxe nous permet de mettre à jour les propriétés individuelles des objets de tableaux. Par exemple :
$données[0].FirstName = 'Thibault'
Cette commande met à jour la propriété FirstName du premier élément de notre tableau et la remplace par « Thibault ».
Accéder à toutes les propriétés d’un tableau d’objets
Dans la plupart des langages de programmation, nous devrions utiliser un processus itératif (cf ci-dessus) pour accéder à toutes les propriétés d’un tableau d’objets. C’est également possible dans PowerShell, à l’aide de la commande suivante :
$données | ForEach-Object {$_.LastName}
Cette commande renvoie une liste de toutes les propriétés LastName de notre tableau, mais elle utilise énormément de ressources de calcul et elle est difficile à écrire chaque fois que vous souhaitez consulter ces données. Il existe un raccourci dans PowerShell. Exécutez cette commande :
$données.LastName
Et la même liste s’affichera. PowerShell prend chaque objet tour à tour, comme précédemment, mais il en masque la complexité sous-jacente.
Opérateurs pour les tableaux
La quasi-totalité des opérateurs que nous utilisons pour les éléments de données individuels dans PowerShell fonctionne également avec les tableaux, mais certains fonctionnent un peu différemment lorsqu’ils sont utilisés de cette façon. Nous allons vous présenter les opérateurs les plus courants et vous expliquer comment les utiliser dans des tableaux.
-join
L’opérateur -join est l’une des commandes les plus couramment utilisées dans PowerShell. Elle est très utile dans les tableaux. Elle peut être utilisée de manière itérative dans un tableau pour les regrouper dans la sortie d’un tableau.
Prenons un exemple. Commençons par créer un tableau simple :
$données = @(1,2,3,4)
Utilisons ensuite l’opérateur -join pour insérer un tiret entre chaque élément, et sortir le résultat :
$données -join '-'
Cette commande renvoie « 1-2-3-4 ». Vous pouvez également utiliser l’opérateur -join sans délimiteur. Dans ce cas, les éléments du tableau seront rendus sous la forme d’une série de valeurs non séparées.
-contains
Dans les tableaux, l’opérateur -contains fonctionne quasiment de la même façon que lorsqu’il est utilisé sur des points de données individuels. Vous pouvez l’utiliser pour vérifier si un tableau contient une chaîne spécifique : une valeur booléenne sera renvoyée. Par exemple :
PS> $données = @('rouge','vert','bleu')
PS> $données -contains 'vert'
True
Égalités
Deux opérateurs permettent de vérifier l’égalité dans PowerShell : -eq et -ne. Si vous êtes habitué à utiliser ces opérateurs sur des valeurs individuelles, leur fonctionnement dans des tableaux pourrait vous sembler un peu étrange. Avec -eq, par exemple, l’opérateur ne renvoie pas la valeur booléenne « True », mais l’objet correspondant.
Par exemple :
PS> $données = @('rouge','vert','bleu')
PS> $données -eq 'vert'
vert
L’opérateur -ne fonctionne de manière similaire, sauf qu’il renvoie toutes les valeurs qui ne sont pas égales à celle spécifiée. Donc :
PS> $données = @('rouge','vert','bleu')
PS> $données -ne 'vert'
rouge
bleu
Vous pouvez toutefois, si vous le souhaitez, utiliser une instruction if() pour comparer la sortie de ces opérateurs avec le résultat attendu. Cela renverra une sortie « True » ou « False ».
Comment ajouter des valeurs dans un tableau
Après tout ce que nous venons de voir, vous vous demandez peut-être pourquoi nous n’avons pas abordé l’ajout d’éléments de données dans un tableau. C’est parce qu’il n’existe aucun moyen de le faire. Une fois créé, un tableau garde la même taille. Par conséquent, pour l’agrandir, vous devez le copier dans un nouveau tableau et supprimer l’original.
Cela a l’air compliqué, mais PowerShell gère ce processus pour vous à l’aide d’une série d’opérateurs très simples. Il existe deux moyens d’effectuer cette action.
Ajout de tableau
PowerShell peut regrouper deux tableaux à l’aide de l’opérateur « + », ce qui masque la complexité réelle de l’action que le système exécute. Par exemple, si vous créez les deux tableaux de test suivants :
$premier = @( 'Zéro' 'Un' ) $second = @( 'Deux' 'Trois' )
Vous pouvez ensuite les regrouper comme suit :
PS> $premier + $second
Cela crée un nouveau tableau contenant les quatre valeurs, et en renvoie les résultats. Notez tout de même que le nouveau tableau ne sera pas renommé. Pour ce faire, nous utilisons l’opérateur +=.
Opérateur += pour combiner des tableaux
Plutôt que d’utiliser l’opérateur « + » comme dans l’exemple ci-dessus, nous aurions pu utiliser l’opérateur « += », qui permet de créer un tout nouveau tableau :
$premier += 'Deux, Trois'
Cette commande a l’air simple, mais elle cache le processus que PowerShell exécute réellement. Il copie toutes les valeurs du tableau $premier et crée un nouveau tableau contenant les valeurs supplémentaires. Il supprime ensuite le tableau d’origine.
Cela peut-être problématique, car cela consomme beaucoup de ressources de calcul. Avec de petits tableaux, vous ne le remarquerez peut-être pas, mais avec une grande quantité de données, cette méthode pourrait rapidement saturer votre système. Voici un moyen de contourner ce problème.
Types de tableaux
Jusqu’à présent, nous avons utilisé les tableaux par défaut de PowerShell. Même si PowerShell ne l’a pas précisé, les tableaux créés précédemment étaient tous du même type : [PSObject[]]. Ce type de tableau peut contenir tous types de données.
Tableaux à une dimension
Il vous arrivera cependant parfois de vouloir restreindre le type de données ou d’objets qu’un tableau peut contenir à un seul type. Nous pouvons le faire avec un tableau à une dimension, qui ne peut contenir que le type de données spécifié.
Par exemple, pour créer un tableau ne contenant que des nombres entiers, nous pouvons utiliser la commande suivante :
PS> [int[]] $nombres = 1,2,3
Si vous incluez le mauvais type de valeur dans un tableau à une dimension, un code d’erreur est renvoyé.
ArrayList
Comme nous l’avons déjà indiqué, l’ajout d’éléments dans un tableau peut être compliqué. Il existe cependant un type de collection différent, ArrayList, qui gère cette tâche de manière plus sophistiquée. Pour utiliser ce type de collection, nous allons devoir appeler .Net Framework, ce qui peut générer des sorties gênantes.
Pour créer une classe ArrayList et y ajouter des éléments, exécutez la commande suivante :
$monTableau = [System.Collections.ArrayList]::new()
[void]$monTableau.Add('Valeur')
Nous pouvons ici utiliser le constructeur .Net par défaut pour créer une nouvelle classe ArrayList, puis faire appel à l’opérateur -Add pour y ajouter des éléments. L’opérateur [void] permet d’éviter les résultats étranges que ces commandes renvoient parfois et qui altèrent le code.
Pour aller plus loin
Vous venez de découvrir les types de tableaux les plus courants dans PowerShell, mais il en existe quelques autres. Si vous êtes un utilisateur PowerShell débutant, il est judicieux de commencer par utiliser des ArrayLists plutôt que des tableaux individuels, mais sachez que les utilisateurs avancés n’ont pas recours à ce type de tableaux.
La plupart des programmeurs avancés utilisent un type de liste générique nommé List[]. Ce type de liste est un peu plus complexe à utiliser, car il provient directement du langage C#. Toutefois, une fois maîtrisé, il offre bien plus de flexibilité que les tableaux présentés jusqu’ici.
Fonctions de tableau avancées
Outre les fonctionnalités de base que nous avons déjà abordées, il existe un certain nombre de fonctions de tableaux plus avancées, ainsi que d’autres fonctionnalités supplémentaires, que vous découvrirez à mesure de votre utilisation.
Tableaux de taille prédéfinie
La méthode standard de création de tableaux décrite ci-dessus génère un tableau dont la taille est déterminée par le nombre d’éléments qu’il contient. Cependant, vous pouvez créer un tableau d’une taille spécifique en utilisant le constructeur new($size).
Pour ce faire, saisissez :
$données = [Object[]]::new(4)
Si vous exécutez une requête.count sur ce tableau, elle renvoie « 4 », car même s’il ne contient aucune donnée, il remplira l’espace par 0. Ceci peut être très utile si vous avez besoin d’initialiser un nouveau tableau rempli de zéros, car un tableau de taille prédéfinie est initialement rempli de 0.
Multiplier les tableaux
La multiplication des objets dans un tableau, particulièrement des chaînes, perturbe la plupart des utilisateurs la première fois. Des scripts if() très complexes peuvent donner ce résultat, mais il existe un moyen beaucoup plus simple de l’obtenir :
PS> $données = @('rouge','vert','bleu')
PS> $données * 3
Eh oui. Cela crée un nouveau tableau où chaque valeur est répétée trois fois. Vous pouvez également utiliser cette commande pour remplir un tableau de zéros (ou toute autre valeur par défaut) en créant un tableau avec la valeur choisie, puis en la multipliant autant de fois que vous le souhaitez.
Tableaux imbriqués
À l’instar de nombreux autres langages de programmation, PowerShell prend en charge les tableaux imbriqués. La méthode standard dans PowerShell consiste à utiliser un tableau à plusieurs dimensions. L’exemple le plus simple est de créer un tableau à deux dimensions :
$données = @(@(1,2,3),@(4,5,6),@(7,8,9)) $données2 = @( @(1,2,3), @(4,5,6), @(7,8,9) )
La structure de données créée avec cette commande est un tableau classique, qui peut être utilisé comme ceux écrits dans d’autres langages de programmation. Par exemple, pour accéder à une valeur particulière dans ce tableau, vous devrez spécifier deux dimensions.
Si nous souhaitions accéder à la valeur « 3 », nous utiliserions la commande suivante :
PS> $dehors = 0 PS> $dedans = 2 PS> $données[$dehors][$dedans] 3
Cette commande peut ensuite être utilisée pour accéder à n’importe quelle valeur, mais vous devez ajouter des crochets imbriqués pour entrer dans chaque niveau du tableau.
Le mot de la fin
Toutes les instructions ci-dessus peuvent paraître difficiles à digérer pour beaucoup d’utilisateurs débutant avec PowerShell, mais elles ont été minutieusement choisies pour l’apprentissage de ce langage. En combinant ces diverses techniques, vous pouvez créer des scripts puissants pour automatiser bon nombre des tâches les plus fréquentes et chronophages exécutées dans PowerShell.
Ces compétences vous permettront également d’aller plus loin, au-delà de PowerShell. Nombre des langages courants utilisés pour gérer la cybersécurité, comme NetCat et Nmap, s’appuient sur les mêmes principes que PowerShell. Par conséquent, utiliser PowerShell pour améliorer votre cybersécurité constitue un excellent moyen de découvrir comment sécuriser vos systèmes de manière plus générale.
