Condividi tramite

2. Struttura lessicale

Nota editoriale

Importante

La specifica del linguaggio di Windows PowerShell 3.0 è stata pubblicata nel dicembre 2012 ed è basata su Windows PowerShell 3.0. Questa specifica non riflette lo stato corrente di PowerShell. Non è previsto l'aggiornamento di questa documentazione per riflettere lo stato corrente. Questa documentazione è presentata qui per riferimento cronologico.

Il documento delle specifiche è disponibile come documento di Microsoft Word dall'area download di Microsoft al seguente indirizzo: https://www.microsoft.com/download/details.aspx?id=36389 Questo documento Word è stato convertito per la presentazione qui su Microsoft Learn. Durante la conversione sono state apportate alcune modifiche editoriali per supportare la formattazione per la piattaforma Docs. Sono stati corretti alcuni errori di digitazioni e errori secondari.

2.1 Grammatiche

Questa specifica mostra la sintassi del linguaggio di PowerShell usando due grammatiche. La grammatica lessicale (§B.1) mostra in che modo i caratteri Unicode vengono combinati per formare caratteri di terminazione 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 questa specifica.

Qualsiasi uso dei caratteri 'a' fino a 'z' nelle grammatiche non fa distinzione tra maiuscole e minuscole. Ciò significa che le lettere maiuscole e minuscole in variabili, alias, nomi di funzione, parole chiave, istruzioni e operatori vengono ignorate. Tuttavia, in questa specifica, tali 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 notazione ~opt~ 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 a un traduttore 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 script. Lo script stesso non ha alcun nome, se stesso, e prende il nome dal file di origine. La fine del file indica la fine dello script.

Uno script può facoltativamente contenere una firma digitale. Non è necessario un ambiente host per elaborare testo che segue una firma o qualsiasi elemento simile a una firma. La creazione e l'uso delle firme digitali non sono coperti 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 nuovi caratteri di riganel flusso di origine di input la divide in righe che possono essere usate per operazioni quali 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 dall'uso dei commenti.

Un commento a riga singola inizia con il carattere # e termina con un carattere di nuova 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 riga di origine intera o può estendersi su un numero qualsiasi di righe di origine.

Un commento viene considerato come spazio vuoto.

Le produzioni precedenti implicano che

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

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

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

Un oggetto requires-comment specifica i criteri che devono essere soddisfatti per consentire l'esecuzione dello script contenitore. Il criterio principale è la versione di PowerShell usata per eseguire lo script. Il requisito di versione minima è specificato nel modo seguente:

#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 di una riga di origine. Uno script può contenere più requires-comment.

Una sequenza di caratteri viene riconosciuta come commento solo se tale 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 agli spazi bianchi, la sequenza di avvio del commento può essere preceduta anche da qualsiasi carattere che termina un'espressione o un'istruzione (ad esempio ), }, ], ', ", o ;).

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

Esistono quattro altre forme di un commento richiesto:

#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:

Lo spazio vuoto è costituito da qualsiasi sequenza di uno o più caratteri di spazio vuoto .

Ad eccezione del fatto che lo spazio vuoto può fungere da separatore per i token, viene ignorato.

