about_Operators

Artikel
05/09/2024

Kurze Beschreibung

Beschreibt die Operatoren, die von PowerShell unterstützt werden.

Lange Beschreibung

Ein Operator ist ein Sprachelement, das Sie in einem Befehl oder Ausdruck verwenden können. PowerShell unterstützt mehrere Arten von Operatoren, um Sie bei der Bearbeitung von Werten zu unterstützen.

Arithmetische Operatoren

Verwenden Sie arithmetische Operatoren (+, -, *, /, ), %um Werte in einem Befehl oder Ausdruck zu berechnen. Mit diesen Operatoren können Sie Werte hinzufügen, subtrahieren, multiplizieren oder dividieren und den Rest (Modulus) eines Divisionsvorgangs berechnen.

Der Additionsoperator verkettet Elemente. Der Multiplikationsoperator gibt die angegebene Anzahl von Kopien jedes Elements zurück. Sie können arithmetische Operatoren für jeden .NET-Typ verwenden, der sie implementiert, z. B.: Int, String, , DateTimeHashtable, und Arrays.

Bitweise Operatoren (-band, , -bxor-bor, -shl-bnot, , ) -shrbearbeiten die Bitmuster in -Werten.

Weitere Informationen finden Sie unter about_Arithmetic_Operators.

Zuweisungsoperatoren

Verwenden Sie Zuweisungsoperatoren (=, +=, *=-=, /=, , ), %=um Variablen Werte zuzuweisen, zu ändern oder anzufügen. Sie können arithmetische Operatoren mit einer Zuweisung kombinieren, um das Ergebnis der arithmetischen Operation einer Variablen zuzuweisen.

Weitere Informationen finden Sie unter about_Assignment_Operators.

Vergleichsoperatoren

Verwenden Sie Vergleichsoperatoren (-eq, , -ne-gt, -lt-le, , ), -geum Werte und Testbedingungen zu vergleichen. Sie können beispielsweise zwei Zeichenfolgenwerte vergleichen, um zu bestimmen, ob sie gleich sind.

Die Vergleichsoperatoren enthalten auch Operatoren, die Muster in Text suchen oder ersetzen. Die Operatoren (, , ) verwenden reguläre Ausdrücke, und (-like, -notlike) verwenden Wildcards *. -replace-notmatch-match

Containment-Vergleichsoperatoren bestimmen, ob ein Testwert in einem Verweissatz (-in, , -notin-contains, -notcontains) angezeigt wird.

Typvergleichsoperatoren (-is, ) bestimmen, -isnotob ein Objekt von einem bestimmten Typ ist.

Weitere Informationen finden Sie unter about_Comparison_Operators.

Logische Operatoren

Verwenden Sie logische Operatoren (-and, -or, -xor, -not, ), !um bedingte Anweisungen mit einer einzelnen komplexen Bedingung zu verbinden. Sie können beispielsweise einen logischen -and Operator verwenden, um einen Objektfilter mit zwei verschiedenen Bedingungen zu erstellen.

Weitere Informationen finden Sie unter about_Logical_Operators.

Umleitungsoperatoren

Verwenden Sie Umleitungsoperatoren (>, >>, 2>, 2>>und 2>&1), um die Ausgabe eines Befehls oder Ausdrucks an eine Textdatei zu senden. Die Umleitungsoperatoren funktionieren wie das Out-File Cmdlet (ohne Parameter), ermöglichen aber auch das Umleiten der Fehlerausgabe an die angegebenen Dateien. Sie können auch das Cmdlet verwenden, um die Tee-Object Ausgabe umzuleiten.

Weitere Informationen finden Sie unter about_Redirection

Split- und Join-Operatoren

Die -split Operatoren und -join teilen und kombinieren Teilzeichenfolgen. Der -split Operator teilt eine Zeichenfolge in Teilzeichenfolgen auf. Der -join Operator verkettet mehrere Zeichenfolgen zu einer einzelnen Zeichenfolge.

Weitere Informationen finden Sie unter about_Split und about_Join.

Typoperatoren

Verwenden Sie die Typoperatoren (-is, -isnot, -as), um den .NET Framework Typ eines Objekts zu suchen oder zu ändern.

Weitere Informationen finden Sie unter about_Type_Operators.

Unäre Operatoren

Verwenden Sie die Operatoren unär ++ und -- , um Werte zu inkrementieren oder zu dekrementieren und - zu negieren. Um z. B. die Variable $a von 9 auf zu inkrementieren, 10geben Sie ein $a++.

Weitere Informationen finden Sie unter about_Arithmetic_Operators.

Spezielle Operatoren

