Operatoren in Verse | Fortnite Dokumentation

Operators sind spezielle functions, die in der Programmiersprache Verse definiert sind, um Aktionen wie mathematische Operationen mit ihren operands auszuführen. Beispielsweise ist im Ausdruck 1 + 2 das + ein Operator und 1 und 2 sind beides Operanden.

Es gibt drei Formate für Operatoren, die du in Verse sehen wirst:

Präfix: Es gibt nur einen Operanden und der Operator ist vor dem Operanden.
Infix: Es gibt zwei Operanden und der Operator ist zwischen den Operanden.
Postfix: Es gibt nur einen Operanden und der Operator ist hinter dem Operanden.

Diese Seite beschreibt alle in Verse verwendbaren Operatoren, wie sie funktionieren und ihre order of evaluation, wenn sie in Kombination mit anderen Operatoren verwendet werden.

Liste aller Operatoren und Vorrang der Operatoren

Wenn mehrere Operatoren im selben Ausdruck verwendet werden, werden sie in der Reihenfolge des höchsten bis niedrigsten Vorrangs ausgewertet. In der folgenden Tabelle sind alle eingebauten Operatoren in Verse und ihre Rangfolge aufgeführt.

Name	Bediener	Beschreibung	Operatorenformat	Vorrang des Operators	Beispiel
Abfrage	`?`	Der Operator `?` prüft, ob ein `logischer` Wert `true` ist. Siehe Abfrage für weitere Details.	postfix	11.	`BossDefeated?`
Nicht	`nicht`	Der Operator `not` negiert den Erfolg oder Misserfolg eines Ausdrucks. Siehe Not für weitere Details.	Präfix	26.	`not BossDefeated?`
Positiv	`+`	Du kannst den Operator `+` als Präfix für eine Zahl verwenden, um deinen Code visuell auszurichten, aber der Wert der Zahl ändert sich dadurch nicht. Siehe Math für weitere Details.	Präfix	26.	`+MyScore`
Negativ	`-`	Du kannst den Operator `-` als Präfix einer Zahl verwenden, um den Zahlenwert zu negieren. Siehe Math für weitere Details.	Präfix	26.	`-MyScore`
Multiplikation	`*`	Das `*` multipliziert zwei Zahlenwerte miteinander. Siehe Math für weitere Details.	Infix	7	`MyScore * ScoreMultiplier`
Division	`/`	Der Operator `/` teilt den ersten Zahlenoperanden durch den zweiten Zahlenoperanden. Die ganzzahlige Division ist fehlbar. Siehe Math für weitere Details.	Infix	7	`MyScore / ScorePenalty`
Zusatz	`+`	Der Operator `+` addiert zwei Zahlenwerte. Wenn du ihn mit Strings und Arrays verwendest, werden die beiden Werte verkettet. Siehe Math für weitere Details.	Infix	6	`MyScore + ScoreBonus`
Subtraktion	`-`	Der Operator `-` subtrahiert den zweiten Zahlenoperanden vom ersten Operanden. Siehe Math für weitere Details.	Infix	6	`MyScore - ScorePenalty`
Additionszuweisung	`set +=`	Mit diesem Operator kannst du Addition und Zuweisung in der gleichen Operation kombinieren, um den Wert einer Variablen zu aktualisieren. Siehe Math für weitere Details.	Infix	5	`set MyScore += ScoreBonus`
Subtraktionszuweisung	`set -=`	Mit diesem Operator kannst du Subtraktion und Zuweisung in der gleichen Operation kombinieren, um den Wert einer Variablen zu aktualisieren. Siehe Math für weitere Details.	Infix	5	`set MyScore -= ScorePenalty`
Multiplikationszuweisung	`set *=`	Mit diesem Operator kannst du Multiplikation und Zuweisung in der gleichen Operation kombinieren, um den Wert einer Variablen zu aktualisieren. Siehe Math für weitere Details.	Infix	5	`set MyScore *= ScoreMultiplier`
Divisionszuweisung	`set /=`	Mit diesem Operator kannst du Division und Zuweisung in der gleichen Operation kombinieren, um den Wert einer Variablen zu aktualisieren, es sei denn, die Variable ist eine ganze Zahl. Siehe Math für weitere Details.	Infix	5	`set MyScore /= ScorePenalty`
Ist gleich	`=`	Der Operator `=` ist erfolgreich, wenn der linke Operand gleich dem rechten Operanden ist. Schlägt ansonsten fehl. Siehe Vergleich für weitere Details.	Infix	44	`MyScore = HighScore`
Ungleich	`<>`	Der `<>`-Operator ist erfolgreich, wenn der linke Operand nicht gleich dem rechten Operanden ist. Schlägt ansonsten fehl. Siehe Vergleich für weitere Details.	Infix	44	`MyScore <> HighScore`
Kleiner als	`<`	Der Operator `<` ist erfolgreich, wenn der linke Operand kleiner als der rechte Operand ist. Schlägt ansonsten fehl. Siehe Vergleich für weitere Details.	Infix	44	`MyScore < HighScore`
Kleiner als oder gleich wie	`<=`	Der Operator `<=` ist erfolgreich, wenn der linke Operand kleiner oder gleich dem rechten Operanden ist. Schlägt ansonsten fehl. Siehe Vergleich für weitere Details.	Infix	44	`MyScore <= HighScore`
Größer als	`>`	Der Operator `>` ist erfolgreich, wenn der linke Operand größer als der rechte Operand ist. Schlägt ansonsten fehl. Siehe Vergleich für weitere Details.	Infix	44	`MyScore > HighScore`
Größer als oder gleich wie	`>=`	Der Operator `>=` ist erfolgreich, wenn der linke Operand größer oder gleich dem rechten Operanden ist. Schlägt ansonsten fehl. Siehe Vergleich für weitere Details.	Infix	44	`MyScore >= HighScore`
Außerdem	`and`	Der Operator `and` ist nur erfolgreich, wenn alle Operanden erfolgreich sind. Siehe And/Or-Operatoren für weitere Details.	Infix	3	`BossDefeated? and TargetScoreReached?`
Oder	`or`	Der Entscheidungsoperator `or` ist erfolgreich, wenn mindestens einer der Operanden erfolgreich ist. Siehe And/Or-Operatoren für weitere Details.	Infix	10	`BossDefeated? or TargetScoreReached?`
Initialisierung von Variablen und Konstanten	`: =`	Mit diesem Operator kannst du Werte in einer Konstanten oder Variable speichern. Siehe Constants and Variables für weitere Details.	Infix	1	`MyScore : int = 42`
Variablenzuweisung	`set =`	Mit diesem Operator kannst du die in einer Variablen gespeicherten Werte aktualisieren. Siehe Constants and Variables für weitere Details.	Infix	1	`set MyScore = 42`

