about_analisi_sintattica

Breve descrizione

Descrive il modo in cui PowerShell analizza i comandi.

Descrizione lunga

Quando si immette un comando al prompt dei comandi, PowerShell suddivide il testo del comando in una serie di segmenti denominati token e quindi determina come interpretare ogni token.

Ad esempio, se si digita:

Write-Host book

PowerShell suddivide il comando in due token, Write-Host e booke interpreta ogni token in modo indipendente usando una delle due modalità di analisi principali: modalità di espressione e modalità argomento.

Annotazioni

Quando PowerShell analizza l'input del comando tenta di risolvere i nomi dei comandi in cmdlet o eseguibili nativi. Se il nome di un comando non ha una corrispondenza esatta, PowerShell antepone Get- il comando come verbo predefinito. PowerShell, ad esempio, analizza Process come Get-Process. Non è consigliabile usare questa funzionalità per i motivi seguenti:

• È inefficiente. In questo modo PowerShell esegue la ricerca più volte.
• I programmi esterni con lo stesso nome vengono risolti per primi, pertanto è possibile che non venga eseguito il cmdlet previsto.
• Get-Help e Get-Command non riconoscono nomi senza verbo.

Modalità di espressione

La modalità di espressione è destinata alla combinazione di espressioni, necessarie per la manipolazione dei valori in un linguaggio di scripting. Le espressioni sono rappresentazioni di valori nella sintassi di PowerShell e possono essere semplici o composite, ad esempio:

Le espressioni letterali sono rappresentazioni dirette dei relativi valori:

'hello'
32

Le espressioni di variabile contengono il valore della variabile a cui fanno riferimento:

$x
$script:path

Gli operatori combinano altre espressioni per la valutazione:

-12
-not $Quiet
3 + 7
$input.Length -gt 1