Spezielle Operatoren verfügen über bestimmte Anwendungsfälle, die nicht in eine andere Operatorgruppe passen. Mit speziellen Operatoren können Sie beispielsweise Befehle ausführen, den Datentyp eines Werts ändern oder Elemente aus einem Array abrufen.

Gruppierungsoperator `( )`

Wie in anderen Sprachen dient dazu, (...) die Operatorrangfolge in Ausdrücken außer Kraft zu setzen. Beispiel: (1 + 2) / 3

In PowerShell gibt es jedoch zusätzliche Verhaltensweisen.

(...) ermöglicht es Ihnen, die Ausgabe eines Befehls an einem Ausdruck teilnehmen zu lassen. Beispiel:
```
PS> (Get-Item *.txt).Count -gt 10
True
```
Bei Verwendung als erstes Segment einer Pipeline führt das Umschließen eines Befehls oder Ausdrucks in Klammern immer zur Enumeration des Ausdrucksergebnisses. Wenn die Klammern einen Befehl umschließen, wird er bis zum Abschluss ausgeführt, wobei alle Ausgaben im Arbeitsspeicher gesammelt werden , bevor die Ergebnisse über die Pipeline gesendet werden.

Subexpression-Operator `$( )`

Gibt das Ergebnis einer oder mehrerer Anweisungen zurück. Gibt für ein einzelnes Ergebnis einen Skalar zurück. Gibt für mehrere Ergebnisse ein Array zurück. Verwenden Sie dies, wenn Sie einen Ausdruck in einem anderen Ausdruck verwenden möchten. Beispielsweise, um die Ergebnisse des Befehls in einen Zeichenfolgenausdruck einzubetten.

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

Array-Subexpression-Operator `@( )`

Gibt das Ergebnis einer oder mehrerer Anweisungen als Array zurück. Das Ergebnis ist immer ein Array von 0 oder mehr Objekten.

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

Syntax des Hashtabellenliterals `@{}`

Ähnlich wie beim Array-Teilausdruck wird diese Syntax verwendet, um eine Hashtabelle zu deklarieren. Weitere Informationen finden Sie unter about_Hash_Tables.

Anrufoperator `&`

Führt einen Befehl, ein Skript oder einen Skriptblock aus. Mit dem Aufrufoperator, der auch als "Aufrufoperator" bezeichnet wird, können Sie Befehle ausführen, die in Variablen gespeichert und durch Zeichenfolgen oder Skriptblöcke dargestellt werden. Der Aufrufoperator wird in einem untergeordneten Bereich ausgeführt. Weitere Informationen zu Bereichen finden Sie unter about_Scopes.

In diesem Beispiel wird ein Befehl in einer Zeichenfolge gespeichert und mithilfe des Aufrufoperators ausgeführt.

PS> $c = "get-executionpolicy"
PS> $c
get-executionpolicy
PS> & $c
AllSigned

Der Aufrufoperator analysiert keine Zeichenfolgen. Dies bedeutet, dass Sie befehlsparameter nicht innerhalb einer Zeichenfolge verwenden können, wenn Sie den Aufrufoperator verwenden.

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.

Das Cmdlet Invoke-Expression kann Code ausführen, der bei Verwendung des Aufrufoperators Analysefehler verursacht.

PS> & "1+1"
& : The term '1+1' 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.
At line:1 char:2
+ & "1+1"
+  ~~~~~
    + CategoryInfo          : ObjectNotFound: (1+1:String) [], CommandNotFoundException
    + FullyQualifiedErrorId : CommandNotFoundException
PS> Invoke-Expression "1+1"
2

Sie können den Aufrufoperator verwenden, um Skripts mit ihren Dateinamen auszuführen. Das folgende Beispiel zeigt einen Skriptdateinamen, der Leerzeichen enthält. Wenn Sie versuchen, das Skript auszuführen, zeigt PowerShell stattdessen den Inhalt der Zeichenfolge in Anführungszeichen an, die den Dateinamen enthält. Mit dem Aufrufoperator können Sie den Inhalt der Zeichenfolge ausführen, die den Dateinamen enthält.

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!

Weitere Informationen zu Skriptblöcken finden Sie unter about_Script_Blocks.

Hintergrundoperator `&`

Führt die Pipeline vor ihr im Hintergrund in einem PowerShell-Auftrag aus. Dieser Operator verhält sich ähnlich wie der UNIX-Steuerungsoperator amper and (&), der den Befehl vor dem Befehl asynchron in Subshell als Auftrag ausführt.