Wenn es im selben Ausdruck Operatoren mit der gleichen Rangfolge gibt, werden sie von links nach rechts ausgewertet. Zum Beispiel in dem Ausdruck 3*2/4 haben die beiden Operatoren * und / den gleichen Vorrang, also wird 3*2 zuerst ausgewertet und sein Ergebnis wird der restlichen Operand für den / Operator.

Du kannst die Reihenfolge, in der die Operatoren ausgewertet werden, ändern, indem du Ausdrücke mit () gruppierst. Beispielsweise ergeben (1+2)*3 und 1+(2*3) nicht dasselbe Ergebnis. Siehe Gruppierung für weitere Details.

Vergleich

Du kannst den Verlauf von Erfolg und Misserfolg mit Vergleichsausdrücken steuern, die den Operator inequality und equality verwenden. Vergleichsausdrücke sind failable, daher kannst du Vergleichsoperatoren nur in Fehlerkontexten verwenden, zum Beispiel in if-expressions.

Die folgende Tabelle beschreibt jeden Operator und welche types er unterstützt. Alle Vergleichsoperatoren verwenden das Infix-Format.

Bediener	Unterstützte integrierte Typen	Beschreibung
`<`	`float` `int`	Der Operator `<` ist erfolgreich, wenn der linke Operand kleiner als der rechte Operand ist. Schlägt ansonsten fehl.
`<=`	`float` `int`	Der Operator `<=` ist erfolgreich, wenn der linke Operand kleiner als oder gleich dem rechten Operanden ist. Schlägt ansonsten fehl.
`>`	`float` `int`	Der Operator `>` ist erfolgreich, wenn der linke Operand größer als der rechte Operand ist. Schlägt ansonsten fehl.
`>=`	`float` `int`	Der Operator `>=` ist erfolgreich, wenn der linke Operand größer als oder gleich dem rechten Operanden ist. Schlägt ansonsten fehl.
`<>`	`float` `int` `logic` `string` `enum`	Der Operator `<>` ist erfolgreich, wenn der linke Operand ungleich dem rechten Operanden ist. Schlägt ansonsten fehl.
`=`	`float` `int` `logic` `string` `enum`	Der Operator `=` ist erfolgreich, wenn der linke Operand gleich dem rechten Operanden ist. Schlägt ansonsten fehl.

