9. Tableaux

Note éditoriale

Important

La spécification du langage Windows PowerShell 3.0 a été publiée en décembre 2012 et est basée sur Windows PowerShell 3.0. Cette spécification ne reflète pas l’état actuel de PowerShell. Il n’existe aucun plan de mise à jour de cette documentation pour refléter l’état actuel. Cette documentation est présentée ici pour référence historique.

Le document de spécification est disponible en tant que document Microsoft Word à partir du Centre de téléchargement Microsoft à l’adresse : https://www.microsoft.com/download/details.aspx?id=36389 ce document Word a été converti pour présentation ici sur Microsoft Learn. Pendant la conversion, certaines modifications éditoriales ont été apportées pour prendre en charge la mise en forme de la plateforme Docs. Certaines fautes de frappe et erreurs mineures ont été corrigées.

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 entier croissant commençant à zéro. Tout élément individuel est accessible via l’opérateur de sous-script 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 de tableau. Un tableau ayant un ou plusieurs éléments dont les valeurs sont de n’importe quel type de tableau est appelé tableau dentelé. Un tableau multidimensionnel a plusieurs dimensions, auquel cas, le nombre d’éléments dans chaque ligne d’une 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 est appelé longueurdu tableau, 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 à 2 dimensions B ayant M lignes, chaque ligne ayant 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 n’ont pas besoin de tous avoir le 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 1 dimensionnel a un type type[], un tableau à 2 dimensions a un type type[,], un tableau 3 dimensions a un type type[,,], et ainsi de suite, où type est un objet pour un tableau de types non contraintes, ou le type contraint pour un tableau contraint (§9.4).

Tous les types de tableaux sont dérivés du type Array (§4.3.2).

9.2 Création de tableaux

Un tableau est créé à l'aide d'une expression de création de tableau , qui prend les formes suivantes : opérateur de virgule unaire (§7.2.1),expression de tableau (§7.1.7), opérateur de virgule binaire (§7.3), opérateur de plage (§7.4) ou cmdlet New-Object .

Voici quelques exemples de création et d’utilisation de tableaux :

$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 non initialisé explicitement est la valeur par défaut du type de cet élément (autrement dit, $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 +=, qui entraînent la création d’un nouveau tableau sans contraintes 1 dimensionnel. Les tableaux existants sont inchangés. Consultez §7.7.3 pour plus d’informations et §9.4 pour une discussion sur l’ajout à un tableau de types contraints.

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 et ce type devient le type de contrainte pour ce tableau. Toutefois, en spécifiant le type object[], il n’existe vraiment aucune contrainte en tant que valeur de n’importe quel type peut être affectée à un élément d’un tableau de ce type.

La concaténation de deux tableaux (§7.7.3) entraîne toujours un nouveau tableau qui n’est pas entraîné même si les deux tableaux sont limités 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 de référence, une variable désignant un tableau peut être faite pour faire référence à n’importe quel tableau de n’importe quel 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’affectation d’un tableau implique une copie superficielle ; autrement dit, la variable affectée fait référence au même tableau, 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] fait référence à un tableau de 1 élément, l’entier 7, accessible via $list[1][0], comme indiqué. Comparez cela avec le cas subtilement différent suivant :

$list = $colors, 7, (1.2, "yes") # 7 has no prefix comma
">$($list[1])<"

Ici, $list[1] fait référence à une scalaire, l’entier 7, 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

Ceci est abordé dans §7.1.4.1.

9.8 Vérification des limites

Ceci est abordé dans §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 à l’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

Bien qu’il soit possible de parcourir un tableau en accédant à chacun de ses éléments par l’opérateur d’indice, nous pouvons énumérer 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 $elem
}

foreach ($elem in -5..5) {
    # do something with element via $elem
}

$a = New-Object 'int[,]' 3, 2
foreach ($elem in $a) {
    # do something with element via $elem
}

9.12 Aplatissement des tableaux multidimensionnels

Certaines opérations sur un tableau multidimensionnel (comme la réplication (§7.6.3) et la concaténation (§7.7.3)) nécessitent que ce tableau soit aplatissement; autrement dit, pour être transformé en tableau 1 dimensionnel de type nonconstrainé. 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 « rouge », $true, 10, 20, 30 et 40.