7. Expressions

Article
01/10/2025

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.

Syntaxe:

expression:
    primary-expression
    bitwise-expression
    logical-expression
    comparison-expression
    additive-expression
    multiplicative-expression

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

dashdash:
    dash dash

Description:

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

Le chiffre "123" est une expression qui désigne la valeur "int" 123.
L’expression 1,2,3,4 désigne l’objet tableau de 4 é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 éléments.

À l’exception de 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 comportement non spécifié : $i++ + $i, $i + --$iet $w[$j++] = $v[$j].

Une implémentation de PowerShell peut prendre en charge les types définis par l’utilisateur, et ces types peuvent avoir des opérations définies sur eux. 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 plus grande. Si une expression de niveau supérieur contient un opérateur d’effet secondaire, la valeur de cette expression n’est pas écrite dans le pipeline ; sinon, elle l'est. Consultez §7.1.1 pour obtenir une discussion détaillée sur ce sujet.

En règle générale, une expression qui désigne une collection ([§4§4]) est énumérée dans ses éléments constituants 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 en trois valeurs int, plus la int 99. Toutefois, dans le troisième cas, l’expression est un appel direct à une applet de commande, de sorte que le résultat n’est 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 op_<operation> correspondante.

7.1 Expressions principales

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 parenthèses. Si l’expression désigne une variable, l’expression entre parenthèses désigne cette même variable. Par exemple, $x.m et ($x).m sont équivalents.

Les parenthèses de regroupement peuvent être utilisées dans une expression pour documenter la priorité par défaut et l’associativité au sein de cette expression. Ils peuvent également être utilisés pour remplacer cette priorité par défaut et l’associativité. 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 deuxième cas, les parenthèses modifient la sémantique, ce qui entraîne un tableau dont deux éléments sont un tableau de 2 ints et l’int 6 scalaire.

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 les premier et 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 l’écriture de la valeur, car * n’est pas un opérateur d’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, placez 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, nous avons une substitution de variable (§2.3.5.2) qui se déroule dans une chaîne littérale :

">$($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 sûr, 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 d’effet secondaire 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

Considérez l’exemple suivant qui a deux effets secondaires, dont aucun n’est au 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:
    primary-expression . new-line~opt~ member-name
    primary-expression :: new-line~opt~ member-name

Notez qu’aucun espace blanc n’est autorisé après d’expression primaire.

Description:

L’opérateur . est utilisé pour sélectionner un membre d’instance à partir d’un objet ou une clé à partir 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 de droite 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 dans 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 de droite 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 de droite 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:
    primary-expression . new-line~opt~ member-name argument-list
    primary-expression :: new-line~opt~ member-name argument-list

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

Notez qu’aucun espace blanc n’est autorisé après d’expression primaire.

Description:

Une expression d'invocation appelle la méthode désignée par primary-expression.member-name ou primary-expression::member-name. Les parenthèses dans liste d’arguments contiennent une liste éventuellement vide et séparée par des virgules d’expressions qui désignent les arguments dont les valeurs sont passées à la méthode. Avant l’appel de la méthode, les arguments sont évalués et convertis conformément aux règles de §6, le cas échéant, pour correspondre aux types attendus par la méthode. L'ordre d’évaluation de primary-expression.member-name, primary-expression::member-nameet 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

Accès aux éléments 7.1.4

Syntaxe:

element-access:
    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 1 dimensionnel, consultez §7.1.4.5.

Lorsque expression primaire désigne un tableau à 1 dimension A, l’opérateur [] retourne l’élément situé à A[0 + expression] après la conversion de la valeur de expression 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 1 dimensionnel, les positions négatives n’ont aucune signification particulière.

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

Si un accès en lecture sur un élément non existant est tenté, 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 3 dimensions $a, 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]

Si un accès en écriture à un élément non existant est tenté, une exception IndexOutOfRange est levée.

7.1.4.2 Mise en indice d’une chaîne

Description:

Lorsque expression primaire désigne une chaîne S, l’opérateur [] retourne le caractère situé à la position de base zéro indiquée par expression, en tant que char. 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 expression primaire désigne une table de hachage, l’opérateur [] retourne la ou 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 a ce type, sauf si aucune clé de ce type n’existe, auquel cas, le résultat est $null. Si $null est utilisé comme clé, le comportement dépend de 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 expression primaire 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 ayant le nom spécifié par expression. Le type d’expression doit être 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. Si aucun élément enfant n’existe 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 expression primaire désigne un objet d’un type énumérable (§4) ou d’une table de hachage, et expression est un tableau à 1 dimension, le résultat est une tranche de tableau (§9.9) contenant les éléments de expression primaire désignées par les éléments de expression.