Sowohl <>als auch = werden auch für array, map, tuple und class-Instanzen unterstützt, allerdings mit Einschränkungen. Die Instanzen array, map und tuple können nur unterstützte Typen enthalten, und class-Instanzen werden nur unterstützt, wenn sie mindestens ein var-Element enthalten.

Entscheidung

Du kannst den Ablauf von Erfolg und Fehlschlag mit Entscheidungsausdrücken steuern, die die Operatoren not, and, und or verwenden. Entscheidungsausdrücke sind fehlbar, d.h. Sie können Vergleichsoperatoren nur in Fehlerkontexten verwenden, wie z.B. in if-Ausdrücken. Sie können alle Ausdrücke, die erfolgreich oder nicht erfolgreich sind, mit Entscheidungsoperatoren verwenden.

Nicht-Operator

Der Entscheidungsoperator not negiert den Erfolg oder Misserfolg eines Ausdrucks. Der Operator not verwendet das Präfixformat.

Wenn zum Beispiel expression fehlschlägt, wird not expression erfolgreich sein. Wenn expression erfolgreich ist, schlägt not expression fehl und die Auswirkungen von expression werden nie übernommen (als ob der Ausdruck nie stattgefunden hätte).

Nachdem beispielsweise der folgende Code ausgeführt wurde, hat Example immer noch den Anfangswert 0:

Verse

var Example : int = 0
if (not (set Example = ExampleArray[0])) { … }

var Example : int = 0
if (not (set Example = ExampleArray[0])) { … }

Du kannst not not expression verwenden, um zu prüfen, ob ein Ausdruck erfolgreich sein wird, aber um sicherzustellen, dass der Ausdruck nie ausgeführt wird.

Ergebnis des Ausdrucks p	Ergebnis des Ausdrucks not p	Ergebnis des Ausdrucks not not p
Erfolgreich und das Ergebnis ist `p`	Der Ausdruck schlägt fehl, und der Effekt von `p` wird nicht übernommen. Das Ergebnis des Ausdrucks ist kein Wert.	Der Ausdruck ist erfolgreich, aber die Effekte von `p` werden nicht übernommen. Das Ergebnis des Ausdrucks ist `true`.
Schlägt fehl und Ergebnis ist kein Wert	Der Ausdruck ist erfolgreich. Das Ergebnis des Ausdrucks ist `true`.	Der Ausdruck schlägt fehl. Das Ergebnis des Ausdrucks ist kein Wert.

Referenz für den not-Operator, der einen Ausdruck auswertet, dargestellt durch p.

Und / Oder-Operatoren

Der Entscheidungsoperator and verwendet das Infixformat und ist ein fehlbarer Ausdruck, der erfolgreich ist, wenn beide Operanden erfolgreich sind, bzw. fehlschlägt, wenn mindestens ein Operand fehlschlägt.

Der Entscheidungsoperator or verwendet das Infixformat und ist:

Ein Fehlerkontext für den ersten Operanden.
Nur dann ein fehlbarer Ausdruck, wenn der zweite Operand fehlbar ist.

Der Operator or überspringt die Auswertung des zweiten Operanden, wenn der erste Operand erfolgreich ist.

Die folgende Tabelle beschreibt die Ergebnisse aller Operandenkombinationen von Erfolg und Misserfolg für Entscheidungsausdrücke mit den Operatoren and und or.

Ergebnis des Ausdrucks p	Ergebnis des Ausdrucks q	Ergebnis des Ausdrucks p und q	Ergebnis des Ausdrucks p oder q
Erfolgreich und Ergebnis ist `p`	Erfolgreich und das Ergebnis ist `q`	Der Ausdruck ist erfolgreich, sodass der Effekt von beiden `p` und `q` übernommen werden. Das Ergebnis des Ausdrucks ist `q`.	Der Ausdruck ist erfolgreich und nur die Effekte von `p` werden übernommen. `q` wird nicht ausgeführt, weil `p` erfolgreich ist. Das Ergebnis des Ausdrucks ist `p`.
Erfolgreich und das Ergebnis ist `p`	Schlägt fehl und Ergebnis ist kein Wert	Der Ausdruck schlägt fehl und der Effekt von beiden `p` und `q` wird nicht übernommen. Das Ergebnis ist kein Wert.	Der Ausdruck ist erfolgreich und nur die Effekte von `p` werden übernommen. `q` wird nicht ausgeführt, weil `p` erfolgreich ist. Das Ergebnis des Ausdrucks ist `p`.
Schlägt fehl und Ergebnis ist kein Wert	Erfolgreich und das Ergebnis ist `q`	Der Ausdruck schlägt fehl und der Effekt von beiden `p` und `q` wird nicht übernommen. Das Ergebnis ist kein Wert.	Der Ausdruck ist erfolgreich und nur die Effekte von `q` werden übernommen. Das Ergebnis des Ausdrucks ist `q`.
Schlägt fehl und Ergebnis ist kein Wert	Schlägt fehl und Ergebnis ist kein Wert	Der Ausdruck schlägt fehl und der Effekt von beiden `p` und `q` wird nicht übernommen. Das Ergebnis ist kein Wert.	Der Ausdruck schlägt fehl und der Effekt von beiden `p` und `q` wird nicht übernommen. Das Ergebnis des Ausdrucks ist kein Wert.

