about_Operators

  • Articolo

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.

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

Formatta le stringhe usando il metodo format degli oggetti stringa. Immettere la stringa di formato a sinistra 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}

Per altre informazioni, vedere il metodo String.Format e la formattazione composita.

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]

Vedi anche