Dieser Operator entspricht funktional Start-Job. Standardmäßig startet der Hintergrundoperator die Aufträge im aktuellen Arbeitsverzeichnis des Aufrufers, der die parallelen Aufgaben gestartet hat. Im folgenden Beispiel wird die grundlegende Verwendung des Hintergrundauftragsoperators veranschaulicht.

Get-Process -Name pwsh &

Dieser Befehl entspricht funktional der folgenden Verwendung von Start-Job:

Start-Job -ScriptBlock {Get-Process -Name pwsh}

Genau wie Start-Jobgibt der & Hintergrundoperator ein Job -Objekt zurück. Dieses Objekt kann mit Receive-Job und Remove-Jobverwendet werden, so als hätten Start-Job Sie den Auftrag gestartet.

$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

Der & Hintergrundoperator ist auch ein Anweisungsabschlusszeichen, genau wie der UNIX-Steuerelementoperator amper and (&). Dadurch können Sie zusätzliche Befehle nach dem & Hintergrundoperator aufrufen. Im folgenden Beispiel wird der Aufruf zusätzlicher Befehle nach dem & Hintergrundoperator veranschaulicht.

$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

Dies entspricht dem folgenden Skript:

$job = Start-Job -ScriptBlock {Get-Process -Name pwsh}
Receive-Job $job -Wait

Wenn Sie mehrere Befehle ausführen möchten, jeder in einem eigenen Hintergrundprozess, aber alle in einer Zeile, platzieren & Sie einfach zwischen und nach jedem der Befehle.

Get-Process -Name pwsh & Get-Service -Name BITS & Get-CimInstance -ClassName Win32_ComputerSystem &

Weitere Informationen zu PowerShell-Aufträgen finden Sie unter about_Jobs.

Castoperator `[ ]`

Konvertiert oder beschränkt Objekte in den angegebenen Typ. Wenn die Objekte nicht konvertiert werden können, generiert PowerShell einen Fehler.

[DateTime] '2/20/88' - [DateTime] '1/20/88' -eq [TimeSpan] '31'

Eine Umwandlung kann auch ausgeführt werden, wenn eine Variable mithilfe der Umwandlungsnotation zugewiesen wird.

Kommaoperator `,`

Als binärer Operator erstellt das Komma ein Array oder fügt an das array an, das erstellt wird. Im Ausdrucksmodus erstellt das Komma als unärer Operator ein Array mit nur einem Element. Platzieren Sie das Komma vor dem Member.

$myArray = 1,2,3
$SingleArray = ,1
Write-Output (,1)

Da Write-Object ein Argument erwartet, müssen Sie den Ausdruck in Klammern setzen.

Dot-Sourcing-Operator `.`

Führt ein Skript im aktuellen Bereich aus, sodass alle Funktionen, Aliase und Variablen, die das Skript erstellt, dem aktuellen Bereich hinzugefügt werden und vorhandene überschrieben werden. Vom Skript deklarierte Parameter werden zu Variablen. Parameter, für die kein Wert angegeben wurde, werden zu Variablen ohne Wert. Die automatische Variable $args wird jedoch beibehalten.

. c:\scripts\sample.ps1 1 2 -Also:3

Hinweis

Auf den Dot-Sourcing-Operator folgt ein Leerzeichen. Verwenden Sie das Leerzeichen, um den Punkt vom Punktsymbol (.) zu unterscheiden, das das aktuelle Verzeichnis darstellt.

Im folgenden Beispiel wird das Sample.ps1 Skript im aktuellen Verzeichnis im aktuellen Bereich ausgeführt.

. .\sample.ps1

Formatoperator `-f`

Formatiert Zeichenfolgen mithilfe der Formatmethode von Zeichenfolgenobjekten. Geben Sie die Formatzeichenfolge auf der linken Seite des Operators und die objekte ein, die auf der rechten Seite des Operators formatiert werden sollen.

"{0} {1,-10} {2:N}" -f 1,"hello",[math]::pi

1 hello      3.14

Wenn Sie die geschweiften Klammern ({}) in der formatierten Zeichenfolge beibehalten müssen, können Sie sie mit Escapezeichen versehen, indem Sie die geschweiften Klammern verdoppeln.

"{0} vs. {{0}}" -f 'foo'

foo vs. {0}

Weitere Informationen finden Sie unter String.Format-Methode und zusammengesetzte Formatierung.

Indexoperator `[ ]`

Wählt Objekte aus indizierten Auflistungen aus, z. B. Arrays und Hashtabellen. Arrayindizes sind nullbasiert, sodass das erste Objekt als [0]indiziert wird. Sie können auch negative Indizes verwenden, um die letzten Werte abzurufen. Hashtabellen werden nach Schlüsselwert indiziert.