A differenza di alcuni linguaggi più diffusi, PowerShell non considera gli spazi vuoti dei caratteri di terminazione riga (§2.2.2). Tuttavia, un terminatore di riga può essere considerato come spazio bianco precedendolo immediatamente con un carattere backtick, ` (U+0060). Ciò è necessario quando il contenuto di una riga è completo sintatticamente, ma la riga seguente contiene token che devono essere associati 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 è proseguita. 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. La maggior parte delle volte, si tratta del primo token in un'istruzione; Tuttavia, ci sono altre posizioni, come indicato dalla grammatica. Un token simile a una parola chiave, ma non viene usato in un contesto di parola chiave, è un nome di comando o un argomento di comando.

Le parole chiave class, definefrom, using, e var sono riservate per l'uso futuro.

Annotazioni

Nota dell'editor: le class parole chiave e using sono state introdotte in 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 (§5). La variabile $? è discusso in §2.3.2.2. Gli ambiti sono descritti in §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 racchiuso da parentesi graffe, che inizia con $, seguito da un set delimitato da parentesi graffe di quasi uno o più caratteri arbitrari; e un nome di variabile comune, che anch'esso inizia con $, seguito da un set di uno o più caratteri da un set più restrittivo rispetto a quanto consentito da un nome di variabile con parentesi graffe. Ogni nome di variabile ordinario può essere espresso usando il corrispondente nome di variabile con parentesi graffe.

$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 la distinzione tra maiuscole e minuscole non è significativa.

Esistono diversi tipi di variabili: definite dall'utente (§2.3.2.1), automatic (§2.3.2.2) e preferenza (§2.3.2.3). Possono coesistere tutti nello stesso ambito (§3.5).

Si consideri la definizione e le chiamate di funzione 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 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 @ invece di $ come primo carattere della variabile da passare. Questa notazione può essere usata solo come argomento di un comando.

I nomi vengono suddivisi in vari namespace, ognuno dei quali viene archiviato su un'unità virtuale (§3.1). Ad esempio, le variabili vengono archiviate in Variable:, le variabili di ambiente vengono archiviate in Env:, le funzioni vengono archiviate in Function:e gli alias vengono archiviati in Alias:. È possibile accedere a tutti questi nomi come variabili usando la produzione dello spazio dei nomi variabile all'interno di ambito variabile. 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 Variable: equivale all'uso dello stesso nome 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 di preferenza è 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 le informazioni sullo stato sull'ambiente PowerShell. I valori possono essere letti nello script scritto dall'utente ma non scritti.

Annotazioni

La tabella originariamente trovata 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 di 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.

Annotazioni

La tabella originariamente trovata 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 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 agli argomenti è denominato associazione di parametri.

Esistono tre tipi di argomento:

  • Parametro switch (§8.10.5): ha la forma command-parameter in cui first-parameter-char e parameter-chars insieme formano il nome dello switch, che corrisponde al nome di un parametro (senza il suo 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 i due punti finali sono presenti, l'argomento immediatamente successivo deve designare un valore di tipo bool e il parametro corrispondente viene impostato su tale valore. Ad esempio, le chiamate seguenti sono equivalenti:

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

  • Parametro con argomento (§8.10.2): Questo ha la forma command-parameter dove first-parameter-char e parameter-chars insieme costituiscono il nome del parametro, che corrisponde al nome di un parametro (senza il trattino iniziale) nel comando che viene richiamato. Non ci devono essere due punti alla fine. L'argomento immediatamente dopo designa un valore associato. Ad esempio, dato un comando Get-Power, con i parametri $Base e $Exponent, le chiamate seguenti sono equivalenti:

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

  • Argomento posizionale (§8.10.2): gli argomenti e i relativi parametri 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 Get-Power, che ha parametri $Base e $Exponent nelle posizioni 0 e 1, rispettivamente, richiama il comando seguente:

    Get-Power 5 3

Vedere §8.2 per informazioni dettagliate sui parametri -- speciali e --%.

Quando viene richiamato un comando, un nome di parametro può essere abbreviato; è possibile usare qualsiasi parte iniziale distinta del nome completo, purché non 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 moltiplicatori (§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 letterale intero è determinato dal relativo valore, dalla presenza o dall'assenza di suffisso long-type e dalla presenza di un moltiplicatore numerico (§2.3.5.1.3).

Per un valore letterale intero senza suffisso di tipo long

  • Se il valore può essere rappresentato dal tipo int (§4.2.3), questo è il tipo;
  • In caso contrario, se il relativo valore può essere rappresentato dal tipo long (§4.2.3), allora quello è il suo tipo.
  • In caso contrario, se il valore può essere rappresentato dal tipo decimale (§2.3.5.1.2), allora è quello il suo tipo.
  • In caso contrario, è rappresentato dal tipo double (§2.3.5.1.2).

Per un letterale intero con suffisso di tipo long

  • Se il valore può essere rappresentato dal tipo long (§4.2.3), questo è il tipo;
  • In caso contrario, tale valore letterale è malformato.

Nella rappresentazione a due complementi 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 viene normalmente considerato come un valore letterale di tipo long, se è 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 viene normalmente considerato come un valore letterale reale di tipo decimale, se è 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 20000000000000 (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 sono indicati rispettivamente dall'assenza o dalla presenza del suffisso decimal-type-suffix. Non esiste un valore letterale float reale.

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

Se il valore delle cifre decimali di exponent-part in un valore letterale reale doppio è minore del valore minimo supportato, il valore di tale valore letterale reale double è 0. Se il valore delle cifre decimali di exponent-part in un valore letterale reale decimale è minore del minimo supportato, tale valore letterale non è corretto. Se il valore delle cifre decimali di exponent-part in un valore letterale reale doppio o decimale è maggiore del valore massimo supportato, tale valore letterale non viene formato correttamente.

Alcuni esempi di valori letterali reali doppi 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, con scala 1), 1.2345e-1d (ad esempio, 0.12345, con scala 5) e 1.2345e-3d (ad esempio, 0.0012345, con scala 7).

Annotazioni

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 sarebbe mal formato.

Annotazioni

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

La grammatica consente a un numero reale doppio letterale di avere un suffisso di tipo l o L. Un token di questo tipo è in realtà un valore letterale integer il cui valore è rappresentato dal tipo long.

Annotazioni

Questa funzionalità è stata mantenuta per garantire la compatibilità con le versioni precedenti di PowerShell. Tuttavia, i programmatori sono sconsigliati di usare letterali interi di questa forma perché possono facilmente oscurare il valore effettivo del 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 moltiplicatori

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 uno di un set di potenze di uso comune di 10. il moltiplicatore numerico 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.30Dmb ≡ 1363148.80
GB gigabyte (1024 x 1024 x 1024) 0x10 Gb ≡ 17179869184
tbc terabyte (1024 x 1024 x 1024 x 1024) 1,4e23 tb ≡ 1,539316278864E+35
Pb petabyte (1024 x 1024 x 1024 x 1024 x 1024) 0x12Lpb ≡ 20266198323167232

2.3.5.2 Valori letterali di 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 caratteri virgolette singole. Gli esempi sono '' e 'rosso'.

  • expandable-string-literal (virgolette doppie su una sola riga), ossia una sequenza di zero o più caratteri racchiusi tra una coppia di caratteri virgolette doppie. Gli esempi sono "" e "rosso".

  • verbatim-here-string-literal (virgolette singole a riga multipla), ovvero una sequenza di zero o più caratteri delimitati dalle coppie di caratteri @single-quote-character e single-quote-character@, tutte contenute rispettivamente in due o più righe di origine. Ecco alcuni esempi:

    @'
'@

@'
line 1
'@

@'
line 1
line 2
'@

  • expandable-here-string-literal (tra virgolette doppie a più righe), ovvero una sequenza di zero o più caratteri delimitati dalle coppie di caratteri @double-quote-character e double-quote-character@, tutti contenuti in due o più righe di origine. Ecco alcuni esempi:

    @"
"@

@"
line 1
"@

@"
line 1
line 2
"@

Per verbatim-here-string-literals e expandable-here-string-literal, ad eccezione degli spazi vuoti (che viene ignorato) nessun carattere può seguire la stessa riga di origine della coppia di caratteri delimitatore di apertura e nessun carattere può precedere sulla stessa riga di origine della coppia di caratteri delimitatore di chiusura.

Il corpo di un verbatim-here-string-literal o di 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 sull'ultima riga di origine che precede il delimitatore di chiusura non fa parte del corpo del letterale.

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

Il carattere utilizzato per delimitare un letterale di stringa verbatim o un letterale di stringa espandibile può essere incluso in un letterale di stringa di questo tipo scrivendo quel carattere due volte, in successione. Ad esempio, 'What''s the time?' e "I said, ""Hello"".". Tuttavia, un carattere tra virgolette singole non ha un significato speciale all'interno di un letterale stringa espandibile e un carattere tra virgolette doppie non ha alcun significato speciale all'interno di un letterale stringa verbatim.

Un letterale di stringa espandibile e un letterale di here-string espandibile possono contenere caratteri di escape (§2.3.7). Ad esempio, quando la seguente stringa letterale viene scritta 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 letterale di stringa espandibile o un letterale di stringa qui-espandibile contiene il nome di una variabile, a meno che tale nome non sia preceduto immediatamente da un carattere di escape, viene sostituito dalla rappresentazione in stringa del valore della variabile (§6.7). Questa operazione è nota come sostituzione di variabili.

Annotazioni

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

Ad esempio, il codice sorgente

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

restituisce il valore di expandable-string-literal

The value of $count is 10.

Tenere presente 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-literals e expandable-here-string-literals supportano anche una sorta di sostituzione denominata espansione dell'espressione secondaria, trattando il testo del form $( ... ) come sottoespressione (§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 dell'espressione secondaria 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)"

risultano nei seguenti valori di tipo expandable-string-literal:

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

La fonte seguente,

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

restituisce il seguente expandable-string-literal

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

Queste quattro righe potrebbero essere state scritte in modo più conciso come segue:

"`$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 literal di stringa espandibile 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, un'espressione secondaria può contenere stringhe letterali con sostituzione delle variabili ed espansione di sottoespressione. Si noti anche che i delimitatori di stringhe espandibili interni non devono essere preceduti da escape; il fatto che si trovino all'interno di un'espressione secondaria significa che non possono essere caratteri di terminazione per il valore letterale di stringa espandibile esterno.

