Feedback

2. Lexicale structuur

  • Artikel
  • 25 minuten om te lezen

2.1 Grammatica's

Deze specificatie toont de syntaxis van de PowerShell-taal met behulp van twee grammatica's. De lexicale grammatica (B.1) laat zien hoe Unicode-tekens worden gecombineerd tot regel-eindtekens, opmerkingen, witruimte en tokens. De syntactische grammatica (B.2) laat zien hoe de tokens die het resultaat zijn van de lexicale grammatica worden gecombineerd om PowerShell-scripts te vormen.

Voor het gemak worden fragmenten van deze grammatica's gerepliceerd op de juiste plaatsen in deze specificatie.

Elk gebruik van de tekens 'a' tot en met 'z' in de grammatica is niet hoofd- en hoofdindief. Dit betekent dat letters in variabelen, aliassen, functienamen, trefwoorden, instructies en operators worden genegeerd. In deze specificatie worden dergelijke namen echter in kleine letters geschreven, met uitzondering van een aantal automatische en voorkeursvariabelen.

2.2 Lexicale analyse

2.2.1 Scripts

Syntaxis:

Tip

De ~opt~ notatie in de syntaxisdefinities geeft aan dat de lexicale entiteit optioneel is in de syntaxis.

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

Beschrijving:

De invoerbronstroom naar een PowerShell-translator is de invoer in een script, dat een reeks Unicode-tekens bevat. De lexicale verwerking van deze stroom omvat het verminderen van die tekens in een reeks tokens, die de invoer van syntactische analyse worden.

Een script is een groep PowerShell-opdrachten die zijn opgeslagen in een scriptbestand. Het script zelf heeft geen naam per se en neemt de naam op uit het bronbestand. Het einde van dat bestand geeft het einde van het script aan.

Een script kan eventueel een digitale handtekening bevatten. Een hostomgeving is niet vereist voor het verwerken van tekst die volgt op een handtekening of iets dat eruitziet als een handtekening. Het maken en gebruiken van digitale handtekeningen valt niet onder deze specificatie.

2.2.2 Regel-einden

Syntaxis:

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

Beschrijving:

De aanwezigheid van nieuwe regeltekens in de invoerbronstroom verdeelt deze in regels die kunnen worden gebruikt voor bijvoorbeeld foutrapportage en de detectie van het einde van een opmerking met één regel.

Een lijn-eindending kan worden behandeld als witruimte (2.2.4).

2.2.3 Opmerkingen

Syntaxis:

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 #

Beschrijving:

Broncode kan worden geannoeerd door het gebruik van opmerkingen.

Een opmerking met één regel begint met het teken # en eindigt met een new-line-character.

Een scheidingsteken begint met het tekenpaar <# en eindigt met het tekenpaar #>. Deze kan optreden als onderdeel van een bronlijn, als een hele bronregel, of kan een groot aantal bronlijnen omspannen.

Een opmerking wordt behandeld als witruimte.

De bovenstaande afbeelding impliceert dat

  • Opmerkingen worden niet genest.
  • De tekenreeksen <# en #> hebben geen speciale betekenis in een opmerking met één regel.
  • Het teken # heeft geen speciale betekenis in een opmerking met scheidingstekens.

De lexicale grammatica impliceert dat er geen opmerkingen kunnen worden gemaakt binnen tokens.

(Zie .A voor informatie over het maken van scriptbestanden die opmerkingen met speciale waarde bevatten die worden gebruikt voor het genereren van documentatie van scriptbestanden.)

Een requires-comment bevat de criteria waaraan moet worden voldaan om het script te kunnen uitvoeren. Het primaire criterium is de versie van PowerShell die wordt gebruikt om het script uit te voeren. De minimale versievereiste wordt als volgt opgegeven:

#requires -Version N[.n]

Waarbij N de (vereiste) hoofdversie is en n de (optionele) secundaire versie.

Een requires-comment kan aanwezig zijn in elk scriptbestand; Deze kan echter niet aanwezig zijn in een functie of cmdlet. Dit moet het eerste item op een bronregel zijn. Een script kan meerdere requires-comments bevatten.

Een tekenreeks wordt alleen herkend als een opmerking als die reeks begint met # of <#. Hello#there wordt bijvoorbeeld beschouwd als één token, terwijl hello #there wordt beschouwd als het token hello gevolgd door een opmerking met één regel. Naast de volgende witruimte kan de beginvolgorde van de opmerking ook worden voorafgegaan door een expressie-beëindigend of instructie-beëindigend teken ( )zoals , }, ], ', "of ;).

