about_Operators
Descrizione breve
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 che consentono di modificare i 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 addizione concatena gli elementi. L'operatore di moltiplicazione restituisce il numero specificato di copie di ogni elemento. È possibile usare operatori aritmetici in qualsiasi tipo .NET che li implementi, ad esempio, Int, StringDateTime, Hashtablee matrici.
Gli operatori bit per bit (-band, -bor, -bxor-bnot, -shl) -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, -ne, -gt-lt, -le) -geper confrontare valori e 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 sostituiscono modelli nel testo. Gli operatori (-match, -notmatch, -replace) usano espressioni regolari e (-like, -notlike) usano caratteri *jolly .
Gli operatori di confronto del 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 operatori logici (-and, -or, -not-xor, , ) !per connettere le istruzioni condizionali in un'unica condizionale complessa. Ad esempio, è possibile usare un operatore logico -and per creare un filtro 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 di un'espressione a un file di testo. Gli operatori di reindirizzamento funzionano come il Out-File cmdlet (senza parametri), ma consentono anche di reindirizzare l'output degli errori ai file specificati. È anche possibile usare il Tee-Object cmdlet per reindirizzare l'output.
Per altre informazioni, vedere about_Redirection
Operatori di divisione e join
Gli -split operatori e -join dividono e combinano le sottostringhe. L'operatore -split divide una stringa in sottostringhe. 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 incrementare 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 rientrano in nessun altro gruppo 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
In PowerShell, tuttavia, esistono comportamenti aggiuntivi.
Raggruppamento di espressioni dei risultati
(...) consente di consentire all'output da un comando di partecipare a un'espressione.
Ad esempio:
PS> (Get-Item *.txt).Count -gt 10
True
Espressioni raggruppate di piping
Se 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 fino al completamento con tutto l'output raccolto in memoria prima che i risultati vengano inviati tramite la pipeline.
Il raggruppamento di un'espressione prima del piping garantisce anche che l'elaborazione successiva dell'oggetto per oggetto non possa interferire con l'enumerazione usata dal comando per produrre l'output.
Raggruppamento di istruzioni di assegnazione
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 attraverso 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 tra 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 di funzionamento per incremento 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 non restituisce nulla e non assegna nulla a $textFiles, che viene considerato $false in un contesto booleano. Se uno o più oggetti FileInfo vengono assegnati a $textFiles, l'condizionale restituisce $true. È possibile usare il valore di $textFiles nel corpo dell'istruzione if .
Nota
Sebbene questa tecnica sia 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 valore 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 di sottoespressione della 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 dei valori letterali 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 usarlo 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 parametri di comando 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 nome del file. Un file 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 tra virgolette, PowerShell visualizza il contenuto della stringa tra 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 background &
Esegue la pipeline prima in background in un processo di PowerShell. Questo operatore agisce in modo analogo alla e commerciale dell'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 &
Tale comando è funzionalmente equivalente 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 & background è anche un terminatore di istruzione, proprio come l'operatore di controllo UNIX e commerciale (&). In questo modo è possibile 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 in 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 a usando la notazione cast.
Operatore virgola ,
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. I 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 dot sourcing è seguito da uno spazio. Usare lo spazio per distinguere il punto dal simbolo punto (.) che rappresenta la directory corrente.
Nell'esempio seguente lo script Sample.ps1 nella directory corrente viene eseguito nell'ambito corrente.
. .\sample.ps1
Operatore Format -f
Fornire l'accesso alla funzionalità di formattazione composita .NET. Una stringa di formato composito è costituita da testo fisso mescolato con segnaposto indicizzato, denominato elementi di formato. Questi elementi di formato corrispondono agli oggetti nell'elenco.
Ogni elemento di formato usa il formato seguente ed è costituito dai componenti riportati di seguito:
{index[,alignment][:formatString]}
Le parentesi graffe corrispondenti ({ e }) sono obbligatorie.
L'operazione di formattazione produce una stringa risultato costituita dal testo fisso originale alternato alla rappresentazione di stringa degli oggetti dell'elenco. Per altre informazioni, vedere Formattazione composita.
Immettere la stringa di formato composito 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 aggiungere zero-pad a un valore numerico con l'identificatore personalizzato "0". Il numero di zeri che seguono : indica la larghezza massima a cui aggiungere 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}
Operatore Index [ ]
Seleziona oggetti da raccolte indicizzate, ad esempio matrici e tabelle hash. Gli indici di matrice sono in base 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 index 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, l'operatore index 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 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 sul lato sinistro.
# 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 range può essere usato per rappresentare una matrice di numeri interi o caratteri sequenziali. I valori uniti dall'operatore range definiscono i valori iniziale e finale 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 numero 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 range per rappresentare in modo affidabile i membri di un'enumerazione.
Intervalli di caratteri
Per creare un intervallo di caratteri, racchiudere i caratteri tra 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 allo stesso modo assegnando 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 nella matrice vengono uniti in una stringa. I caratteri sono separati dal valore della variabile di $OFS 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 member-access .
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 in tale raccolta e usa l'operatore in ognuno di essi. Per altre informazioni, vedere about_Member-Access_Enumeration.
Operatore membro statico ::
Chiama le proprietà statiche e i metodi di una classe .NET. Per trovare le proprietà statiche e i metodi di un oggetto, utilizzare 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 semplici casi condizionali.
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 di destra 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 di destra all'operando di sinistra solo se l'operando di 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 di destra 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 ai membri, ?., o l'accesso agli elementi, , ?[]al relativo operando solo se l'operando restituisce un valore diverso da 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, ad esempio ${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 $() di sottoespressione. Per altre informazioni, vedere la sezione Nome variabile di about_Variables.
Nell'esempio seguente viene restituito il valore di PropName .
$a = @{ PropName = 100 }
${a}?.PropName
100
Nell'esempio seguente viene restituito 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
Nell'esempio seguente viene restituito null senza tentare di accedere all'elemento indicizzato.
$a = $null
${a}?[0]