Referenz für die Operatoren and und or, die Ausdrücke auswerten, dargestellt durch p und q.

Mathematik

Mit mathematischen Ausdrücken kannst du die vier Grundrechenarten (Addition, Subtraktion, Multiplikation und Division) mit Zahlenwerten durchführen und Strings zusammenfügen. Alle Operatoren verwenden das Infix-Format, außer + und - können auch ein Präfix für Zahlenwerte sein. Es gibt auch Zuweisungsoperatoren, z. B. set X += 10. Sie sind fast dasselbe wie die Durchführung der Operation und die anschließende Zuweisung des Ergebnisses, set X = X + 10, mit dem Unterschied, dass das X in diesem Fall nur einmal ausgewertet wird. Das Ergebnis eines Zuweisungsoperators ist der Wert, der zur Aktualisierung der Variablen verwendet wird.

Die folgende Tabelle beschreibt jeden Operator und welche Typen er unterstützt.

Bediener	Unterstützte integrierte Typen	Beschreibung
`+`	`float` `int` `string` `Array`	Der Operator `+` addiert zwei Zahlenwerte. Wenn du ihn mit Strings und Arrays verwendest, werden die beiden Werte verkettet. Du kannst den Operator `+` auch als Präfix vor einer Zahl verwenden, z. B. `+6`, die dir hilft deinen Code visuell auszurichten, aber er ändert den Wert der Zahl nicht.
`-`	`float` `int`	Der Operator `-` subtrahiert den zweiten Zahlenoperanden vom ersten Operanden. Du kannst auch den Operator `-` als Präfix vor einer Zahl verwenden, um den Zahlenwert zu negieren, zum Beispiel `-3.2`.
`*`	`float` `int`	Das `*` multipliziert zwei Zahlenwerte miteinander.
`/`	`float` `int` (fehlbar)	Der Operator `/` teilt den ersten Zahlenoperanden durch den zweiten Zahlenoperanden. Eine ganzzahlige Division ist fehlbar und liefert den Typ `rational`. Weitere Informationen zur Ganzzahldivision findest du unter int.
`set +=`	`float` `int` `string` `Array`	Mit diesem Operator kannst du Addition und Zuweisung in der gleichen Operation kombinieren, um den Wert einer Variablen zu aktualisieren.
`set -=`	`float` `int`	Mit diesem Operator kannst du Subtraktion und Zuweisung in der gleichen Operation kombinieren, um den Wert einer Variablen zu aktualisieren.
`set *=`	`float` `int`	Mit diesem Operator kannst du Multiplikation und Zuweisung in der gleichen Operation kombinieren, um den Wert einer Variablen zu aktualisieren.
`set /=`	`float`	Mit diesem Operator kannst du Division und Zuweisung in der gleichen Operation kombinieren, um den Wert einer Variablen zu aktualisieren, es sei denn, die Variable ist eine ganze Zahl. Weitere Informationen zur Ganzzahldivision findest du unter int.

Abfrage

Abfrageausdrücke verwenden den Operator ? (Abfrage) und prüfen, ob ein logischer -Wert True ist. Andernfalls schlägt der Ausdruck fehl. Der Operator ? (Abfrage) verwendet das Postfix-Format.

Ergebnis des Ausdrucks p	Ergebnis des Ausdrucks p?
`true`	Erfolgreich und das Ergebnis ist `true`.
`false`	Schlägt fehl und das Ergebnis ist kein Wert.

Referenz für das ? (Abfrage) Operator, der Ausdrücke auswertet, dargestellt durch p.

Zum Beispiel:

Verse

if (IsMorning?):
    Say("Good Morning!")

if (IsMorning?):
    Say("Good Morning!")