Opérateurs dans Verse | Fortnite Documentation

Les opérateurs sont des fonctions spéciales définies en langage de programmation Verse pour effectuer des actions, telles que les actions mathématiques, sur leurs opérandes. Par exemple, dans l'expression 1 + 2, le + est un opérateur, et 1 et 2 sont deux opérandes.

Il existe trois formats d'opérateurs que vous verrez dans Verse :

Préfixe : il n'y a qu'un seul opérande et l'opérateur est situé avant l'opérande.
Infixe : il y a deux opérandes et l'opérateur est situé entre les opérandes.
Suffixe : il n'y a qu'un seul opérande, et l'opérateur est situé après l'opérande.

Sur cette page, nous décrivons tous les opérateurs que vous pouvez utiliser dans Verse, leur fonctionnement et leur ordre d'évaluation lorsqu'ils sont utilisés en combinaison avec d'autres opérateurs.

Liste complète des opérateurs et précédence des opérateurs

Lorsque plusieurs opérateurs sont utilisés dans la même expression, ils sont évalués en fonction de leur précédence, de la plus élevée à la plus faible. Consultez le tableau ci-dessous pour connaître tous les opérateurs intégrés dans Verse et leur précédence.

Nom	Opérateur	Description	Format de l'opérateur	Précédence des opérateurs	Exemple
Query (requête)	`?`	L'opérateur `?` vérifie si une valeur `logic` est définie sur `true`. Consultez la rubrique Requête pour en savoir plus.	postfix (suffixe)	9	`BossDefeated?`
Non	`not`	L'opérateur `not` nie la réussite ou l'échec d'une expression. Consultez la rubrique Not pour en savoir plus.	Préfixe	8	`not BossDefeated?`
Positif	`+`	Vous pouvez utiliser l'opérateur `+` comme préfixe à un nombre pour aligner votre code visuellement, mais il ne changera pas la valeur du nombre. Consultez la rubrique Math pour en savoir plus.	Préfixe	8	`+MyScore`
Négatif	`-`	Vous pouvez utiliser l'opérateur `-` comme préfixe à un nombre pour rendre négative la valeur du nombre. Consultez la rubrique Math pour en savoir plus.	Préfixe	8	`-MyScore`
Multiplication	`*`	L'opérateur `*` multiplie deux valeurs numériques ensemble. Consultez la rubrique Math pour en savoir plus.	infix (infixe)	7	`MyScore * ScoreMultiplier`
Division	`/`	L'opérateur `/` divise le premier opérande numérique par le second opérande numérique. La division des nombres entiers est faillible. Consultez la rubrique Math pour en savoir plus.	infix (infixe)	7	`MyScore / ScorePenalty`
Addition	`+`	L'opérateur `+` additionne deux valeurs numériques. Lorsqu'il est utilisé avec des chaînes de caractères et des matrices, les deux valeurs sont concaténées. Consultez la rubrique Math pour en savoir plus.	infix (infixe)	6	`MyScore + ScoreBonus`
Soustraction	`-`	L'opérateur `-` soustrait le deuxième opérande numérique au premier opérande. Consultez la rubrique Math pour en savoir plus.	infix (infixe)	6	`MyScore - ScorePenalty`
Assignation de l'addition	`set +=`	Cet opérateur vous permet de combiner l'addition et l'affectation dans la même opération pour mettre à jour la valeur d'une variable. Consultez la rubrique Math pour en savoir plus.	infix (infixe)	5	`set MyScore += ScoreBonus`
Affectation de soustraction	`set -=`	Cet opérateur vous permet de combiner la soustraction et l'affectation dans la même opération pour mettre à jour la valeur d'une variable. Consultez la rubrique Math pour en savoir plus.	infix (infixe)	5	`set MyScore -= ScorePenalty`
Affectation de multiplication	`set *=`	Cet opérateur vous permet de combiner la multiplication et l'affectation dans la même opération pour mettre à jour la valeur d'une variable. Consultez la rubrique Math pour en savoir plus.	infix (infixe)	5	`set MyScore *= ScoreMultiplier`
Assignation de la division	`set /=`	Cet opérateur vous permet de combiner la division et l'affectation dans la même opération pour mettre à jour la valeur d'une variable, à moins que la variable soit un nombre entier. Consultez la rubrique Math pour en savoir plus.	infix (infixe)	5	`set MyScore /= ScorePenalty`
Égal à	`=`	L'opérateur `=` réussit lorsque l'opérande de gauche est égal à l'opérande de droite. Dans le cas contraire, il échoue. Consultez la rubrique Comparaison pour en savoir plus.	infix (infixe)	4	`MyScore = HighScore`
Différent de	`<>`	L'opérateur `<>` réussit lorsque l'opérande de gauche est différent de l'opérande de droite. Dans le cas contraire, il échoue. Consultez la rubrique Comparaison pour en savoir plus.	infix (infixe)	4	`MyScore <> HighScore`
Inférieur à	`<`	L'opérateur `<` réussit lorsque l'opérande de gauche est inférieur à l'opérande de droite. Dans le cas contraire, il échoue. Consultez la rubrique Comparaison pour en savoir plus.	infix (infixe)	4	`MyScore < HighScore`
Inférieur ou égal à	`<=`	L'opérateur `<=` réussit lorsque l'opérande de gauche est inférieur ou égal à l'opérande de droite. Dans le cas contraire, il échoue. Consultez la rubrique Comparaison pour en savoir plus.	infix (infixe)	4	`MyScore <= HighScore`
Supérieur à	`>`	L'opérateur `>` réussit lorsque l'opérande de gauche est supérieur à l'opérande de droite. Dans le cas contraire, il échoue. Consultez la rubrique Comparaison pour en savoir plus.	infix (infixe)	4	`MyScore > HighScore`
Supérieur ou égal à	`>=`	L'opérateur `>=` réussit lorsque l'opérande de gauche est supérieur ou égal à l'opérande de droite. Dans le cas contraire, il échoue. Consultez la rubrique Comparaison pour en savoir plus.	infix (infixe)	4	`MyScore >= HighScore`
Et	`and`	L'opérateur `and` réussit uniquement lorsque tous les opérandes réussissent. Consultez la rubrique Opérateurs And/Or pour en savoir plus.	infix (infixe)	3	`BossDefeated? and TargetScoreReached?`
Ou	`or`	L'opérateur `or` réussit si au moins l'un des opérandes réussit. Consultez la rubrique Opérateurs And/Or pour en savoir plus.	infix (infixe)	2	`BossDefeated? or TargetScoreReached?`
Initialisation des variables et des constantes	`: =`	Cet opérateur permet de stocker des valeurs dans une constante ou une variable. Consultez la rubrique Constantes et variables pour en savoir plus.	infix (infixe)	1	`MyScore : int = 42`
Affectation de variables	`set =`	Cet opérateur permet de mettre à jour les valeurs stockées dans une variable. Consultez la rubrique Constantes et variables pour en savoir plus.	infix (infixe)	1	`set MyScore = 42`

