Partager via

7. Expressions

  • Article

Syntaxe :

expression:
    logical-expression

Description :

Une expression est une séquence d’opérateurs et d’opérandes qui désigne une méthode, une fonction, un emplacement accessible en écriture ou une valeur, qui spécifie le calcul d’une valeur, qui produit un ou plusieurs effets secondaires, ou qui effectue une combinaison de ces derniers. Par exemple,

  • Le littéral 123 est une expression qui désigne la valeur entière 123.
  • L’expression 1,2,3,4 désigne l’objet tableau à quatre éléments dont les valeurs sont affichées.
  • L’expression 10.4 * $a spécifie un calcul.
  • L’expression $a++ produit un effet secondaire.
  • L’expression $a[$i--] = $b[++$j] effectue une combinaison de ces opérations.

À l’exception de ce qui est spécifié pour certains opérateurs, l’ordre d’évaluation des termes dans une expression et l’ordre dans lequel les effets secondaires ont lieu ne sont pas spécifiés. Voici quelques exemples de comportements non spécifiés : $i++ + $i, $i + --$i et $w[$j++] = $v[$j].

Une implémentation de PowerShell peut fournir une prise en charge des types définis par l’utilisateur, et ces types peuvent avoir des opérations définies. Tous les détails de ces types et opérations sont définis par l’implémentation.

Une expression de niveau supérieur est une expression qui ne fait pas partie d’une expression de plus grande taille. Si une expression de niveau supérieur contient un opérateur à effet secondaire, la valeur de cette expression n’est pas écrite dans le pipeline ; dans le cas contraire, elle l’est. Pour obtenir une discussion détaillée de cet aspect, consultez §7.1.1.

En règle générale, une expression qui désigne une collection (§4) est énumérée en ses éléments constitutifs lorsque la valeur de cette expression est utilisée. Toutefois, ce n’est pas le cas lorsque l’expression est un appel d’applet de commande. Par exemple,

$x = 10,20,30
$a = $($x; 99)                     # $a.Length is 4

$x = New-Object 'int[]' 3
$a = $($x; 99)                     # equivalent, $a.Length is 4

$a = $(New-Object 'int[]' 3; 99)   # $a.Length is 2

Dans les deux premières utilisations de l’opérateur $(...), l’expression désignant la collection est la variable $x, qui est énumérée, ce qui donne trois valeurs int, plus l’int 99. Toutefois, dans le troisième cas, l’expression est un appel direct à une applet de commande ; le résultat n’est donc pas énuméré, et $a est un tableau de deux éléments, int[3] et int.

Si une opération n’est pas définie par PowerShell, le type de la valeur désignée par l’opérande gauche est inspecté pour voir s’il a une méthode correspondante op_<operation>.

7.1 Expressions primaires

Syntaxe :

primary-expression:
    value
    member-access
    element-access
    invocation-expression
    post-increment-expression
    post-decrement-expression

value:
    parenthesized-expression
    sub-expression
    array-expression
    script-block-expression
    hash-literal-expression
    literal
    type-literal
    variable

7.1.1 Parenthèses de regroupement

Syntaxe :

Conseil

La notation ~opt~ dans les définitions de syntaxe indique que l’entité lexicale est facultative dans la syntaxe.

parenthesized-expression:
    ( new-lines~opt~ pipeline new-lines~opt~ )

Description :

Une expression entre parenthèses est une expression primaire dont le type et la valeur sont identiques à ceux de l’expression sans les parenthèses. Si l’expression désigne une variable, l’expression entre parenthèses désigne cette même variable. Par exemple, $x.m and ($x).m sont équivalentes.

Les parenthèses de regroupement peuvent être utilisées dans une expression pour documenter la priorité et l’associativité par défaut dans cette expression. Elles peuvent également être utilisées pour remplacer cette priorité et associativité par défaut. Par exemple,

4 + 6 * 2    # 16
4 + (6 * 2)  # 16 document default precedence
(4 + 6) * 2  # 20 override default precedence

En règle générale, les parenthèses de regroupement au niveau le plus élevé sont redondantes. Toutefois, ce n’est pas toujours le cas. Prenons l’exemple suivant :

2,4,6       # Length 3; values 2,4,6
(2,4),6     # Length 2; values [object[]],int

Dans le second cas, les parenthèses modifient la sémantique, ce qui donne un tableau dont les deux éléments sont un tableau de 2 ints et le scalaire int 6.

Voici une autre exception :

23.5/2.4          # pipeline gets 9.79166666666667
$a = 1234 * 3.5   # value not written to pipeline
$a                # pipeline gets 4319

Dans le premier et le troisième cas, la valeur du résultat est écrite dans le pipeline. Toutefois, bien que l’expression dans le deuxième cas soit évaluée, le résultat n’est pas écrit dans le pipeline en raison de la présence de l’opérateur à effet secondaire = au niveau supérieur. (La suppression de la partie $a = permet d’écrire la valeur, car * n’est pas un opérateur à effet secondaire.)

Pour empêcher que la valeur d’une expression ne contenant pas d’effets secondaires de niveau supérieur soit écrite dans le pipeline, ignorez-la explicitement, comme suit :

# None of these value are written to pipeline
[void](23.5/2.4)
[void]$a
$null = $a
$a > $null

Pour écrire dans le pipeline la valeur d’une expression contenant des effets secondaires de niveau supérieur, mettez cette expression entre parenthèses, comme suit :

($a = 1234 * 3.5) # pipeline gets 4319

Les parenthèses de regroupement dans ce cas ne sont pas redondantes.

Dans l’exemple suivant, une substitution de variable (§2.3.5.2) a lieu dans un littéral de chaîne :

">$($a = -23)<"    # value not written to pipeline, get
><
">$(($a = -23))<"  # pipeline gets >-23<

Dans le premier cas, les parenthèses représentent les parenthèses de non regroupement des délimiteurs d’une sous-expression, et comme l’expression de niveau supérieur contient un opérateur à effet secondaire, la valeur de l’expression n’est pas écrite dans le pipeline. Bien entendu, les caractères > et < sont toujours écrits.) Si des parenthèses de regroupement sont ajoutées, comme indiqué dans le deuxième cas, l’écriture est activée.

Les exemples suivants contiennent chacun des opérateurs à effets secondaires de niveau supérieur :

$a = $b = 0      # value not written to pipeline
$a = ($b = 0)    # value not written to pipeline
($a = ($b = 0))  # pipeline gets 0

++$a             # value not written to pipeline
(++$b)           # pipeline gets 1

$a--             # value not written to pipeline
($b--)           # pipeline gets 1

L’utilisation de parenthèses de regroupement autour d’une expression ne contenant aucun effet secondaire de niveau supérieur rend ces parenthèses redondantes. Par exemple :

$a      # pipeline gets 0
($a)    # no side effect, so () redundant

Prenons l’exemple suivant qui a deux effets secondaires, dont aucun n’est de niveau supérieur :

12.6 + ($a = 10 - ++$b) # pipeline gets 21.6.

Le résultat est écrit dans le pipeline, car l’expression de niveau supérieur n’a aucun effet secondaire.

7.1.2 Accès aux membres

Syntaxe :

member-access: Note no whitespace is allowed after primary-expression. 
    primary-expression . member-name
    primary-expression :: member-name

Description :

L’opérateur . est utilisé pour sélectionner un membre d’instance à partir d’un objet, ou une clé d’un Hashtable. L’opérande gauche doit désigner un objet, et l’opérande droit doit désigner un membre d’instance accessible.

Soit l’opérande droit désigne un membre d’instance accessible dans le type de l’objet désigné par l’opérande gauche, soit, si l’opérande gauche désigne un tableau, l’opérande droit désigne les membres d’instance accessibles au sein de chaque élément du tableau.

Un espace blanc n’est pas autorisé avant l’opérateur ..

Cet opérateur est associatif à gauche.

L’opérateur :: est utilisé pour sélectionner un membre statique à partir d’un type donné. L’opérande gauche doit désigner un type, et l’opérande droit doit désigner un membre statique accessible dans ce type.

Un espace blanc n’est pas autorisé avant l’opérateur ::.

Cet opérateur est associatif à gauche.

Si l’opérande droit désigne un emplacement accessible en écriture dans le type de l’objet désigné par l’opérande gauche, l’expression entière désigne un emplacement accessible en écriture.

Exemples :

$a = 10, 20, 30
$a.Length                    # get instance property

(10, 20, 30).Length

$property = "Length"
$a.$property                 # property name is a variable

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123
}
$h1.FirstName                # designates the key FirstName
$h1.Keys                     # gets the collection of keys

[int]::MinValue              # get static property
[double]::PositiveInfinity   # get static property
$property = "MinValue"
[long]::$property            # property name is a variable

foreach ($t in [byte], [int], [long]) {
    $t::MaxValue             # get static property
}

$a = @{ID = 1 }, @{ID = 2 }, @{ID = 3 }
$a.ID                        # get ID from each element in the array

7.1.3 Expressions d’appel

Syntaxe :

invocation-expression: Note no whitespace is allowed after primary-expression. 
    primary-expression . member-name argument-list
    primary-expression :: member-name argument-list

argument-list:
    ( argument-expression-list~opt~ new-lines~opt~ )

Description :

Une invocation-expression appelle la méthode désignée par primary-expression.member-name ou primary-expression::member-name. Les parenthèses dans argument-list contiennent une liste, éventuellement vide, d’expressions séparées par des virgules qui désignent les arguments dont les valeurs sont passées à la méthode. Avant que la méthode ne soit appelée, les arguments sont évalués et convertis conformément aux règles du §6, si nécessaire, pour correspondre aux types attendus par la méthode. L’ordre d’évaluation de primary-expression.member-name, primary-expression::member-name et des arguments n’est pas spécifié.