Dans le cas d’une table de hachage, la tranche de tableau contient les valeurs associées aux clés fournies, sauf si aucune clé de ce type n’existe, auquel cas, l’élément correspondant est $null. Si $null est utilisé comme nom de clé, le comportement dépend de 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[,5]                    # slice with Length 1
$a[@()]                   # slice with Length 0
$a[-1..-3]                # slice with Length 3, 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 2 ($null/123)

Windows PowerShell : lorsque l'expression est une collection de deux noms de clés ou plus, si $null est utilisé comme nom de clé, ce nom de clé est ignoré 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

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 en type int et valeur zéro avant l’évaluation de l’opérateur. Le type de la valeur désignée par d’expression primaire peut changer lorsque le résultat est stocké. Consultez §7.11 pour une discussion sur le changement de type via l’affectation.

Le résultat produit par l'opérateur postfixé ++ est la valeur désignée par l'opérande. Une fois ce résultat obtenu, la valeur désignée par l’opérande est incrémentée par 1 du type approprié. Le type du résultat de l’expression E++ est identique au résultat de l’expression E + 1 (§7.7).

Le résultat produit par l'opérateur postfix -- est la valeur désignée par l'opérande. Une fois ce résultat obtenu, la valeur désignée par l’opérande est décrémentée par 1 du type approprié. Le type du résultat de l’expression E-- est identique au 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 behavior

$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 ; sinon, le résultat est le tableau 1 dimensionnel nonconstrainé 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:

bloc de paramètres est décrit dans §8.10.9. named-block-list est décrit dans §8.10.7.

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

La liste de blocs nommée ou la liste d’instructions est exécutée et les types et les valeurs des résultats sont les types et les valeurs des résultats de ces ensembles 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, consultez §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, sauf le type Null. Les valeurs associées peuvent avoir n’importe quel type, y compris le type Null, et chacune de ces valeurs peut être n’importe quelle 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 un 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 contraint par 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 d’un paramètre de fonction (§8.10.2)

Exemples:

[int].IsPrimitive        # $true
[Object[]].FullName      # "System.Object[]"
[int[,,]].GetArrayRank() # 3