Un stringa letterale espandibile o stringa letterale espandibile-qui che contiene una sostituzione di variabile o un'espansione di sottoespressione viene valutata ogni volta che il valore letterale viene utilizzato; per esempio

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

risultante dai valori espandibili-stringa-letteraliseguenti:

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

Il contenuto di un valore letterale verbatim-here-string-literal viene acquisito verbatim, incluso qualsiasi spazio vuoto iniziale o finale all'interno del corpo. Di conseguenza, i caratteri a virgoletta singolaincorporati non devono essere raddoppiati e non esiste alcuna sostituzione o espansione. Ad esempio:

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

che risulta nel letterale

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

Il contenuto di una stringa letterale espandibile 'here-string' è soggetto a sostituzione ed espansione, ma qualsiasi spazio bianco iniziale o finale all'interno del corpo, ma al di fuori di qualsiasi sottoespressione, viene acquisito verbatim e i caratteri di virgolette doppie incorporati non devono essere raddoppiati. Ad esempio:

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

che restituisce il valore letterale seguente quando viene espanso:

That's it!
2 * 3 = 6

Per entrambi verbatim-here-string-literals e expandable-here-string-literals, ogni terminatore di riga nel corpo viene rappresentato nel valore letterale risultante in una modalità definita dall'implementazione. Ad esempio, in