Cet opérateur est associatif à gauche.

Le type du résultat d’une invocation-expression est un désignateur de méthode (§4.5.24).

Exemples :

[math]::Sqrt(2.0)            # call method with argument 2.0
[char]::IsUpper("a")         # call method
$b = "abc#$%XYZabc"
$b.ToUpper()                 # call instance method

[math]::Sqrt(2)              # convert 2 to 2.0 and call method
[math]::Sqrt(2D)             # convert 2D to 2.0 and call method
[math]::Sqrt($true)          # convert $true to 1.0 and call method
[math]::Sqrt("20")           # convert "20" to 20 and call method

$a = [math]::Sqrt            # get method descriptor for Sqrt
$a.Invoke(2.0)               # call Sqrt via the descriptor
$a = [math]::("Sq"+"rt")     # get method descriptor for Sqrt
$a.Invoke(2.0)               # call Sqrt via the descriptor
$a = [char]::ToLower         # get method descriptor for ToLower
$a.Invoke("X")               # call ToLower via the descriptor

7.1.4 Accès aux éléments

Syntaxe :

element-access: Note no whitespace is allowed between primary-expression and [.
    primary-expression [ new-lines~opt~ expression new-lines~opt~ ]

Description :

Il ne doit pas y avoir d’espace blanc entre primary-expression et le crochet gauche ([).

7.1.4.1 Mise en indice d’un tableau

Description :

Les tableaux sont abordés en détail dans §9. Si expression est un tableau unidimensionnel, consultez §7.1.4.5.

Lorsque primary-expression désigne un tableau unidimensionnel A, l’opérateur [] retourne l’élément situé à A[0 + expression] une fois que la valeur d’expression a été convertie en int. Le résultat a le type d’élément du tableau mis en indice. Si expression est négative, A[expression] désigne l’élément situé à A[A.Length + expression].

Lorsque primary-expression désigne un tableau à deux dimensions B, l’opérateur [] retourne l’élément situé à B[0 + row,0 + column] une fois que la valeur des composants row et column d’expression (qui sont spécifiés sous forme de liste séparée par des virgules) a été convertie en int. Le résultat a le type d’élément du tableau mis en indice. Contrairement à un tableau unididimensionnel, les positions négatives n’ont aucune signification particulière.

Lorsque primary-expression désigne un tableau à trois dimensions ou plus, les règles pour les tableaux à deux dimensions s’appliquent, et les positions de la dimension sont spécifiées sous la forme d’une liste de valeurs séparées par des virgules.

En cas de tentative d’accès en lecture à un élément non existant, le résultat est $null. L’écriture dans un élément non existant constitue une erreur.

Pour une expression d’indice de tableau multidimensionnel, l’ordre d’évaluation des expressions de position de dimension n’est pas spécifié. Par exemple, étant donné un tableau $a à trois dimensions, le comportement de $a[$i++,$i,++$i] n’est pas spécifié.

Si expression est un tableau, consultez §7.1.4.5.

Cet opérateur est associatif à gauche.

Exemples :

$a = [int[]](10,20,30) # [int[]], Length 3
$a[1] # returns int 20
$a[20] # no such position, returns $null
$a[-1] # returns int 30, i.e., $a[$a.Length-1]
$a[2] = 5 # changes int 30 to int 5
$a[20] = 5 # implementation-defined behavior

$a = New-Object 'double[,]' 3,2
$a[0,0] = 10.5 # changes 0.0 to 10.5
$a[0,0]++ # changes 10.5 to 10.6

$list = ("red",$true,10),20,(1.2, "yes")
$list[2][1] # returns string "yes"

$a = @{ A = 10 },@{ B = $true },@{ C = 123.45 }
$a[1]["B"] # $a[1] is a Hashtable, where B is a key

$a = "red","green"
$a[1][4] # returns string "n" from string in $a[1]

En cas de tentative d’accès en écriture à un élément non existant, une exception IndexOutOfRange est levée.

7.1.4.2 Mise en indice d’une chaîne

Description :

Lorsque primary-expression désigne une chaîne S, l’opérateur [] retourne le caractère situé à la position de base zéro indiquée par expression, sous la forme d’un caractère. Si expression est supérieure ou égale à la longueur de cette chaîne, le résultat est $null. Si expression est négative, S[expression] désigne l’élément situé à S[S.Length + expression].

Exemples :

$s = "Hello"   # string, Length 5, positions 0-4
$c = $s[1]     # returns "e" as a string
$c = $s[20]    # no such position, returns $null
$c = $s[-1]    # returns "o", i.e., $s[$s.Length-1]

7.1.4.3 Mise en indice d’une table de hachage

Description :

Lorsque primary-expression désigne une table de hachage, l’opérateur [] retourne les valeurs associées aux clés désignées par expression. Le type d’expression n’est pas limité.

Lorsque expression est un nom de clé unique, le résultat est la valeur associée et il a ce type, sauf si aucune clé de ce type n’existe. Dans ce cas, le résultat est $null. Si $null est utilisé comme clé, le comportement est défini par l’implémentation. Si expression est un tableau de noms de clés, consultez §7.1.4.5.

Si expression est un tableau, consultez §7.1.4.5.

Exemples :

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1['FirstName']     # the value associated with key FirstName
$h1['BirthDate']     # no such key, returns $null

$h1 = @{ 10 = "James"; 20.5 = "Anderson"; $true = 123 }
$h1[10]              # returns value "James" using key 10
$h1[20.5]            # returns value "Anderson" using key 20.5
$h1[$true]           # returns value 123 using key $true

Lorsque expression est un nom de clé unique, si $null est utilisé comme seule valeur pour mettre en indice une table de hachage, une exception NullArrayIndex est levée.

7.1.4.4 Mise en indice d’un document XML

Description :

Lorsque primary-expression désigne un objet de type XML, expression est convertie en chaîne, si nécessaire, et l’opérateur [] retourne le premier élément enfant portant le nom spécifié par expression. Le type d’expression doit être une chaîne. Le type du résultat est défini par l’implémentation. Le résultat peut être mis en indice pour retourner son premier élément enfant. S’il n’existe aucun élément enfant avec le nom spécifié par expression, le résultat est $null. Le résultat ne désigne pas un emplacement accessible en écriture.

Exemples :

$x = [xml]@"
<Name>
<FirstName>Mary</FirstName>
<LastName>King</LastName>
</Name>
"@

$x['Name']                # refers to the element Name
$x['Name']['FirstName']   # refers to the element FirstName within Name
$x['FirstName']           # No such child element at the top level, result is `$null`

Le type du résultat est System.Xml.XmlElement ou System.String.

7.1.4.5 Génération de sections de tableau

Lorsque primary-expression désigne un objet d’un type qui est énumérable (§4) ou une table de hachage, et qu’expression est un tableau unidimensionnel, le résultat est une section de tableau (§9.9) contenant les éléments de primary-expression désignés par les éléments d’expression.

Dans le cas d’une table de hachage, la section de tableau contient les valeurs associées aux clés fournies, sauf si aucune clé de ce type n’existe. Dans ce cas, l’élément correspondant est $null. Si $null est utilisé comme nom de clé, le comportement est défini par l’implémentation.

Exemples :

$a = [int[]](30,40,50,60,70,80,90)
$a[1,3,5]                 # slice has Length 3, value 40,60,80
++$a[1,3,5][1]            # preincrement 60 in array 40,60,80
$a[,5]                    # slice with Length 1
$a[@()]                   # slice with Length 0
$a[-1..-3]                # slice with Length 0, value 90,80,70
$a = New-Object 'int[,]' 3,2
$a[0,0] = 10; $a[0,1] = 20; $a[1,0] = 30
$a[1,1] = 40; $a[2,0] = 50; $a[2,1] = 60
$a[(0,1),(1,0)]           # slice with Length 2, value 20,30, parens needed
$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1['FirstName']          # the value associated with key FirstName
$h1['BirthDate']          # no such key, returns $null
$h1['FirstName','IDNum']  # returns [object[]], Length 2 (James/123)
$h1['FirstName','xxx']    # returns [object[]], Length 2 (James/$null)
$h1[$null,'IDNum']        # returns [object[]], Length 1 (123)

Windows PowerShell : lorsque expression est une collection d’au moins deux noms de clés, si $null est utilisé comme un nom de clé, cette clé est ignorée et n’a aucun élément correspondant dans le tableau résultant.

7.1.5 Opérateurs suffixés d’incrémentation et de décrémentation

Syntaxe :

post-increment-expression:
    primary-expression ++

post-decrement-expression:
    primary-expression dashdash

dashdash:
    --

Description :

primary-expression doit désigner un emplacement accessible en écriture ayant une valeur de type numérique (§4) ou la valeur $null. Si la valeur désignée par l’opérande est $null, cette valeur est convertie vers le type int et la valeur zéro avant l’évaluation de l’opérateur. Le type de la valeur désignée par primary-expression peut changer lorsque le résultat est stocké. Pour obtenir une discussion concernant le changement de type par le biais de l’affectation, voir §7.11.

Le résultat produit par l’opérateur ++ suffixé est la valeur désignée par l’opérande. Une fois le résultat obtenu, la valeur désignée par l’opérande est incrémentée de 1 du type approprié. Le type du résultat de l’expression E++ est le même que pour le résultat de l’expression E + 1 (§7.7).

Le résultat produit par l’opérateur -- suffixé est la valeur désignée par l’opérande. Une fois le résultat obtenu, la valeur désignée par l’opérande est décrémentée de 1 du type approprié. Le type du résultat de l’expression E-- est le même que pour le résultat de l’expression E - 1 (§7.7).

Ces opérateurs binaires sont associatifs à gauche.

Exemples :

$i = 0                # $i = 0
$i++                  # $i is incremented by 1
$j = $i--             # $j takes on the value of $i before the decrement

$a = 1,2,3
$b = 9,8,7
$i = 0
$j = 1
$b[$j--] = $a[$i++]   # $b[1] takes on the value of $a[0], then $j is
                      # decremented, $i incremented

$i = 2147483647       # $i holds a value of type int
$i++                  # $i now holds a value of type double because
                      # 2147483648 is too big to fit in type int

[int]$k = 0           # $k is constrained to int
$k = [int]::MaxValue  # $k is set to 2147483647
$k++                  # 2147483648 is too big to fit, imp-def bahavior

$x = $null            # target is unconstrained, $null goes to [int]0
$x++                  # value treated as int, 0->1

7.1.6 Opérateur $(...)

Syntaxe :

sub-expression:
    $( new-lines~opt~ statement-list~opt~ new-lines~opt~ )

Description :

Si statement-list est omis, le résultat est $null. Sinon, statement-list est évalué. Les objets écrits dans le pipeline dans le cadre de l’évaluation sont collectés dans un tableau unidimensionnel sans contrainte, dans l’ordre. Si le tableau d’objets collectés est vide, le résultat est $null. Si le tableau d’objets collectés contient un seul élément, le résultat est cet élément ; dans le cas contraire, le résultat est le tableau unidimensionnel sans contrainte des résultats collectés.

Exemples :

$j = 20
$($i = 10) # pipeline gets nothing
$(($i = 10)) # pipeline gets int 10
$($i = 10; $j) # pipeline gets int 20
$(($i = 10); $j) # pipeline gets [object[]](10,20)
$(($i = 10); ++$j) # pipeline gets int 10
$(($i = 10); (++$j)) # pipeline gets [object[]](10,22)
$($i = 10; ++$j) # pipeline gets nothing
$(2,4,6) # pipeline gets [object[]](2,4,6)

7.1.7 Opérateur @(...)

Syntaxe :

array-expression:
    @( new-lines~opt~ statement-list~opt~ new-lines~opt~ )

Description :

Si statement-list est omis, le résultat est un tableau unidimensionnel sans contrainte de longueur zéro. Sinon, statement-list est évalué et les objets écrits dans le pipeline dans le cadre de l’évaluation sont collectés dans un tableau unidimensionnel sans contrainte, dans l’ordre. Le résultat est le tableau unidimensionnel sans contrainte (éventuellement vide).

Exemples :

$j = 20
@($i = 10)             # 10 not written to pipeline, result is array of 0
@(($i = 10))           # pipeline gets 10, result is array of 1
@($i = 10; $j)         # 10 not written to pipeline, result is array of 1
@(($i = 10); $j)       # pipeline gets 10, result is array of 2
@(($i = 10); ++$j)     # pipeline gets 10, result is array of 1
@(($i = 10); (++$j))   # pipeline gets both values, result is array of 2
@($i = 10; ++$j)       # pipeline gets nothing, result is array of 0

$a = @(2,4,6)          # result is array of 3
@($a)                  # result is the same array of 3
@(@($a))               # result is the same array of 3

7.1.8 Expression de bloc de script

Syntaxe :

script-block-expression:
    { new-lines~opt~ script-block new-lines~opt~ }

script-block:
    param-block~opt~ statement-terminators~opt~ script-block-body~opt~

script-block-body:
    named-block-list
    statement-list

Description :

param-block est décrit dans §8.10.9. named-block-list est décrit dans §8.10.7.

Un bloc de script est un bloc sans nom d’instructions qui peut être utilisé comme une seule unité. Les blocs de script peuvent être utilisés pour appeler un bloc de code comme s’il s’agissait d’une commande unique, ou ils peuvent être assignés à des variables qui peuvent être exécutées.

named-block-list ou statement-list est exécutée, et le type et les valeurs du résultat sont le type et les valeurs des résultats de ces jeux d’instructions.

Une script-block-expression a un type scriptblock (§4.3.7).

Si param-block est omis, tous les arguments passés au bloc de script sont disponibles via $args (§8.10.1).

Pendant la liaison de paramètre, un bloc de script peut être passé en tant qu’objet de bloc de script ou en tant que résultat après l’évaluation du bloc de script. Pour plus d’informations, voir §6.17.

7.1.9 Expression de littéral de hachage

Syntaxe :

hash-literal-expression:
    @{ new-lines~opt~ hash-literal-body~opt~ new-lines~opt~ }

hash-literal-body:
    hash-entry
    hash-literal-body statement-terminators hash-entry

hash-entry:
    key-expression = new-lines~opt~ statement

key-expression:
    simple-name
    unary-expression

statement-terminators:
    statement-terminator
    statement-terminators statement-terminator

statement-terminator:
    ;
    new-line-character

Description :

Une hash-literal-expression est utilisée pour créer une table de hachage (§10) de zéro, un ou plusieurs éléments, chacun étant une paire clé/valeur.

La clé peut avoir n’importe quel type, à l’exception du type Null. Les valeurs associées peuvent avoir n’importe quel type, y compris le type Null, et chacune de ces valeurs peut être toute expression qui désigne la valeur souhaitée, y compris $null.

L’ordre des paires clé/valeur n’est pas significatif.

Exemples :

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$last = "Anderson"; $IDNum = 120
$h2 = @{ FirstName = "James"; LastName = $last; IDNum = $IDNum + 3 }
$h3 = @{ }
$h4 = @{ 10 = "James"; 20.5 = "Anderson"; $true = 123 }

qui crée deux tables de hachage, $h1 et $h2, chacune contenant trois paires clé/valeur, et une troisième, $h3, qui est vide. La table de hachage $h4 contient des clés de différents types.

7.1.10 Expression de littéral de type

Syntaxe :

type-literal:
    [ type-spec ]

type-spec:
    array-type-name new-lines~opt~ dimension~opt~ ]
    generic-type-name new-lines~opt~ generic-type-arguments ]
    type-name