• valori letterali stringa carattere devono essere contenuti tra virgolette.
• Numeri vengono considerati come valori numerici anziché come una serie di caratteri (a meno che non siano esclusi con un carattere di escape).
• operatori , inclusi operatori unari come - e -not e operatori binari come + e -gt, vengono interpretati come operatori e applicano le rispettive operazioni sui relativi argomenti (operandi).
• Le espressioni di attributo e di conversione vengono analizzate come espressioni e applicate alle espressioni subordinate, ad esempio [int] '7'.
• I riferimenti alle variabili vengono valutati in base ai relativi valori, ma lo splatting (ovvero l'incollaggio di set di parametri precompilati) è vietato e causa un errore del parser.
• Qualsiasi altra cosa verrà considerata come un comando da richiamare.

Modalità argomento

Durante l'analisi, PowerShell cerca prima di tutto di interpretare l'input come espressione. Tuttavia, quando viene rilevata una chiamata al comando, l'analisi continua in modalità argomento. Se si dispone di argomenti che contengono spazi, ad esempio percorsi, è necessario racchiudere tali valori di argomento tra virgolette.

La modalità argomento è progettata per l'analisi di argomenti e parametri per i comandi in un ambiente shell. Tutto l'input viene considerato come una stringa espandibile a meno che non usi una delle sintassi seguenti:

• Il simbolo del dollaro ($) seguito dal nome di una variabile inizia un riferimento alla variabile, altrimenti viene interpretato come parte della stringa espandibile. Il riferimento alla variabile può includere l'accesso ai membri o l'indicizzazione.

  • I caratteri aggiuntivi che seguono riferimenti a variabili semplici, ad esempio $HOME, vengono considerati parte dello stesso argomento. Racchiudere il nome della variabile tra parentesi graffe ({}) per separarlo dai caratteri successivi. Ad esempio: ${HOME}.
  • Quando il riferimento alla variabile include l'accesso ai membri, il primo di eventuali caratteri aggiuntivi viene considerato l'inizio di un nuovo argomento. Ad esempio, $HOME.Length-more restituisce due argomenti: il valore di $HOME.Length e la stringa letterale -more.

• Virgolette (' e ") indicano l'inizio delle stringhe

• Parentesi graffe ({}) iniziano un nuovo blocco di script

• Le virgole (,) introducono elenchi passati come array, tranne quando il comando da chiamare è un'applicazione nativa, nel qual caso vengono interpretati come parte della stringa espandibile. Le virgole iniziali, consecutive o finali non sono supportate.

• Parentesi (()) iniziano una nuova espressione

• L'operatore Subexpression ($()) inizia un'espressione incorporata

• Initial at sign (@) inizia le sintassi delle espressioni, ad esempio splatting (@args), matrici (@(1,2,3)) e valori letterali della tabella hash (@{a=1;b=2}).

• (), $()e @() all'inizio di un token creare un nuovo contesto di analisi che può contenere espressioni o comandi annidati.

  • Se seguito da caratteri aggiuntivi, il primo carattere aggiuntivo viene considerato l'inizio di un nuovo argomento separato.
  • Se preceduto da un valore letterale $() non racchiuso tra virgolette, funziona come una stringa espandibile, () inizia un nuovo argomento che è un'espressione e @() viene considerato letterale @ con () l'inizio di un nuovo argomento che è un'espressione.

• Tutto il resto viene considerato come una stringa espandibile, ad eccezione dei metacharacter che richiedono ancora l'escape.

  • I metacaratteri in modalità argomento (caratteri con un significato sintattico speciale) sono: <space> ' " ` , ; ( ) { } | & < > @ #. Di questi, < > @ # sono speciali solo all'inizio di un token.

• Il token di interruzione dell'analisi (--%) altera l'interpretazione di tutti gli argomenti rimanenti. Per altre informazioni, vedere la sezione token di arresto dell'analisi qui sotto.

Esempi

La tabella seguente fornisce diversi esempi di token elaborati in modalità di espressione e modalità di argomento e la valutazione di tali token. Per questi esempi, il valore della variabile $a è 4.

Esempio	Modalità	Risultato
2	Espressione	2 (intero)
`2	Espressione	"2" (comando)
Write-Output 2	Espressione	2 (intero)
2+2	Espressione	4 (intero)
Write-Output 2+2	Argomentazione	"2+2" (una stringa)
Write-Output(2+2)	Espressione	4 (intero)
$a	Espressione	4 (intero)
Write-Output $a	Espressione	4 (intero)
$a+2	Espressione	6 (intero)
Write-Output $a+2	Argomentazione	"4+2" (stringa)
$-	Argomentazione	"$-" (comando)
Write-Output $-	Argomentazione	"$-" (stringa)
a$a	Espressione	a$a (comando)
Write-Output a$a	Argomentazione	"a4" (stringa)
a'$a'	Espressione	a$a (comando)
Write-Output a'$a'	Argomentazione	"a$a" (stringa)
a"$a"	Espressione	a$a (comando)
Write-Output a"$a"	Argomentazione	"a4" (stringa)
a$(2)	Espressione	"a$(2)" (comando)
Write-Output a$(2)	Argomentazione	a2 (stringa)

Ogni token può essere interpretato come un tipo di oggetto, ad esempio Boolean o String. PowerShell tenta di determinare il tipo di oggetto dall'espressione. Il tipo di oggetto dipende dal tipo di parametro previsto da un comando e dal fatto che PowerShell sappia convertire l'argomento nel tipo corretto. Nella tabella seguente vengono illustrati diversi esempi dei tipi assegnati ai valori restituiti dalle espressioni.

Esempio	Modalità	Risultato
Write-Output !1	Argomento	"!1" (stringa)
Write-Output (!1)	espressione	Falso (Booleano)
Write-Output (2)	espressione	2 (intero)
Set-Variable AB A,B	Argomento	'A','B' (matrice)
CMD /CECHO A,B	Argomento	'A,B' (stringa)
CMD /CECHO $AB	espressione	'A B' (matrice)
CMD /CECHO :$AB	Argomento	':A B' (stringa)

Passaggio di argomenti a comandi nativi

Quando si eseguono comandi nativi da PowerShell, gli argomenti vengono prima analizzati da PowerShell. Gli argomenti analizzati vengono quindi uniti in una singola stringa con ogni parametro separato da uno spazio.

Ad esempio, il comando seguente chiama il programma icacls.exe.

icacls X:\VMS /grant Dom\HVAdmin:(CI)(OI)F

Per eseguire questo comando in PowerShell 2.0, è necessario usare caratteri di escape per impedire a PowerShell di interpretazione errata delle parentesi.

icacls X:\VMS /grant Dom\HVAdmin:`(CI`)`(OI`)F

Token di interruzione dell'analisi

A partire da PowerShell 3.0, è possibile usare il token di arresto dell'analisi (--%) per impedire a PowerShell di interpretare l'input come comandi o espressioni di PowerShell.

Annotazioni

Il token di interruzione dell'analisi è destinato esclusivamente all'uso su piattaforme Windows.

Quando si chiama un comando nativo, mettere il token di interruzione dell'analisi prima degli argomenti del programma. Questa tecnica è molto più semplice rispetto all'uso di caratteri di escape per evitare errori di interpretazione.

Quando incontra un token che interrompe l'analisi, PowerShell tratta i caratteri rimanenti nella riga come testo letterale. L'unica interpretazione eseguita consiste nel sostituire i valori per le variabili di ambiente che usano la notazione standard di Windows, ad esempio %USERPROFILE%.

icacls X:\VMS --% /grant Dom\HVAdmin:(CI)(OI)F

PowerShell invia la stringa di comando seguente al programma icacls.exe:

X:\VMS /grant Dom\HVAdmin:(CI)(OI)F

Il token di "protezione dell'analisi" è valido solo fino al successivo carattere di nuova riga o di pipeline. Non è possibile utilizzare un carattere di continuazione (`) per estenderne l'effetto o utilizzare un delimitatore di comando (;) per terminarne l'effetto.

Oltre ai %variable% riferimenti alle variabili di ambiente, non è possibile incorporare altri elementi dinamici nel comando. L'escape di un % carattere come %%, come è possibile fare all'interno dei file batch, non è supportato. %<name>% i token vengono espansi invariabilmente. Se <name> non fa riferimento a una variabile d'ambiente definita, il token viene passato attraverso as-is.

Non è possibile utilizzare il reindirizzamento del flusso (come >file.txt) perché vengono passati alla lettera come argomenti al comando di destinazione.

Passaggio di argomenti contenenti caratteri virgolette

Alcuni comandi nativi prevedono argomenti che contengono caratteri virgolette. In genere, l'analisi della riga di comando di PowerShell rimuove il carattere di virgolette specificato. Gli argomenti analizzati vengono quindi uniti in una singola stringa con ogni parametro separato da uno spazio. Questa stringa viene quindi assegnata alla proprietà Arguments di un ProcessStartInfo oggetto . Le virgolette all'interno della stringa devono essere precedute da virgolette aggiuntive o da barre rovesciate (\).

Annotazioni

Il carattere barra rovesciata (\) non viene riconosciuto come carattere di escape da PowerShell. È il carattere di escape utilizzato dall'API sottostante per ProcessStartInfo.Arguments.

Per altre informazioni sui requisiti di escape, vedere la documentazione relativa a ProcessStartInfo.Arguments.

Gli esempi seguenti utilizzano lo TestExe.exe strumento. Questo strumento viene usato dai test di Pester nel repository di origine di PowerShell. L'obiettivo di questi esempi è passare il percorso "C:\Program Files (x86)\Microsoft\" della directory a un comando nativo in modo che abbia ricevuto il percorso come stringa tra virgolette.

Il parametro echoargs di TestExe visualizza i valori ricevuti come argomenti per l'eseguibile. È possibile usare questo strumento per verificare di avere preceduto correttamente l'escape dei caratteri negli argomenti.

TestExe -echoargs """""${env:ProgramFiles(x86)}\Microsoft\\"""""
TestExe -echoargs """""C:\Program Files (x86)\Microsoft\\"""""
TestExe -echoargs "\""C:\Program Files (x86)\Microsoft\\"""
TestExe -echoargs --% "\"C:\Program Files (x86)\Microsoft\\"
TestExe -echoargs --% """C:\Program Files (x86)\Microsoft\\""
TestExe -echoargs --% """%ProgramFiles(x86)%\Microsoft\\""

L'output è lo stesso per tutti gli esempi:

Arg 0 is <"C:\Program Files (x86)\Microsoft\">

È possibile compilare TestExe dal codice sorgente. Vedere TestExe.

Passaggio di argomenti ai comandi di PowerShell

A partire da PowerShell 3.0, è possibile utilizzare il token end-of-parameters (--) per impedire a PowerShell di interpretare l'input come parametri di PowerShell. Si tratta di una convenzione specificata nella specifica POSIX Shell e Utilities.

Il token di fine parametri (--) indica che tutti gli argomenti seguenti devono essere passati nella loro forma originale come se le virgolette doppie fossero poste intorno a loro. Ad esempio, usando -- è possibile restituire la stringa -InputObject senza usare virgolette o averla interpretata come parametro:

Write-Output -- -InputObject

-InputObject

A differenza del token di arresto dell'analisi (--%), tutti i valori che seguono il token -- possono essere interpretati come espressioni da PowerShell.

Write-Output -- -InputObject $env:PROCESSOR_ARCHITECTURE

-InputObject
AMD64

Questo comportamento si applica solo ai comandi di PowerShell. Se si usa il token -- quando si chiama un comando esterno, la stringa -- viene passata come argomento a tale comando.

TestExe -echoargs -a -b -- -c

L'output mostra che -- viene passato come argomento a TestExe.

Arg 0 is <-a>
Arg 1 is <-b>
Arg 2 is <-->
Arg 3 is <-c>

Vedere anche

• informazioni_sulla_sintassi_comandi