$lit = @"
abc
xyz
"@

la seconda riga del corpo ha due spazi iniziali e la prima e la seconda linea del corpo hanno terminatori di linea; 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".

Annotazioni

Per facilitare la leggibilità dell'origine, i valori letterali stringa lunghi possono essere suddivisi in più righe di origine senza inserire 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 ai suoi operandi di designare uno dei quattro tipi di stringa letterale.

Annotazioni

Anche se non esiste un valore letterale carattere per se, 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 entrambi verbatim-here-string-literal e expandable-here-string-literal, ogni terminatore di linea all'interno del corpo è rappresentato esattamente come è stato fornito.

2.3.5.3 Valore letterale Null

Vedere la variabile $null automatica (§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 (§9) utilizzando l'operatore unario virgola (§7.2.1), l'espressione matrice (§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 la scrittura di espressioni di tipo Hashtable (§10) usando un'espressione hash-literal-expression (§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 uso futuro.

Annotazioni

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

Il nome che segue il trattino in un operatore è riservato a tale scopo solo in un contesto di operatore.

Un operatore che inizia con trattino non deve avere 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 ad un carattere, utilizzando il carattere prefisso 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 Interruzione di modulo (U+000C)
`n Nuova riga (U+000A)
`r Ritorno a capo (U+000D)
`t Scheda orizzontale (U+0009)
`v Tabulazione verticale (U+0009)
`' Virgolette singole (U+0027)
`" Virgolette doppie (U+0022)
`` Backtick (U+0060)
`0 NUL (U+0000)
`x Se x è un carattere diverso da quelli mostrati sopra, il carattere di 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 far 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").

  • Last updated on