9. Tableaux
9.1 Introduction
PowerShell prend en charge des tableaux d’une ou de plusieurs dimensions, pouvant avoir chacune zéro, un ou plusieurs éléments. Dans une dimension, les éléments sont numérotés dans l’ordre croissant des entiers, en partant de zéro.
Chaque élément est accessible via l’opérateur d’indice de tableau [] (§7.1.4). Le nombre de dimensions d’un tableau correspond à son rang.
Un élément peut contenir une valeur de n’importe quel type, y compris un type tableau. Un tableau contenant un ou plusieurs éléments avec des valeurs de type tableau est appelé tableau en escalier. Un tableau multidimensionnel a plusieurs dimensions. Le nombre d’éléments de chaque ligne de dimension est le même. Un élément de tableau en escalier peut contenir un tableau multidimensionnel, et vice versa.
Les tableaux multidimensionnels sont stockés dans l’ordre principal des lignes. Le nombre d’éléments d’un tableau correspond à sa longueur, qui est fixe lors de la création du tableau. Par conséquent, les éléments d’un tableau unidimensionnel A dont la longueur est N sont accessibles (c’est-à-dire, mis en indice) à l’aide des expressions A[0], A[1], ..., A[N-1]. Les éléments d’un tableau à deux dimensions B contenant M lignes, et chaque ligne contenant N colonnes, sont accessibles à l’aide des expressions B[0,0], B[0,1], ..., B[0,N-1], B[1,0], B[1,1], ..., B[1,N-1], ..., B[M-1,0], B[M-1,1], ..., B[M-1,N-1].
Et ainsi de suite pour les tableaux avec au moins trois dimensions.
Par défaut, un tableau est polymorphe, c’est-à-dire que ses éléments ne doivent pas nécessairement être tous du même type. Par exemple,
$items = 10,"blue",12.54e3,16.30D # 1-D array of length 4
$items[1] = -2.345
$items[2] = "green"
$a = New-Object 'object[,]' 2,2 # 2-D array of length 4
$a[0,0] = 10
$a[0,1] = $false
$a[1,0] = "red"
$a[1,1] = $null
Un tableau unidimensionnel a le type type[], un tableau à deux dimensions a le type type[,], un tableau à trois dimensions a le type type[,,], etc., où type correspond à l’objet d’un tableau de type non contraint, ou au type contraint d’un tableau contraint (§9.4).
Tous les types de tableaux sont dérivés du type Tableau (§4.3.2).
9.2 Création de tableaux
Un tableau est créé via une expression de création de tableau, qui peut avoir les formes suivantes : opérateur virgule unaire (§7.2.1), expression de tableau (§7.1.7), opérateur virgule binaire (§7.3), opérateur de plage (§7.4) ou applet de commande New-Object.
Voici quelques exemples de création et d’utilisation d’un tableau :
$values = 10, 20, 30
for ($i = 0; $i -lt $values.Length; ++$i) {
"`$values[$i] = $($values[$i])"
}
$x = , 10 # x refers to an array of length 1
$x = @(10) # x refers to an array of length 1
$x = @() # x refers to an array of length 0
$a = New-Object 'object[,]' 2, 2 # create a 2x2 array of anything
$a[0, 0] = 10 # set to an int value
$a[0, 1] = $false # set to a boolean value
$a[1, 0] = "red" # set to a string value
$a[1, 1] = 10.50D # set to a decimal value
foreach ($e in $a) { # enumerate over the whole array
$e
}
Ce qui suit est écrit dans le pipeline :
$values[0] = 10
$values[1] = 20
$values[2] = 30
10
False
red
10.50
La valeur initiale par défaut d’un élément qui n’est pas explicitement initialisé est la valeur par défaut du type de cet élément (c’est-à-dire $false, zéro ou $null).
9.3 Concaténation de tableaux
Les tableaux de type et de longueur arbitraires peuvent être concaténés par le biais des opérateurs + et +=, tous deux entraînant la création d’un nouveau tableau unidimensionnel non contraint. Les tableaux existants restent inchangés. Pour plus d’informations, consultez §7.7.3, et pour en savoir plus sur l’ajout d’un tableau de type contraint, consultez §9.4.
9.4 Types d’éléments contraints
Un tableau unidimensionnel peut être créé avec un type contraint en préfixant l’expression de création de tableau avec un cast de type tableau. Par exemple,
$a = [int[]](1,2,3,4) # constrained to int
$a[1] = "abc" # implementation-defined behavior
$a += 1.23 # new array is unconstrained
La syntaxe de création d’un tableau multidimensionnel nécessite la spécification d’un type. Ce type devient alors le type de contrainte de ce tableau. Toutefois, si vous spécifiez le type object[], il n’y aura pas vraiment de contrainte, car une valeur de tout type peut être assignée à un élément d’un tableau de ce type.
La concaténation de deux tableaux (§7.7.3) aboutit toujours à la création d’un nouveau tableau non contraint, même si les deux tableaux sont contraints par le même type. Par exemple,
$a = [int[]](1,2,3) # constrained to int
$b = [int[]](10,20) # constrained to int
$c = $a + $b # constraint not preserved
$c = [int[]]($a + $b) # result explicitly constrained to int
9.5 Tableaux en tant que types référence
Comme les types de tableau sont des types référence, vous pouvez obtenir d’une variable désignant un tableau qu’elle référence un tableau de n’importe quels rang, longueur et type d’élément. Par exemple,
$a = 10,20 # $a refers to an array of length 2
$a = 10,20,30 # $a refers to a different array, of length 3
$a = "red",10.6 # $a refers to a different array, of length 2
$a = New-Object 'int[,]' 2,3 # $a refers to an array of rank 2
L’assignation d’un tableau implique une copie superficielle, c’est-à-dire que la variable assignée référence le même tableau, et qu’aucune copie du tableau n’est effectuée. Par exemple,
$a = 10,20,30
">$a<"
$b = $a # make $b refer to the same array as $a
">$b<"
$a[0] = 6 # change value of [0] via $a
">$a<"
">$b<" # change is reflected in $b
$b += 40 # make $b refer to a new array
$a[0] = 8 # change value of [0] via $a
">$a<"
">$b<" # change is not reflected in $b
Ce qui suit est écrit dans le pipeline :
>10 20 30<
>10 20 30<
>6 20 30<
>6 20 30<
>8 20 30<
>6 20 30 40<
9.6 Tableaux en tant qu’éléments de tableau
Tout élément d’un tableau peut lui-même être un tableau. Par exemple,
$colors = "red", "blue", "green"
$list = $colors, (,7), (1.2, "yes") # parens in (,7) are redundant; they
# are intended to aid readability
"`$list refers to an array of length $($list.Length)"
">$($list[1][0])<"
">$($list[2][1])<"
Ce qui suit est écrit dans le pipeline :
$list refers to an array of length 3
>7<
>yes<
$list[1] référence un tableau comprenant 1 élément, l’entier 7, qui est accessible via $list[1][0], comme cela est indiqué. Comparez ceci avec le cas légèrement différent qui suit :
$list = $colors, 7, (1.2, "yes") # 7 has no prefix comma
">$($list[1])<"
Ici, $list[1] référence un scalaire, l’entier 7, qui est accessible via $list[1].
Prenons l’exemple suivant :
$x = [string[]]("red","green")
$y = 12.5, $true, "blue"
$a = New-Object 'object[,]' 2,2
$a[0,0] = $x # element is an array of 2 strings
$a[0,1] = 20 # element is an int
$a[1,0] = $y # element is an array of 3 objects
$a[1,1] = [int[]](92,93) # element is an array of 2 ints
9.7 Indices négatifs
Ce sujet est abordé au paragraphe §7.1.4.1.
9.8 Contrôle des limites
Ce sujet est abordé au paragraphe §7.1.4.1.
9.9 Sections de tableau
Une section de tableau est un tableau unidimensionnel non contraint dont les éléments sont des copies de zéro, un ou plusieurs éléments d’une collection. Une section de tableau est créée à l’aide de l’opérateur d’indice [] (§7.1.4.5).
9.10 Copie d’un tableau
Un ensemble contigu d’éléments peut être copié d’un tableau à un autre à l’aide de la méthode [Array]::Copy. Par exemple,
$a = [int[]](10,20,30)
$b = [int[]](0,1,2,3,4,5)
[Array]::Copy($a, $b, 2) # $a[0]->$b[0],
$a[1]->$b[1]
[Array]::Copy($a, 1, $b, 3, 2) # $a[1]->$b[3],
$a[2]->$b[4]
9.11 Énumération d’un tableau
Même s’il est possible d’exécuter une boucle sur un tableau en accédant à chacun de ses éléments par le biais de l’opérateur d’indice, nous pouvons énumérer les éléments de ce tableau à l’aide de l’instruction foreach. Pour un tableau multidimensionnel, les éléments sont traités dans l’ordre principal des lignes. Par exemple,
$a = 10, 53, 16, -43
foreach ($elem in $a) {
# do something with element via $e
}
foreach ($elem in -5..5) {
# do something with element via $e
}
$a = New-Object 'int[,]' 3, 2
foreach ($elem in $a) {
# do something with element via $e
}
9.12 Aplatissement des tableaux multidimensionnels
Certaines opérations exécutées sur un tableau multidimensionnel (comme la réplication (§7.6.3) et la concaténation (§7.7.3)) nécessitent que ce tableau soit aplati, autrement dit, qu’il soit converti en tableau unidimensionnel de type non contraint. Le tableau obtenu prend tous les éléments dans l’ordre principal des lignes.
Prenons l’exemple suivant :
$a = "red",$true
$b = (New-Object 'int[,]' 2,2)
$b[0,0] = 10
$b[0,1] = 20
$b[1,0] = 30
$b[1,1] = 40
$c = $a + $b
Le tableau désigné par $c contient les éléments « red », $true, 10, 20, 30 et 40.