2. Struttura lessicale

2.1 Grammatiche

Questa specifica illustra la sintassi del linguaggio di PowerShell usando due grammatiche. La grammatica lessicale (§B.1) mostra come i caratteri Unicode vengono combinati per formare terminatori di riga, commenti, spazi vuoti e token. La grammatica sintattica (§B.2) mostra come i token risultanti dalla grammatica lessicale vengono combinati per formare script di PowerShell.

Per praticità, i frammenti di queste grammatiche vengono replicati in posizioni appropriate in tutta questa specifica.

Qualsiasi uso dei caratteri da "a" a "z" nelle grammatiche non fa distinzione tra maiuscole e minuscole. Ciò significa che la distinzione tra maiuscole e minuscole in variabili, alias, nomi di funzioni, parole chiave, istruzioni e operatori viene ignorata. In questa specifica, tuttavia, questi nomi vengono scritti in lettere minuscole, ad eccezione di alcune variabili automatiche e di preferenza.

2.2 Analisi lessicale

2.2.1 Script

Sintassi:

Suggerimento

La ~opt~ notazione nelle definizioni della sintassi indica che l'entità lessicale è facoltativa nella sintassi.

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

Descrizione:

Il flusso di origine di input per un convertitore di PowerShell è l'input in uno script che contiene una sequenza di caratteri Unicode. L'elaborazione lessicale di questo flusso comporta la riduzione di tali caratteri in una sequenza di token, che diventano l'input dell'analisi sintattica.

Uno script è un gruppo di comandi di PowerShell archiviati in un file di script. Lo script stesso non ha alcun nome, di per sé, e ne prende il nome dal file di origine. La fine del file indica la fine dello script.

Uno script può contenere facoltativamente una firma digitale. Un ambiente host non è necessario per elaborare testo che segue una firma o qualsiasi elemento simile a una firma. La creazione e l'uso di firme digitali non sono coperte da questa specifica.

2.2.2 Terminatori di riga

Sintassi:

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

Descrizione:

La presenza di new-line-character s nel flusso di origine di input lo divide in righe che possono essere usate per la segnalazione degli errori e il rilevamento della fine di un commento a riga singola.

Un terminatore di riga può essere considerato come spazio vuoto (§2.2.4).

2.2.3 Commenti

Sintassi:

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 #

Descrizione:

Il codice sorgente può essere annotato usando i commenti.

Un commento a riga singola inizia con il carattere e termina con un nuovo carattere di # riga.

Un commento delimitato inizia con la coppia di caratteri e termina con la coppia di caratteri <# #> . Può verificarsi come parte di una riga di origine, come intera riga di origine o può estendersi su un numero qualsiasi di righe di origine.

Un commento viene considerato come spazio vuoto.

Le produzione precedenti implicano che

  • I commenti non vengono annidati.
  • Le sequenze di caratteri <# e #> non hanno alcun significato speciale in un commento a riga singola.
  • Il carattere # non ha alcun significato speciale in un commento delimitato.

La grammatica lessicale implica che i commenti non possono verificarsi all'interno dei token.

Per informazioni sulla creazione di file script contenenti commenti con valori speciali usati per generare la documentazione dai file di script, vedere .A.

Un requires-comment specifica i criteri che devono essere soddisfatti per l'esecuzione dello script contenitore. Il criterio principale è la versione di PowerShell usata per eseguire lo script. Il requisito di versione minimo viene specificato come segue:

#requires -Version N[.n]

Dove N è la versione principale (obbligatoria) e n è la versione secondaria (facoltativa).

Un requires-comment può essere presente in qualsiasi file di script. tuttavia, non può essere presente all'interno di una funzione o di un cmdlet. Deve essere il primo elemento in una riga di origine. Uno script può contenere più elementi requires-comment.

Una sequenza di caratteri viene riconosciuta come commento solo se la sequenza inizia con # o <# . Ad esempio, hello#è considerato un singolo token, mentre hello #there è considerato il token hello seguito da un commento a riga singola. Oltre allo spazio vuoto seguente, la sequenza di inizio del commento può essere preceduta anche da qualsiasi carattere di terminazione dell'espressione o di terminazione dell'istruzione (ad esempio ) , , , , o } ] ' " ; ).

