2. Structure lexicale

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.

2.1 Grammaires

Cette spécification montre la syntaxe du langage PowerShell à l’aide de deux grammaires. La grammaire lexicale (§B.1) montre comment les caractères Unicode sont combinés pour former des terminateurs de ligne, des commentaires, des espaces blancs et des jetons. La grammaire syntaxique (§B.2) montre comment les jetons résultant de la grammaire lexicale sont combinés pour former des scripts PowerShell.

Pour des raisons pratiques, les fragments de ces grammaires sont répliqués dans des emplacements appropriés dans toute cette spécification.

Toute utilisation des caractères « a » à « z » dans les grammaires ne respecte pas la casse. Cela signifie que la casse dans les variables, les alias, les noms de fonction, les mots clés, les instructions et les opérateurs est ignorée. Toutefois, tout au long de cette spécification, ces noms sont écrits en minuscules, à l’exception de certaines variables automatiques et de préférence.

2.2 Analyse lexicale

Scripts 2.2.1

Syntaxe:

Conseil

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

input:
    input-elements~opt~   signature-block~opt~

input-elements:
    input-element
    input-elements   input-element

input-element:
    whitespace
    comment
    token

signature-block:
    signature-begin   signature   signature-end

signature-begin:
    new-line-character   # SIG # Begin signature block   new-line-character

signature:
    base64 encoded signature blob in multiple single-line-comments

signature-end:
    new-line-character   # SIG # End signature block   new-line-character

Description:

Le flux de source d’entrée d’un convertisseur PowerShell est l’entrée d’un script, qui contient une séquence de caractères Unicode. Le traitement lexical de ce flux implique la réduction de ces caractères dans une séquence de jetons, qui vont devenir l’entrée de l’analyse syntaxique.

Un script est un groupe de commandes PowerShell stockées dans un fichier de script . Le script lui-même n’a pas de nom, par lui-même, et prend son nom à partir de son fichier source. La fin de ce fichier indique la fin du script.

Un script peut éventuellement contenir une signature numérique. Un environnement hôte n’est pas nécessaire pour traiter un texte qui suit une signature ou tout ce qui ressemble à une signature. La création et l’utilisation de signatures numériques ne sont pas couvertes par cette spécification.

2.2.2 Terminateurs de ligne

Syntaxe:

new-line-character:
    Carriage return character (U+000D)
    Line feed character (U+000A)
    Carriage return character (U+000D) followed by line feed character (U+000A)

new-lines:
    new-line-character
    new-lines new-line-character

Description:

La présence de caractères de nouvelle ligne dans le flux source d’entrée le divise en lignes qui peuvent être utilisées pour des tâches telles que le rapport d’erreurs et la détection de la fin d’un commentaire sur une seule ligne.

Un terminateur de ligne peut être traité comme un espace blanc (§2.2.4).

2.2.3 Commentaires

Syntaxe:

comment:
    single-line-comment
    requires-comment
    delimited-comment

single-line-comment:
    # input-characters~opt~

input-characters:
    input-character
    input-characters input-character

input-character:
    Any Unicode character except a new-line-character

requires-comment:
    #Requires whitespace command-arguments

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

dashdash:
    dash dash

delimited-comment:
    < # delimited-comment-text~opt~ hashes >

delimited-comment-text:
    delimited-comment-section
    delimited-comment-text delimited-comment-section

delimited-comment-section:
    >
    hashes~opt~  not-greater-than-or-hash

hashes:
    #
    hashes #

not-greater-than-or-hash:
    Any Unicode character except > or #

Description:

Le code source peut être annoté par l’utilisation de commentaires .

Un commentaire sur une seule ligne commence par le caractère # et se termine par un caractère de nouvelle ligne.

Un commentaire délimité commence par la paire de caractères <# et se termine par la paire de caractères #>. Elle peut se produire dans le cadre d’une ligne source, en tant que ligne source entière, ou elle peut s’étendre sur n’importe quel nombre de lignes sources.

Un commentaire est traité comme un espace blanc.

Les productions ci-dessus impliquent que

• Les commentaires ne peuvent pas être imbriqués.
• Les séquences de caractères <# et #> n’ont aucune signification particulière dans un commentaire à une seule ligne.
• Le caractère # n’a aucune signification particulière dans un commentaire délimité.

La grammaire lexicale implique que les commentaires ne peuvent pas se produire à l’intérieur des jetons.

(Consultez §A pour plus d’informations sur la création de fichiers de script qui contiennent des commentaires à valeur spéciale utilisés pour générer de la documentation à partir de fichiers de script.)

Un requires-comment spécifie les critères qui doivent être remplis pour que son script contenant soit autorisé à s’exécuter. Le critère principal est la version de PowerShell utilisée pour exécuter le script. La configuration requise pour la version minimale est spécifiée comme suit :

#Requires -Version N[.n]

Où N est la version principale (obligatoire) et n est la version mineure (facultative).

Un requires-comment peut être présent dans n’importe quel fichier de script. Toutefois, il ne peut pas être présent à l’intérieur d’une fonction ou d’une cmdlet. Il doit s’agir du premier élément d’une ligne source. Un script peut contenir plusieurs requires-comment.

