Introduction

La manipulation des tableaux en PowerShell est une notion essentielle à maîtriser. Outre le fait que leur utilisation 
soit aisée, il faut savoir que dès lors que le résultat d’une commande retourne plusieurs objets, PowerShell renvoie 
un  tableau  d’objets.  Nous  allons  voir  dans  ce  chapitre  qu’il  existe  différents  types  de  tableaux  et  que  ces  derniers 
sont capables de contenir des éléments de types distincts si nécessaire.  
Tableaux à une dimension

Le  tableau  à  une  dimension  est  le  cas  le  plus  simple,  les  valeurs  sont  mises  les  unes  après  les  autres,  et  il  suffit 
d’indiquer un numéro d’indice (ou index) pour accéder au contenu. Un tableau à une dimension est parfois appelé liste 
ou collection. 

Par exemple ici : 

La valeur 18 est contenue dans le tableau à l’indice 0. 

La valeur 22 est contenue dans le tableau à l’indice 1. 

Les indices de tableau commencent à 0 et non pas à 1 comme avec d’autres langages.  

1. Initialiser un tableau vide

Il y a mille et une façon de procéder pour déclarer un tableau, mais dans sa plus simple expression, la déclaration 
d’un tableau vide peut se faire de la manière suivante : 

$monTableau = @()

La  variable  $monTableau  est  à  présent  un  tableau  vide  non  typé.  C’est­à­dire  que  celui­ci  pourra  contenir  tout 
type d’objet. 

Contraindre le type d’un tableau 

Il est possible de contraindre le type de données que pourra contenir un tableau. Pour ce faire, il suffit de spécifier 
le type entre crochets devant le nom du tableau lors de sa définition. 

Par exemple : 

[Int[]]$monTableau1 = @()
[String[]]$monTableau2 = @()
[Double[]]$monTableau3 = @()

Attention de ne pas oublier de mettre une paire de crochets vides après le type, comme Int[]. Si vous ne le faites 
pas,  PowerShell  émettra  une  erreur  indiquant  qu’il  ne  peut  convertir  un  tableau  en  une  valeur  entière.  En  effet  un 
type  [Int]  simple  (sans  la  paire  de  crochets  vide  en  suffixe)  indique  un  objet  de  type  entier  et  non  un  tableau 
d’entiers. 

Bonne pratique ! 
 Une bonne pratique lorsque l’on connaît à l’avance (ce qui est généralement le cas) le type des données que doit contenir 
un  tableau  est  de  systématiquement  contraindre  les  tableaux,  mais  aussi  les  variables.  De  cette  manière,  une  erreur 
sera vite détectée, nous évitant ainsi de longues séances de débogage. 

Exemple : Tentative d’affectation d’une valeur non admise par un tableau contraint 

PS > $monTableau1[0] = ’Bonjour’

Cannot convert value "Bonjour" to type "System.Int32". Error: "Input

string was not in a correct format."
...

L’erreur  s’est produite car le tableau $monTableau1 ne peut accueillir que des valeurs entières. Cependant, nous ne 
nous serions pas aperçus de notre erreur si nous n’avions pas typé la variable. 

2. Initialiser un tableau avec des valeurs

Il est possible de déclarer un tableau et de l’initialiser en même temps. Pour ce faire, il suffit de lui affecter plusieurs 
valeurs séparées par une virgule, la virgule étant le séparateur de valeurs lorsque l’on a affaire à un tableau. 

Exemple : Initialisation d’un tableau avec des valeurs 

PS > $tab = @(1,5,9,10,6)

ou : 

PS > $tab = 1,5,9,10,6

Notez que nous avons ici utilisé deux formes distinctes pour affecter des valeurs à un tableau. Sachez qu’elles sont 
toutes les deux parfaitement admises et reviennent au même, la première forme étant simplement plus explicite que 
la seconde. 

$tab définit un tableau de type entier contenant la valeur 1 à l’indice 0, puis la valeur  5 à l’indice 1, puis 9 à l’indice 
2, etc. 

À  noter  que,  pour  un  tableau  non  contraint,  le  type  des  valeurs  contenues  dans  le  tableau est  attribué  de  façon 
automatique. Cependant, de la même manière que pour initialiser un tableau vide, nous pouvons contraindre le type 
des données que peut contenir un tableau. 

Exemple 

PS > [int[]]$tab = 1,2,3

Vous noterez les crochets  [] immédiatement après le nom du type. Ces crochets indiquent qu’il s’agit d’un tableau 
de valeurs du type en question. Dans cet exemple, le tableau $tab ne peut contenir que des entiers. 
 Un tableau peut aussi s’initialiser avec l’opérateur de plage, exemple : $tab = 1..20 est un tableau d’entiers qui 