S'il existe des opérateurs avec la même précédence dans la même expression, ils sont alors évalués de gauche à droite. Par exemple, dans l'expression 3*2/4, étant donné que les opérateurs * et / ont la même précédence, 3*2 est évalué en premier et son résultat devient l'opérande gauche de l'opérateur /.

Vous pouvez changer l'ordre d'évaluation des opérateurs en regroupant les expressions avec (). Par exemple, (1+2)*3 et 1+(2*3) n'évaluent pas le même résultat. Consultez la rubrique Regroupement pour en savoir plus.

Comparaison

Vous pouvez contrôler le flux de réussite et d'échec avec des expressions de comparaison, qui utilisent les opérateurs d'inégalité et d'égalité. Dans la mesure où les expressions de décision sont faillibles, vous ne pouvez utiliser les opérateurs de comparaison que dans des contextes d'échec, notamment dans les expressions if.

Le tableau ci-dessous décrit chaque opérateur et les types qu'il prend en charge. Tous les opérateurs de comparaison utilisent le format infixe.

Opérateur	Types intégrés pris en charge	Description
`<`	`float` `int`	L'opérateur `<` réussit lorsque l'opérande de gauche est inférieur à l'opérande de droite. Dans le cas contraire, il échoue.
`<=`	`float` `int`	L'opérateur `<=` réussit lorsque l'opérande de gauche est inférieur ou égal à l'opérande de droite. Dans le cas contraire, il échoue.
`>`	`float` `int`	L'opérateur `>` réussit lorsque l'opérande de gauche est supérieur à l'opérande de droite. Dans le cas contraire, il échoue.
`>=`	`float` `int`	L'opérateur `>=` réussit lorsque l'opérande de gauche est supérieur ou égal à l'opérande de droite. Dans le cas contraire, il échoue.
`<>`	`float` `int` `logique` `chaîne` `enum`	L'opérateur `<>` réussit lorsque l'opérande de gauche est différent de l'opérande de droite. Dans le cas contraire, il échoue.
`=`	`float` `int` `logique` `chaîne` `enum`	L'opérateur `=` réussit lorsque l'opérande de gauche est égal à l'opérande de droite. Dans le cas contraire, il échoue.