Une séquence de caractères n’est reconnue qu’en tant que commentaire si cette séquence commence par # ou <#. Par exemple, hello#there est considéré comme un jeton unique, tandis que hello #there est considéré comme le jeton hello suivi d’un commentaire sur une seule ligne. Ainsi que l’espace blanc suivant, la séquence de début de commentaire peut également être précédée de n’importe quel caractère de fin d’expression ou de fin d’instruction (par exemple, ), }, ], ', "ou ;).

Un requires-comment ne peut pas être présent dans un composant logiciel enfichable.

Il existe quatre autres formes de nécessitant un commentaire:

#Requires -Assembly AssemblyId
#Requires -Module ModuleName
#Requires -PSSnapin PSSnapin [ -Version *N* [.n] ]
#Requires -ShellId ShellId

2.2.4 Espace blanc

Syntaxe:

whitespace:
    Any character with Unicode class Zs, Zl, or Zp
    Horizontal tab character (U+0009)
    Vertical tab character (U+000B)
    Form feed character (U+000C)
    ` (The backtick character U+0060) followed by new-line-character

Description:

L’espace blanc se compose d’une séquence d’un ou de plusieurs espaces blancs.

À l’exception du fait que l’espace blanc peut agir comme séparateur pour les jetons, il est ignoré.

Contrairement à certains langages populaires, PowerShell ne considère pas les caractères de fin de ligne (§2.2.2) comme un espace blanc. Toutefois, une marque de fin de ligne peut être traitée comme un espace blanc en la faisant précéder immédiatement d’un caractère de guillement inversé, ` (U+0060). Cela est nécessaire lorsque le contenu d’une ligne est terminé de manière syntactique, mais la ligne suivante contient des jetons destinés à être associés à la ligne précédente. Par exemple

$number = 10 # assigns 10 to $number; nothing is written to the pipeline
+ 20 # writes 20 to the pipeline
- 50 # writes -50 to the pipeline
$number # writes $number's value, 10, to the pipeline

Dans cet exemple, la ligne de base indique que la ligne source est continue. L’expression suivante équivaut à $number = 10 + 20 - 50.

$number = 10 `
+ 20 `
- 50
$number # writes $number's value to the pipeline
-20

2.3 Jetons

Syntaxe:

token:
    keyword
    variable
    command
    command-parameter
    command-argument-token
    integer-literal
    real-literal
    string-literal
    type-literal
    operator-or-punctuator

Description:

Un jeton est le plus petit élément lexical dans le langage PowerShell.

Les jetons peuvent être séparés par de nouvelles lignes, des commentaires, des espaces blancs ou toute combinaison de ces éléments.

2.3.1 Mots clés

Syntaxe:

keyword: one of
    begin          break          catch       class
    continue       data           define      do
    dynamicparam   else           elseif      end
    exit           filter         finally     for
    foreach        from           function    if
    in             inlinescript   parallel    param
    process        return         switch      throw
    trap           try            until       using
    var            while          workflow

Description:

Un mot clé est une séquence de caractères qui a une signification spéciale lorsqu’il est utilisé dans un emplacement dépendant du contexte. Le plus souvent, il s’agit du premier jeton d’une instruction ; toutefois, il existe d’autres emplacements, comme indiqué par la grammaire. (Un jeton qui ressemble à un mot clé, mais qui n’est pas utilisé dans un contexte de mot clé, est un nom de commande ou un argument de commande .)

Les mots clés class, define, from, usinget var sont réservés pour une utilisation ultérieure.

Remarque

Remarque de l’éditeur : les mots clés class et using ont été introduits dans PowerShell 5.0. Consultez about_Classes et about_Using.

2.3.2 Variables

Syntaxe:

variable:
    $$
    $?
    $^
    $   variable-scope~opt~  variable-characters
    @   variable-scope~opt~  variable-characters
    braced-variable


braced-variable:
    ${   variable-scope~opt~   braced-variable-characters   }

variable-scope:
    Global:
    Local:
    Private:
    Script:
    Using:
    Workflow:
    variable-namespace

variable-namespace:
    variable-characters   :

variable-characters:
    variable-character
    variable-characters   variable-character

variable-character:
    A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nd
    _   (The underscore character U+005F)
    ?

braced-variable-characters:
    braced-variable-character
    braced-variable-characters   braced-variable-character

braced-variable-character:
    Any Unicode character except
        }   (The closing curly brace character U+007D)
        `   (The backtick character U+0060)
    escaped-character

escaped-character:
    `   (The backtick character U+0060) followed by any Unicode character

Description:

Les variables sont abordées en détail dans (§5). La variable $ ? est abordé dans §2.3.2.2. Les étendues sont abordées dans §3.5.

Les variables $$ et $^ sont réservées à une utilisation dans un environnement interactif, qui est en dehors de l’étendue de cette spécification.