contient toutes les valeurs allant de 1 à 20. 

Un tableau peut cependant être hétérogène, et dans ce cas, l’affectation des types se fait valeur par valeur. 

Exemple 

PS > $tab = 1, 2.5, ’A’

3. Lire un tableau à une dimension

Pour lire un tableau à une dimension, plusieurs méthodes sont possibles. 

La  plus  simple  est  de  saisir  son  nom  dans  la  console  puis  de  presser  la  touche  [Entrée].  Dans  ce  cas,  tous  les 
éléments  du  tableau  seront  retournés.  Pour  lire  une  valeur  à  un  indice  précis,  il  suffit  d’indiquer  entre  crochets 
l’indice voulu. 

PS > $tab[0]
1

Pour lire plusieurs valeurs à des indices précis, il suffit, cette fois­ci, d’indiquer entre crochets les indices séparés par 
des virgules. 

PS > $tab[0,2]
1
3

Ici, seules les valeurs à l’indice 0 et 2 sont obtenues, la valeur à l’indice 1 ne l’est pas. 

Vous  pouvez  aussi  afficher  plusieurs  valeurs  avec  l’opérateur  de  plage.  Exemple  :  $tab[0..20] 
affichera les valeurs de l’indice 0 à 20. 

Maintenant,  supposons  que  nous  souhaitions  uniquement  lire  la  valeur  contenue  au  dernier  indice.  Une  des 
méthodes consiste à savoir combien de valeurs sont contenues dans notre tableau. Ceci se fait grâce à la propriété 
Length : 

PS > $tab[$tab.Length-1]
3

Notez que nous enlevons une unité à la propriété Length parce que les indices commencent à 0 et non à 1. 

Mais il y a une autre méthode plus simple : les indices négatifs. 

Lorsque vous utilisez un indice négatif, vous faites référence au nombre d’indices depuis la fin du tableau. 

Exemple 
 PS > $tab[-1]
3
PS > $tab[-3..-1]
1
2
3

La méthode la plus courante pour lire un tableau reste toutefois le parcours de tableaux avec des boucles Foreach 
et For. Pour en savoir plus, reportez­vous au chapitre Boucles et conditions. 

4. Concaténer deux tableaux

Avec PowerShell, la concaténation de tableaux se fait avec l’opérateur +. Supposons que pour un motif quelconque 
nous  ayons  besoin  de  concaténer  deux  tableaux  (ou  plus).  Pour  cela,  il  suffit  d’additionner  les  tableaux  avec 
l’opérateur +. 

Exemple d’addition de deux tableaux de caractères nommés $chaine1 et $chaine2 : 

PS > $chaine1 = ’P’,’o’,’w’,’e’,’r’

PS > $chaine2 = ’S’,’h’,’e’,’l’,’l’
PS > $chaine1 + $chaine2
P
o
w
e
r
S
h
e
l
l

5. Ajouter un élément à un tableau

L’ajout  d’une  valeur  à  un  tableau  se  fait  avec  l’opérateur  +=.  Ainsi  en  tapant  la  ligne  suivante,  nous  ajoutons  la 
valeur 4 à notre tableau : 

PS > $tab= 1,2,3

PS > $tab += 4
PS > $tab
1
2
3
4
6. Modifier la valeur d’un élément

La modification d’un élément dans un tableau revient en fait à faire une affectation avec l’opérateur =. 

Exemple,  en  tapant  $tab[2]=1  nous  modifions  la  valeur  contenue  à  l’indice  2  (la  troisième  valeur,  donc).  En 
réalité, c’est une nouvelle affectation qui est réalisée, et celle­ci écrasera l’ancienne valeur par la nouvelle. 

Exemple 

PS > $tab = ’A’, ’B’

PS > $tab[0] = ’C’
PS > $tab
C
B

7. Supprimer un élément

À moins d’utiliser un tableau de type  ArrayList (non traité dans ce livre car il s’agit d’un type peu utilisé par les 
scripteurs mais plus par les développeurs), il n’est pas possible de supprimer un élément d’un tableau. Cependant, il 
existe une solution alternative, permettant de contourner le problème. Celle­ci consiste à effectuer une recopie d’un 
tableau en y excluant un ou plusieurs indices. 

Exemple 

Suppression d’éléments dans un tableau 

Prenons l’exemple de vos dernières notes à l’examen de fin d’étude. 

PS > $notes = 12, 18, 10, 14, 8, 11

N’ayant pas brillé en algorithmique et programmation (8) vous décidez de supprimer cette note qui ne vous satisfait 
pas du tout. 

Pour cela, procédons tout simplement à la recopie des éléments du tableau à l’exception de la valeur à l’indice 4 : 

PS > $notes = $notes[0..3 + 5]