<> et = sont également pris en charge par les instances de matrice, mappage, tuple et classe, mais avec des restrictions. Les instances de matrice, mappage et tuple ne peuvent contenir que des types pris en charge, et les instances de classe ne sont prises en charge que si elles contiennent au moins un membre var.

Décision

Vous pouvez contrôler le flux de réussite et d'échec avec des expressions de décision, qui utilisent les opérateurs not, and et or. Dans la mesure où les expressions de décision sont faillibles, vous ne pouvez utiliser les opérateurs de comparaison que dans des contextes d'échec, notamment dans les expressions if. Vous pouvez utiliser toutes les expressions qui réussissent ou échouent avec les opérateurs de décision.

Opérateur Not

L'opérateur de décision not inverse la réussite ou l'échec d'une expression. L'opérateur not utilise le format préfixe.

Par exemple, si expression échoue, l'expression not réussit. Lorsque l'expression réussit, l'expression not échoue et les effets de expression ne sont jamais validés (comme si l'expression n'avait jamais existé).

Par exemple, après l'exécution du code suivant, Example a toujours la valeur initiale 0 :

Verse

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

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

Vous pouvez utiliser not not expression comme moyen de vérifier si une expression va réussir, mais faire en sorte que l'expression n'ait jamais lieu.

Résultat de l'expression p	Résultat de l'expression not p	Résultat de l'expression not not p
L'expression réussit et le résultat est `p`	L'expression échoue et les effets de `p` ne sont pas validés. Le résultat de l'expression n'a pas de valeur.	L'expression réussit, mais les effets de `p` ne sont pas validés. Le résultat de l'expression est `true`.
L'expression échoue et le résultat n'a pas de valeur	L'expression réussit. Le résultat de l'expression est `true`.	L'expression échoue. Le résultat de l'expression n'a pas de valeur.

Référence pour l'opérateur not évaluant une expression, représentée par p.

Opérateurs And/Or

L'opérateur de décision and utilise le format infixe. Il s'agit d'une expression faillible qui réussit si les deux opérandes réussissent, ou qui échoue si au moins un opérande échoue.

L'opérateur de décision or utilise le format infixe et est :

un contexte d'échec pour le premier opérande ;
une expression faillible uniquement si le second opérande est faillible.

L'opérateur or n'effectue pas d'évaluation du second opérande si le premier opérande réussit.

Le tableau ci-dessous décrit les résultats de toutes les combinaisons d'opérandes de réussite et d'échec pour les expressions de décision utilisant les opérateurs and et or.

