Expression Defer dans Verse | Fortnite Documentation

L'expression defer retarde l'exécution du code jusqu'à ce que l'étendue sorte. Vous pouvez utiliser l'expression defer pour effectuer des tâches de nettoyage comme la réinitialisation des variables. Même s'il y a une sortie anticipée (comme return ou break) depuis l'étendue actuelle, les expressions dans un bloc defer seront exécutées tant que defer est rencontré avant la sortie.

Le code suivant montre comment utiliser defer pour réinitialiser une variable tout en utilisant cette même variable comme valeur return Dans cette fonction, RoundScore est retourné et les expressions du bloc defer sont exécutées immédiatement après.

Cela signifie que vous n'avez pas besoin de créer une variable temporaire pour enregistrer la valeur de RoundScore avant qu'elle ne soit réinitialisée.

OnRoundEnd<public>() : void =
var ScoreThisRound : int = AddRoundScoreToTotalScore()
Print("Points scored this round: {ScoreThisRound}")

<# Ajoute RoundScore à TotalScore et réinitialise RoundScore à 0.
Retourne le RoundScore ajouté. #>
AddRoundScoreToTotalScore<public>() : int = 
	defer:
		set RoundScore = 0
		UpdateUI()
	set TotalScore += RoundScore
	return RoundScore

Utiliser l'expression Defer

Vous pouvez utiliser une expression defer à l'intérieur de n'importe quel bloc de code séquentiel tel qu'un bloc, loop, for, if, branch ou même un autre defer.

Les expressions dans un bloc defer doivent être immédiates (et non asynchrones) — avec une exception. Les expressions async peuvent toujours être utilisées dans un defer si elles sont rendues immédiates en utilisant :

apparition :
branch (si le defer se trouve à l'intérieur d'un bloc async, comme dans une coroutine)

Un defer n'a pas de résultat, et ne peut pas être utilisé comme argument ou comme valeur d'affectation.

defer	defer avant une sortie
`expression0 defer: expression1 expression2 expression3` expression0 defer: expression1 expression2 expression3	`name() : type = expression0 defer: expression1 expression2 return expression3` name() : type = expression0 defer: expression1 expression2 return expression3
Cliquez sur l'image pour l'agrandir.	Cliquez sur l'image pour l'agrandir.

Une expression defer sera uniquement exécutée si elle est rencontrée avant qu'une sortie anticipée ne se produise.

defer avec retour anticipé defer avec une expression async annulée

defer avec retour anticipé	defer avec une expression async annulée
`expression0 if (conditions): return defer: expression1 expression2` expression0 if (conditions): return defer: expression1 expression2	`expression0 race: block: # annulée lors de slow-async-expression slow-async-expression defer: expression1 expression2 block: # se termine en premier fast-async-expression defer: expression3 expression4 expression5` expression0 race: block: # annulée lors de slow-async-expression slow-async-expression defer: expression1 expression2 block: # se termine en premier fast-async-expression defer: expression3 expression4 expression5
Cliquez sur l'image pour l'agrandir.	Cliquez sur l'image pour l'agrandir.

expression0
if (conditions):
    return
defer:
    expression1
expression2

expression0
race:
    block: # annulée lors de slow-async-expression
        slow-async-expression
        defer:
            expression1
        expression2
     block: # se termine en premier
         fast-async-expression
         defer:
             expression3
         expression4
expression5

Cliquez sur l'image pour l'agrandir.

Plusieurs expressions defer qui apparaissent dans la même étendue s'accumulent. L'ordre dans lequel elles sont exécutées est l'ordre inverse de celui de leur occurrence, c'est-à-dire l'ordre FILO (première entrée, dernière sortie). Dans la mesure où la dernière expression defer rencontrée dans une étendue donnée est exécutée en premier, les expressions à l'intérieur de cette dernière expression defer peuvent faire référence à un contexte (comme des variables) qui sera nettoyé par d'autres expressions defer rencontrées plus tôt et exécutées plus tard.

Verse n'a pas de destruction déterministe, mais defer permet un comportement similaire à RAII pour assurer le nettoyage.

**Plusieurs expressions defer dans un bloc de code	Plusieurs expressions defer dans des blocs de code différents
`expression0 defer: expression1 expression2 defer: expression3 expression4` expression0 defer: expression1 expression2 defer: expression3 expression4	`expression0 if (conditions): expression1 defer: expression2 expression3 expression4 defer: expression5 expression6` expression0 if (conditions): expression1 defer: expression2 expression3 expression4 defer: expression5 expression6
Cliquez sur l'image pour l'agrandir.	Cliquez sur l'image pour l'agrandir.

La sortie anticipée est autorisée dans un bloc defer tant que la sortie ne transfère pas le contrôle en dehors de l'étendue du defer. Par exemple, l'utilisation d'une boucle avec break est autorisée à l'intérieur d'un defer, mais ce break doit maintenir l'exécution du code à l'intérieur du bloc defer. Il ne peut pas faire référence à un loop en dehors du bloc defer.

Toutes les variables qui ont été rencontrées dans l'étendue nesting extérieure d'un defer peuvent être utilisées dans cette expression defer.

Rappelez-vous que defer s'exécute en dernier au moment de la sortie de l'étendue. Cela signifie qu'il utilise l'état du programme (y compris les valeurs des variables) à ce moment-là, et non au moment où le defer est rencontré. Le code ci-dessous imprimera 10 parce que defer s'exécute immédiatement après que MyScore soit défini sur 10.

var MyScore = 5
defer: 
	Print(MyScore)
set MyScore = 10

Utiliser une expression defer comme dernière expression dans une étendue revient au même que de ne pas l'utiliser du tout. Par exemple, ces deux ensembles d'expressions seront exécutés exactement dans le même ordre, donc defer n'est pas nécessaire :

Sans expression defer	Avec expression defer
`expression0 expression1 expression2` expression0 expression1 expression2	`expression0 expression1 defer: expression2` expression0 expression1 defer: expression2