Bei einer Liste von Indizes gibt der Indexoperator eine Liste von Elementen zurück, die diesen Indizes entsprechen.

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...

Wenn ein Objekt keine indizierte Auflistung ist, gibt die Verwendung des Indexoperators für den Zugriff auf das erste Element das Objekt selbst zurück. Indexwerte über das erste Element hinaus geben zurück $null.

PS> (2)[0]
2
PS> (2)[-1]
2
PS> (2)[1] -eq $null
True
PS> (2)[0,0] -eq $null
True

Pipelineoperator `|`

Sendet ("Pipes") die Ausgabe des Befehls, der ihm vorangestellt ist, an den Befehl, der darauf folgt. Wenn die Ausgabe mehr als ein Objekt (eine "Auflistung") enthält, sendet der Pipelineoperator die Objekte einzeln.

Get-Process | Get-Member
Get-Service | Where-Object {$_.StartType -eq 'Automatic'}

Pipelinekettenoperatoren `&&` und `||`

Führen Sie die rechte Pipeline basierend auf dem Erfolg der linken Pipeline bedingt aus.

# 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

Weitere Informationen finden Sie unter About_Pipeline_Chain_Operators.

Bereichsoperator `..`

Stellt die sequenziellen ganzen Zahlen in einem ganzzahligen Array dar, wobei eine obere und eine untere Grenze vorhanden sind.

1..10
foreach ($a in 1..$max) {Write-Host $a}

Sie können Bereiche auch in umgekehrter Reihenfolge erstellen.

10..1
5..-5 | ForEach-Object {Write-Output $_}

Ab PowerShell 6 funktioniert der Bereichsoperator sowohl mit Zeichen als auch mit Ganzen Zahlen.

Um einen Bereich von Zeichen zu erstellen, schließen Sie die Begrenzungszeichen in Anführungszeichen ein.

PS> 'a'..'f'
a
b
c
d
e
f

PS> 'F'..'A'
F
E
D
C
B
A

Memberzugriffsoperator `.`

Greift auf die Eigenschaften und Methoden eines Objekts zu. Der Membername kann ein Ausdruck sein.

$myProcess.peakWorkingSet
(Get-Process PowerShell).kill()
'OS', 'Platform' | Foreach-Object { $PSVersionTable. $_ }

Wenn Sie ab PowerShell 3.0 den Operator für ein Listensammlungsobjekt verwenden, das nicht über das Element verfügt, listet PowerShell automatisch die Elemente in dieser Auflistung auf und verwendet den Operator für jedes element. Weitere Informationen finden Sie unter about_Member-Access_Enumeration.

Statischer Memberoperator `::`

Ruft die statischen Eigenschaften und Methoden einer .NET Framework-Klasse auf. Verwenden Sie den Static-Parameter des Get-Member Cmdlets, um die statischen Eigenschaften und Methoden eines Objekts zu ermitteln. Der Membername kann ein Ausdruck sein.

[datetime]::Now
'MinValue', 'MaxValue' | Foreach-Object { [int]:: $_ }

Ternärer Operator `? <if-true> : <if-false>`

Sie können den ternären Operator in einfachen bedingten Fällen als Ersatz für die if-else Anweisung verwenden.

Weitere Informationen finden Sie unter about_If.

NULL-Sammeloperator `??`

Der NULL-Sammeloperator ?? gibt den Wert seines linken Operanden zurück, wenn er nicht NULL ist. Andernfalls wertet er den rechten Operanden aus und gibt sein Ergebnis zurück. Der Operator ?? wertet seinen rechten Operanden nicht aus, wenn der linke Operand mit ungleich NULL auswertet wird.

$x = $null
$x ?? 100

Im folgenden Beispiel wird der rechte Operand nicht ausgewertet.

[string] $todaysDate = '1/10/2020'
$todaysDate ?? (Get-Date).ToShortDateString()

1/10/2020

Der NULL-Sammelzuordnungsoperator`??=`

Der NULL-Sammelzuordnungsoperator??= weist den Wert seines rechten Operanden dem linken Operanden nur zu, wenn der linke Operand mit NULL ausgewertet wird. Der Operator ??= wertet seinen rechten Operanden nicht aus, wenn der linke Operand mit ungleich NULL auswertet wird.

$x = $null
$x ??= 100
$x

Im folgenden Beispiel wird der rechte Operand nicht ausgewertet.

[string] $todaysDate = '1/10/2020'
$todaysDate ??= (Get-Date).ToShortDateString()

1/10/2020

NULL-bedingte Operatoren `?.` und `?[]`

