about_Operators
Breve descrizione
Descrive gli operatori supportati da PowerShell.
Descrizione lunga
Un operatore è un elemento del linguaggio che è possibile usare in un comando o in un'espressione. PowerShell supporta diversi tipi di operatori per facilitare la modifica dei valori.
Operatori aritmetici
Usare operatori aritmetici (+, -, *, /, %) per calcolare i valori in un comando o in un'espressione. Con questi operatori è possibile aggiungere, sottrarre, moltiplicare o dividere i valori e calcolare il resto (modulo) di un'operazione di divisione.
L'operatore di aggiunta concatena gli elementi. L'operatore di moltiplicazione restituisce il numero specificato di copie di ogni elemento. È possibile usare gli operatori aritmetici in qualsiasi tipo .NET che li implementa, ad esempio: IntStringDateTimeHashtable, e Matrici.
Operatori bit per bit (-band, -bxor-shl-bor-bnot) -shrmodificano i modelli di bit nei valori.
Per altre informazioni, vedere about_Arithmetic_Operators.
Operatori di assegnazione
Usare gli operatori di assegnazione (=, *=/=+=-=%=, ) per assegnare, modificare o aggiungere valori alle variabili. È possibile combinare operatori aritmetici con assegnazione per assegnare il risultato dell'operazione aritmetica a una variabile.
Per altre informazioni, vedere about_Assignment_Operators.
Operatori di confronto
Usare gli operatori di confronto (-eq, -le-lt-ne-gt-ge) per confrontare i valori e le condizioni di test. Ad esempio, è possibile confrontare due valori stringa per determinare se sono uguali.
Gli operatori di confronto includono anche operatori che trovano o sostituisci i modelli nel testo. Gli operatori (-match, -notmatch, -replace) usano espressioni regolari e (-like, -notlike) usano caratteri *jolly.
Gli operatori di confronto di contenimento determinano se un valore di test viene visualizzato in un set di riferimenti (-in, -notin, -contains-notcontains).
Gli operatori di confronto dei tipi (-is, -isnot) determinano se un oggetto è di un determinato tipo.
Per altre informazioni, vedere about_Comparison_Operators.
Operatori logici
Usare gli operatori logici (-and, -or, -xor, -not, !) per connettere le istruzioni condizionali in un singolo condizionale complesso. Ad esempio, è possibile usare un operatore logico -and per creare un filtro dell'oggetto con due condizioni diverse.
Per altre informazioni, vedere about_Logical_Operators.
Operatori di reindirizzamento
Usare gli operatori di reindirizzamento (>, >>2>, 2>>, e 2>&1) per inviare l'output di un comando o un'espressione a un file di testo. Gli operatori di reindirizzamento funzionano come il cmdlet (senza parametri), ma consentono anche di reindirizzare l'output Out-File degli errori ai file specificati. È anche possibile usare il cmdlet per reindirizzare l'output Tee-Object .
Per altre informazioni, vedere about_Redirection
Operatori di divisione e join
Gli -split operatori e dividono e -join combinano sottostringa. L'operatore -split suddivide una stringa in sottostringa. L'operatore -join concatena più stringhe in una singola stringa.
Per altre informazioni, vedere about_Split e about_Join.
Operatori di tipo
Usare gli operatori di tipo (-is, -isnot, -as) per trovare o modificare il tipo .NET di un oggetto.
Per altre informazioni, vedere about_Type_Operators.
Operatori unari
Usare gli operatori unari ++ e -- per aumentare o decrementare i valori e - per la negazione. Ad esempio, per incrementare la variabile $a da 9 a 10, si digita $a++.
Per altre informazioni, vedere about_Arithmetic_Operators.
Operatori speciali
Gli operatori speciali hanno casi d'uso specifici che non si adattano ad altri gruppi di operatori. Ad esempio, gli operatori speciali consentono di eseguire comandi, modificare il tipo di dati di un valore o recuperare elementi da una matrice.
Operatore di raggruppamento ( )
Come in altri linguaggi, (...) serve a sostituire la precedenza dell'operatore nelle espressioni. ad esempio (1 + 2) / 3
Tuttavia, in PowerShell sono disponibili comportamenti aggiuntivi.
Raggruppamento di espressioni dei risultati
(...) consente di consentire l'output da un comando che partecipa a un'espressione.
Ad esempio:
PS> (Get-Item *.txt).Count -gt 10
True
Espressioni raggruppate di piping
Quando viene usato come primo segmento di una pipeline, il wrapping di un comando o di un'espressione tra parentesi causa invariabilmente l'enumerazione del risultato dell'espressione. Se le parentesi eseguono il wrapping di un comando, viene eseguito al completamento con tutti gli output raccolti in memoria prima dell'invio dei risultati tramite la pipeline.
Raggruppare un'espressione prima del piping garantisce inoltre che l'elaborazione successiva di oggetti per oggetto non possa interferire con l'enumerazione usata dal comando per produrre il relativo output.
Istruzioni di raggruppamento delle assegnazioni
Le istruzioni di assegnazione non raggruppate non generano valori di output. Quando si raggruppa un'istruzione di assegnazione, il valore della variabile assegnata viene passato e può essere usato in espressioni più grandi. Ad esempio:
PS> ($var = 1 + 2)
3
PS> ($var = 1 + 2) -eq 3
True
Il wrapping dell'istruzione nelle parentesi lo trasforma in un'espressione che restituisce il valore di $var.
Questo comportamento si applica a tutti gli operatori di assegnazione, inclusi operatori composti come +=, e gli operatori di incremento () e decremento (++--).
Tuttavia, l'ordine dell'operazione per incrementi e decremento dipende dalla loro posizione.
PS> $i = 0
PS> (++$i) # prefix
1
PS> $i = 0
PS> ($i++) # postfix
0
PS> $i
1
Nel caso del prefisso, il valore di viene incrementato prima di $i essere restituito. Nel caso del prefisso il valore di $i viene incrementato dopo l'output.
È anche possibile usare questa tecnica Nel contesto di un'istruzione condizionale, ad esempio l'istruzione if .
if ($textFiles = Get-ChildItem *.txt) {
$textFiles.Count
}
In questo esempio, se nessun file corrisponde, il Get-ChildItem comando restituisce nulla e non assegna nulla a $textFiles, considerato $false in un contesto booleano. Se uno o più oggetti FileInfo vengono assegnati a $textFiles, il condizionale restituisce $true. È possibile usare il valore di $textFiles nel corpo dell'istruzione if .
Nota
Anche se questa tecnica è comoda e concisa, può causare confusione tra l'operatore di assegnazione () e l'operatore di confronto di uguaglianza (=-eq).
Operatore subexpression $( )
Restituisce il risultato di una o più istruzioni. Per un singolo risultato, restituisce un scalare. Per più risultati, restituisce una matrice. Usare questa opzione quando si vuole usare un'espressione all'interno di un'altra espressione. Ad esempio, per incorporare i risultati del comando in un'espressione stringa.
PS> "Today is $(Get-Date)"
Today is 12/02/2019 13:15:20
PS> "Folder list: $((dir c:\ -dir).Name -join ', ')"
Folder list: Program Files, Program Files (x86), Users, Windows
Operatore sottoespressione matrice @( )
Restituisce il risultato di una o più istruzioni come matrice. Il risultato è sempre una matrice di 0 o più oggetti.
PS> $list = @(Get-Process | Select-Object -First 10; Get-Service | Select-Object -First 10 )
PS> $list.GetType()
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Object[] System.Array
PS> $list.Count
20
PS> $list = @(Get-Service | Where-Object Status -eq Starting )
PS> $list.GetType()
IsPublic IsSerial Name BaseType
-------- -------- ---- --------
True True Object[] System.Array
PS> $list.Count
0
Sintassi letterale della tabella hash @{}
Analogamente alla sottoespressione della matrice, questa sintassi viene usata per dichiarare una tabella hash. Per altre informazioni, vedere about_Hash_Tables.
Operatore di chiamata &
Esegue un comando, uno script o un blocco di script. L'operatore di chiamata, noto anche come operatore di chiamata, consente di eseguire comandi archiviati in variabili e rappresentati da stringhe o blocchi di script. L'operatore di chiamata viene eseguito in un ambito figlio. Per altre informazioni sugli ambiti, vedere about_Scopes. È possibile usare questa opzione per compilare stringhe contenenti il comando, i parametri e gli argomenti necessari e quindi richiamare la stringa come se fosse un comando. Le stringhe create devono seguire le stesse regole di analisi di un comando digitato nella riga di comando. Per altre informazioni, vedere about_Parsing.
In questo esempio viene archiviato un comando in una stringa ed eseguito usando l'operatore di chiamata.
PS> $c = "get-executionpolicy"
PS> $c
get-executionpolicy
PS> & $c
AllSigned
L'operatore di chiamata non analizza le stringhe. Ciò significa che non è possibile usare i parametri dei comandi all'interno di una stringa quando si usa l'operatore di chiamata.
PS> $c = "Get-Service -Name Spooler"
PS> $c
Get-Service -Name Spooler
PS> & $c
& : The term 'Get-Service -Name Spooler' is not recognized as the name of a
cmdlet, function, script file, or operable program. Check the spelling of
the name, or if a path was included, verify that the path is correct and
try again.
Il cmdlet Invoke-Expression può eseguire codice che causa errori di analisi quando si usa l'operatore di chiamata.
PS> & "1+1"
&: The term '1+1' is not recognized as a name of a cmdlet, function, script
file, or executable program. Check the spelling of the name, or if a path was
included, verify that the path is correct and try again.
PS> Invoke-Expression "1+1"
2
È possibile eseguire uno script usando il relativo nome file. Un file di script deve avere un'estensione .ps1 di file eseguibile. I file con spazi nel percorso devono essere racchiusi tra virgolette. Se si tenta di eseguire il percorso con virgolette, PowerShell visualizza il contenuto della stringa con virgolette anziché eseguire lo script. L'operatore di chiamata consente di eseguire il contenuto della stringa contenente il nome file.
PS C:\Scripts> Get-ChildItem
Directory: C:\Scripts
Mode LastWriteTime Length Name
---- ------------- ------ ----
-a---- 8/28/2018 1:36 PM 58 script name with spaces.ps1
PS C:\Scripts> ".\script name with spaces.ps1"
.\script name with spaces.ps1
PS C:\Scripts> & ".\script name with spaces.ps1"
Hello World!
Per altre informazioni sui blocchi di script, vedere about_Script_Blocks.
Operatore in background &
Esegue la pipeline prima di essere eseguita in background in un processo di PowerShell. Questo operatore agisce in modo analogo all'operatore di controllo UNIX (&), che esegue il comando prima che venga eseguito in modo asincrono in sottoshell come processo.
Questo operatore è funzionalmente equivalente a Start-Job. Per impostazione predefinita, l'operatore in background avvia i processi nella directory di lavoro corrente del chiamante che ha avviato le attività parallele. Nell'esempio seguente viene illustrato l'utilizzo di base dell'operatore del processo in background.
Get-Process -Name pwsh &
Questo comando equivale in modo funzionale all'utilizzo seguente di Start-Job:
Start-Job -ScriptBlock {Get-Process -Name pwsh}
Proprio come Start-Job, l'operatore & di sfondo restituisce un Job oggetto. Questo oggetto può essere usato con Receive-Job e Remove-Job, come se fosse stato usato Start-Job per avviare il processo.
$job = Get-Process -Name pwsh &
Receive-Job $job -Wait
NPM(K) PM(M) WS(M) CPU(s) Id SI ProcessName
------ ----- ----- ------ -- -- -----------
0 0.00 221.16 25.90 6988 988 pwsh
0 0.00 140.12 29.87 14845 845 pwsh
0 0.00 85.51 0.91 19639 988 pwsh
Remove-Job $job
L'operatore & in background è anche un terminatore dell'istruzione, proprio come l'operatore di controllo UNIX ampersand (&). Ciò consente di richiamare comandi aggiuntivi dopo l'operatore & in background. Nell'esempio seguente viene illustrata la chiamata di comandi aggiuntivi dopo l'operatore & in background.
$job = Get-Process -Name pwsh & Receive-Job $job -Wait
NPM(K) PM(M) WS(M) CPU(s) Id SI ProcessName
------ ----- ----- ------ -- -- -----------
0 0.00 221.16 25.90 6988 988 pwsh
0 0.00 140.12 29.87 14845 845 pwsh
0 0.00 85.51 0.91 19639 988 pwsh
Equivale allo script seguente:
$job = Start-Job -ScriptBlock {Get-Process -Name pwsh}
Receive-Job $job -Wait
Se si desidera eseguire più comandi, ognuno nel proprio processo in background, ma tutti su una riga, è sufficiente posizionare & tra e dopo ognuno dei comandi.
Get-Process -Name pwsh & Get-Service -Name BITS & Get-CimInstance -ClassName Win32_ComputerSystem &
Per altre informazioni sui processi di PowerShell, vedere about_Jobs.
Operatore cast [ ]
Converte o limita gli oggetti nel tipo specificato. Se gli oggetti non possono essere convertiti, PowerShell genera un errore.
[DateTime] '2/20/88' - [DateTime] '1/20/88' -eq [TimeSpan] '31'
Un cast può essere eseguito anche quando una variabile viene assegnata all'uso della notazione cast.
Operatore virgole ,
Come operatore binario, la virgola crea una matrice o aggiunge alla matrice da creare. In modalità espressione, come operatore unario, la virgola crea una matrice con un solo membro. Posizionare la virgola prima del membro.
$myArray = 1,2,3
$SingleArray = ,1
Write-Output (,1)
Poiché Write-Output prevede un argomento, è necessario inserire l'espressione tra parentesi.
Operatore dot sourcing .
Esegue uno script nell'ambito corrente in modo che tutte le funzioni, gli alias e le variabili create dallo script vengano aggiunte all'ambito corrente, eseguendo l'override di quelle esistenti. I parametri dichiarati dallo script diventano variabili. Parametri per i quali non è stato assegnato alcun valore diventano variabili senza valore. Tuttavia, la variabile $args automatica viene mantenuta.
. c:\scripts\sample.ps1 1 2 -Also:3
Nota
L'operatore di origine punti è seguito da uno spazio. Utilizzare lo spazio per distinguere il punto dal simbolo punto (.) che rappresenta la directory corrente.
Nell'esempio seguente viene eseguito lo script Sample.ps1 nella directory corrente nell'ambito corrente.
. .\sample.ps1
Operatore di formato -f
Formatta le stringhe usando il metodo di formato degli oggetti stringa. Immettere la stringa di formato sul lato sinistro dell'operatore e gli oggetti da formattare sul lato destro dell'operatore.
"{0} {1,-10} {2:N}" -f 1,"hello",[math]::pi
1 hello 3.14
È possibile zero-pad un valore numerico con l'identificatore personalizzato "0". Il numero di zero seguenti : indica la larghezza massima a cui si aggiunge la stringa formattata.
"{0:00} {1:000} {2:000000}" -f 7, 24, 365
07 024 000365
Se è necessario mantenere le parentesi graffe ({}) nella stringa formattata, è possibile eseguirne l'escape raddoppiando le parentesi graffe.
"{0} vs. {{0}}" -f 'foo'
foo vs. {0}
Per altre informazioni, vedere il metodo String.Format e La formattazione composita.
Operatore di indice [ ]
Seleziona oggetti da raccolte indicizzate, ad esempio matrici e tabelle hash. Gli indici di matrice sono basati su zero, quindi il primo oggetto viene indicizzato come [0]. È anche possibile usare indici negativi per ottenere gli ultimi valori. Le tabelle hash vengono indicizzate in base al valore della chiave.
Dato un elenco di indici, l'operatore di indice restituisce un elenco di membri corrispondenti a tali indici.
PS> $a = 1, 2, 3
PS> $a[0]
1
PS> $a[-1]
3
PS> $a[2, 1, 0]
3
2
1
(Get-HotFix | Sort-Object installedOn)[-1]
$h = @{key="value"; name="PowerShell"; version="2.0"}
$h["name"]
PowerShell
$x = [xml]"<doc><intro>Once upon a time...</intro></doc>"
$x["doc"]
intro
-----
Once upon a time...
Quando un oggetto non è una raccolta indicizzata, usando l'operatore di indice per accedere al primo elemento restituisce l'oggetto stesso. I valori di indice oltre il primo elemento restituiscono $null.
PS> (2)[0]
2
PS> (2)[-1]
2
PS> (2)[1] -eq $null
True
PS> (2)[0,0] -eq $null
True
Operatore pipeline |
Invia ("pipe") l'output del comando che lo precede al comando che lo segue. Quando l'output include più oggetti (una "raccolta"), l'operatore della pipeline invia gli oggetti uno alla volta.
Get-Process | Get-Member
Get-Service | Where-Object {$_.StartType -eq 'Automatic'}
Operatori && della catena di pipeline e ||
Eseguire in modo condizionale la pipeline sul lato destro in base all'esito positivo della pipeline laterale sinistra.
# If Get-Process successfully finds a process called notepad,
# Stop-Process -Name notepad is called
Get-Process notepad && Stop-Process -Name notepad
# If npm install fails, the node_modules directory is removed
npm install || Remove-Item -Recurse ./node_modules
Per altre informazioni, vedere About_Pipeline_Chain_Operators.
Operatore intervallo ..
L'operatore di intervallo può essere usato per rappresentare una matrice di numeri interi o caratteri sequenziali. I valori aggiunti dall'operatore intervallo definiscono i valori di inizio e fine dell'intervallo.
Nota
Il supporto per gli intervalli di caratteri è stato aggiunto in PowerShell 6.
Intervalli di numeri
1..10
$max = 10
foreach ($a in 1..$max) {Write-Host $a}
È anche possibile creare intervalli in ordine inverso.
10..1
5..-5 | ForEach-Object {Write-Output $_}
I valori iniziale e finale dell'intervallo possono essere qualsiasi coppia di espressioni che restituiscono un intero o un carattere. Gli endpoint dell'intervallo devono essere convertibili in interi con segno a 32 bit ([int32]). I valori più grandi causano un errore. Inoltre, se l'intervallo viene acquisito in una matrice, la dimensione della matrice risultante è limitata a [int]::MaxValue - 56. Questa è la dimensione massima di una matrice in .NET.
Ad esempio, è possibile usare i membri di un'enumerazione per i valori iniziale e finale.
PS> enum Food {
Apple
Banana = 3
Kiwi = 10
}
PS> [Food]::Apple..[Food]::Kiwi
0
1
2
3
4
5
6
7
8
9
10
Importante
L'intervallo risultante non è limitato ai valori dell'enumerazione. Rappresenta invece l'intervallo di valori tra i due valori specificati. Non è possibile usare l'operatore di intervallo per rappresentare in modo affidabile i membri di un'enumerazione.
Intervalli di caratteri
Per creare un intervallo di caratteri, racchiudere i caratteri nelle virgolette.
PS> 'a'..'f'
a
b
c
d
e
f
PS> 'F'..'A'
F
E
D
C
B
A
Se si assegna un intervallo di caratteri a una stringa, viene trattato lo stesso assegnazione di una matrice di caratteri a una stringa.
PS> [string]$s = 'a'..'e'
$s
a b c d e
$a = 'a', 'b', 'c', 'd', 'e'
$a
a b c d e
I caratteri della matrice vengono aggiunti a una stringa. I caratteri sono separati dal valore della $OFS variabile di preferenza. Per altre informazioni, vedere about_Preference_Variables.
L'ordine dei caratteri nella matrice è determinato dal valore ASCII del carattere. Ad esempio, i valori ASCII di c e X sono rispettivamente 99 e 88. Tale intervallo verrebbe presentato in ordine inverso.
PS> 'c'..'X'
c
b
a
`
_
^
]
\
[
Z
Y
X
Operatore di accesso ai membri .
Accede alle proprietà e ai metodi di un oggetto. Il nome del membro può essere un'espressione.
$myProcess.peakWorkingSet
(Get-Process PowerShell).kill()
'OS', 'Platform' | Foreach-Object { $PSVersionTable. $_ }
A partire da PowerShell 3.0, quando si usa l'operatore in un oggetto raccolta di elenchi che non ha il membro, PowerShell enumera automaticamente gli elementi di tale raccolta e usa l'operatore su ognuno di essi. Per altre informazioni, vedere about_Member-Access_Enumeration.
Operatore membro statico ::
Chiama le proprietà e i metodi statici di una classe .NET. Per trovare le proprietà statiche e i metodi di un oggetto, usare il parametro Static del Get-Member cmdlet. Il nome del membro può essere un'espressione.
[datetime]::Now
'MinValue', 'MaxValue' | Foreach-Object { [int]:: $_ }
Operatore Ternario ? <if-true> : <if-false>
È possibile usare l'operatore ternario come sostituzione dell'istruzione if-else in casi condizionali semplici.
Per altre informazioni, vedere about_If.
Operatore null-coalescing ??
L'operatore di coalescenza di valori Null ?? restituisce il valore dell'operando di sinistra se non è Null. In caso contrario, valuta l'operando di destra e ne restituisce il risultato. L'operatore ?? non valuta l'operando di destra se l'operando di sinistra restituisce un valore non Null.
$x = $null
$x ?? 100
100
Nell'esempio seguente l'operando destro non verrà valutato.
[string] $todaysDate = '1/10/2020'
$todaysDate ?? (Get-Date).ToShortDateString()
1/10/2020
Operatore di assegnazione null-coalescing ??=
L'operatore ??= di assegnazione null-coalescing assegna il valore dell'operando destro al suo operando a sinistra solo se l'operando a sinistra restituisce null. L'operatore ??= non valuta l'operando di destra se l'operando di sinistra restituisce un valore non Null.
$x = $null
$x ??= 100
$x
100
Nell'esempio seguente l'operando destro non verrà valutato.
[string] $todaysDate = '1/10/2020'
$todaysDate ??= (Get-Date).ToShortDateString()
$todaysDate
1/10/2020
Operatori ?. condizionali Null e ?[]
Nota
Questa funzionalità è stata spostata da sperimentale a mainstream in PowerShell 7.1.
Un operatore condizionale null applica un accesso membro, ?., o l'accesso agli elementi, all'operazione all'operando ?[]solo se l'operando restituisce null. In caso contrario, restituisce Null.
Poiché in PowerShell ? può essere incluso nel nome della variabile, è necessario specificare formalmente il nome della variabile per usare questi operatori. È necessario usare parentesi graffe ({}) intorno ai nomi delle variabili come ${a} o quando ? fa parte del nome ${a?}della variabile .
Nota
La sintassi del nome della variabile di ${<name>} non deve essere confusa con l'operatore $() subexpression. Per altre informazioni, vedere Sezione Nome variabile di about_Variables.
Nell'esempio seguente viene restituito il valore di PropName .
$a = @{ PropName = 100 }
${a}?.PropName
100
L'esempio seguente restituisce Null senza tentare di accedere al nome del membro PropName.
$a = $null
${a}?.PropName
In questo esempio viene restituito il valore dell'elemento indicizzato.
$a = 1..10
${a}?[0]
1
L'esempio seguente restituisce Null senza tentare di accedere all'elemento indicizzato.
$a = $null
${a}?[0]