dimension:
    ,
    dimension ,

generic-type-arguments:
    type-spec new-lines~opt~
    generic-type-arguments , new-lines~opt~ type-spec

array-type-name:
    type-name [

generic-type-name:
    type-name [

Description :

Un type-literal est représenté dans une implémentation par un type sous-jacent non spécifié. Par conséquent, un nom de type est un synonyme de son type sous-jacent.

Les littéraux de type sont utilisés dans plusieurs contextes :

  • Spécification d’une conversion explicite (§6, §7.2.9)
  • Création d’un tableau à contrainte de type (§9.4)
  • Accès aux membres statiques d’un objet (§7.1.2)
  • Spécification d’une contrainte de type sur une variable (§5.3) ou un paramètre de fonction (§8.10.2)

Exemples :

[int], [object[] et [int[,,]] sont des exemples de littéraux de type. Un type de pile générique (§4.4) spécialisé pour contenir des chaînes peut être écrit sous la forme [Stack[string]], et un type de dictionnaire générique spécialisé pour contenir des clés int avec des valeurs de chaîne associées peut être écrit sous la forme [Dictionary[int,string]].

Le type d’un type-literal est System.Type. Le nom complet du type Stack[string] suggéré ci-dessus est System.Collections.Generic.Stack[int]. Le nom complet du type Dictionary[int,string] suggéré ci-dessus est System.Collections.Generic.Dictionary[int,string].

7.2 Opérateurs unaires

Syntaxe :

unary-expression:
    primary-expression
    expression-with-unary-operator

expression-with-unary-operator:
    , new-lines~opt~ unary-expression
    -not new-lines~opt~ unary-expression
    ! new-lines~opt~ unary-expression
    -bnot new-lines~opt~ unary-expression
    + new-lines~opt~ unary-expression
    dash new-lines~opt~ unary-expression
    pre-increment-expression
    pre-decrement-expression
    cast-expression
    -split new-lines~opt~ unary-expression
    -join new-lines~opt~ unary-expression

dash:*
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

pre-increment-expression:
    ++ new-lines~opt~ unary-expression

pre-decrement-expression:
    dashdash new-lines~opt~ unary-expression

cast-expression:
    type-literal unary-expression

dashdash:
    dash dash

7.2.1 Opérateur virgule unaire

Description :

Cet opérateur crée un tableau unidimensionnel sans contrainte ayant un élément, dont le type et la valeur sont ceux de unary-expression.

Cet opérateur est associatif à droite.

Exemples :

$a = ,10         # create an unconstrained array of 1 element, $a[0],
                 # which has type int

$a = ,(10,"red") # create an unconstrained array of 1 element,
$a[0],
                 # which is an unconstrained array of 2 elements,
                 # $a[0][0] an int, and $a[0][1] a string

$a = ,,10        # create an unconstrained array of 1 element, which is
                 # an unconstrained array of 1 element, which is an int
                 # $a[0][0] is the int. Contrast this with @(@(10))

7.2.2 NOT logique

Description :

L’opérateur -not convertit la valeur désignée par unary-expression en type bool (§6.2), si nécessaire, et produit un résultat de ce type. Si la valeur de unary-expression est true, le résultat est false, et vice versa. L’opérateur ! est une autre orthographe pour -not.

Cet opérateur est associatif à droite.

Exemples :

-not $true         # False
-not -not $false   # False
-not 0             # True
-not 1.23          # False
!"xyz"             # False

7.2.3 NOT au niveau du bit

Description :

L’opérateur -bnot convertit la valeur désignée par unary-expression en un type entier (§6.4), si nécessaire. Si la valeur convertie peut être représentée dans le type int, il s’agit du type de résultat. Sinon, si la valeur convertie peut être représentée dans un type long, il s’agit du type de résultat. Dans les autres cas, l’expression est mal formée. La valeur obtenue est le complément binaire de la valeur convertie.

Cet opérateur est associatif à droite.

Exemples :

-bnot $true         # int with value 0xFFFFFFFE
-bnot 10            # int with value 0xFFFFFFF5
-bnot 2147483648.1  # long with value 0xFFFFFFFF7FFFFFFF
-bnot $null         # int with value 0xFFFFFFFF
-bnot "0xabc"       # int with value 0xFFFFF543

7.2.4 Plus unaire

Description :

Une expression de la forme +unary-expression est traitée comme si elle était écrite 0 + unary-expression (§7.7). Le littéral entier 0 est de type int.

Cet opérateur est associatif à droite.

Exemples :

+123L         # type long, value 123
+0.12340D     # type decimal, value 0.12340
+"0xabc"      # type int, value 2748

7.2.5 Moins unaire

Description :

Une expression de la forme -unary-expression est traitée comme si elle était écrite 0 - unary-expression (§7.7). Le littéral entier 0 est de type int.

Cet opérateur est associatif à droite.

Exemples :

-$true # type int, value -1 -123L # type long, value -123 -0.12340D # type decimal, value -0.12340

7.2.6 Opérateurs préfixés d’incrémentation et de décrémentation

Description :

unary-expression doit désigner un emplacement accessible en écriture ayant une valeur de type numérique (§4) ou la valeur $null. Si la valeur désignée par son unary-expression est $null, la valeur de unary-expression est convertie vers le type int et la valeur zéro avant l’évaluation de l’opérateur.

Notes

Le type de la valeur désignée par unary-expression peut changer lorsque le résultat est stocké. Pour obtenir une discussion concernant le changement de type par le biais de l’affectation, voir §7.11.

Pour l’opérateur préfixé ++, la valeur de unary-expression est incrémentée de 1 du type approprié. Le résultat est la nouvelle valeur une fois l’incrémentation effectuée. L’expression ++E équivaut à E += 1 (§7.11.2).

Pour l’opérateur préfixé --, la valeur de unary-expression est décrémentée de 1 du type approprié. Le résultat est la nouvelle valeur une fois la décrémentation effectuée. L’expression --E équivaut à E -= 1 (§7.11.2).

Ces opérateurs sont associatifs à droite.

Exemples :

$i = 0                # $i = 0
$++i                  # $i is incremented by 1
$j = --$i             # $i is decremented then $j takes on the value of $i

$a = 1,2,3
$b = 9,8,7
$i = 0;
$j = 1
$b[--$j] = $a[++$i]   # $j is # decremented, $i incremented, then $b[0]
                      # takes on the value of $a[1]

$i = 2147483647       # $i holds a value of type int
++$i                  # $i now holds a value of type double because
                      # 2147483648 is too big to fit in type int

[int]$k = 0           # $k is constrained to int
$k = [int]::MinValue  # $k is set to -2147483648
$--k                  # -2147483649 is too small to fit, imp-def behavior

$x = $null            # target is unconstrained, $null goes to [int]0
$--x                  # value treated as int, 0->-1

7.2.7 Opérateur -join unaire

Description :

L’opérateur -join unaire produit une chaîne qui est la concaténation de la valeur d’un ou plusieurs objets désignés par unary-expression. (Un séparateur peut être inséré à l’aide de la version binaire de cet opérateur (§7.8.4.4).)

unary-expression peut être une valeur scalaire ou une collection.

Exemples :

-join (10, 20, 30)             # result is "102030"
-join (123, $false, 19.34e17)  # result is "123False1.934E+18"
-join 12345                    # result is "12345"
-join $null                    # result is ""

7.2.8 Opérateur -split unaire

Description :

L’opérateur -split unaire fractionne une ou plusieurs chaînes désignées par unary-expression, et retourne leurs sous-parties dans un tableau de chaînes unidimensionnel avec contrainte. Il traite tout groupe contigu d’espaces blancs comme délimiteur entre des sous-parties successives. (Une chaîne de délimiteur explicite peut être spécifiée à l’aide de la version binaire de cet opérateur (§7.8.4.5).) Cet opérateur a deux variantes (§7.8).

Le texte du délimiteur n’est pas inclus dans les chaînes résultantes. Les espaces blancs de début et de fin dans la chaîne d’entrée sont ignorés. Une chaîne d’entrée vide ou qui contient uniquement des espaces produit un tableau à une chaîne qui est vide.

unary-expression peut désigner une valeur scalaire ou un tableau de chaînes.

Exemples :

-split " red\`tblue\`ngreen " # 3 strings: "red", "blue", "green"
-split ("yes no", "up down") # 4 strings: "yes", "no", "up", "down"
-split " " # 1 (empty) string

7.2.9 Opérateur de conversion

Description :

Cet opérateur convertit explicitement (§6) la valeur désignée par unary-expression vers le type désigné par type-literal. Si type-literal est différent de void, le type du résultat est le type nommé, et la valeur est la valeur après la conversion. Si type-literal est void, aucun objet n’est écrit dans le pipeline et il n’y a aucun résultat.

Quand une expression de tout type est castée en ce même type, le type et la valeur résultants sont le type et la valeur de unary-expression.

Cet opérateur est associatif à droite.

Exemples :

[bool]-10        # a bool with value True
[int]-10.70D     # a decimal with value -10
[int]10.7        # an int with value 11
[long]"+2.3e+3"  # a long with value 2300
[char[]]"Hello"  # an array of 5 char with values H, e, l, l, and o.

7.3 Opérateur virgule binaire

Syntaxe :

array-literal-expression:
    unary-expression
    unary-expression , new-lines~opt~ array-literal-expression

Description :

L’opérateur virgule binaire crée un tableau unidimensionnel dont les éléments sont les valeurs désignées par ses opérandes, dans l’ordre lexical. Le tableau a un type sans contrainte.

Exemples :

2,4,6                    # Length 3; values 2,4,6
(2,4),6                  # Length 2; values [object[]],int
(2,4,6),12,(2..4)        # Length 3; [object[]],int,[object[]]
2,4,6,"red",$null,$true  # Length 6

L’ajout de parenthèses de regroupement à certaines expressions de virgules binaires ne documente pas la priorité par défaut ; au lieu de cela, il modifie le résultat.

7.4 Opérateur de plage

Syntaxe :

range-expression:
array-literal-expression
range-expression *..* new-lines~opt~
array-literal-expression

Description :

Une expression de crée un tableau unidimensionnel sans contrainte dont les éléments sont les valeurs de la séquence int spécifiée par les limites de plage. Les valeurs désignées par les opérandes sont converties en int, si nécessaire (§6.4). L’opérande désignant la valeur inférieure après conversion est la limite inférieure, tandis que l’opérande désignant la valeur supérieure après conversion est la limite supérieure. Les deux limites peuvent être identiques, auquel cas le tableau résultant a une longueur égale à 1. Si l’opérande gauche désigne la limite inférieure, la séquence est triée par ordre croissant. Si l’opérande gauche désigne la limite supérieure, la séquence est triée par ordre décroissant.

D’un point de vue conceptuel, cet opérateur est un raccourci pour la séquence d’opérateurs de virgules binaires correspondante. Par exemple, la plage 5..8 peut également être générée à l’aide de 5,6,7,8. Toutefois, si une séquence croissante ou décroissante est nécessaire sans avoir de tableau, une implémentation peut éviter de générer un tableau réel. Par exemple, dans foreach ($i in 1..5) { ... }, aucun tableau n’a besoin d’être créé.

Une range-expression peut être utilisée pour spécifier une section de tableau (§9.9).

Exemples :

1..10        # ascending range 1..10
-500..-495   # descending range -500..-495
16..16       # sequence of 1

$x = 1.5
$x..5.40D    # ascending range 2..5

$true..3     # ascending range 1..3
-2..$null    # ascending range -2..0
"0xf".."0xa" # descending range 15..10

7.5 Opérateur de format

Syntaxe :

format-expression:
    range-expression
    format-expression format-operator new-lines~opt~ range-expression

format-operator:
    dash f

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Description :

Une format-expression met en forme une ou plusieurs valeurs désignées par range-expression selon une chaîne de spécification de format désignée par format-expression. Les positions des valeurs désignées par range-expression sont numérotées à partir de zéro et dans l’ordre lexical. Le résultat est de type string.

Une chaîne de spécification de format peut contenir zéro, une ou plusieurs spécifications de format, chacune ayant la forme suivante :

{N [ ,M ][ : FormatString ]}

N représente une position de valeur de range-expression (obligatoire), M représente la largeur d’affichage minimale (facultative) et FormatString indique le format (facultatif). Si la largeur d’une valeur mise en forme dépasse la largeur spécifiée, la largeur augmente en conséquence. Les valeurs dont les positions ne sont pas référencées dans FormatString sont ignorées une fois leurs effets secondaires évalués. Si N fait référence à une position inexistante, le comportement est défini par l’implémentation. Les valeurs de type $null et les valeurs void sont mises en forme en tant que chaînes vides. Les tableaux sont mis en forme comme pour sub-expression (§7.1.6). Pour inclure les caractères « { » et « } » dans une spécification de format sans qu’ils soient interprétés comme des délimiteurs de format, écrivez-les respectivement « {{ » et « }} ».

Pour obtenir une définition complète des spécifications de format, consultez le type System.IFormattable dans le rapport technique ECMA TR/84.

Exemples :

`$i` = 10; $j = 12
"{2} <= {0} + {1}\`n" -f $i,$j,($i+$j)  # 22 <= 10 + 12
">{0,3}<" -f 5                          # > 5<
">{0,-3}<" -f 5                         # >5 <
">{0,3:000}<" -f 5                      # >005<
">{0,5:0.00}<" -f 5.0                   # > 5.00<
">{0:C}<" -f 1234567.888                # >$1,234,567.89<
">{0:C}<" -f -1234.56                   # >($1,234.56)<
">{0,12:e2}<" -f 123.456e2              # > 1.23e+004<
">{0,-12:p}<" -f -0.252                 # >-25.20 % <
$format = ">{0:x8}<"
$format -f 123455                       # >0001e23f<

Dans une spécification de format, si N fait référence à une position inexistante, une FormatError est levée.

7.6 Opérateurs de multiplication

Syntaxe :

multiplicative-expression:
    format-expression
    multiplicative-expression * new-lines~opt~ format-expression
    multiplicative-expression / new-lines~opt~ format-expression
    multiplicative-expression % new-lines~opt~ format-expression

7.6.1 Multiplication

Description :

Le résultat de l’opérateur de multiplication * est le produit des valeurs désignées par les deux opérandes après que les conversions arithmétiques habituelles (§6.15) ont été appliquées.

Cet opérateur est associatif à gauche.

Exemples :

12 * -10L      # long result -120
-10.300D * 12  # decimal result -123.600
10.6 * 12      # double result 127.2
12 * "0xabc"   # int result 32976

7.6.2 Réplication de chaîne

Description :

Lorsque l’opérande gauche désigne une chaîne, l’opérateur binaire * crée une nouvelle chaîne qui contient celle désignée par l’opérande gauche, répliquée le nombre de fois désignée par la valeur de l’opérande droit telle que convertie en type entier (§6.4).

Cet opérateur est associatif à gauche.

Exemples :

"red" * "3"       # string replicated 3 times
"red" * 4         # string replicated 4 times
"red" * 0         # results in an empty string
"red" * 2.3450D   # string replicated twice
"red" * 2.7       # string replicated 3 times

7.6.3 Réplication de tableau

Description :

Lorsque l’opérande gauche désigne un tableau, l’opérateur binaire * crée un nouveau tableau unidimensionnel sans contrainte qui contient la valeur désignée par l’opérande gauche, répliquée le nombre de fois désignée par la valeur de l’opérande droit telle que convertie en type entier (§6.4). Un nombre de réplication égal à zéro produit un tableau de longueur 1. Si l’opérande gauche désigne un tableau multidimensionnel, il est aplati (§9.12) avant d’être utilisé.

Cet opérateur est associatif à gauche.

Exemples :

$a = [int[]](10,20)              # [int[]], Length 2*1
$a * "3"                         # [object[]], Length 2*3
$a * 4                           # [object[]], Length 2*4
$a * 0                           # [object[]], Length 2*0
$a * 2.3450D                     # [object[]], Length 2*2
$a * 2.7                         # [object[]], Length 2*3
(New-Object 'float[,]' 2,3) * 2  # [object[]], Length 2*2

7.6.4 Division

Description :

Le résultat de l’opérateur de division / est le quotient lorsque la valeur désignée par l’opérande gauche est divisée par la valeur désignée par l’opérande droit après que les conversions arithmétiques habituelles (§6.15) ont été appliquées.

En cas de tentative de division d’une valeur entière ou décimale par zéro, une erreur avec fin d’exécution définie par l’implémentation est déclenchée.

Cet opérateur est associatif à gauche.

Exemples :

10/-10      # int result -1
12/-10      # double result -1.2
12/-10D     # decimal result 1.2
12/10.6     # double result 1.13207547169811
12/"0xabc"  # double result 0.00436681222707424

En cas de tentative de division d’une valeur entière ou décimale par zéro, une exception RuntimeException est levée.

7.6.5 Reste

Description :

Le résultat de l’opérateur de reste % est le reste lorsque la valeur désignée par l’opérande gauche est divisée par la valeur désignée par l’opérande droit après que les conversions arithmétiques habituelles (§6.15) ont été appliquées.

En cas de tentative de division d’une valeur entière ou décimale par zéro, une erreur avec fin d’exécution définie par l’implémentation est déclenchée.

Exemples :

10 % 3          # int result 1
10.0 % 0.3      # double result 0.1
10.00D % "0x4"  # decimal result 2.00

En cas de tentative de division d’une valeur entière ou décimale par zéro, une exception RuntimeException est levée.

7.7 Opérateurs additifs

Syntaxe :

additive-expression:
    multiplicative-expression
    additive-expression + new-lines~opt~ multiplicative-expression
    additive-expression dash new-lines~opt~ multiplicative-expression

7.7.1 Addition

Description :

Le résultat de l’opérateur d’addition + est la somme des valeurs désignées par les deux opérandes après que les conversions arithmétiques habituelles (§6.15) ont été appliquées.

Cet opérateur est associatif à gauche.

Exemples :

12 + -10L       # long result 2
-10.300D + 12   # decimal result 1.700
10.6 + 12       # double result 22.6
12 + "0xabc"    # int result 2760

7.7.2 Concaténation de chaînes

Description :

Lorsque l’opérande gauche désigne une chaîne, l’opérateur binaire + crée une nouvelle chaîne qui contient la valeur désignée par l’opérande gauche, suivie immédiatement des valeurs désignées par l’opérande droit telles que converties en type chaîne (§6.8).

Cet opérateur est associatif à gauche.

Exemples :

"red" + "blue"      # "redblue"
"red" + "123"       # "red123"
"red" + 123         # "red123"
"red" + 123.456e+5  # "red12345600"
"red" + (20,30,40)  # "red20 30 40"

7.7.3 Concaténation de tableaux

Description :

Lorsque l’opérande gauche désigne un tableau, l’opérateur binaire + crée un nouveau tableau unidimensionnel sans contrainte qui contient les éléments désignés par l’opérande gauche, suivis immédiatement des valeurs désignées par l’opérande droit. Les tableaux multidimensionnels présents dans l’un ou l’autre opérande sont aplatis (§9.12) avant d’être utilisés.

Cet opérateur est associatif à gauche.

Exemples :

$a = [int[]](10,20)               # [int[]], Length 2
$a + "red"                        # [object[]], Length 3
$a + 12.5,$true                   # [object[]], Length 4
$a + (New-Object 'float[,]' 2,3)  # [object[]], Length 8
(New-Object 'float[,]' 2,3) + $a  # [object[]], Length 8

7.7.4 Concaténation de tables de hachage

Description :

Lorsque les deux opérandes désignent des tables de hachage, l’opérateur binaire + crée une nouvelle table de hachage qui contient les éléments désignés par l’opérande gauche, suivis immédiatement des éléments désignés par l’opérande droit.

Si les tables de hachage contiennent la même clé, une erreur avec fin d’exécution définie par l’implémentation est levée.

Cet opérateur est associatif à gauche.

Exemples :

$h1 = @{ FirstName = "James"; LastName = "Anderson" }
$h2 = @{ Dept = "Personnel" }
$h3 = $h1 + $h2      # new Hashtable, Count = 3

Si les tables de hachage contiennent la même clé, une exception de type BadOperatorArgument est levée.

7.7.5 Soustraction

Description :

Le résultat de l’opérateur de soustraction - est la différence lorsque la valeur désignée par l’opérande droit est soustraite de la valeur désignée par l’opérande gauche après que les conversions arithmétiques habituelles (§6.15) ont été appliquées.

Cet opérateur est associatif à gauche.

Exemples :

12 - -10L      # long result 2c
-10.300D - 12  # decimal result -22.300
10.6 - 12      # double result -1.4
12 - "0xabc"   # int result -2736

7.8 Opérateurs de comparaison

Syntaxe :

comparison-operator: one of
    dash as           dash ccontains     dash ceq
    dash cge          dash cgt           dash cle
    dash clike        dash clt           dash cmatch
    dash cne          dash cnotcontains  dash cnotlike
    dash cnotmatch    dash contains      dash creplace
    dash csplit       dash eq            dash ge
    dash gt           dash icontains     dash ieq
    dash ige          dash igt           dash ile
    dash ilike        dash ilt           dash imatch
    dash in           dash ine           dash inotcontains
    dash inotlike     dash inotmatch     dash ireplace
    dash is           dash isnot         dash isplit
    dash join         dash le            dash like
    dash lt           dash match         dash ne
    dash notcontains  dash notin         dash notlike
    dash notmatch     dash replace       dash shl
    dash shr          dash split

dash:
    - (U+002D)
    EnDash character (U+2013)
    EmDash character (U+2014)
    Horizontal bar character (U+2015)

Description :

Le type de la valeur désignée par l’opérande gauche détermine comment la valeur désignée par l’opérande droit est convertie (§6), si nécessaire, avant que la comparaison soit effectuée.

Certains comparison-operator s, (écrits ici -op) ont deux variantes, une qui respecte la casse (-c op) et une autre qui ne la respecte pas (-i op). La version -op est équivalente à -i op. Le respect de la casse est explicite uniquement avec les comparaisons de valeurs de type chaîne. Dans les contextes de comparaison de valeurs autres que des chaînes, les deux variantes se comportent de la même façon.

Ces opérateurs binaires sont associatifs à gauche.

7.8.1 Opérateurs relationnels et d’égalité

Description :

Il existe deux opérateurs d’égalité : égalité (-eq) et inégalité (-ne), et quatre opérateurs relationnels : inférieur à (-lt), inférieur ou égal à (-le), supérieur à (-gt) et supérieur ou égal à (-ge). Chacun d’entre eux a deux variantes (§7.8).

Pour que deux chaînes soient égales, elles doivent avoir la même longueur et le même contenu, et même la casse, le cas échéant.

Si la valeur désignée par l’opérande gauche n’est pas une collection, le résultat est de type bool. Dans le cas contraire, le résultat est un tableau unidimensionnel sans contrainte, éventuellement vide, contenant les éléments de la collection qui sont évalués True lorsqu’ils sont comparés à la valeur désignée par l’opérande droit.

Exemples :

10 -eq "010"           # True, int comparison
"010" -eq 10           # False, string comparison
"RED" -eq "Red"        # True, case-insensitive comparison
"RED" -ceq "Red"       # False, case-sensitive comparison
"ab" -lt "abc"         # True

10,20,30,20,10 -ne 20  # 10,30,10, Length 3
10,20,30,20,10 -eq 40  # Length 0
10,20,30,20,10 -ne 40  # 10,20,30,20,10, Length 5
10,20,30,20,10 -gt 25  # 30, Length 1
0,1,30 -ne $true       # 0,30, Length 2
0,"00" -eq "0"         # 0 (int), Length 1

7.8.2 Opérateurs d’imbrication

Description :

Il y a quatre opérateurs d’imbrication : contient (-contains), ne contient pas (‑notcontains), dans (-in) et pas dans (-notin). Chacun d’entre eux a deux variantes (§7.8).

Les opérateurs d’imbrication retournent un résultat de type bool qui indique si une valeur se produit (ou ne se produit pas) au moins une fois dans les éléments d’un tableau. Avec -contains et ‑notcontains, la valeur est désignée par l’opérande droit, et le tableau est désigné par l’opérande gauche. Avec -in et -notin, les opérandes sont inversés. La valeur est désignée par l’opérande gauche, et le tableau est désigné par l’opérande droit.

Dans le cadre de ces opérateurs, si l’opérande de tableau a une valeur scalaire, celle-ci est traitée comme un tableau d’un élément.

Exemples :

10,20,30,20,10 -contains 20     # True
10,20,30,20,10 -contains 42.9   # False
10,20,30 -contains "10"         # True
"010",20,30 -contains 10        # False
10,20,30,20,10 -notcontains 15  # True
"Red",20,30 -ccontains "RED"    # False

7.8.3 Opérateurs de conversion et de test de type

Description :

L’opérateur de type -is teste si la valeur désignée par l’opérande gauche a le type, ou est dérivée d’un type qui a le type, désigné par l’opérande droit. L’opérande droit doit désigner un type ou une valeur qui peut être convertie en un type (par exemple une chaîne qui nomme un type). Le type du résultat est bool. L’opérateur de type -isnot retourne la négation logique de la forme -is correspondante.

L’opérateur de type -as tente de convertir la valeur désignée par l’opérande gauche dans le type désigné par l’opérande droit. L’opérande droit doit désigner un type ou une valeur qui peut être convertie en un type (par exemple une chaîne qui nomme un type). Si la conversion échoue, $null est retourné ; sinon, la valeur convertie est retournée et le type de retour de ce résultat est le type au moment de l’exécution de la valeur convertie.

Exemples :

$a = 10            # value 10 has type int
$a -is [int]       # True

$t = [int]
$a -isnot $t       # False
$a -is "int"       # True
$a -isnot [double] # True

$x = [int[]](10,20)
$x -is [int[]]     # True

$a = "abcd"        # string is derived from object
$a -is [object]    # True

$x = [double]
foreach ($t in [int],$x,[decimal],"string") {
    $b = (10.60D -as $t) * 2  # results in int 22, double 21.2
}                             # decimal 21.20, and string "10.6010.60"

7.8.4 Opérateurs de manipulation de texte et critères spéciaux

7.8.4.1 Opérateurs -like et -notlike

Description :

Si l’opérande gauche ne désigne pas une collection, le résultat est de type bool. Dans le cas contraire, le résultat est un tableau unidimensionnel sans contrainte, éventuellement vide, contenant les éléments de la collection qui sont évalués True lorsqu’ils sont comparés à la valeur désignée par l’opérande droit. L’opérande droit peut désigner une chaîne qui contient des expressions génériques (§3.15). Ces opérateurs ont deux variantes (§7.8).

Exemples :

"Hello" -like "h*"                   # True, starts with h
"Hello" -clike "h*"                  # False, does not start with lowercase h
"Hello" -like "*l*"                  # True, has an l in it somewhere
"Hello" -like "??l"                  # False, no length match

"-abc" -like "[-xz]*"                # True, - is not a range separator
"#$%\^&" -notlike "*[A-Za-z]"        # True, does not end with alphabetic character
"He" -like "h[aeiou]?*"              # False, need at least 3 characters
"When" -like "*[?]"                  # False, ? is not a wildcard character
"When?" -like "*[?]"                 # True, ? is not a wildcard character

"abc","abbcde","abcgh" -like "abc*"  # object[2], values
"abc" and "abcgh"

7.8.4.2 Opérateurs -match et -notmatch

Description :

Si l’opérande gauche ne désigne pas une collection, le résultat est de type bool, et si ce résultat est $true, les éléments de la table de hachage $matches sont définis sur les chaînes qui correspondent (ou ne correspondent pas) à la valeur désignée par l’opérande droit. Dans le cas contraire, le résultat est un tableau unidimensionnel sans contrainte, éventuellement vide, contenant les éléments de la collection qui sont évalués True lorsqu’ils sont comparés à la valeur désignée par l’opérande droit, et $matches n’est pas défini. L’opérande droit peut désigner une chaîne qui contient des expressions régulières (§3.16), auquel cas elle porte le nom de pattern. Ces opérateurs ont deux variantes (§7.8).

Ces opérateurs prennent en charge les sous-correspondances (§7.8.4.6).

Exemples :

"Hello" -match ".l"                    # True, $matches key/value is 0/"el"
"Hello" -match '\^h.*o$'               # True, $matches key/value is
0/"Hello"
"Hello" -cmatch '\^h.*o$'              # False, $matches not set
"abc\^ef" -match ".\\\^e"              # True, $matches key/value is 0/"c\^e"

"abc" -notmatch "[A-Za-z]"             # False
"abc" -match "[\^A-Za-z]"              # False
"He" -match "h[aeiou]."                # False, need at least 3 characters
"abc","abbcde","abcgh" -match "abc.*"  # Length is 2, values "abc", "abcgh"

7.8.4.3 Opérateur -replace

Description :

L’opérateur -replace autorise le remplacement de texte dans une ou plusieurs chaînes désignées par l’opérande gauche à l’aide des valeurs désignées par l’opérande droit. Cet opérateur a deux variantes (§7.8). L’opérande droit a l’une des formes suivantes :

  • La chaîne à rechercher, qui peut contenir des expressions régulières (§3.16). Dans ce cas, la chaîne de remplacement est implicitement ""
  • Un tableau de deux objets contenant la chaîne à rechercher, suivie de la chaîne de remplacement

Si l’opérande gauche désigne une chaîne, le résultat est de type chaîne. Si l’opérande gauche désigne un tableau unidimensionnel de chaînes, le résultat est un tableau unidimensionnel sans contrainte, dont la longueur est identique à celle du tableau de l’opérande gauche, contenant les chaînes d’entrée une fois le remplacement terminé.

Cet opérateur prend en charge les sous-correspondances (§7.8.4.6).

Exemples :

"Analogous","an apple" -replace "a","*"      # "*n*logous","*n *pple"
"Analogous" -creplace "[aeiou]","?"          # "An?l?g??s"
"Analogous","an apple" -replace '\^a',"%%A"  # "%%Analogous","%%An apple"
"Analogous" -replace "[aeiou]",'$&$&'        # "AAnaaloogoouus"

7.8.4.4 Opérateur binaire -join

Description :

L’opérateur binaire -join produit une chaîne qui est la concaténation de la valeur d’un ou plusieurs objets désignés par l’opérande gauche après conversion en chaîne (§6.7), si nécessaire. La chaîne désignée par l’opérande droit est utilisée pour séparer les valeurs (éventuellement vides) dans la chaîne résultante.

L’opérande gauche peut être une valeur scalaire ou une collection.

Exemples :

(10, 20, 30) -join "\|"    # result is "10\|20\|30"
12345 -join ","            # result is "12345", no separator needed
($null,$null) -join "<->"  # result is "<->", two zero-length values

7.8.4.5 Opérateur binaire -split

Description :

L’opérateur binaire -split fractionne une ou plusieurs chaînes désignées par l’opérande gauche, et retourne leurs sous-parties dans un tableau de chaînes unidimensionnel avec contrainte. Cet opérateur a deux variantes (§7.8). L’opérande gauche peut désigner une valeur scalaire ou un tableau de chaînes. L’opérande droit a l’une des formes suivantes :

  • Une chaîne de délimitation
  • Un tableau de deux objets contenant une chaîne de délimitation suivie d’un nombre de fractionnements numérique
  • Un tableau de trois objets contenant une chaîne de délimitation, un nombre de fractionnements numérique et une chaîne d’options
  • Un bloc de script
  • Un tableau de deux objets contenant un bloc de script suivi d’un nombre de fractionnements numérique

La chaîne de délimitation peut contenir des expressions régulières (§3.16). Elle est utilisée pour localiser les sous-parties avec les chaînes d’entrée. Le délimiteur n’est pas inclus dans les chaînes résultantes. Si l’opérande gauche désigne une chaîne vide, il en résulte un élément de chaîne vide. Si la chaîne de délimitation est une chaîne vide, elle se trouve à chaque position de caractère dans les chaînes d’entrée.

Par défaut, toutes les sous-parties des chaînes d’entrée sont placées dans le résultat sous forme d’éléments distincts. Toutefois, le nombre de fractionnements peut être utilisé pour modifier ce comportement. Si ce nombre est négatif, égal à zéro, ou supérieur ou égal au nombre de sous-parties dans une chaîne d’entrée, chaque sous-section va dans un élément distinct. Si ce nombre est inférieur au nombre de sous-parties dans la chaîne d’entrée, il y a des éléments de décompte dans le résultat, l’élément final contenant toutes les sous-parties au-delà des premières décompte - 1 sous-parties.

Une chaîne d’options contient zéro, un ou plusieurs noms d’options, chaque paire adjacente étant séparée par une virgule. Les espaces blancs de début, de fin et incorporés sont ignorés. Les noms d’options peuvent être dans n’importe quel ordre, et ils respectent la casse.

Si une chaîne d’options contient le nom d’option SimpleMatch, elle peut également contenir le nom d’option ignoreCase. Si une chaîne d’options contient le nom d’option RegexMatch, ou si elle ne contient ni RegexMatch ni SimpleMatch, elle peut contenir n’importe quel nom d’option, sauf SimpleMatch. Toutefois, elle ne doit pas contenir à la fois Multiline et Singleline.

Voici l’ensemble des noms d’options :

Option Description
CultureInvariant Ignore les différences culturelles dans la langue lors de l’évaluation du délimiteur.
ExplicitCapture Ignore les groupes de correspondances non nommés afin que seuls les groupes de capture explicites soient retournés dans la liste de résultats.
IgnoreCase Force la mise en correspondance qui ne respecte pas la casse, même si -csplit est utilisé.
IgnorePatternWhitespace Ignore les espaces blancs sans séquence d’échappement et les commentaires marqués avec le signe dièse (#).
Multiline Ce mode reconnaît le début et la fin des lignes et des chaînes. Le mode par défaut est Singleline.
RegexMatch Utilise la mise en correspondance d’expression régulière pour évaluer le délimiteur. Il s’agit de la valeur par défaut.
SimpleMatch Utilise une comparaison de chaînes simple lors de l’évaluation du délimiteur.
Singleline Ce mode ne reconnaît que le début et la fin des chaînes. Il s'agit du mode par défaut.

Le bloc de script (§7.1.8) spécifie les règles de détermination du délimiteur, et doit correspondre au type bool.

Exemples :

"one,forty two,," -split ","              # 5 strings: "one" "forty two" "" ""

"abc","de" -split ""                      # 9 strings: "" "a" "b" "c" "" "" "d" "e" ""

"ab,cd","1,5,7,8" -split ",", 2           # 4 strings: "ab" "cd" "1" "5,7,8"

"10X20x30" -csplit "X", 0, "SimpleMatch"  # 2 strings: "10" "20x30"

"analogous" -split "[AEIOU]", 0, "RegexMatch, IgnoreCase"
                                          # 6 strings: "" "n" "l" "g" "" "s"

"analogous" -split { $_ -eq "a" -or $_ -eq "o" }, 4
                                          # 4 strings: "" "n" "l" "gous"

7.8.4.6 Sous-correspondances

Le pattern mis en correspondance par -match, -notmatch et -replace peut contenir des sous-parties (appelées sous-correspondances) délimitées par des parenthèses. Prenons l’exemple suivant :

"red" -match "red"

Le résultat est $true, et la clé 0 de $matches contient « red », cette partie de la chaîne désignée par l’opérande gauche qui correspond exactement au pattern désigné par l’opérande droit.

Dans l’exemple suivant, le pattern entier est une sous-correspondance :

"red" -match "(red)"

Comme précédemment, la clé 0 contient « red ». Toutefois, la clé 1 contient également « red », qui est la partie de la chaîne désignée par l’opérande gauche qui correspond exactement à la sous-correspondance.

Considérez le pattern suivant, plus complexe :

"red" -match "((r)e)(d)"

Ce pattern autorise les sous-correspondances de « r », « re », « d » ou « red ».

Là encore, la clé 0 contient « red ». La clé 1 contient « re », la clé 2 contient « r » et la clé 3 contient « d ». Les paires clé/valeur sont dans l’ordre de correspondance de gauche à droite dans le pattern, les correspondances de chaînes plus longues précédant les plus courtes.

Dans le cas de -replace, le texte de remplacement peut accéder aux sous-correspondances via les noms de la forme $n, où la première correspondance est $1, la seconde est $3 et ainsi de suite. Par exemple,

"Monday morning" -replace '(Monday|Tuesday) (morning|afternoon|evening)','the $2 of $1'

La chaîne obtenue est « the morning of Monday ».

Au lieu que les clés dans $matches soient des index de base zéro, les sous-correspondances peuvent être nommées à l’aide de la forme ?<*name*>. Par exemple, "((r)e)(d)" peut être écrit avec trois sous-correspondances nommées, m1, m2 et m3, comme suit : "(?<m1>(?<m2>r)e)(?<m3>d)".

7.8.5 Opérateurs de décalage

Description :

L’opérateur de décalage vers la gauche (-shl) et l’opérateur de décalage vers la droite (-shr) convertissent la valeur désignée par l’opérande gauche en un type entier et la valeur désignée par l’opérande droit en int, si nécessaire, à l’aide des conversions arithmétiques habituelles (§6.15).

L’opérateur de décalage vers la gauche décale l’opérande gauche vers la gauche d’un nombre de bits calculés comme décrit ci-dessous. Les positions de bits vides de poids faible sont définies sur zéro.

L’opérateur de décalage vers la droite décale l’opérande gauche vers la droite d’un nombre de bits calculés comme décrit ci-dessous. Les bits de poids faible de l’opérande gauche sont ignorés, et les bits restants sont décalés vers la droite. Lorsque l’opérande gauche est une valeur signée, les positions de bits vides de poids fort prennent la valeur zéro si l’opérande gauche n’est pas négatif, et prennent la valeur un si l’opérande gauche est négatif. Lorsque l’opérande gauche est une valeur non signée, les positions de bits vides de poids fort sont définies sur zéro.

Lorsque l’opérande gauche est de type int, le chiffre du décalage est donné par les cinq bits de poids faible de l’opérande droit. Lorsque l’opérande droit est de type long, le chiffre du décalage est donné par les six bits de poids faible de l’opérande droit.

Exemples :

0x0408 -shl 1             # int with value 0x0810
0x0408 -shr 3             # int with value 0x0081
0x100000000 -shr 0xfff81  # long with value 0x80000000

7.9 Opérateurs au niveau du bit

Syntaxe :

bitwise-expression:
    comparison-expression
    bitwise-expression -band new-lines~opt~ comparison-expression
    bitwise-expression -bor new-lines~opt~ comparison-expression
    bitwise-expression -bxor new-lines~opt~ comparison-expression

Description :

L’opérateur AND au niveau du bit -band, l’opérateur OR au niveau du bit -bor et l’opérateur XOR au niveau du bit -bxor convertissent les valeurs désignées par leurs opérandes en types entiers, si nécessaire, à l’aide des conversions arithmétiques habituelles (§6.15). Après la conversion, si les deux valeurs sont de type int, le résultat est de type int. Autrement, si les deux valeurs sont de type long, le résultat est de type long. Si une valeur est de type int et l’autre de type long, le résultat est de type long. Dans les autres cas, l’expression est mal formée. Le résultat est l’opération AND, OR ou XOR au niveau du bit, respectivement, des valeurs d’opérande éventuellement converties.

Ces opérateurs binaires sont associatifs à gauche. Ils sont commutatifs si aucun des opérandes ne contient d’effet secondaire.

Exemples :

0x0F0F -band 0xFE    # int with value 0xE
0x0F0F -band 0xFEL   # long with value 0xE
0x0F0F -band 14.6    # long with value 0xF

0x0F0F -bor 0xFE     # int with value 0xFFF
0x0F0F -bor 0xFEL    # long with value 0xFFF
0x0F0F -bor 14.40D   # long with value 0xF0F

0x0F0F -bxor 0xFE    # int with value 0xFF1
0x0F0F -bxor 0xFEL   # long with value 0xFF1
0x0F0F -bxor 14.40D  # long with value 0xF01
0x0F0F -bxor 14.6    # long with value 0xF00

7.10 Opérateurs logiques

Syntaxe :

logical-expression:
    bitwise-expression
    logical-expression -and new-lines~opt~ bitwise-expression
    logical-expression -or new-lines~opt~ bitwise-expression
    logical-expression -xor new-lines~opt~ bitwise-expression

Description :

L’opérateur AND logique -and convertit les valeurs désignées par ses opérandes en bool, si nécessaire (§6.2). Le résultat est le AND logique des valeurs d’opérande éventuellement converties, et il est de type bool. Si l’opérande gauche est évalué comme False, l’opérande droit n’est pas évalué.

L’opérateur OR logique -or convertit les valeurs désignées par ses opérandes en bool, si nécessaire (§6.2). Le résultat est le OR logique des valeurs d’opérande éventuellement converties, et il est de type bool. Si l’opérande gauche est évalué comme True, l’opérande droit n’est pas évalué.

L’opérateur XOR logique -xor convertit les valeurs désignées par ses opérandes en bool (§6.2). Le résultat est le XOR logique des valeurs d’opérande éventuellement converties, et il est de type bool.

Ces opérateurs binaires sont associatifs à gauche.

Exemples :

$j = 10
$k = 20
($j -gt 5) -and (++$k -lt 15)   # True -and False -> False
($j -gt 5) -and ($k -le 21)     # True -and True -> True
($j++ -gt 5) -and ($j -le 10)   # True -and False -> False
($j -eq 5) -and (++$k -gt 15)   # False -and True -> False

$j = 10
$k = 20
($j++ -gt 5) -or (++$k -lt 15)  # True -or False -> True
($j -eq 10) -or ($k -gt 15)     # False -or True -> True
($j -eq 10) -or (++$k -le 20)   # False -or False -> False

$j = 10
$k = 20
($j++ -gt 5) -xor (++$k -lt 15) # True -xor False -> True
($j -eq 10) -xor ($k -gt 15)    # False -xor True -> True
($j -gt 10) -xor (++$k -le 25)  # True -xor True -> False

7.11 Opérateurs d’assignation

Syntaxe :

assignment-expression:
    expression assignment-operator statement

assignment-operator: *one of
    =   dash =   +=   *=   /=   %=

Description :

Un opérateur d’assignation stocke une valeur à l’emplacement accessible en écriture désigné par expression. Pour obtenir une description d’assignment-operator =, voir §7.11.1. Pour plus d’informations sur tous les autres assignment-operator s, voir §7.11.2.

Une expression d’assignation a la valeur désignée par expression après que l’assignation a eu lieu ; toutefois, cette expression d’assignation ne désigne pas elle-même un emplacement accessible en écriture. Si expression est de type contraint (§5.3), le type utilisé dans cette contrainte est le type du résultat. Dans le cas contraire, le type du résultat est le type après l’application des conversions arithmétiques habituelles (§6.15).

Cet opérateur est associatif à droite.

7.11.1 Assignation simple

Description :

Dans une assignation simple (=), la valeur désignée par statement remplace la valeur stockée à l’emplacement accessible en écriture désigné par expression. Toutefois, si expression désigne une clé inexistante dans une table de hachage, cette clé est ajoutée à la table de hachage avec une valeur associée de la valeur désignée par statement.

Comme le montre la grammaire, expression peut désigner une liste séparée par des virgules d’emplacements accessibles en écriture. C’est ce que l’on appelle l’assignation multiple. statement désigne une liste d’une ou plusieurs valeurs séparées par des virgules. Les virgules de la liste de l’un ou l’autre opérande font partie de la syntaxe d’assignation multiple, et ne représentent pas l’opérateur virgule binaire. Les valeurs sont extraites de la liste désignée par statement, dans l’ordre lexical, et stockées à l’emplacement accessible en écriture correspondant désigné par expression. Si la liste désignée par statement a moins de valeurs qu’il n’y a d’emplacements expression accessibles en écriture, les emplacements excédentaires prennent la valeur $null. Si la liste désignée par statement a plus de valeurs qu’il n’y a d’emplacements expression accessibles en écriture, tous sauf l’emplacement expression le plus à droite prennent la valeur statement correspondante, et l’emplacement expression le plus à droite devient un tableau unidimensionnel sans contrainte avec toutes les valeurs statement restantes en tant qu’éléments.

Pour les énoncés qui ont des valeurs (§8.1.2), statement peut être un énoncé.

Exemples :

$a = 20; $b = $a + 12L             # $b has type long, value 22
$hypot = [Math]::Sqrt(3*3 + 4*4)   # type double, value 5
$a = $b = $c = 10.20D              # all have type decimal, value 10.20
$a = (10,20,30),(1,2)              # type [object[]], Length 2
[int]$x = 10.6                     # type int, value 11
[long]$x = "0xabc"                 # type long, value 0xabc
$a = [float]                       # value type literal [float]
$i,$j,$k = 10,"red",$true          # $i is 10, $j is "red", $k is True
$i,$j = 10,"red",$true             # $i is 10, $j is [object[]], Length 2
$i,$j = (10,"red"),$true           # $i is [object[]], Length 2, $j is True
$i,$j,$k = 10                      # $i is 10, $j is $null, $k is $null

$h = @{}
[int] $h.Lower, [int] $h.Upper = -split "10 100"

$h1 = @{ FirstName = "James"; LastName = "Anderson"; IDNum = 123 }
$h1.Dept = "Finance"               # adds element Finance
$h1["City"] = "New York"           # adds element City

[int]$Variable:v = 123.456         # v takes on the value 123
${E:output.txt} = "a"              # write text to the given file
$Env:MyPath = "x:\data\file.txt"   # define the environment variable
$Function:F = { param ($a, $b) "Hello there, $a, $b" }
F 10 "red"                         # define and invoke a function
function Demo { "Hi there from inside Demo" }
$Alias:A = "Demo"                  # create alias for function Demo
A                                  # invoke function Demo via the alias

7.11.2 Assignation composée

Description :

Une assignation composée se présente sous la forme E1 op= E2 et est équivalente à l’expression d’assignation simple E1 = E1 op (E2), sauf que dans le cas d’une assignation composée, l’expression E1 n’est évaluée qu’une seule fois. Si expression est de type contraint (§5.3), le type utilisé dans cette contrainte est le type du résultat. Dans le cas contraire, le type du résultat est déterminé par op. Pour *=, voir §7.6.1, §7.6.2, §7.6.3 ; pour /=, voir §7.6.4 ; pour %=, voir §7.6.5 ; pour +=, voir §7.7.1, §7.7.2, §7.7.3 ; pour -=, voir §7.7.5.

Notes

Un opérande désignant une valeur sans contrainte de type numérique peut avoir son type modifié par un opérateur d’assignation lorsque le résultat est stocké.

Exemples :

$a = 1234; $a *= (3 + 2)  # type is int, value is 1234 * (3 + 2)
$b = 10,20,30             # $b[1] has type int, value 20
$b[1] /= 6                # $b[1] has type double, value 3.33...

$i = 0
$b = 10,20,30
$b[++$i] += 2             # side effect evaluated only once

[int]$Variable:v = 10     # v takes on the value 10
$Variable:v -= 3          # 3 is subtracted from v

${E:output.txt} = "a"     # write text to the given file
${E:output.txt} += "b"    # append text to the file giving ab
${E:output.txt} *= 4      # replicate ab 4 times giving abababab

7.12 Opérateurs de redirection

Syntaxe :

pipeline:
    assignment-expression
    expression redirections~opt~ pipeline-tail~opt~
    command verbatim-command-argument~opt~ pipeline-tail~opt~

redirections:
    redirection
    redirections redirection

redirection:
    merging-redirection-operator
    file-redirection-operator redirected-file-name

redirected-file-name:
    command-argument
    primary-expression

file-redirection-operator: one of
    >   >>   2>   2>>   3>   3>>   4>   4>>
    5>  5>>  6>   6>>   >    >>    <

merging-redirection-operator: one of
    >&1   2>&1   3>&1   4>&1   5>&1   6>&1
    >&2   1>&2   3>&2   4>&2   5>&2   6>&2

Description :

L’opérateur de redirection > prend la sortie standard du pipeline et la redirige vers l’emplacement désigné par redirected-file-name, en remplaçant le contenu actuel de cet emplacement.

L’opérateur de redirection >> prend la sortie standard du pipeline et la redirige vers l’emplacement désigné par redirected-file-name, en ajoutant au contenu actuel de cet emplacement, le cas échéant. Si cet emplacement n’existe pas, il est créé.

L’opérateur de redirection de la forme n> prend la sortie du flux n du pipeline et la redirige vers l’emplacement désigné par redirect-file-name, en remplaçant le contenu actuel de cet emplacement.

L’opérateur de redirection de la forme n>> prend la sortie du flux n du pipeline et la redirige vers l’emplacement désigné par redirect-file-name, en ajoutant au contenu actuel de cet emplacement, le cas échéant. Si cet emplacement n’existe pas, il est créé.

L’opérateur de redirection de la forme m>&n écrit la sortie du flux m au même emplacement que le flux n.

Les flux valides sont les suivants :

STREAM Description
1 Flux de sortie standard
2 Flux de sortie d’erreur
3 Flux de sortie d’avertissement
4 Flux de sortie détaillé
5 Flux de sortie de débogage
* Flux de sortie standard, sortie d’erreur, sortie d’avertissement, sortie détaillée et sortie de débogage

Les opérateurs de redirection 1>&2, 6>, 6>> et < sont réservés pour une utilisation ultérieure.

Si, à la sortie, la valeur de redirection-file-name est $null, la sortie est ignorée.

En règle générale, la valeur d’une expression contenant un effet secondaire de niveau supérieur n’est pas écrite dans le pipeline, à moins que cette expression soit placée entre parenthèses. Toutefois, si une telle expression est l’opérande gauche d’un opérateur qui redirige la sortie standard, la valeur est écrite.

Exemples :

$i = 200                       # pipeline gets nothing
$i                             # pipeline gets result
$i > output1.txt               # result redirected to named file
++$i >> output1.txt            # result appended to named file
type file1.txt 2> error1.txt   # error output redirected to named file
type file2.txt 2>> error1.txt  # error output appended to named file
dir -Verbose 4> verbose1.txt   # verbose output redirected to named file

# Send all output to output2.txt
dir -Verbose -Debug -WarningAction Continue *> output2.txt

# error output redirected to named file, verbose output redirected
# to the same location as error output
dir -Verbose 4>&2 2> error2.txt