Résultat de l'expression p	Résultat de l'expression q	Résultat de l'expression p and q	Résultat de l'expression p or q
L'expression réussit et le résultat est `p`	L'expression réussit et le résultat est `q`	Étant donné que l'expression réussit, les effets de `p` et `q` sont tous deux validés. Le résultat de l'expression est `q`.	L'expression réussit, et seuls les effets de `p` sont validés. `q` n'est pas exécuté, car `p` a réussi. Le résultat de l'expression est `p`.
L'expression réussit et le résultat est `p`	L'expression échoue et le résultat n'a pas de valeur	L'expression échoue et les effets de `p` et `q` ne sont pas validés. Le résultat n'a aucune valeur.	L'expression réussit, et seuls les effets de `p` sont validés. `q` n'est pas exécuté, car `p` a réussi. Le résultat de l'expression est `p`.
L'expression échoue et le résultat n'a pas de valeur	L'expression réussit et le résultat est `q`	L'expression échoue et les effets de `p` et `q` ne sont pas validés. Le résultat n'a aucune valeur.	L'expression réussit, et seuls les effets de `q` sont validés. Le résultat de l'expression est `q`.
L'expression échoue et le résultat n'a pas de valeur	L'expression échoue et le résultat n'a pas de valeur	L'expression échoue et les effets de `p` et `q` ne sont pas validés. Le résultat n'a aucune valeur.	L'expression échoue et les effets de `p` et `q` ne sont pas validés. Le résultat de l'expression n'a pas de valeur.

Référence pour les opérateurs and et or évaluant des expressions, représentées par p et q.

Math

Les expressions mathématiques vous permettent d'exécuter les quatre opérations mathématiques élémentaires (addition, soustraction, multiplication et division) avec des valeurs numériques, et d'additionner des chaînes. Tous les opérateurs utilisent le format infixe, hormis + et -, qui peuvent aussi être un préfixe pour les valeurs numériques. Il existe également des opérateurs d'assignation, par exemple, set X += 10. C'est presque la même chose que d'effectuer l'opération, puis d'affecter le résultat, set X = X + 10, la différence étant que le X dans ce cas n'est évalué qu'une seule fois. Le résultat d'un opérateur d'affectation est la valeur utilisée pour mettre à jour la variable.

Le tableau ci-dessous décrit chaque opérateur et les types qu'il prend en charge.

Opérateur	Types intégrés pris en charge	Description
`+`	`float` `int` `chaîne` `matrice`	L'opérateur `+` additionne deux valeurs numériques. Lorsqu'il est utilisé avec des chaînes de caractères et des matrices, les deux valeurs sont concaténées. Vous pouvez également utiliser l'opérateur `+` comme préfixe à un nombre, par exemple `+6`, pour aligner votre code visuellement, mais il ne changera pas la valeur du nombre.
`-`	`float` `int`	L'opérateur `-` soustrait le deuxième opérande numérique au premier opérande. Vous pouvez également utiliser l'opérateur `-` comme préfixe à un nombre pour rendre négative la valeur du nombre, par exemple `-3,2`.
`*`	`float` `int`	L'opérateur `*` multiplie deux valeurs numériques ensemble.
`/`	`float` `int` (faillible)	L'opérateur `/` divise le premier opérande numérique par le second opérande numérique. La division entière est faillible et renvoie le type `rationnel`. Pour en savoir plus sur la division des nombres entiers, consultez la rubrique int.
`set +=`	`float` `int` `chaîne` `matrice`	Cet opérateur vous permet de combiner l'addition et l'affectation dans la même opération pour mettre à jour la valeur d'une variable.
`set -=`	`float` `int`	Cet opérateur vous permet de combiner la soustraction et l'affectation dans la même opération pour mettre à jour la valeur d'une variable.
`set *=`	`float` `int`	Cet opérateur vous permet de combiner la multiplication et l'affectation dans la même opération pour mettre à jour la valeur d'une variable.
`set /=`	`float`	Cet opérateur vous permet de combiner la division et l'affectation dans la même opération pour mettre à jour la valeur d'une variable, à moins que la variable soit un nombre entier. Pour en savoir plus sur la division des nombres entiers, consultez la rubrique int.

Query (requête)

Les expressions de requête utilisent l'opérateur ? (query) et vérifier si une valeur logique est true. Sinon, l'expression échoue. L'opérateur ? (requête) utilise le format suffixe.

Résultat de l'expression p	Résultat de l'expression p ?
`true`	L'expression réussit et le résultat est `true`.
`false`	L'expression échoue et le résultat n'a pas de valeur.

Référence pour l'opérateur ? opérateur (requête) évaluant les expressions, représenté par p.

Par exemple :

Verse

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

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