PS > $notes
12
18
10
14
11

Si l’on ne connaît pas les indices, ou si le nombre de notes à supprimer est trop important, on peut aussi procéder à 
l’application d’un filtre pour obtenir une recopie du tableau avec uniquement les valeurs supérieures ou égales à 10. 

PS > $notes = $notes | Where-Object {$_ -ge 10}

PS > $notes
 12
18
10
14
11

8. Déterminer le nombre d’éléments d’un tableau

Pour  déterminer  la  taille  d’un  tableau  il  suffit  d’utiliser la propriété  Length ou la propriété Count,  cette  dernière 
étant un alias de la propriété Length. 

Exemple : calcul de la taille d’un tableau 

PS > $tab = @(’A’,24,12,’C’)

PS > $tab.length
4

9. Convertir en chaîne le contenu d’un tableau

Il y a des fois où nous souhaitons récupérer le contenu d’un tableau sous forme d’une chaîne de caractères.  

Soit le tableau suivant : 

PS > $tab = @(’A’,24,12,’C’,’XX’,65)

Pour  convertir  son  contenu  en  une  chaîne  unique,  il  suffit  d’effectuer  un  transtypage  grâce  au  type  [String], 
comme ci­après : 

PS > [String]$tab
A 24 12 C XX 65

Il faut savoir que, par défaut, PowerShell utilise l’espace comme séparateur. Pour changer ce comportement, il faut 
jouer sur le contenu de la variable de préférence $OFS. 

Ainsi, observons l’effet de l’affectation de la valeur +--+ à la variable $OFS : 

PS > $OFS = ’+--+’

PS > [String]$tab

A+--+24+--+12+--+C+--+XX+--+65
Tableaux à plusieurs dimensions

Lorsque l’on  parle  de  tableaux  à  plusieurs  dimensions,  on  parle  de  tableaux  à  plusieurs  index,  avec  autant  d’index 
que de dimensions. Ainsi, pour passer d’un tableau à une dimension à un tableau à deux dimensions, il suffit d’ajouter 
un indice permettant de se repérer dans cette nouvelle dimension. 

La  lecture  des  tableaux  à  plusieurs  dimensions  est  semblable  à  ceux  à  une  dimension.  La  seule  contrainte  est  de 
jouer avec les indices. Prenons le cas du tableau ci­dessus. 

La lecture du tableau avec l’indice 0 nous retournera le premier élément du tableau (ici un autre tableau) : 

PS > $tab[0]
1
2
3

Pour obtenir une valeur précise, nous devons tout simplement fixer l’indice de la dimension horizontale et celui de la 
dimension verticale. 

PS > $tab[0][2]
3

Un  tableau  à  plusieurs  dimensions  est  la  plupart  du  temps  un  tableau  de  tableaux.  Autrement dit,  il  s’agit  d’un 
tableau contenant d’autres tableaux. C’est ce que nous allons voir dans l’exemple ci­après. 

Soit la définition du tableau suivant : 

PS > $taboo = @(10..13),@(’Bonjour’,’Au revoir’),@(1.2,0.3,2.33)

Nous avons défini un tableau contenant trois tableaux ; soit respectivement un tableau d’entiers allant des valeurs 10 

à 13, un tableau de chaînes de caractères, et un tableau de nombres à virgules (double). 
 N’oubliez  pas  que  pour  connaître  le  type  d’un  objet  vous  pouvez  utiliser  la  méthode  Gettype(). 
Ainsi, pour déterminer le type du troisième tableau contenu dans $taboo, nous pouvons écrire ceci : 

PS > $taboo[2].Gettype()

Observons à présent le contenu de notre tableau. 

PS > $taboo
10
11
12
13
Bonjour
Au revoir
1,2
0,3
2,33

Observons  maintenant  le  nombre  d’éléments  contenus  dans  $taboo.  D’après  vous,  combien  devrions­nous  en 
trouver ? 

PS > $taboo.length
3

Eh oui trois ! En effet, nous avons bien trois tableaux dans $taboo. 

Récupérons à présent le second tableau : 

PS > $taboo[1]

Bonjour
Au revoir

À présent récupérons le second élément du second tableau : 

PS > $taboo[1][1]

Au revoir

Enfin, une chaîne de caractères étant en réalité un tableau de caractères (type  [char]), nous pouvons également 
indexer le contenu de la chaîne en allant rechercher n’importe quel caractère en spécifiant son index.  

Dans l’exemple ci­après, nous irons chercher le premier caractère : 

PS > $taboo[1][1][0]
A

Mais nous pourrions aussi récupérer les cinq premiers : 

PS > $taboo[1][1][0..4]
A
u

r
e
Tableaux associatifs

1. Tableaux associatifs standards