Hinweis

Dieses Feature wurde von „Experimentell“ in „Mainstream“ in PowerShell 7.1 verschoben.

Ein bedingter NULL-Operator erlaubt den Memberzugriff ?. oder Elementzugriff ?[] auf seinen Operanden nur dann, wenn dieser Operand mit ungleich NULL ausgewertet wird. Andernfalls gibt er NULL zurück.

Da PowerShell erlaubt, dass ? Teil des Variablennamens ist, ist für die Verwendung dieser Operatoren die formale Angabe des Variablennamens erforderlich. Daher ist es nötig, {} um die Variablennamen herum zu platzieren, wie z. B. ${a} oder wenn ? Teil des Variablennamens ${a?} ist.

Im folgenden Beispiel wird der Wert von PropName zurückgegeben.

$a = @{ PropName = 100 }
${a}?.PropName

Das folgende Beispiel gibt NULL zurück, ohne dass versucht wird, auf den Membernamen PropName zuzugreifen.

$a = $null
${a}?.PropName

Auf ähnliche Weise wird der Wert des Elements zurückgegeben.

$a = 1..10
${a}?[0]

Wenn der Operand NULL ist, wird nicht auf das Element zugegriffen und NULL zurückgegeben.

$a = $null
${a}?[0]

Hinweis

Die Syntax des Variablennamens ${<name>} sollte nicht mit dem $()-Subexpression-Operator verwechselt werden. Weitere Informationen finden Sie im Abschnitt „Variablenname“ von about_Variables.

Freigeben über

about_Operators

Kurze Beschreibung

Lange Beschreibung

Arithmetische Operatoren

Zuweisungsoperatoren

Vergleichsoperatoren

Logische Operatoren

Umleitungsoperatoren

Split- und Join-Operatoren

Typoperatoren

Unäre Operatoren

Spezielle Operatoren

Gruppierungsoperator `( )`

Subexpression-Operator `$( )`

Array-Subexpression-Operator `@( )`

Syntax des Hashtabellenliterals `@{}`

Anrufoperator `&`

Hintergrundoperator `&`

Castoperator `[ ]`

Kommaoperator `,`

Dot-Sourcing-Operator `.`

Formatoperator `-f`

Indexoperator `[ ]`

Pipelineoperator `|`

Pipelinekettenoperatoren `&&` und `||`

Bereichsoperator `..`

Memberzugriffsoperator `.`

Statischer Memberoperator `::`

Ternärer Operator `? <if-true> : <if-false>`

NULL-Sammeloperator `??`

Der NULL-Sammelzuordnungsoperator`??=`

NULL-bedingte Operatoren `?.` und `?[]`

Weitere Informationen

Zusätzliche Ressourcen

Freigeben über

about_Operators

Kurze Beschreibung

Lange Beschreibung

Arithmetische Operatoren

Zuweisungsoperatoren

Vergleichsoperatoren

Logische Operatoren

Umleitungsoperatoren

Split- und Join-Operatoren

Typoperatoren

Unäre Operatoren

Spezielle Operatoren

Gruppierungsoperator ( )

Subexpression-Operator $( )

Array-Subexpression-Operator @( )

Syntax des Hashtabellenliterals @{}

Anrufoperator &

Hintergrundoperator &

Castoperator [ ]

Kommaoperator ,

Dot-Sourcing-Operator .

Formatoperator -f

Indexoperator [ ]

Pipelineoperator |

Pipelinekettenoperatoren && und ||

Bereichsoperator ..

Memberzugriffsoperator .

Statischer Memberoperator ::

Ternärer Operator ? <if-true> : <if-false>

NULL-Sammeloperator ??

Der NULL-Sammelzuordnungsoperator??=

NULL-bedingte Operatoren ?. und ?[]

Weitere Informationen

Zusätzliche Ressourcen

Gruppierungsoperator `( )`

Subexpression-Operator `$( )`

Array-Subexpression-Operator `@( )`

Syntax des Hashtabellenliterals `@{}`

Anrufoperator `&`

Hintergrundoperator `&`

Castoperator `[ ]`

Kommaoperator `,`

Dot-Sourcing-Operator `.`

Formatoperator `-f`

Indexoperator `[ ]`

Pipelineoperator `|`

Pipelinekettenoperatoren `&&` und `||`

Bereichsoperator `..`

Memberzugriffsoperator `.`

Statischer Memberoperator `::`

Ternärer Operator `? <if-true> : <if-false>`

NULL-Sammeloperator `??`

Der NULL-Sammelzuordnungsoperator`??=`

NULL-bedingte Operatoren `?.` und `?[]`