Un requires-comment non può essere presente all'interno di uno snap-in.

Esistono altre quattro forme di un'operazione requires-comment:

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

2.2.4 Spazio vuoto

Sintassi:

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

Descrizione:

Gli spazi vuoti sono costituiti da qualsiasi sequenza di uno o più spazi vuoti.

Fatta eccezione per il fatto che gli spazi vuoti possono fungere da separatore per i token, vengono ignorati.

A differenza di alcuni linguaggi più diffusi, PowerShell non considera i caratteri di terminazione di riga (§2.2.2) come spazi vuoti. Tuttavia, un carattere di terminazione di riga può essere considerato come spazio vuoto facendolo precedere immediatamente da un carattere di backtick ` (U+0060). Questa operazione è necessaria quando il contenuto di una riga è completo sintatticamente, ma la riga seguente contiene token da associare alla riga precedente. Ad esempio,

$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 questo esempio, il backtick indica che la riga di origine è continua. L'espressione seguente equivale a $number = 10 + 20 - 50 .

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

2.3 Token

Sintassi:

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

Descrizione:

Un token è l'elemento lessicale più piccolo all'interno del linguaggio di PowerShell.

I token possono essere separati da nuove righe, commenti, spazi vuoti o qualsiasi combinazione.

2.3.1 Parole chiave

Sintassi:

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

Descrizione:

Una parola chiave è una sequenza di caratteri che ha un significato speciale quando viene usata in una posizione dipendente dal contesto. Nella maggior parte dei casi, si tratta del primo token in un'istruzione. Tuttavia, esistono altre posizioni, come indicato dalla grammatica. Un token simile a una parola chiave, ma non usato in un contesto di parola chiave, è un nome di comando o un argomento di comando.

Le parole class chiave , , , e sono riservate per un uso define from using var futuro.

Nota

Nota dell'editor: le class parole chiave e sono state introdotte in using PowerShell 5.0. Vedere about_Classes e about_Using.

2.3.2 Variabili

Sintassi:

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

Descrizione:

Le variabili sono descritte in dettaglio in (Sezione 5). La variabile $? è descritto in §2.3.2.2. Gli ambiti sono descritti in [Sezione 3.5.][]

Le variabili $$ e sono riservate per l'uso in un ambiente interattivo, che non rientra $^ nell'ambito di questa specifica.

Esistono due modi per scrivere un nome di variabile: un nome di variabile tra parentesi graffe , che inizia con , seguito da un set delimitato da parentesi graffe di uno o più caratteri quasi arbitrari; e un nome di variabile normale, che inizia anche con , seguito da un set di uno o più caratteri di un set più restrittivo rispetto a un nome di variabile tra parentesi $ graffe $ consentite. Ogni nome di variabile normale può essere espresso usando un nome di variabile tra parentesi graffe corrispondente.

$totalCost
$Maximum_Count_26

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

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

Non esiste alcun limite per la lunghezza di un nome di variabile, tutti i caratteri in un nome di variabile sono significativi e le lettere maiuscole/minuscole non sono distinte.

Esistono diversi tipi di variabili: definita dall'utente ([§2.3.2.1),][]automatica (§2.3.2.2) e preferenza (§2.3.2.3). Possono coesistere tutte nello stesso ambito (§3.5).

Si considerino la definizione di funzione e le chiamate seguenti:

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

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

Ogni argomento viene passato per posizione o nome, uno alla volta. Tuttavia, un set di argomenti può essere passato come gruppo con l'espansione in singoli argomenti gestiti dall'ambiente di runtime. Questa espansione automatica degli argomenti è nota come splatting. Ad esempio,

$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

Questa operazione viene ottenuta @ usando anziché come primo carattere della variabile $ passata. Questa notazione può essere usata solo in un argomento di un comando.

I nomi vengono partizionati in vari spazi dei nomi, ognuno dei quali è archiviato in un'unità virtuale (§3.1). Ad esempio, le variabili vengono archiviate in , le variabili di ambiente vengono archiviate in , le funzioni vengono Variable: Env: archiviate in Function: e gli alias vengono archiviati in Alias: . È possibile accedere a tutti questi nomi come variabili usando la produzione variable-namespace all'interno di variable-scope. Ad esempio,

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

Qualsiasi uso di un nome di variabile con uno spazio dei nomi esplicito equivale all'uso dello stesso nome Variable: di variabile senza tale qualifica. Ad esempio, $v e $Variable:v sono intercambiabili.

Oltre a essere definite nel linguaggio , le variabili possono essere definite anche dal cmdlet New-Variable.

2.3.2.1 Variabili definite dall'utente

Qualsiasi nome di variabile consentito dalla grammatica, ma non usato dalle variabili automatiche o delle preferenze, è disponibile per le variabili definite dall'utente.

Le variabili definite dall'utente vengono create e gestite dallo script definito dall'utente.

2.3.2.2 Variabili automatiche

Le variabili automatiche archiviano informazioni sullo stato dell'ambiente PowerShell. I valori possono essere letti nello script scritto dall'utente, ma non scritti.

Nota

La tabella originariamente presente in questo documento è stata rimossa per ridurre la duplicazione. Per un elenco completo delle variabili automatiche, vedere about_Automatic_Variables.

2.3.2.3 Variabili di preferenza

Le variabili preferenza archiviano le preferenze utente per la sessione. Vengono creati e inizializzati dall'ambiente di runtime di PowerShell. I valori possono essere letti e scritti nello script scritto dall'utente.

Nota

La tabella originariamente presente in questo documento è stata rimossa per ridurre la duplicazione. Per un elenco completo delle variabili di preferenza, vedere about_Preference_Variables.

2.3.3 Comandi

Sintassi:

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 Parametri

Sintassi:

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

Descrizione:

Quando viene richiamato un comando, le informazioni possono essere passate a esso tramite uno o più argomenti i cui valori sono accessibili dall'interno del comando tramite un set di parametri corrispondenti. Il processo di corrispondenza dei parametri con gli argomenti è detto associazione di parametri.

Esistono tre tipi di argomento:

  • Parametro switch (§8.10.5): ha il formato command-parameter dove first-parameter-char e parameter-chars costituiscono insieme il nome dell'opzione, che corrisponde al nome di un parametro (senza il relativo carattere iniziale) nel comando - richiamato. Se i due punti finali vengono omessi, la presenza di questo argomento indica che il parametro corrispondente deve essere impostato su $true . Se sono presenti i due punti finali, l'argomento immediatamente seguente deve designare un valore di tipo bool e il parametro corrispondente è impostato su tale valore. Ad esempio, le chiamate seguenti sono equivalenti:

    Set-MyProcess -Strict
    Set-MyProcess -Strict: $true
    
  • Parametro con argomento (§8.10.2): ha il formato command-parameter dove first-parameter-char e parameter-chars costituiscono insieme il nome del parametro, che corrisponde al nome di un parametro (senza il relativo -iniziale) nel comando richiamato. Non devono essere presenti due punti finali. L'argomento immediatamente seguente definisce un valore associato. Ad esempio, dato un comando Get-Power , che dispone di parametri e , le chiamate seguenti sono $base $exponent equivalenti:

    Get-Power -base 5 -exponent 3
    Get-Power -exponent 3 -base 5
    
  • Argomento posizionale (§8.10.2): gli argomenti e i parametri corrispondenti all'interno dei comandi hanno posizioni con la prima posizione zero. L'argomento nella posizione 0 è associato al parametro nella posizione 0. L'argomento nella posizione 1 è associato al parametro nella posizione 1; E così via. Ad esempio, dato un comando , che dispone di parametri e nelle posizioni 0 e 1, rispettivamente, il comando viene Get-Power $base $exponent richiamato dal codice seguente:

    Get-Power 5 3
    

Per informazioni dettagliate sui parametri speciali e , vedere La sezione [8.2.][] -- --%

Quando viene richiamato un comando, un nome di parametro può essere abbreviato. È possibile usare qualsiasi parte iniziale distinta del nome completo, purché non sia ambigua rispetto ai nomi degli altri parametri accettati dallo stesso comando.

Per informazioni sull'associazione di parametri, [vedere §8.14][].

2.3.5 Valori letterali

Sintassi:

literal:
    integer-literal
    real-literal
    string-literal

2.3.5.1 Valori letterali numerici

Esistono due tipi di valori letterali numerici: integer (§2.3.5.1.1) e real (§2.3.5.1.2). Entrambi possono avere suffissi di moltiplicatore (§2.3.5.1.3).

2.3.5.1.1 Valori letterali integer

Sintassi:

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

Descrizione:

Il tipo di un valore letterale integer è determinato dal relativo valore, dalla presenza o dall'assenza di long-type-suffix e dalla presenza di un moltiplicatore numerico ( §2.3.5.1.3).

Per un valore letterale integer senza suffisso long-type

  • Se il relativo valore può essere rappresentato dal tipo int (§4.2.3), ovvero il tipo;
  • In caso contrario, se il relativo valore può essere rappresentato dal tipo long (§4.2.3), ovvero il tipo.
  • In caso contrario, se il relativo valore può essere rappresentato dal tipo decimal (§2.3.5.1.2), ovvero il tipo.
  • In caso contrario, è rappresentato dal tipo double (§2.3.5.1.2).

Per un valore letterale integer con suffisso long-type

  • Se il valore può essere rappresentato dal tipo long (§4.2.3), ovvero il tipo;
  • In caso contrario, il formato del valore letterale non è corretto.

Nella rappresentazione a complemento a due dei valori integer è presente un valore negativo maggiore di quello positivo. Per il tipo int, il valore aggiuntivo è -2147483648. Per il tipo long, il valore aggiuntivo è -9223372036854775808. Anche se il token 2147483648 verrebbe in genere considerato come valore letterale di tipo long, se viene preceduto immediatamente dall'operatore unario - , tale operatore e valore letterale vengono considerati come un valore letterale di tipo int con il valore più piccolo. Analogamente, anche se il token 9223372036854775808 verrebbe in genere considerato come un valore letterale reale di tipo decimal, se viene immediatamente preceduto dall'operatore unario - , tale operatore e valore letterale vengono considerati come un valore letterale di tipo long con il valore più piccolo.

Alcuni esempi di valori letterali integer sono 123 (int), 123L (long) e 200000000000 (long).

Non esiste un valore letterale integer di tipo byte.

2.3.5.1.2 Valori letterali reali

Sintassi:

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)

Descrizione:

Un valore letterale reale può contenere un moltiplicatore numerico (§2.3.5.1.3).

Esistono due tipi di valore letterale reale: double e decimal. Questi valori sono indicati rispettivamente dall'assenza o dalla presenza di decimal-type-suffix. Non esiste un valore letterale reale float.

Un valore letterale reale double è di tipo double (§4.2.4.1). Un valore letterale decimale reale è di tipo decimal (§4.2.4.2). Gli zeri finali nella parte frazionaria di un valore letterale decimale reale sono significativi.

Se il valore delle cifre decimali della parte esponente in un valore letterale reale doppio è minore del valore minimo supportato, il valore di tale valore letterale reale doppio è 0. Se il valore delle cifre decimali della parte esponente in un valore letterale decimale reale è minore del valore minimo supportato, il formato del valore letterale non è corretto. Se il valore delle cifre decimali della parte esponente in un valore letterale reale double o decimal è maggiore del valore massimo supportato, tale valore letterale non è in formato corretto.

Alcuni esempi di valori letterali reali double sono 1., 1.23, .45e35, 32.e+12 e 123.456E-231.

Alcuni esempi di valori letterali reali decimali sono 1d (con scala 0), 1,20d (con scala 2), 1,23450e1d (ad esempio, 12.3450, con scala 4), 1,2345e3d (ad esempio, 1234.5, che ha scala 1), 1,2345e-1d (ad esempio, 0,12345, con scala 5) e 1,2345e-3d (ad esempio, 0,0012345, che ha scala 7).

Nota

Poiché un valore letterale reale doppio non deve avere una parte frazionaria o esponente, le parentesi di raggruppamento in (123). M è necessario per assicurarsi che la proprietà o il metodo M sia selezionato per l'oggetto integer il cui valore è 123. Senza queste parentesi, il valore letterale reale non sarebbe corretto.

Nota

Anche se PowerShell non fornisce valori letterali per infinità e NaN, è possibile ottenere equivalenti double reali simili a valori letterali dalle proprietà statiche di sola lettura PositiveInfinity, NegativeInfinity e NaN dei tipi float e double (§4.2.4.1).

La grammatica consente a ciò che inizia come valore letterale reale doppio di avere un l suffisso L di tipo o . Tale token è in realtà un valore letterale integer il cui valore è rappresentato dal tipo long.

Nota

Questa funzionalità è stata mantenuta per garantire la compatibilità con le versioni precedenti di PowerShell. Tuttavia, i programmatori sono sconsigliati dall'uso di valori letterali integer di questo formato perché possono facilmente nascondere il valore effettivo del valore letterale. Ad esempio, 1.2L ha valore 1, 1.2345e1L ha valore 12 e 1,2345e-5L ha valore 0, nessuno dei quali è immediatamente ovvio.

2.3.5.1.3 Suffissi del moltiplicatore

Sintassi:

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

Descrizione:

Per praticità, i valori letterali interi e reali possono contenere un moltiplicatore numerico , che indica una delle potenza usate comunemente di 10. numeric-multiplier può essere scritto in qualsiasi combinazione di lettere maiuscole o minuscole.

Moltiplicatore Significato Esempio
kb kilobyte (1024) 1 kb ≡ 1024
mb megabyte (1024 x 1024) 1,30 Dmb ≡ 1363148.80
Gb gigabyte (1024 x 1024 x 1024) 0x10Gb ≡ 17179869184
Tb terabyte (1024 x 1024 x 1024 x 1024) 1,4e23tb ≡ 1,5393162788864E+35
Pb petabyte (1024 x 1024 x 1024 x 1024 x 1024 x 1024) 0x12Lpb ≡ 20266198323167232

2.3.5.2 Valori letterali stringa

Sintassi:

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 @

Descrizione:

Esistono quattro tipi di valori letterali stringa:

  • verbatim-string-literal (virgolette singole a riga singola), ovvero una sequenza di zero o più caratteri delimitati da una coppia di virgolette singole. Gli esempi sono '' e 'red'.

  • expandable-string-literal (virgolette doppie a riga singola), ovvero una sequenza di zero o più caratteri delimitati da una coppia di virgolette doppie. Gli esempi sono "" e "red".

  • verbatim-here-string-literal (virgolette singole su più righe), ovvero una sequenza di zero o più caratteri delimitati dalle coppie di caratteri @single-quote-character e single-quote-character@, rispettivamente, tutti contenuti in due o più righe di origine. Alcuni esempi:

    @'
    '@
    
    @'
    line 1
    '@
    
    @'
    line 1
    line 2
    '@
    
  • expandable-here-string-literal (virgolette doppie su più righe), ovvero una sequenza di zero o più caratteri delimitati dalle coppie di caratteri @double-quote-character e double-quote-character@, rispettivamente, tutti contenuti in due o più righe di origine. Alcuni esempi:

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

Per verbatim-here-string-literal s e expandable-here-string-literal s, ad eccezione degli spazi vuoti (che vengono ignorati), nessun carattere può seguire nella stessa riga di origine della coppia di caratteri delimitatori di apertura e nessun carattere può precedere sulla stessa riga di origine della coppia di caratteri del delimitatore di chiusura.

Il corpo di un verbatim-here-string-literal o un expandable-here-string-literal inizia all'inizio della prima riga di origine dopo il delimitatore di apertura e termina alla fine dell'ultima riga di origine che precede il delimitatore di chiusura. Il corpo può essere vuoto. Il terminatore di riga nell'ultima riga di origine che precede il delimitatore di chiusura non fa parte del corpo del valore letterale.

Un valore letterale di uno di questi tipi ha una stringa di tipo (§4.3.1).

Il carattere usato per delimitare un verbatim-string-literal o expandable-string-literal può essere contenuto in tale valore letterale stringa scrivendo tale carattere due volte, in successione. Ad esempio, 'What''s the time?' e "I said, ""Hello"".". Tuttavia, un carattere virgoletta singola non ha alcun significato speciale all'interno di un valore letterale stringa espandibile e un carattere tra virgolette doppie non ha alcun significato speciale all'interno di un verbatim-string-literal.

Un expandable-string-literal e un expandable-here-string-literal possono contenere caratteri di escape s(§2.3.7). Ad esempio, quando il valore letterale stringa seguente viene scritto nella pipeline, il risultato è come illustrato di seguito:

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

Se un expandable-string-literal o expandable-here-string-literal contiene il nome di una variabile, a meno che tale nome non sia preceduto immediatamente da un carattere di escape, viene sostituito dalla rappresentazione di stringa del valore della variabile (§6.7). Questa operazione è nota come sostituzione di variabili.

Nota

Se il nome della variabile fa parte di un'espressione più grande, viene sostituito solo il nome della variabile. Se, ad esempio, $a è una matrice contenente gli elementi 100 e 200, viene restituito mentre viene ">$a.Length<" >100 200.Length< ">$($a.Length)<" restituito >2< . Vedere l'espansione delle espressioni secondarie di seguito.

Ad esempio, il codice sorgente

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

risultati in expandable-string-literal

The value of $count is 10.

Considerare quanto segue:

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

Il risultato è

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

expandable-string-literal s e expandable-here-string-literal s supportano anche un tipo di sostituzione denominata espansione di espressioni secondarie, trattando il testo del modulo come $( ... ) sottoesa (§7.1.6). Tale testo viene sostituito dalla rappresentazione di stringa del valore dell'espressione (§6.8). Qualsiasi spazio vuoto usato per separare i token all'interno dell'elenco di istruzioni della sottoesa viene ignorato per quanto riguarda la costruzione della stringa di risultato.

Gli esempi,

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

il risultato è il seguente expandable-string-literal s:

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

L'origine seguente,

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

il risultato è il valore expandable-string-literal seguente:

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

Queste quattro righe potrebbero essere state scritte in modo più sintetico nel modo seguente:

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

Nell'esempio seguente,

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

il valore expandable-string-literal risultante è il seguente:

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

Come illustrato, una sottoeserzione può contenere valori letterali stringa con sostituzione di variabili e espansione di espressioni secondarie. Si noti anche che i delimitatori di expandable-string-literal interni non devono essere preceduti da caratteri di escape. Il fatto che si trova all'interno di una sottoesa indica che non possono essere terminatori per l'elemento expandable-string-literal esterno.

Un expandable-string-literal o expandable-here-string-literal contenente una sostituzione di variabile o un'espansione di espressioni secondarie viene valutato ogni volta che viene usato il valore letterale; Per esempio

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

che comporta i seguenti valori expandable-string-literal:

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

Il contenuto di un verbatim-here-string-literal viene utilizzato come verbatim, inclusi gli spazi vuoti iniziali o finali all'interno del corpo. Di conseguenza, i caratteri racchiusi tra virgolette singole incorporati non devono essere raddoppiati e non sono presenti sostituzioni o espansioni. Ad esempio,

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

che determina il valore letterale

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

Il contenuto di un expandable-here-string-literal è soggetto a sostituzione ed espansione, ma qualsiasi spazio vuoto iniziale o finale all'interno del corpo, ma all'esterno di qualsiasi espressione secondaria, viene assunto verbatim e non è necessario raddoppiare i caratteri racchiusi tra virgolette doppie incorporati. Ad esempio,

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

che determina il valore letterale seguente quando viene espanso:

That's it!
2 * 3 = 6

Per verbatim-here-string-literal s e expandable-here-string-literal s, ogni terminatore di riga all'interno del corpo è rappresentato nel valore letterale risultante in modo definito dall'implementazione. Ad esempio, in

$lit = @"
abc
xyz
"@

la seconda riga del corpo ha due spazi iniziali e la prima e la seconda riga del corpo hanno terminatori di riga; Tuttavia, il terminatore per la seconda riga del corpo non fa parte di tale corpo. Il valore letterale risultante equivale a: "abc<implementation-defined character sequence>xyz" .

Nota

Per facilitare la leggibilità dell'origine, i valori letterali stringa lunghi possono essere suddivisi in più righe di origine senza che vengano inseriti caratteri di terminazione di riga. Questa operazione viene eseguita scrivendo ogni parte come valore letterale separato e concatenando le parti con l'operatore + (§7.7.2). Questo operatore consente agli operandi di designare uno dei quattro tipi di valore letterale stringa.

Nota

Anche se non esiste un valore letterale carattere per se stesso, lo stesso effetto può essere ottenuto accedendo al primo carattere in una stringa di 1 carattere, come indicato di seguito: [char]"A" o "A"[0] .

Per verbatim-here-string-literal s e expandable-here-string-literal s, ogni terminatore di riga all'interno del corpo è rappresentato esattamente come è stato fornito.

2.3.5.3 Valore letterale Null

Vedere la variabile automatica $null (§2.3.2.2).

2.3.5.4 Valori letterali booleani

Vedere le variabili $false automatiche e $true (§2.3.2.2).

2.3.5.5 Valori letterali di matrice

PowerShell consente di scrivere espressioni di tipo matrice (Sezione 9) usando l'operatore virgola unario ([§7.2.1),][] array-expression (§7.1.7), l'operatore virgola binario (§7.3) e l'operatore di intervallo (§7.4).

2.3.5.6 Valori letterali hash

PowerShell consente di scrivere espressioni di tipo Hashtable (Sezione 10) usando un'espressione hash-literal (§7.1.9)

2.3.5.7 Nomi dei tipi

Sintassi:

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 Operatori e segni di punteggiatura

Sintassi:

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

Descrizione:

&& e || sono riservati per un uso futuro.

Nota

Nota dell'editor: gli operatori della catena di pipeline && e sono stati introdotti in || PowerShell 7. Vedere about_Pipeline_Chain_Operators.

Il nome seguente trattino in un operatore è riservato a tale scopo solo in un contesto dell'operatore.

Un operatore che inizia con dash non deve contenere spazi vuoti tra il trattino e il token che lo segue.

2.3.7 Caratteri di escape

Sintassi:

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

Descrizione:

Un carattere di escape è un modo per assegnare un'interpretazione speciale a un carattere assegnandogli un prefisso carattere backtick (U+0060). La tabella seguente illustra il significato di ogni carattere di escape:

Carattere di escape Significato
`a Avviso (U+0007)
`b Backspace (U+0008)
`f Avanzamento modulo (U+000C)
`n Nuova riga (U+000A)
`r Ritorno a capo (U+000D)
`t Scheda Orizzontale (U+0009)
`v Scheda Verticale (U+0009)
`' Virgoletta singola (U+0027)
`" Virgolette doppie (U+0022)
`` Backtick (U+0060)
`0 NUL (U+0000)
`x Se x è un carattere diverso da quelli indicati in precedenza, il carattere backtick viene ignorato e x viene preso letteralmente.

L'implicazione della voce finale nella tabella precedente è che gli spazi che altrimenti separano i token possono essere resi parte di un token. Ad esempio, un nome di file contenente uno spazio può essere scritto come Test` Data.txt (nonché 'Test Data.txt' o "Test Data.txt" ).