Il existe deux façons d’écrire un nom de variable : un nom de variable entre accolades, qui commence par $, suivi d’un jeu délimité par des accolades d’un ou de plusieurs caractères quasi arbitraires, et d’un nom de variable ordinaire, qui commence par $, suivi d’un ensemble d’un ou de plusieurs caractères d’un jeu plus restrictif que le nom de la variable entre accolades. Chaque nom de variable ordinaire peut être exprimé à l’aide d’un nom de variable entre accolades correspondant.

$totalCost
$Maximum_Count_26

$végösszeg # Hungarian
$итог # Russian
$総計 # Japanese (Kanji)

${Maximum_Count_26}
${Name with`twhite space and `{punctuation`}}
${E:\\File.txt}

Il n’existe aucune limite quant à la longueur d’un nom de variable, tous les caractères d’un nom de variable sont significatifs et la casse n’est pas distincte.

Il existe plusieurs types de variables différents : défini par l’utilisateur (§2.3.2.1), automatique (§2.3.2.2) et préférence (§2.3.2.3). Ils peuvent coexister dans la même étendue (§3.5).

Tenez compte de la définition et des appels de fonction suivants :

function Get-Power ([long]$Base, [int]$Exponent) { ... }

Get-Power 5 3 # $Base is 5, $Exponent is 3
Get-Power -Exponent 3 -Base 5 # " " "

Chaque argument est passé par position ou par nom, un à la fois. Toutefois, un ensemble d’arguments peut être passé en tant que groupe avec l’extension en arguments individuels gérés par l’environnement d’exécution. Cette expansion d’arguments automatique est appelée projection. Par exemple

$values = 5,3 # put arguments into an array
Get-Power @values

$hash = @{ Exponent = 3; Base = 5 } # put arguments into a Hashtable
Get-Power @hash

function Get-Power2 { Get-Power @args } # arguments are in an array

Get-Power2 -Exponent 3 -Base 5 # named arguments splatted named in
@args
Get-Power2 5 3 # position arguments splatted positionally in @args

Pour ce faire, utilisez @ au lieu de $ comme premier caractère de la variable passée. Cette notation ne peut être utilisée que dans un argument dans une commande.

Les noms sont partitionnés en différents espaces de noms qui sont stockés sur un lecteur virtuel (§3.1). Par exemple, les variables sont stockées sur Variable:, les variables d’environnement sont stockées sur Env:, les fonctions sont stockées sur Function:et les alias sont stockés sur Alias:. Tous ces noms sont accessibles en tant que variables à l’aide de la production de variable-namespace au sein de variable-scope. Par exemple

function F { "Hello from F" }
$Function:F # invokes function F

Set-Alias A F
$Alias:A # invokes function F via A

$Count = 10
$Variable:Count # accesses variable Count
$Env:PATH # accesses environment variable PATH

Toute utilisation d’un nom de variable avec un espace de noms de Variable: explicite équivaut à l’utilisation de ce même nom de variable sans cette qualification. Par exemple, $v et $Variable:v sont interchangeables.

En plus d’être définies dans le langage, les variables peuvent également être définies par l’applet de commande new-variable.

2.3.2.1 Variables définies par l’utilisateur

Tout nom de variable autorisé par la grammaire, mais non utilisé par les variables automatiques ou de préférence, est disponible pour les variables définies par l’utilisateur.

Les variables définies par l’utilisateur sont créées et gérées par un script défini par l’utilisateur.

2.3.2.2 Variables automatiques

Les variables automatiques stockent des informations d’état sur l’environnement PowerShell. Leurs valeurs peuvent être lues dans un script écrit par l’utilisateur, mais pas écrites.

Remarque

La table trouvée à l’origine dans ce document a été supprimée pour réduire la duplication. Pour obtenir la liste complète des variables automatiques, consultez about_Automatic_Variables.

2.3.2.3 Variables de préférence

Les variables de préférence stockent les préférences utilisateur pour la session. Ils sont créés et initialisés par l’environnement d’exécution PowerShell. Leurs valeurs peuvent être lues et écrites dans un script écrit par l’utilisateur.

Remarque

La table trouvée à l’origine dans ce document a été supprimée pour réduire la duplication. Pour obtenir la liste complète des variables de préférence, consultez about_Preference_Variables.

2.3.3 Commandes

Syntaxe:

generic-token:
    generic-token-parts

generic-token-parts:
    generic-token-part
    generic-token-parts generic-token-part

generic-token-part:
    expandable-string-literal
    verbatim-here-string-literal
    variable
    generic-token-char

generic-token-char:
    Any Unicode character except
        {   }   (   )   ;   ,   |   &   $
        ` (The backtick character U+0060)
        double-quote-character
        single-quote-character
        whitespace
        new-line-character
        escaped-character

generic-token-with-subexpr-start:
    generic-token-parts $(

2.3.4 Paramètres

Syntaxe:

command-parameter:
    dash first-parameter-char parameter-chars colon~opt~

first-parameter-char:
    A Unicode character of classes Lu, Ll, Lt, Lm, or Lo
    _ (The underscore character U+005F)
    ?

parameter-chars:
    parameter-char
    parameter-chars parameter-char

parameter-char:
    Any Unicode character except
        { } ( ) ; , \| & . [
        colon
        whitespace
        new-line-character

colon:
    : (The colon character U+003A)

verbatim-command-argument-chars:
    verbatim-command-argument-part
    verbatim-command-argument-chars verbatim-command-argument-part

verbatim-command-argument-part:
    verbatim-command-string
    & non-ampersand-character
    Any Unicode character except
        |
        new-line-character

non-ampersand-character:
    Any Unicode character except &

verbatim-command-string:
    double-quote-character non-double-quote-chars
    double-quote-character

non-double-quote-chars:
    non-double-quote-char
    non-double-quote-chars non-double-quote-char

non-double-quote-char:
    Any Unicode character except
        double-quote-character

Description:

Lorsqu’une commande est appelée, les informations peuvent être transmises via un ou plusieurs arguments dont les valeurs sont accessibles à partir de la commande via un ensemble de paramètres de correspondants. Le processus de correspondance des paramètres à des arguments est appelé liaison de paramètres.

Il existe trois types d’arguments :

• Paramètre booléen (§8.10.5) : sa forme est de type command-parameter où first-parameter-char et parameter-chars forment ensemble le nom du commutateur, qui correspond au nom d’un paramètre (sans son - initial) dans la commande appelée. Si le deux-points final est omis, la présence de cet argument indique que le paramètre correspondant doit être configuré sur $true. Si le deux-points final est présent, l’argument suivant doit désigner une valeur de type bool, et le paramètre correspondant est défini sur cette valeur. Par exemple, les appels suivants sont équivalents :

  Set-MyProcess -Strict
  Set-MyProcess -Strict: $true
  

• Paramètre avec argument (§8.10.2) -- Cela a la forme paramètre-commande où premier-caractère-paramètre et caractères-paramètre composent ensemble le nom du paramètre, qui correspond au nom d’un paramètre (sans son premier -) dans la commande invoquée. Il ne doit pas y avoir de signe deux-points de fin. L’argument immédiatement suivant désigne une valeur associée. Par exemple, étant donné une commande Get-Power, qui a des paramètres $Base et $Exponent, les appels suivants sont équivalents :

  Get-Power -Base 5 -Exponent 3
  Get-Power -Exponent 3 -Base 5
  

• Argument positionnel (§8.10.2) : les arguments et leurs paramètres correspondants à l’intérieur des commandes ont des positions avec la première position zéro. L’argument à la position 0 est lié au paramètre à la position 0 ; l’argument dans la position 1 est lié au paramètre à la position 1 ; et ainsi de suite. Par exemple, en fonction d’une commande Get-Power, qui a des paramètres $Base et $Exponent dans les positions 0 et 1, respectivement, la commande peut être appelée comme suit :

  Get-Power 5 3
  

Consultez §8.2 pour plus d’informations sur les paramètres spéciaux -- et --%.

Lorsqu’une commande est appelée, un nom de paramètre peut être abrégé ; toute partie principale distincte du nom complet peut être utilisée, à condition qu’elle soit non ambiguë en ce qui concerne les noms des autres paramètres acceptés par la même commande.

Pour plus d’informations sur la liaison de paramètres, consultez §8.14.

2.3.5 Littéraux

Syntaxe:

literal:
    integer-literal
    real-literal
    string-literal

2.3.5.1 Littéraux numériques

Il existe deux types de littéraux numériques : entier (§2.3.5.1.1) et réel (§2.3.5.1.2). Les deux peuvent avoir des suffixes multiplicateurs (§2.3.5.1.3).

2.3.5.1.1 Littéraux entiers

Syntaxe:

integer-literal:
    decimal-integer-literal
    hexadecimal-integer-literal

decimal-integer-literal:
    decimal-digits numeric-type-suffix~opt~ numeric-multiplier~opt~

decimal-digits:
    decimal-digit
    decimal-digit decimal-digits

decimal-digit: one of
    0  1  2  3  4  5  6  7  8  9

numeric-type-suffix:
    long-type-suffix
    decimal-type-suffix

hexadecimal-integer-literal:
    0x hexadecimal-digits long-type-suffix~opt~
    numeric-multiplier~opt~

hexadecimal-digits:
    hexadecimal-digit
    hexadecimal-digit decimal-digits

hexadecimal-digit: one of
    0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f

long-type-suffix:
    l

numeric-multiplier: one of
    kb mb gb tb pb

Description:

Le type d’un littéral entier est déterminé par sa valeur, la présence ou l’absence de suffixe de type longet la présence d’un multiplicateur numérique (§2.3.5.1.3).

Pour un littéral entier sans long-type-suffix

• Si sa valeur peut être représentée par int de type (§4.2.3), c’est-à-dire son type ;
• Sinon, si sa valeur peut être représentée par type long (§4.2.3), c’est-à-dire son type.
• Sinon, si sa valeur peut être représentée par type décimal (§2.3.5.1.2), c’est-à-dire son type.
• Sinon, il est représenté par type double (§2.3.5.1.2).

Pour un littéral entier avec long-type-suffix

• Si sa valeur peut être représentée par type long (§4.2.3), c’est-à-dire son type ;
• Sinon, ce littéral est incorrect.

Dans la représentation à deux compléments de valeurs entières, il y a une valeur négative plus qu’il y a de positif. Pour le type int, cette valeur supplémentaire est -2147483648. Pour le type long, cette valeur supplémentaire est -9223372036854775808. Même si le jeton 2147483648 est normalement traité comme un littéral de type long, s’il est précédé immédiatement par l’opérateur unaire, cet opérateur et ce littéral sont traités comme un littéral de type int ayant la plus petite valeur. De même, même si le jeton 9223372036854775808 serait généralement traité comme un littéral réel de type décimal, s'il est immédiatement précédé de l'opérateur unaire -, cet opérateur et le littéral sont alors traités comme un littéral de type long ayant la plus petite valeur.

Certains exemples de littéraux entiers sont 123 (int), 123L (long) et 2000000000 (long).

Il n’existe pas de littéral entier de type octet.

2.3.5.1.2 Littéraux réels

Syntaxe:

real-literal:
    decimal-digits . decimal-digits exponent-part~opt~ decimal-type-suffix~opt~ numeric-multiplier~opt~
    . decimal-digits exponent-part~opt~ decimal-type-suffix~opt~ numeric-multiplier~opt~
    decimal-digits exponent-part decimal-type-suffix~opt~ numeric-multiplier~opt~

exponent-part:
    e sign~opt~  decimal-digits

sign: one of
    +
    dash

decimal-type-suffix:
    d
    l

numeric-multiplier: one of
    kb mb gb tb pb

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

Description:

Un littéral réel peut contenir un numeric-multiplier (§2.3.5.1.3).

Il existe deux types de littéraux réels : double et decimal. Elles sont indiquées par l’absence ou la présence, respectivement, de suffixe de type décimal. (Il n’existe pas de littéral réel flottant.)

Un littéral réel double a le type double (§4.2.4.1). Un littéral réel décimal a le type decimal (§4.2.4.2). Les zéros de fin dans la partie fractionnaire d’un littéral réel décimal sont significatifs.

Si la valeur des decimal-digits de l’exponent-part dans un littéral réel double est inférieure à la valeur minimale prise en charge, la valeur de ce double littéral réel est 0. Si la valeur des decimal-digits de l’exponent-part dans un littéral réel est inférieure à la valeur minimale prise en charge, ce littéral est mal formé. Si la valeur des decimal-digits de l’exponent-part dans un littéral double ou réel est supérieure à la valeur maximale prise en charge, ce littéral est mal formé.

Certains exemples de littéraux réels doubles sont 1., 1.23, .45e35, 32.e+12 et 123.456E-231.

Quelques exemples de littéraux réels décimaux sont 1d (dont l’échelle est 0), 1,20d (qui a l’échelle 2), 1,23450e1d (c’est-à-dire 12,3450, qui a l’échelle 4), 1,2345e3d (c’est-à-dire, 1234.5, qui a l’échelle 1), 1.2345e-1d (c.-à-d. 0,12345, qui a l’échelle 5) et 1,2345e-3d (c’est-à-dire 0,0012345, qui a l’échelle 7).

Remarque

Comme un littéral double réel n'a pas forcément besoin d'une partie fractionnaire ou exposante, les parenthèses de regroupement dans (123).M sont nécessaires afin d'assurer que la propriété ou la méthode M est sélectionnée pour l'objet entier ayant pour valeur 123. Sans ces parenthèses, le littéral réel serait incorrect.

Remarque

Bien que PowerShell ne fournisse pas de littéraux pour les infinis et les naNs, des équivalents littéraux réels doubles peuvent être obtenus à partir des propriétés statiques en lecture seule PositiveInfinity, NegativeInfinity et NaN des types float et double (§4.2.4.1).

La grammaire permet à ce qui commence en tant que littéral double réel d’avoir un suffixe de type l ou L. Un tel jeton est en fait un littéral entier dont la valeur est représentée par le type long.

Remarque

Cette fonctionnalité a été conservée pour la compatibilité descendante avec les versions antérieures de PowerShell. Toutefois, les programmeurs sont déconseillés d’utiliser des littéraux entiers de cette forme, car ils peuvent facilement masquer la valeur réelle du littéral. Par exemple, 1.2L a la valeur 1, 1.2345e1L a la valeur 12 et 1.2345e-5L a la valeur 0, aucune d’entre elles n’est immédiatement évidente.

2.3.5.1.3 Suffixes multiplicateurs

Syntaxe:

numeric-multiplier: *one of*
    kb mb gb tb pb

Description:

Pour des raisons pratiques, les littéraux entiers et réels peuvent contenir un numeric-multiplier, ce qui indique un ensemble de puissances couramment utilisées de 10. Le multiplicateur numérique peut être écrit avec n’importe quelle combinaison de lettres majuscules et minuscules.

Multiplicateur	Signification	Exemple
kb	kilooctet (1024)	1 ko ≡ 1024
mb	mégaoctet (1024 x 1024)	1.30Dmb ≡ 1363148.80
go	gigaoctets (1024 x 1024 x 1024)	0x10 Gb ≡ 17179869184
TB	téraoctet (1024 x 1024 x 1024 x 1024)	1.4e23 tb ≡ 1.5393162788864E+35
po	pétaoctet (1024 x 1024 x 1024 x 1024 x 1024 x 1024)	0x12Lpb ≡ 20266198323167232

2.3.5.2 Littéraux de chaîne

Syntaxe:

string-literal:
    expandable-string-literal
    expandable-here-string-literal
    verbatim-string-literal
    verbatim-here-string-literal

expandable-string-literal:
    double-quote-character expandable-string-characters~opt~  dollars~opt~ double-quote-character

double-quote-character:
    " (U+0022)
    Left double quotation mark (U+201C)
    Right double quotation mark (U+201D)
    Double low-9 quotation mark (U+201E)

expandable-string-characters:
      expandable-string-part
      expandable-string-characters
      expandable-string-part

expandable-string-part:
    Any Unicode character except
        $
        double-quote-character
        ` (The backtick character U+0060)
    braced-variable
    $ Any Unicode character except
        (
        {
        double-quote-character
        ` (The backtick character U+0060)*
    $ escaped-character
    escaped-character
    double-quote-character double-quote-character

dollars:
    $
    dollars $

expandable-here-string-literal:
    @  double-quote-character  whitespace~opt~  new-line-character
        expandable-here-string-characters~opt~  new-line-character  double-quote-character  @

expandable-here-string-characters:
    expandable-here-string-part
    expandable-here-string-characters  expandable-here-string-part

expandable-here-string-part:
    Any Unicode character except
        $
        new-line-character
    braced-variable
    $ Any Unicode character except
        (
        new-line-character
    $ new-line-character  Any Unicode character except double-quote-char
    $ new-line-character double-quote-char  Any Unicode character except @
    new-line-character  Any Unicode character except double-quote-char
    new-line-character double-quote-char  Any Unicode character except @

expandable-string-with-subexpr-start:
    double-quote-character  expandable-string-chars~opt~  $(

expandable-string-with-subexpr-end:
    double-quote-char

expandable-here-string-with-subexpr-start:
    @  double-quote-character  whitespace~opt~  new-line-character  expandable-here-string-chars~opt~  $(

expandable-here-string-with-subexpr-end:
    new-line-character  double-quote-character  @

verbatim-string-literal:
    single-quote-character verbatim-string-characters~opt~ single-quote-char

single-quote-character:
    ' (U+0027)
    Left single quotation mark (U+2018)
    Right single quotation mark (U+2019)
    Single low-9 quotation mark (U+201A)
    Single high-reversed-9 quotation mark (U+201B)

verbatim-string-characters:
    verbatim-string-part
    verbatim-string-characters verbatim-string-part

verbatim-string-part:
    *Any Unicode character except* single-quote-character
    single-quote-character  single-quote-character

verbatim-here-string-literal:
    @ single-quote-character whitespace~opt~  new-line-character
        verbatim-here-string-characters~opt~  new-line-character
            single-quote-character *@*

verbatim-*here-string-characters:
    verbatim-here-string-part
    verbatim-here-string-characters  verbatim-here-string-part

verbatim-here-string-part:
    Any Unicode character except* new-line-character
    new-line-character  Any Unicode character except single-quote-character
    new-line-character  single-quote-character  Any Unicode character except @

Description:

Il existe quatre types de littéraux de chaînes :

• verbatim-string-literal (une seule ligne, guillemets simples), qui est une séquence de zéro ou plusieurs caractères délimités par une paire de single-quote-character. Par exemple '' et 'red'.

• expandable-string-literal (une seule ligne, guillemets doubles), qui est une séquence de zéro ou plusieurs caractères délimités par une paire de double-quote-character. Par exemple "" et "red".

• verbatim-here-string-literal (à plusieurs lignes, guillemets simples), qui est une séquence de zéro, un ou plusieurs caractères délimités par les paires de caractères @single-quote-character et single-quote-character@, respectivement, le tout contenu sur au moins deux lignes sources. Voici quelques exemples :

  @'
  '@
  
  @'
  line 1
  '@
  
  @'
  line 1
  line 2
  '@
  

• expandable-here-string-literal (à plusieurs lignes, guillemets doubles), qui est une séquence de zéro, un ou plusieurs caractères délimités par les paires de caractères @double-quote-character et double-quote-character@, respectivement, le tout contenu sur au moins deux lignes sources. Voici quelques exemples :

  @"
  "@
  
  @"
  line 1
  "@
  
  @"
  line 1
  line 2
  "@
  

Pour les littéraux de chaîne verbatim-here-string-literal et expandable-here-string-literal, à l’exception des espaces blancs (qui sont ignorés), aucun caractère ne peut suivre la même ligne source que la paire de caractères délimiteurs d’ouverture, et aucun caractère ne peut précéder la même ligne source que la paire de caractères délimiteurs de fin.

Le corps d’un verbatim-here-string-literal ou d’un expandable-here-string-literal commence au début de la première ligne source suivant le délimiteur d’ouverture, et se termine à la fin de la dernière ligne source précédant le délimiteur de fin. Le corps peut être vide. La marque de fin de ligne sur la dernière ligne source précédant le délimiteur de fin ne fait pas partie du corps de ce littéral.

Un littéral de l’un de ces genres a le type string (§4.3.1).

Le caractère utilisé pour délimiter un verbatim-string-literal ou expandable-string-literal peut être contenu dans un tel littéral de chaîne en écrivant ce caractère deux fois à la suite. Par exemple, 'What''s the time?' et "I said, ""Hello"".". Toutefois, un single-quote-character n’a aucune signification particulière dans un expandable-string-literal, et un double-quote-character n’a aucune signification particulière à l’intérieur d’un verbatim-string-literal.

Un expandable-string-literal et un expandable-here-string-literal peuvent contenir des escaped-character (§2.3.7). Par exemple, lorsque le littéral de chaîne suivant est écrit dans le pipeline, le résultat est le suivant :

"column1`tcolumn2`nsecond line, `"Hello`", ```Q`5`!"

column1<horizontal-tab>column2<new-line>
second line, "Hello", `Q5!

Si un expandable-string-literal ou expandable-here-string-literal contient le nom d’une variable, à moins que ce nom soit immédiatement précédé d’un caractère d’échappement, il est remplacé par la représentation sous forme de chaîne de la valeur de cette variable (§6.7). Cela est connu sous le nom de substitution de variable.

Remarque

Si le nom de la variable fait partie d’une expression plus grande, seul le nom de la variable est remplacé. Par exemple, si $a est un tableau contenant les éléments 100 et 200, ">$a.Length<" entraîne >100 200.Length< tandis que ">$($a.Length)<" entraîne >2<. Voir le développement de la sous-expression ci-dessous.

Par exemple, le code source

$count = 10
"The value of `$count is $count"

génère l’expandable-string-literal

The value of $count is 10.

Tenez compte des éléments suivants :

$a = "red","blue"
"`$a[0] is $a[0], `$a[0] is $($a[0])" # second [0] is taken literally

Le résultat est

$a[0] is red blue[0], $a[0] is red

Les expandable-string-literal et expandable-here-string-literal prennent également en charge un type de substitution appelé extension de sous-expression, en traitant un texte de la forme $( ... ) comme une sous-expression (§7.1.6). Ce texte est remplacé par la représentation sous forme de chaîne de la valeur de cette expression (§6.8). Tout espace blanc utilisé pour séparer les jetons dans la statement-list de la sous-expression est ignoré en ce qui concerne la construction de la chaîne de résultat.

Les exemples,

$count = 10
"$count + 5 is $($count + 5)"
"$count + 5 is `$($count + 5)"
"$count + 5 is `$(`$count + 5)"

produisent les expandable-string-literal suivants :

10 + 5 is 15
10 + 5 is $(10 + 5)
10 + 5 is $($count + 5)

La source suivante,

$i = 5; $j = 10; $k = 15
"`$i, `$j, and `$k have the values $( $i; $j; $k )"

produit l’expandable-string-literal suivant :

$i, $j, and $k have the values 5 10 15

Ces quatre lignes auraient pu être écrites plus succinctement comme suit :

"`$i, `$j, and `$k have the values $(($i = 5); ($j = 10); ($k = 15))"

Dans l’exemple suivant,

"First 10 squares: $(for ($i = 1; $i -le 10; ++$i) { "$i $($i*$i) " })"

l’expandable-string-literal qui en résulte est le suivant :

First 10 squares: 1 1 2 4 3 9 4 16 5 25 6 36 7 49 8 64 9 81 10 100

Comme indiqué, une sous-expression peut contenir des littéraux de chaîne qui ont à la fois une substitution de variable et une extension de sous-expression. Notez également que les délimiteurs de l’expandable-string-literal interne ne doivent pas être placés dans une séquence d’échappement. Le fait qu’ils se trouvent à l’intérieur d’une sous-expression signifie qu’ils ne peuvent pas être des terminateurs pour l’expandable-string-literal externe.

Un expandable-string-literal ou expandable-here-string-literal contenant une substitution de variable ou une extension de sous-expression est évalué chaque fois que ce littéral est utilisé. Par exemple,

$a = 10
$s1 = "`$a = $($a; ++$a)"
"`$s1 = >$s1<"
$s2 = "`$a = $($a; ++$a)"
"`$s2 = >$s2<"
$s2 = $s1
"`$s2 = >$s2<"

ce qui produit les expandable-string-literal suivants :

$s1 = >$a = 10<
$s2 = >$a = 11<
$s2 = >$a = 10<

Le contenu d’un verbatim-here-string-literal est pris tel quel, y compris tout espace blanc de début ou de fin dans le corps. Par conséquent, les single-quote-character incorporés n’ont pas besoin d’être doublés et il n’y a aucune substitution ou expansion. Par exemple

$lit = @'
That's it!
2 * 3 = $(2*3)
'@

ce qui donne le littéral

That's it!
2 * 3 = $(2*3)

Le contenu d’un expandable-here-string-literal est soumis à la substitution et à l’expansion, mais tout espace blanc de début ou de fin dans le corps, mais en dehors des sous-expressions, est pris tel quel, et les double-quote-character incorporés n’ont pas besoin d’être doublés. Par exemple

$lit = @"
That's it!
2 * 3 = $(2*3)
"@

ce qui entraîne le littéral suivant lorsqu’il est étendu :

That's it!
2 * 3 = 6

Pour les verbatim-here-string-literal et expandable-here-string-literal, chaque terminateur de ligne dans le corps est représenté dans le littéral résultant selon une méthode définie par l’implémentation. Par exemple, dans

$lit = @"
abc
xyz
"@

la deuxième ligne du corps a deux espaces à gauche et les première et deuxième lignes du corps comportent des marques de fin de ligne. Toutefois, le terminateur de la deuxième ligne du corps ne fait pas partie de ce corps. Le littéral résultant est équivalent à : "abc<implementation-defined character sequence>xyz".

Remarque

Pour faciliter la lisibilité du code source, les longues chaînes de caractères peuvent être réparties sur plusieurs lignes de code source sans insérer de terminateurs de ligne. Pour ce faire, écrivez chaque partie en tant que littéral distinct et concatènez les parties avec l’opérateur + (§7.7.2). Cet opérateur permet à ses opérandes de désigner l’un des quatre types de littéraux de chaîne.

Remarque

Bien qu’il n’y ait pas de littéral de caractère en tant que tel, le même effet peut être obtenu en accédant au premier caractère d’une chaîne de 1 caractère, comme suit : [char]"A" ou "A"[0].

Pour les verbatim-here-string-literal et expandable-here-string-literal, chaque terminateur de ligne dans le corps est représenté exactement tel qu’il a été fourni.

2.3.5.3 Littéral Null

Consultez la variable automatique $null (§2.3.2.2).

2.3.5.4 Littéraux booléens

Consultez les variables automatiques $false et $true (§2.3.2.2).

2.3.5.5 Littéraux de tableau

PowerShell permet aux expressions de type tableau (§9) d’être écrites à l’aide de l’opérateur virgule unaire (§7.2.1), d’expression de tableau (§7.1.7), de l’opérateur de virgule binaire (§7.3) et de l’opérateur de plage (§7.4).

2.3.5.6 Littéraux de hachage

PowerShell permet d'écrire des expressions de type Hashtable (§10) à l'aide d'une expression littérale de hachage (§7.1.9)

2.3.5.7 Noms de types

Syntaxe:

type-name:
    type-identifier
    type-name . type-identifier

type-identifier:
    type-characters

type-characters:
    type-character
    type-characters type-character

type-character:
    A Unicode character of classes Lu, Ll, Lt, Lm, Lo, or Nd
    _ (The underscore character U+005F)

array-type-name:
    type-name [

generic-type-name:
    type-name [

2.3.6 Opérateurs et ponctuateurs

Syntaxe:

operator-or-punctuator: one of
    {   }   [   ]   (   )   @(   @{   $(   ;
    &&  ||  &   |   ,   ++  ..   ::   .
    !   *   /   %   +   -   --
    -and   -band   -bnot   -bor
    -bxor   -not   -or     -xor
    assignment-operator
    merging-redirection-operator
    file-redirection-operator
    comparison-operator
    format-operator

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

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

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

format-operator:
    -f

Description:

&& et || sont réservés à une utilisation ultérieure.

Remarque

Remarque de l’éditeur : les opérateurs de chaîne de pipeline && et || ont été introduits dans PowerShell 7. Voir about_Pipeline_Chain_Operators.

Le nom suivant le tiret dans un opérateur est réservé à cet effet uniquement dans un contexte d’opérateur.

Un opérateur qui commence par un tiret ne doit pas comporter d’espace blanc entre ce tiret et le jeton qui le suit.

2.3.7 Caractères échappés

Syntaxe:

escaped-character:
    ` (The backtick character U+0060) followed by any Unicode character

Description:

Un caractère d’échappement est un moyen d’affecter une interprétation spéciale à un caractère en lui donnant un caractère de guillemet inversé en préfixe (U+0060). Le tableau suivant montre la signification de chaque caractère échappé :

Caractère d’échappement	Signification
`a	Alerte (U+0007)
`b	Retour arrière (U+0008)
`f	Flux de formulaire (U+000C)
`n	Nouvelle ligne (U+000A)
`r	Retour chariot (U+000D)
`t	Tabulation horizontale (U+0009)
`v	Tabulation verticale (U+0009)
`'	Apostrophe (U+0027)
`"	Guillemet (U+0022)
``	Guillemet inverse (U+0060)
`0	NUL (U+0000)
`x	Si x est un caractère autre que ceux indiqués ci-dessus, le caractère de soulignement est ignoré et x est pris littéralement.

L’implication de la dernière entrée du tableau ci-dessus est que les espaces qui, autrement, sépareraient des jetons, peuvent faire partie d’un jeton à la place. Par exemple, un nom de fichier contenant un espace peut être écrit en tant que Test` Data.txt (ainsi que 'Test Data.txt' ou "Test Data.txt").