Een requires-comment kan niet aanwezig zijn in een module.

Er zijn vier andere vormen van een requires-comment:

#requires --Assembly AssemblyId
#requires --Module ModuleName
#requires --PsSnapIn PsSnapIn [ -Version *N* [.n] ]
#requires --ShellId ShellId

2.2.4 Witruimte

Syntaxis:

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

Beschrijving:

Witruimte bestaat uit een reeks van een of meer witruimtetekens .

Behalve dat witruimte kan fungeren als scheidingsteken voor tokens, wordt dit genegeerd.

In tegenstelling tot sommige populaire talen beschouwt PowerShell regel-eindtekens (2.2.2) niet als witruimte. Een regel-eindteken kan echter worden behandeld als witruimte door er direct aan vooraf te gaan door een backtick-teken ` (U+0060). Dit is nodig wanneer de inhoud van een regel syntactisch wordt voltooid, maar de volgende regel tokens bevat die zijn bedoeld om te worden gekoppeld aan de vorige regel. Bijvoorbeeld:

$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

In dit voorbeeld geeft de backtick aan dat de bronlijn wordt voortgezet. De volgende expressie is gelijk aan $number = 10 + 20 - 50.

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

2.3 Tokens

Syntaxis:

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

Beschrijving:

Een token is het kleinste lexicale element binnen de PowerShell-taal.

Tokens kunnen worden gescheiden door nieuwe regels, opmerkingen, witruimte of een combinatie hiervan.

2.3.1 Trefwoorden

Syntaxis:

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

Beschrijving:

Een trefwoord is een reeks tekens die een speciale betekenis hebben wanneer deze worden gebruikt op een contextafhankelijke plaats. Dit is meestal het eerste token in een -instructie; Er zijn echter andere locaties, zoals aangegeven door de grammatica. (Een token dat lijkt op een trefwoord, maar niet wordt gebruikt in een trefwoordcontext, is een opdrachtnaam of een opdrachtargument.)

De trefwoorden class, define, from, en usingzijn var gereserveerd voor toekomstig gebruik.

Notitie

Opmerking van de editor: de class trefwoorden en using zijn geïntroduceerd in PowerShell 5.0. Zie about_Classes en about_Using.

2.3.2 Variabelen

Syntaxis:

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

Beschrijving:

Variabelen worden in detail besproken in (;5). De variabele $? wordt besproken in :2.3.2.2. Scopes worden besproken in :3.5.

De variabelen en $$ zijn $^ gereserveerd voor gebruik in een interactieve omgeving, die buiten het bereik van deze specificatie valt.

Er zijn twee manieren om een variabelenaam te schrijven: een naam van een variabele met accolades, $die begint met , gevolgd door een reeks met accolades met scheidingstekens van een of meer bijna willekeurige tekens; en een gewone variabelenaam ,$ die ook begint met , gevolgd door een set van een of meer tekens uit een meer beperkende set dan een variabele met accolades toestaat. Elke gewone variabelenaam kan worden uitgedrukt met behulp van de bijbehorende naam van een variabele met accolades.

$totalCost
$Maximum_Count_26

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

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

Er is geen limiet voor de lengte van de naam van een variabele, alle tekens in de naam van een variabele zijn significant en hoofdletters zijn niet uniek.

Er zijn verschillende soorten variabelen: door de gebruiker gedefinieerd (2.3.2.1), automatisch (2.3.2.2) en voorkeur (2.3.2.3). Ze kunnen allemaal naast elkaar bestaan binnen hetzelfde bereik (3,5).

Houd rekening met de volgende functiedefinitie en aanroepen:

function Get-Power ([long]$base, [int]$exponent) { ... }

Get-Power 5 3 # $base is 5, $exponent is 3
Get-Power -exponent 3 -base 5 # " " "

Elk argument wordt één voor één doorgegeven op positie of naam. Een set argumenten kan echter worden doorgegeven als een groep met uitbreiding naar afzonderlijke argumenten die worden verwerkt door de runtime-omgeving. Deze automatische argumentuitbreiding wordt splatting genoemd. Bijvoorbeeld:

$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

Dit wordt bereikt door te gebruiken @ in plaats van $ als het eerste teken van de variabele die wordt doorgegeven. Deze notatie kan alleen worden gebruikt in een argument voor een opdracht.

Namen worden gepartitied in verschillende naamruimten die elk zijn opgeslagen op een virtueel station (3.1). Variabelen worden bijvoorbeeld opgeslagen op Variable:, omgevingsvariabelen worden opgeslagen op Env:, Function:functies worden opgeslagen op en aliassen worden opgeslagen op Alias:. Al deze namen zijn toegankelijk als variabelen met behulp van de productie van de variabele-naamruimte binnen het variabele bereik. Bijvoorbeeld:

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

Elk gebruik van een variabelenaam met een expliciete Variable: naamruimte is gelijk aan het gebruik van dezelfde variabelenaam zonder die kwalificatie. En zijn $v bijvoorbeeld $Variable:v uitwisselbaar.

Variabelen kunnen niet alleen worden gedefinieerd in de taal, maar ook door de cmdlet New-Variable.

2.3.2.1 Door de gebruiker gedefinieerde variabelen

Elke variabelenaam die is toegestaan door de grammatica, maar niet wordt gebruikt door automatische variabelen of voorkeursvariabelen, is beschikbaar voor door de gebruiker gedefinieerde variabelen.

Door de gebruiker gedefinieerde variabelen worden gemaakt en beheerd door een door de gebruiker gedefinieerd script.

2.3.2.2 Automatische variabelen

Automatische variabelen slaan statusinformatie over de PowerShell-omgeving op. Hun waarden kunnen worden gelezen in door de gebruiker geschreven scripts, maar niet worden geschreven.

Notitie

De tabel die oorspronkelijk in dit document is gevonden, is verwijderd om duplicatie te verminderen. Zie Voor een volledige lijst met automatische variabelen about_Automatic_Variables.

2.3.2.3 Voorkeursvariabelen

Voorkeursvariabelen slaan gebruikersvoorkeuren voor de sessie op. Ze worden gemaakt en geitialiseerd door de PowerShell-runtime-omgeving. Hun waarden kunnen worden gelezen en geschreven in een door de gebruiker geschreven script.

Notitie

De tabel die oorspronkelijk in dit document is gevonden, is verwijderd om duplicatie te verminderen. Zie voor een volledige lijst met voorkeursvariabelen about_Preference_Variables.

2.3.3-opdrachten

Syntaxis:

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 Parameters

Syntaxis:

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

Beschrijving:

Wanneer een opdracht wordt aangeroepen, kan er informatie aan worden doorgegeven via een of meer argumenten waarvan de waarden worden gebruikt vanuit de opdracht via een set bijbehorende parameters. Het proces van het afstemmen van parameters op argumenten wordt parameterbinding genoemd.

Er zijn drie soorten argumenten:

  • Switchparameter (--8.10.5) : dit heeft de opdrachtparameter form, waarbij first-parameter-char en parameter-chars samen de naam van de switch vormen, die overeenkomt met de naam van een parameter ( -zonder de vooraanleiding ) in de opdracht die wordt aangeroepen. Als de dubbele punt wordt weggelaten, geeft de aanwezigheid van dit argument aan dat de bijbehorende parameter wordt ingesteld op $true. Als de volg dubbele punt aanwezig is, moet het argument direct hierna een waarde van het type bool aanwijzen en wordt de bijbehorende parameter ingesteld op die waarde. De volgende aanroepen zijn bijvoorbeeld gelijkwaardig:

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

  • Parameter met argument (--8.10.2) -- Dit heeft de opdrachtparameter form, waarbij first-parameter-char en parameter-chars samen de parameternaam vormen, die overeenkomt met de naam van een parameter (zonder de vooraanstaand -) in de opdracht die wordt aangeroepen. Er mag geen dubbele punt volgen. Met het volgende argument wordt een gekoppelde waarde aangeduid. Als u bijvoorbeeld een opdracht geeft, Get-Powerdie parameters en $base $exponentheeft, zijn de volgende aanroepen gelijkwaardig:

    Get-Power -base 5 -exponent 3
Get-Power -exponent 3 -base 5

  • Positioneel argument (8.10.2) - Argumenten en de bijbehorende parameters in opdrachten hebben posities met de eerste positie nul. Het argument op positie 0 is gebonden aan de parameter op positie 0; het argument op positie 1 is gebonden aan de parameter op positie 1; en meer. Bijvoorbeeld, op basis van een opdracht Get-Powerdie parameters en $base $exponent op respectievelijk de posities 0 en 1 heeft, roept het volgende die opdracht aan:

    Get-Power 5 3

Zie .8.2 voor meer informatie over de speciale parameters -- en --%.

Wanneer een opdracht wordt aangeroepen, kan een parameternaam worden afgekort; elk afzonderlijk vooraanstaand deel van de volledige naam kan worden gebruikt, op voorwaarde dat ondubbelzinnig is met betrekking tot de namen van de andere parameters die door dezelfde opdracht worden geaccepteerd.

Zie voor meer informatie over parameterbinding .8.14.

2.3.5 Literals

Syntaxis:

literal:
    integer-literal
    real-literal
    string-literal

2.3.5.1 Numerieke letterlijke waarde

Er zijn twee soorten numerieke letterlijke waarde: geheel getal (2.3.5.1.1) en echt (2.3.5.1.2). Beide kunnen vermenigvuldigingsachtervoegsels hebben (2.3.5.1.3).

2.3.5.1.1 Integer literals

Syntaxis:

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

Beschrijving:

Het type van een letterlijke waarde van een geheel getal wordt bepaald door de waarde, de aanwezigheid of afwezigheid van een lang-type-achtervoegsel en de aanwezigheid van een numerieke vermenigvuldigingscoëfficiënt (2.3.5.1.3).

Voor een letterlijke geheel getal zonder lang-type-achtervoegsel

  • Als de waarde ervan kan worden weergegeven door het type int (";4.2.3), is dat het type;
  • Anders, als de waarde kan worden weergegeven door het type lang (4.2.3), dat is het type.
  • Als de waarde anders kan worden weergegeven door het type decimaal (2.3.5.1.2), is dat het type.
  • Anders wordt het weergegeven door het type double (2.3.5.1.2).

Voor een literal met gehele getallen met een lang-type-achtervoegsel

  • Als de waarde ervan kan worden weergegeven door het type long (";4.2.3), is dat het type;
  • Anders is die letterlijke vorm onwel.

In de twos-complementweergave van waarden van gehele getallen is er één negatievere waarde dan er positief is. Voor het type int is die extra waarde -2147483648. Voor het lange type is die extra waarde -9223372036854775808. Hoewel het token 2147483648 normaal gesproken wordt behandeld als een letterlijke waarde van het type lang, als het onmiddellijk wordt voorafgegaan door de unaire operator , worden die operator en letterlijke waarde beschouwd als een letterlijke waarde van het type int met de kleinste waarde. En hoewel het token 9223372036854775808 normaal gesproken wordt behandeld als een echte letterlijke waarde van het type decimaal, worden die operator en letterlijke waarde beschouwd als een letterlijke waarde van het type met de kleinste waarde als deze direct worden voorafgegaan door de unaire operator .

Enkele voorbeelden van letterlijke getallen met gehele getallen zijn 123 (int), 123L (lang) en 20000000000 (lang).

Een letterlijke letterlijke geheel getal van het type byte bestaat niet.

2.3.5.1.2 Real literals

Syntaxis:

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)

Beschrijving:

Een echte letterlijke waarde kan een numerieke vermenigvuldigingscoëfficiënt (2.3.5.1.3) bevatten.

Er zijn twee soorten echte letterlijke waarde: dubbel en decimaal. Deze worden aangegeven door respectievelijk de afwezigheid of aanwezigheid van het decimaal-type-achtervoegsel. (Een echte float-letterlijke float bestaat niet.)

Een dubbele werkelijke letterlijke gegevens heeft een dubbel type (4.2.4.1). Een decimaal echt letterlijke waarde heeft het type decimaal (4.2.4.2). Het volgen van nullen in het breukgedeelte van een decimaal echt letterlijke waarde is aanzienlijk.

Als de waarde van de decimale cijfers van het exponent-part in een dubbele werkelijke letterlijke waarde kleiner is dan de minimaal ondersteunde waarde, is de waarde van die dubbele werkelijke letterlijke waarde 0. Als de waarde van de decimale cijfers van het exponent-part in een decimale werkelijke letterlijke waarde kleiner is dan de minimaal ondersteunde waarde, is die letterlijke waarde onwel. Als de waarde van de decimale cijfers van exponent-part in een dubbele of decimale werkelijke letterlijke waarde groter is dan het maximum dat wordt ondersteund, is die letterlijke waarde onwel.

Enkele voorbeelden van dubbele werkelijke letterlijke letterlijke cijfers zijn 1., 1.23, .45e35, 32.e+12 en 123.456E-231.

Enkele voorbeelden van letterlijke decimalen zijn 1d (met schaal 0), 1,20d (met schaal 2), 1,23450e1d (12,3450, met schaal 4), 1,2345e3d (dat wil zeggen, 1234.5, dat schaal 1 heeft, 1.2345e-1d (0,12345 met schaal 5) en 1,2345e-3d (bijvoorbeeld 0,0012345, met schaal 7).

Notitie

Omdat een dubbele werkelijke letterlijke macht geen breuk- of exponentdeel hoeft te hebben, worden de haakjes in gegroepeerd (123). M is nodig om ervoor te zorgen dat de eigenschap of methode M wordt geselecteerd voor het gehele getalobject waarvan de waarde 123 is. Zonder deze haakjes zou de werkelijke letterlijke vorm slecht worden gevormd.

Notitie

Hoewel PowerShell geen letterlijke waarde biedt voor infiniteiten en NaN's, kunnen equivalenten met dubbele letterlijke waarde worden verkregen van de statische alleen-lezeneigenschappen PositiveInfinity, NegativeInfinity en NaN van de typen float en double (4.2.4.1).

Met de grammatica kan wat begint als een dubbele echte letterlijke letterlijke gegevens een achtervoegsel l of L type hebben. Een dergelijk token is eigenlijk een letterlijke waarde van een geheel getal waarvan de waarde wordt weergegeven door het type long.

Notitie

Deze functie is behouden voor achterwaartse compatibiliteit met eerdere versies van PowerShell. Programmeurs worden echter afgeraden om letterlijke waarden van gehele getallen van dit formulier te gebruiken, omdat ze de werkelijke waarde van de letterlijke waarde eenvoudig kunnen verborgen. 1.2L heeft bijvoorbeeld waarde 1, 1,2345e1L heeft waarde 12 en 1,2345e-5L heeft de waarde 0, geen van deze is direct duidelijk.

2.3.5.1.3 Vermenigvuldigingsachtervoegsels

Syntaxis:

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

Beschrijving:

Voor het gemak kunnen gehele getallen en werkelijke letterlijke waardes een numerieke vermenigvuldigingscoëfficiënt bevatten, die een van de veelgebruikte machten van 10 aangeeft. numerieke vermenigvuldigingscoëfficiënt kan worden geschreven in een combinatie van hoofdletters of kleine letters.

Multiplier Betekenis Voorbeeld
Kb kilobyte (1024) 1 kB ≡ 1024
Mb megabyte (1024 x 1024) 1,30 MB ≡ 1363148.80
Gb gigabyte (1024 x 1024 x 1024) 0x10 Gb ≡ 17179869184
Tb terabyte (1024 x 1024 x 1024 x 1024) 1,4e23 tb ≡ 1.5393162788864E+35
pb petabyte (1024 x 1024 x 1024 x 1024 x 1024) 0x12Lpb ≡ 20266198323167232

2.3.5.2 Letterlijke tekenreeksen

Syntaxis:

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 @

Beschrijving:

Er zijn vier soorten letterlijke tekenreeksen:

  • verbatim-string-literal (single-line single-quoted), een reeks van nul of meer tekens die worden scheidingstekens door een paar enkele aaneengavetekens. Voorbeelden zijn '' en 'rood'.

  • expandable-string-literal (dubbel-quoted op één regel), een reeks van nul of meer tekens die wordt scheidingstekens door een paar dubbele aaneengavetekens. Voorbeelden zijn '' en 'rood'.

  • verbatim-here-string-literal (multi-line single-quoted), wat een reeks van nul of meer tekens is die wordt begrensd door de tekenparen @single-quote-character en single-quote-character@, die respectievelijk zijn opgenomen op twee of meer bronregels. Een aantal voorbeelden:

    @'
'@

@'
line 1
'@

@'
line 1
line 2
'@

  • expandable-here-string-literal (dubbel-quoted met meerdere regels), een reeks van nul of meer tekens die worden scheidingstekens @double-quote-character en double-quote-character@, die respectievelijk zijn opgenomen op twee of meer bronregels. Een aantal voorbeelden:

    @"
"@

@"
line 1
"@

@"
line 1
line 2
"@

Voor verbatim-here-string-literals en expandable-here-string-literals, met uitzondering van witruimte (die wordt genegeerd), kunnen er geen tekens volgen op dezelfde bronregel als het scheidingsteken voor openen en kunnen er geen tekens voorafgaan op dezelfde bronregel als het afsluitende scheidingstekenpaar.

De body van een verbatim-here-string-literal of een expandable-here-string-literal begint aan het begin van de eerste bronregel na het scheidingsteken openen en eindigt aan het einde van de laatste bronregel vóór het afsluitende scheidingsteken. De body is mogelijk leeg. Het regelinsluiter op de laatste bronregel voorafgaand aan het afsluitende scheidingsteken maakt geen deel uit van de body van die letterlijke gegevens.

Een letterlijke gegevens van elk van deze typen heeft een tekenreeks van het type (4.3.1).

Het teken dat wordt gebruikt om verbatim-string-literal of expandable-string-literal te definieren, kan worden opgenomen in een dergelijke letterlijke tekenreeks door dat teken tweemaal achter elkaar te schrijven. Bijvoorbeeld 'What''s the time?' en "I said, ""Hello"".". Een enkel aan te geven teken heeft echter geen speciale betekenis binnen een expandable-string-literal en een dubbel aan te geven-teken heeft geen speciale betekenis binnen een verbatim-string-literal.

Een expandable-string-literal en een expandable-here-string-literal kunnen escaped-characters (*2.3.7) bevatten. Wanneer bijvoorbeeld de volgende letterlijke tekenreeks naar de pijplijn wordt geschreven, is het resultaat zoals hieronder wordt weergegeven:

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

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

Als een expandable-string-literal of expandable-here-string-literal de naam van een variabele bevat, tenzij die naam direct wordt voorafgegaan door een escape-teken, wordt deze vervangen door de tekenreeksweergave van de waarde van die variabele (6,7). Dit staat bekend als het vervangen van variabelen.

Notitie

Als de naam van de variabele deel uitmaakt van een grotere expressie, wordt alleen de naam van de variabele vervangen. Als bijvoorbeeld een matrix $a is die de elementen 100 en 200 bevat, ">$a.Length<" resulteert dit in >100 200.Length< , terwijl ">$($a.Length)<" resulteert in >2<. Zie hieronder de subexpressie-uitbreiding.

Bijvoorbeeld de broncode

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

resulteert in de expandable-string-literal

The value of $count is 10.

Overweeg de volgende:

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

Het resultaat is

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

expandable-string-literals en expandable-here-string-literals ondersteunen ook een soort vervanging met de naam subexpressie-uitbreiding, $( ... ) door tekst van het formulier te behandelen als een subexpressie (7.1.6). Deze tekst wordt vervangen door de tekenreeksweergave van de waarde van die expressie (6.8). Witruimte die wordt gebruikt om tokens binnen de instructielijst van de subexpressie te scheiden, wordt genegeerd wat betreft de constructie van de resultaatreeks.

De voorbeelden,

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

resulteert in de volgende expandable-string-literals:

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

De volgende bron,

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

resulteert in de volgende expandable-string-literal:

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

Deze vier regels hadden als volgt beknopter kunnen worden geschreven:

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

In het volgende voorbeeld

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

de resulterende expandable-string-literal is als volgt:

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

Zoals weergegeven, kan een subexpressie letterlijke tekenreeksen bevatten met zowel vervanging van variabelen als uitbreiding van subexpressie. Houd er ook rekening mee dat er geen escape-tekenreeks hoeft te worden gebruikt voor de scheidingstekens van de binnenste expandable-string-literal; het feit dat ze zich in een subexpressie hebben, betekent dat ze geen einden kunnen zijn voor de buitenste expandable-string-literal.

Een expandable-string-literal of expandable-here-string-literal met een variabelevervanging of subexpressie-uitbreiding wordt geëvalueerd telkens als letterlijke gegevens worden gebruikt; bijvoorbeeld

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

dit resulteert in de volgende expandable-string-literals:

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

De inhoud van een letterlijke verbatim-here-string-literal wordt verbatim genomen, inclusief eventuele vooraanstaande of aaneenstaande witruimte in de hoofdruimte. Daarom hoeven ingesloten enkelopgavetekens niet te worden verdubbeld en is er geen vervanging of uitbreiding. Bijvoorbeeld:

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

wat resulteert in de letterlijke

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

De inhoud van een expandable-here-string-literal is onderhevig aan vervanging en uitbreiding, maar elke voor- of nabestaande witruimte in de hoofdletter, maar buiten subexpressie, wordt verbatim genomen en ingesloten dubbele aaneengavetekens hoeven niet te worden verdubbeld. Bijvoorbeeld:

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

wat resulteert in de volgende letterlijke gegevens bij uitvlitsen:

That's it!
2 * 3 = 6

Voor zowel verbatim-here-string-literals als expandable-here-string-literals wordt elk regel-eind in de body weergegeven in de resulterende letterlijke letterlijke op een door de implementatie gedefinieerde manier. Bijvoorbeeld, in

$lit = @"
abc
xyz
"@

de tweede regel van de hoofdlijn heeft twee vooraanstaand spaties, en de eerste en tweede regel van de hoofdlijn hebben regel-einden; Het eind-eind voor de tweede regel van de body maakt echter geen deel uit van die body. De resulterende letterlijke waarde is gelijk aan: "abc<implementation-defined character sequence>xyz".

Notitie

Om de leesbaarheid van de bron te verbeteren, kunnen lange letterlijke tekenreeksen worden verbroken over meerdere bronlijnen zonder dat er regel-einden worden ingevoegd. Dit wordt gedaan door elk deel te schrijven als een afzonderlijke letterlijke en door de onderdelen samen tevoegen met de operator + (7.7.2). Met deze operator kunnen operanden elk van de vier soorten letterlijke tekenreeksen aanwijzen.

Notitie

Hoewel een letterlijke tekenreeks niet per se bestaat, kan hetzelfde effect worden bereikt door als volgt toegang te krijgen tot het eerste teken in een tekenreeks van 1 teken: [char]"A" of "A"[0].

Voor zowel verbatim-here-string-literals als expandable-here-string-literals wordt elk regel-eind in de body exact weergegeven zoals deze is opgegeven.

2.3.5.3 Null literal

Zie de automatische variabele $null (2.3.2.2).

2.3.5.4 Booleaanse letterlijke cijfers

Zie de automatische variabelen $false en $true (2.3.2.2).

2.3.5.5 Letterlijke matrix

Met PowerShell kunnen expressies van het matrixtype (9) worden geschreven met behulp van de unaire komma-operator (7.2.1), matrixexpressie (7.1.7), de binaire komma-operator (7.3) en de bereikoperator (7.4).

2.3.5.6 Hash literals

Met PowerShell kunnen expressies van het type Hashtable (;10) worden geschreven met behulp van een hash-literal-expression (*7.1.9)

2.3.5.7 Typenamen

Syntaxis:

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 Operators en leestekens

Syntaxis:

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

Beschrijving:

&& en || zijn gereserveerd voor toekomstig gebruik.

Notitie

Opmerking van de editor: de pijplijnketenoperators && en || zijn geïntroduceerd in PowerShell 7. Zie about_Pipeline_Chain_Operators.

De naam van het volgende streepje in een operator is alleen voor dat doel gereserveerd in de context van een operator.

Een operator die begint met een streepje mag geen witruimte hebben tussen dat streepje en het token dat erop volgt.

2.3.7 Escape-tekens

Syntaxis:

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

Beschrijving:

Een escape-teken is een manier om een speciale interpretatie toe te wijzen aan een teken door het een voorvoegsel Backtick-teken (U+0060) te geven. In de volgende tabel ziet u de betekenis van elk escape-teken:

Escape-teken Betekenis
`a Waarschuwing (U+0007)
`b Backspace (U+0008)
`f Formulierfeed (U+000C)
`n Nieuwe regel (U+000A)
`r Retour met een rij (U+000D)
`t Horizontaal tabblad (U+0009)
`v Verticaal tabblad (U+0009)
`' Enkele offerte (U+0027)
`" Dubbele prijsopgave (U+0022)
`` Backtick (U+0060)
`0 NUL (U+0000)
`x Als x een ander teken is dan de tekens die hierboven worden weergegeven, wordt het backtick-teken genegeerd en x wordt het letterlijk genomen.

De implicatie van de laatste vermelding in de bovenstaande tabel is dat spaties die anders tokens zouden scheiden, deel kunnen uitmaken van een token. Een bestandsnaam met een spatie kan bijvoorbeeld worden geschreven als Test` Data.txt (evenals 'Test Data.txt' of "Test Data.txt").