Un  tableau  associatif,  aussi  appelé  table  de  hachage,  est  un  tableau  dans  lequel  chaque  valeur  n’est  pas 
référencée  par  un  indice  mais  par  une  clé.  Jusque­là,  nous  avons  vu  que  dans  un  tableau,  chaque  valeur  était 
indexée numériquement. Eh bien dans un tableau associatif, cette notion d’indexation  numérique  n’existe plus, on 
utilise  des  clés  en  tant  qu’identifiants.  Par  exemple,  voici  un  tableau  associatif  dans  lequel chaque  élément  (clé) 
possède une valeur, la valeur étant ici un prix. 

Clé  Valeur 

Video_projecteur  1600 
Television  1400 
Console_de_jeux  400 

Avec  les  tableaux  associatifs,  tout  comme  les  tableaux  classiques,  vous  pouvez  utiliser  des  types  de  données 
hétérogènes. 

a. Déclarer un tableau associatif vide

La déclaration d’un tableau associatif vide s’effectue ainsi : 

$hashtable = @{}

b. Initialiser un tableau associatif avec des données

Pour initialiser un tableau associatif contenant des valeurs, la syntaxe suivante est de rigueur : 

$hashtable = @{<clé1 = valeur>; <clé2 = valeur>;...}

Notez que la création d’un tableau associatif nécessite de placer le symbole arobase @ devant l’accolade ouvrante 
{,  de  séparer  tous  les  couples  clé/valeur  par  des  points­virgules et  de  refermer  l’ensemble  par  l’accolade 
fermante }. 

Reprenons  notre  exemple  avec  les  produits  décrits  précédemment.  Voici  à  quoi  ressemble l’initialisation  du 
tableau : 

PS > $catalogue = @{ Video_projecteur = 1600 ; Television = 1400 ;

Console_de_jeux = 400}

Pour ensuite lire les valeurs contenues dans le tableau, nous pouvons soit taper simplement le nom du tableau 
dans la console : 

PS > $catalogue
 Name Value
---- -----
Console_de_jeux 400
Televison 1400
Video_projecteur 1600

Soit récupérer les éléments un par un, dans ce cas il nous faut utiliser la notation par point ou crochets : 

PS > $catalogue[’Console_de_jeux’]
400

PS > $catalogue.Television
1400

PS > $catalogue.’Television’
1400

Si la clé contient des espaces, il est nécessaire de la mettre entre guillemets. Cela dit, il n’est pas conseillé de créer 
des clés avec des caractères spéciaux tels que les accents et les espaces. 

c. Ajout de données à un tableau associatif

Comme avec un tableau classique, l’ajout de données à un tableau associatif s’effectue avec l’opérateur +=. 

Exemple 

PS > $catalogue += @{Amplificateur = 800}

Vérifions à présent le contenu du tableau : 

PS > $catalogue

Name Value
---- -----
Amplificateur 800
Television 1400
Video_projecteur 1600
Console_de_jeux 400

Il faut savoir que, par défaut, le framework .NET ne conserve pas l’ordre  d’entrée des couples clé/valeurs dans un 
tableau associatif. PowerShell étant basé sur .NET, il n’échappe pas à la règle… 

d. Parcours d’un tableau associatif

Le  parcours  d’une  table  de  hachage  s’effectue  différemment  qu’avec  un  tableau  classique. En  effet,  il  faut 
 connaître le nom d’une clé afin d’en obtenir sa valeur. Pour parcourir un tableau associatif dans son intégralité, la 
première chose à faire est de récupérer toutes les clés (leur nom), puis pour chacune demander sa valeur. 

Récupérer le nom des clés 

Un tableau associatif possède la propriété keys. Cette dernière contient le nom de toutes les clés de la table. 

Exemple 

PS > $catalogue.keys

Amplificateur
Television
Video_projecteur
Console_de_jeux

Récupérer les valeurs 

À présent, il nous suffit d’effectuer une boucle, par exemple avec la commande Foreach-Object, et le tour est 
joué : 

PS > $catalogue.keys | Foreach-Object { $catalogue.$_}

800
1400
1600
400

Mais nous pouvons faire encore plus simple en utilisant la propriété values, comme ci­dessous : 

PS > $catalogue.values

2. Tableaux associatifs ordonnés

Depuis la version 3, il est possible de forcer PowerShell à préserver l’ordre dans lequel les couples clé/valeur ont été 
renseignés. Pour ce faire, il suffit de préfixer le tableau par le type [ordered]. 

Exemple 

PS > $catalogue = [ordered]@{ Video_projecteur = 1600 ;

Television = 1400 ;
Console_de_jeux = 400}

PS > $catalogue
Name Value
---- -----
Video_projecteur 1600
Television 1400
Console_de_jeux 400