Un type de pile générique (§4.4) spécialisé pour contenir des chaînes peut être écrit en tant que [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 en tant que [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

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

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

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

cast-expression:
    type-literal unary-expression

dashdash:
    dash dash

7.2.1 Opérateur de virgule unaire

Description:

L’opérateur de virgule (,) crée un tableau sans contrainte ayant un élément, dont le type et la valeur sont ceux d'expression unaire.

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

Syntaxe:

logical-not-operator:
    dash not

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

Description:

L’opérateur -not convertit la valeur désignée par expression unaire 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

Syntaxe:

bitwise-not-operator:
    dash bnot

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

Description:

L’opérateur -bnot convertit la valeur désignée par expression unaire en 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 le type long il s’agit du type de résultat. Sinon, 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 en tant que 0 + unary-expression (§7.7). Le littéral entier 0 a le 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 en tant que 0 - unary-expression (§7.7). Le littéral entier 0 a le type int. L’opérateur moins peut être l’un des caractères dash listés dans §7.2.

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 d’incrémentation et de décrémentation de préfixe

Description:

L'expression unaire doit désigner un emplacement accessible en écriture avec une valeur de type numérique (§4) ou la valeur $null. Si la valeur désignée par son expression unaire est , la valeur de l'expression unaireest convertie en type int avec la valeur zéro avant que l’opérateur soit évalué.

Remarque

Le type de la valeur désignée par d’expression unaire peut changer lorsque le résultat est stocké. Consultez §7.11 pour une discussion sur le changement de type via l’affectation.

Pour l’opérateur d’incrément de préfixe ++, la valeur de d’expression unaire est incrémentée par 1 du type approprié. Le résultat est la nouvelle valeur après l’incrémentation. L’expression ++E équivaut à E += 1 (§7.11.2).

Pour l’opérateur de décrémentation de préfixe -- , la valeur de d’expression unaire est décrémentée par 1 du type approprié. Le résultat est la nouvelle valeur après la décrémentation. L’expression --E équivaut à E -= 1 (§7.11.2). L’opérateur de décrémentation de préfixe peut être l’un des modèles correspondant au modèle dashdash dans §7.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 becomes -1

7.2.7 Opérateur -join unaire

Syntaxe:

join-operator:
    dash join

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

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 expression unaire. (Un séparateur peut être inséré à l’aide de la version binaire de cet opérateur (§7.8.4.4).)

expression unaire 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

Syntaxe:

split-operator:
    dash split

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

Description:

L’opérateur unaire -split fractionne une ou plusieurs chaînes désignées par l’expression unaire , renvoyant leurs sous-parties dans un tableau de chaînes unidimensionnel limité. Il traite tout groupe contigu de caractères d’espace blanc comme séparateur entre les 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) ou de ses deux variantes (§7.8).

Le texte délimiteur n’est pas inclus dans les chaînes résultantes. L’espace blanc de début et de fin dans la chaîne d’entrée est ignoré. Une chaîne d'entrée qui est vide ou ne contient que des espaces blancs résulte en un tableau contenant une seule chaîne vide.

expression unaire 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 l'expression unaire au type désigné par le littéral de type (§7.1.10). 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.

Lorsqu'une expression de n'importe quel type est convertie en ce même type, le type et la valeur résultants sont ceux de l'expression unairede .

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 de virgule binaire

Syntaxe:

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

Description:

L’opérateur de virgule binaire crée un tableau 1 dimensionnel 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 virgule binaire 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:
    unary-expression .. new-lines~opt~ unary-expression

Description:

Une expression de plage crée un tableau 1 dimensionnel 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 la conversion est la limite inférieure, tandis que l’opérande désignant la valeur supérieure après la conversion est la limite supérieure . Les deux limites peuvent être identiques, auquel cas, le tableau résultant a une longueur 1. Si l’opérande gauche désigne la limite inférieure, la séquence est dans l’ordre croissant. Si l’opérande gauche désigne la limite supérieure, la séquence est dans l’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 ascendante 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 expression de portée peut être utilisée pour spécifier une tranche de tableau (§9.9).

Exemples:

1..10        # ascending range 1..10
-495..-500   # descending range -495..-500
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:
    format-specification-string 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 d’expression de plage sont numérotées à partir de zéro et augmentent dans l’ordre lexical. Le résultat a le type string.

Une chaîne de spécification de format peut contenir zéro ou plusieurs spécifications de format chacune ayant le formulaire suivant :

{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 est augmentée en conséquence. Les valeurs dont les positions ne sont pas référencées dans FormatString sont ignorées après avoir été évaluées pour les effets secondaires. Si N fait référence à une position inexistante, le comportement dépend de l'implémentation. La valeur de type $null et void est mise en forme sous forme de chaînes vides. Les tableaux sont mis en forme comme pour sous-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 en tant que {{ et }}, respectivement.

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

Exemples:

"__{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 % __

$i = 5; $j = 3
"__{0} + {1} <= {2}__" -f $i,$j,($i+$j)  # __5 + 3 <= 8__

$format = "__0x{0:X8}__"
$format -f 65535                         # __0x0000FFFF__

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

7.6 Opérateurs multiplicatifs

Syntaxe:

multiplicative-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 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

Réplication de chaîne 7.6.2

Description:

Lorsque l’opérande gauche désigne une chaîne, l’opérateur binaire * crée une nouvelle chaîne contenant celle désignée par l’opérande gauche, répétée un nombre de fois déterminé par la valeur de l’opérande droit après avoir été convertie en un 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 de gauche désigne un tableau, l’opérateur binaire de * crée un tableau à une dimension non contraint qui contient la valeur désignée par l’opérande de gauche, répliquée le nombre de fois spécifié par la valeur de l’opérande de droite telle qu’elle est convertie en type entier (§6.4). Un nombre de réplications égal à zéro entraîne un tableau de longueur 1. Si l’opérande gauche désigne un tableau multidimensionnel, il est aplatit (§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 les conversions arithmétiques habituelles (§6.15) ont été appliquées.

Si une tentative d’exécution d’une division entière ou décimale par zéro est effectuée, une erreur de fin définie par l’implémentation est généré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

Si une tentative est effectuée pour effectuer une division 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 restant % 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 les conversions arithmétiques habituelles (§6.15) ont été appliquées.

Si une tentative d’exécution d’une division entière ou décimale par zéro est effectuée, une erreur de fin définie par l’implémentation est générée.

Exemples:

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

Si une tentative est effectuée pour effectuer une division entière ou décimale par zéro, une exception RuntimeException est levée.

7.7 Opérateurs additifs

Syntaxe:

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

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

7.7.1 Ajout

Description:

Le résultat de l’opérateur d’ajout + est la somme des valeurs désignées par les deux opérandes après 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îne

Description:

Lorsque l’opérande de gauche désigne une chaîne, l’opérateur de + binaire crée une chaîne qui contient la valeur désignée par l’opérande de gauche suivie immédiatement par la ou les valeurs désignées par l’opérande droit comme étant convertie en chaîne de type (§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 de gauche désigne un tableau, l’opérateur de + binaire crée un tableau unidimensionnel sans contrainte qui contient les éléments désignés par l’opérande gauche suivi immédiatement par les 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 de + binaire crée une table de hachage qui contient les éléments désignés par l’opérande gauche suivis immédiatement par les éléments désignés par l’opérande droit.

Si les tables de hachage contiennent la même clé, une erreur de fin définie par l’implémentation est généré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 les conversions arithmétiques habituelles (§6.15) ont été appliquées. L’opérateur de soustraction peut être l’un des caractères dash listés dans §7.7.

Cet opérateur est associatif à gauche.

Exemples:

12 - -10L      # long result 22
-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-expression:
    primary-expression comparison-operator new-lines~opt~ expression

comparison-operator:
    equality-operator
    relational-operator
    containment-operator
    type-operator
    like-operator
    match-operator

Description:

Le type de la valeur désignée par l’opérande gauche détermine la façon dont la valeur désignée par l’opérande droit est convertie (§6), si nécessaire, avant la comparaison.

Certains opérateurs de comparaison ont deux variantes, l’une sensible à la casse (-c<operator>), et l’autre non sensible à la casse (-i<operator>). La version -<operator> équivaut à -i<operator>. Le respect de la casse est explicite uniquement avec les comparaisons de valeurs de type chaîne. Dans les contextes de comparaison non-chaîne, les deux variantes se comportent de la même façon.

Ces opérateurs binaires sont associatifs à gauche.

7.8.1 Opérateurs d’égalité et de relation

Syntaxe:

equality-operator: one of
    dash eq     dash ceq    dash ieq
    dash ne     dash cne    dash ine

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

relational-operator: one of
    dash lt     dash clt    dash ilt
    dash le     dash cle    dash ile
    dash gt     dash cgt    dash igt
    dash ge     dash cge    dash ige

Description:

Il existe deux opérateurs d’égalité : l’égalité (-eq) et l’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’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 a le 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 de confinement

Syntaxe:

containment-operator: one of
    dash contains       dash ccontains      dash icontains
    dash notcontains    dash cnotcontains   dash inotcontains
    dash in             dash cin            dash iin
    dash notin          dash cnotin         dash inotin

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

Description:

Il existe quatre opérateurs de confinement : contains (-contains), does-not-contains (-notcontains), in (-in) et not-in (-notin). Chacun d’eux a deux variantes (§7.8).

Les opérateurs de confinement 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.

Pour les besoins de ces opérateurs, si l’opérande de tableau a une valeur scalaire, la valeur scalaire 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
"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 test et de conversion de type

Syntaxe:

type-operator: one of
    dash is
    dash as

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

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 du formulaire de -is correspondant.

L’opérateur de type -as tente de convertir la valeur désignée par l’opérande gauche en 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ée ; sinon, la valeur convertie est retournée et le type de retour de ce résultat est le type d’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 correspondance de modèles et de manipulation de texte

7.8.4.1 Les opérateurs -like et -notlike

Syntaxe:

like-operator: one of
    dash like       dash clike      dash ilike
    dash notlike    dash cnotlike   dash inotlike

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

Description:

Si l’opérande gauche ne désigne pas une collection, le résultat a le 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 Les opérateurs -match et -notmatch

Syntaxe:

match-operator: one of
    dash match      dash cmatch     dash imatch
    dash notmatch   dash cnotmatch  dash inotmatch

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

Description:

Si l’opérande gauche ne désigne pas une collection, le résultat a un 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 L’opérateur -replace

Syntaxe:

binary-replace-operator: one of
    dash replace    dash creplace   dash ireplace

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

Description:

L’opérateur -replace autorise le remplacement du 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 :

Chaîne à localiser, qui peut contenir des expressions régulières (§3.16). Dans ce cas, la chaîne de remplacement est implicitement « ».
Tableau de 2 objets contenant la chaîne à localiser, suivi de la chaîne de remplacement.

Si l’opérande gauche désigne une chaîne, le résultat a le type chaîne. Si l’opérande gauche désigne un tableau de chaînes à 1 dimension, le résultat est un tableau 1 dimensionnel sans contrainte, dont la longueur est identique au 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 L’opérateur de -join binaire

Syntaxe:

binary-join-operator: one of
    dash join

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

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 avoir été convertis en chaîne, si nécessaire (§6.7). 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

Syntaxe:

binary-split-operator: one of
    dash split      dash csplit     dash isplit

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

Description:

L’opérateur binaire -split fractionne une ou plusieurs chaînes désignées par l’opérande gauche, retournant leurs sous-parties dans un tableau unidimensionnel limité de chaînes. 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
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élimiteur peut contenir des expressions régulières (§3.16). Il est utilisé pour localiser les sous-éléments avec les chaînes de caractères 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élimiteur 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, zéro ou supérieur ou égal au nombre de sous-parties d’une chaîne d’entrée, chaque sous-partie entre 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 ou plusieurs noms d’options avec chaque paire adjacente 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, il peut également contenir le nom de l’option IgnoreCase. Si une chaîne d’options contient le nom de l’option regexMatch ou qu’elle ne contient pas RegexMatch ou 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 monoligne .
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	Utilisez une comparaison de chaînes simple lors de l’évaluation du délimiteur.
Singleline	Ce mode reconnaît uniquement 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 évaluer le 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 modèle mis en correspondance par -match, -notmatchet -replace peuvent 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 « rouge », cette partie de la chaîne désignée par l’opérande gauche qui correspond exactement au modèle 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 « rouge » ; toutefois, la clé 1 contient elle aussi « rouge », qui est la partie de la chaîne désignée par l'opérande gauche et qui correspond exactement à la sous-expression correspondante.

Tenez compte du modèle suivant, plus complexe :

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

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

Là encore, la touche 0 contient « rouge ». 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 des noms de la forme $n, où la première correspondance est $1, la seconde est $3, etc. 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

Syntaxe:

shift-operator: one of
    dash shl
    dash shr

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

Description:

L’opérateur de décalage à gauche (-shl) et l’opérateur de décalage à droite (-shr) convertissent la valeur désignée par l’opérande gauche en un type entier et, si nécessaire, la valeur désignée par l’opérande droit en int, à 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 faible ordre 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 bas ordre de l’opérande gauche sont ignorés, et les bits restants sont déplacé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 à ordre élevé sont définies sur zéro.

Lorsque l’opérande gauche a un type int, le nombre de décalages est donné par les cinq bits d’ordre inférieur 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:
    unary-expression -band new-lines~opt~ unary-expression
    unary-expression -bor new-lines~opt~ unary-expression
    unary-expression -bxor new-lines~opt~ unary-expression

Description:

L’opérateur AND au niveau du bit -band, l’opérateur OR au niveau du bit -boret l’opérateur XOR au niveau du bit -bxor convertir 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, alors c'est également le type du résultat. Sinon, si les deux valeurs sont de type long, alors le résultat sera également de ce type. Si une valeur a un type int et que l’autre a un type long, le type du résultat est long. Sinon, 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:
    unary-expression -and new-lines~opt~ unary-expression
    unary-expression -or new-lines~opt~ unary-expression
    unary-expression -xor new-lines~opt~ unary-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 l’AND logique des valeurs d’opérande éventuellement converties et a le 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 OU logique des valeurs d'opérandes éventuellement converties et a le 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 a le 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’affectation

Syntaxe:

assignment-expression:
    expression assignment-operator statement

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

Description:

Un opérateur d’affectation stocke une valeur dans l’emplacement accessible en écriture désigné par expression. Pour une discussion sur l'opérateur d'affectation =, consultez §7.11.1. Pour une discussion sur tous les autres opérateurs d’affectation, consultez §7.11.2.

Une expression d’affectation a la valeur désignée par expression une fois l’affectation effectuée ; toutefois, cette expression d’affectation ne désigne pas elle-même un emplacement accessible en écriture. Si expression est contrainte de type (§5.3), le type utilisé dans cette contrainte est le type du résultat ; sinon, le type du résultat est le type après les conversions arithmétiques habituelles (§6.15) ont été appliqués.

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 l'expression désigne une clé inexistante dans une Hashtable, cette clé est ajoutée à la Hashtable avec une valeur associée désignée par l'instruction .

Comme le montre la grammaire, l'expression peut désigner une liste séparée par une virgule d’emplacements pouvant être écrits. C’est ce que l’on appelle l’assignation multiple. instruction 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 instruction, dans l’ordre lexical et stockées dans 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 instructions qui ont des valeurs (§8.1.2), instruction peut être une instruction.

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 Affectation composée

Description:

Une affectation composée a la forme E1 op= E2et équivaut à l’expression d’affectation simple E1 = E1 op (E2) sauf que dans le cas de l’affectation composée, l’expression #E1 est évaluée une seule fois. Si expression est contrainte de type (§5.3), le type utilisé dans cette contrainte est le type du résultat ; sinon, le type du résultat est déterminé par op. Pour *=, consultez §7.6.1, §7.6.2, §7.6.3; pour /=, consultez §7.6.4; pour %=, consultez §7.6.5; pour +=, consultez §7.7.1, §7.7.2, §7.7.3; pour -=, consultez §7.7.5.

Remarque

Un opérande désignant une valeur non contrainte de type numérique peut avoir son type modifié par un opérateur d’affectation 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:
    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 avec le formulaire m>&n écrit la sortie du flux m au même emplacement que le flux n.

Voici les flux valides :

Ruisseau	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	Déboguer le flux de sortie
*	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 à 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, sauf si cette expression est 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

Partager via

7. Expressions

Note éditoriale

7.1 Expressions principales

7.1.1 Parenthèses de regroupement

7.1.2 Accès aux membres

7.1.3 Expressions d’appel

Accès aux éléments 7.1.4

7.1.4.1 Mise en indice d’un tableau

7.1.4.2 Mise en indice d’une chaîne

7.1.4.3 Mise en indice d’une table de hachage

7.1.4.4 Mise en indice d’un document XML

7.1.4.5 Génération de sections de tableau

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

7.1.6 Opérateur $(...)

7.1.7 Opérateur @(...)

7.1.8 Expression de bloc de script

7.1.9 Expression de littéral de hachage

7.1.10 Expression de littéral de type

7.2 Opérateurs unaires

7.2.1 Opérateur de virgule unaire

7.2.2 NOT logique

7.2.3 NOT au niveau du bit

7.2.4 Plus unaire

7.2.5 Moins unaire

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

7.2.7 Opérateur -join unaire

7.2.8 Opérateur -split unaire

7.2.9 Opérateur de conversion

7.3 Opérateur de virgule binaire

7.4 Opérateur de plage

7.5 Opérateur de format

7.6 Opérateurs multiplicatifs

7.6.1 Multiplication

Réplication de chaîne 7.6.2

7.6.3 Réplication de tableau

7.6.4 Division

7.6.5 Reste

7.7 Opérateurs additifs

7.7.1 Ajout

7.7.2 Concaténation de chaîne

7.7.3 Concaténation de tableaux

7.7.4 Concaténation de tables de hachage

7.7.5 Soustraction

7.8 Opérateurs de comparaison

7.8.1 Opérateurs d’égalité et de relation

7.8.2 Opérateurs de confinement

7.8.3 Opérateurs de test et de conversion de type

7.8.4 Opérateurs de correspondance de modèles et de manipulation de texte

7.8.4.1 Les opérateurs -like et -notlike

7.8.4.2 Les opérateurs -match et -notmatch

7.8.4.3 L’opérateur -replace

7.8.4.4 L’opérateur de -join binaire

7.8.4.5 Opérateur binaire -split

7.8.4.6 Sous-correspondances

7.8.5 Opérateurs de décalage

7.9 Opérateurs au niveau du bit

7.10 Opérateurs logiques

7.11 Opérateurs d’affectation

7.11.1 Assignation simple

7.11.2 Affectation composée

7.12 Opérateurs de redirection

Ressources supplémentaires