Operatori in Verse | Unreal Editor per Fortnite Documentazione

Gli operatori sono funzioni speciali definite nel linguaggio di programmazione Verse per eseguire azioni come operazioni matematiche sui loro operandi. Ad esempio, nell'espressione 1 + 2, + è un operatore e 1 e 2 sono operandi.

Ci sono tre formati per gli operatori che vedrai in Verse:

Prefisso: c'è un solo operando e l'operatore si trova prima dell'operando.
Infisso: ci sono due operandi e l'operatore è tra gli operandi.
Postfisso: c'è un solo operando e l'operatore si trova dopo l'operando.

Questa pagina descrive tutti gli operatori che puoi utilizzare in Verse, come funzionano e il loro ordine di valutazione quando vengono utilizzati in combinazione con altri operatori.

Elenco di tutti gli operatori e della precedenza degli operatori

Quando nella stessa espressione vengono utilizzati più operatori, questi vengono valutati nell'ordine di precedenza dal più alto al più basso. La tabella seguente elenca tutti gli operatori incorporati in Verse e la loro precedenza.

Nome	Operatore	Descrizione	Formato operatore	precedenza degli operatori	Esempio
Query	`?`	L'operatore `?` verifica se un valore `logic` è `vero`. Per maggiori dettagli vedi Query.	Postfisso	9	`BossDefeated?`
Not	`not`	L'operatore `not` nega la riuscita o l'errore di un'espressione. Per maggiori dettagli, vedi Not.	Prefisso	8	`not BossDefeated?`
Positivo	`+`	È possibile utilizzare l'operatore `+` come prefisso a un numero per aiutare l'allineamento visivo del codice, ma ciò non modificherà il valore del numero. Per maggiori dettagli, vedi Math.	Prefisso	8	`+MyScore`
Negativo	`-`	È possibile utilizzare l'operatore `-` come prefisso a un numero per negarne il valore. Per maggiori dettagli, vedi Math.	Prefisso	8	`-MyScore`
Moltiplicazione	`*`	L'operatore `*` moltiplica due valori numerici. Per maggiori dettagli, vedi Math.	operatore infisso	7	`MyScore * ScoreMultiplier`
Divisione	`/`	L'operatore `/` divide il primo operando numerico per il secondo. La divisione degli interi è fallibile. Per maggiori dettagli, vedi Math.	operatore infisso	7	`MyScore / ScorePenalty`
Addizione	`+`	L'operatore `+` somma due valori numerici. Quando viene utilizzato con stringhe e array, i due valori vengono concatenati. Per maggiori dettagli, vedi Math.	operatore infisso	6	`MyScore + ScoreBonus`
Sottrazione	`-`	L'operatore `-` sottrae il secondo operando numerico dal primo. Per maggiori dettagli, vedi Math.	operatore infisso	6	`MyScore - ScorePenalty`
Assegnazione di addizione	`set +=`	Con questo operatore è possibile combinare l'addizione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile. Per maggiori dettagli, vedi Math.	operatore infisso	5	`set MyScore += ScoreBonus`
Assegnazione di sottrazione	`set -=`	Con questo operatore è possibile combinare la sottrazione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile. Per maggiori dettagli, vedi Math.	operatore infisso	5	`set MyScore -= ScorePenalty`
Assegnazione di moltiplicazione	`set *=`	Con questo operatore è possibile combinare la moltiplicazione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile. Per maggiori dettagli, vedi Math.	operatore infisso	5	`set MyScore *= ScoreMultiplier`
Assegnazione divisione	`set /=`	Con questo operatore è possibile combinare la divisione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile, a meno che la variabile non sia un numero intero. Per maggiori dettagli, vedi Math.	operatore infisso	5	`set MyScore /= ScorePenalty`
Uguale a	`=`	L'operatore `=` riesce quando l'operando di sinistra è uguale all'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.	operatore infisso	4	`MyScore = HighScore`
Non uguale a	`<>`	L'operatore `<>` riesce quando l'operando di sinistra è diverso dall'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.	operatore infisso	4	`MyScore <> HighScore`
Inferiore a	`<`	L'operatore `<` riesce quando l'operando di sinistra è minore dell'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.	operatore infisso	4	`MyScore < HighScore`
Minore di o uguale a	`<=`	L'operatore `<=` riesce quando l'operando di sinistra è minore o uguale all'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.	operatore infisso	4	`MyScore <= HighScore`
Maggiore di	`>`	L'operatore `>` riesce quando l'operando di sinistra è maggiore dell'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.	operatore infisso	4	`MyScore > HighScore`
Maggiore o uguale a	`>=`	L'operatore `>=` riesce quando l'operando di sinistra è maggiore o uguale all'operando di destra. In caso contrario non riesce. Per maggiori dettagli, vedi Confronto.	operatore infisso	4	`MyScore >= HighScore`
E	`and`	L'operatore `and` riesce solo quando tutti gli operandi hanno esito positivo. Per maggiori dettagli, vedi Operatori And/Or.	operatore infisso	3	`BossDefeated? and TargetScoreReached?`
O	`or`	L'operatore `or` riesce se almeno uno degli operandi ha esito positivo. Per maggiori dettagli, vedi Operatori And/Or.	operatore infisso	2	`BossDefeated? or TargetScoreReached?`
Inizializzazione variabile e costante	`: =`	Con questo operatore è possibile memorizzare i valori in una costante o in una variabile. Per maggiori dettagli, vedi Costanti e variabili.	operatore infisso	1	`MyScore : int = 42`
Assegnazione variabile	`set =`	Con questo operatore è possibile aggiornare i valori memorizzati in una variabile. Per maggiori dettagli, vedi Costanti e variabili.	operatore infisso	1	`set MyScore = 42`

Se nella stessa espressione ci sono operatori con la stessa precedenza, essi vengono valutati da sinistra a destra. Ad esempio, nell'espressione 3*2/4, sia l'operatore * che / hanno la stessa precedenza, quindi 3*2 viene valutato per primo e il suo risultato diventa l'operando a sinistra dell'operatore /.

È possibile modificare l'ordine in cui gli operatori vengono valutati raggruppando le espressioni con (). Ad esempio, (1+2)*3 e 1+(2*3) non danno lo stesso risultato. Per maggiori dettagli, vedi Raggruppamento.

Confronto

Puoi controllare il flusso di esito positivo e negativo con le espressioni di confronto che utilizzano l'operatore di disuguaglianza e uguaglianza. Le espressioni di confronto sono fallibili, quindi è possibile utilizzare gli operatori di confronto solo in contesti di errore, come nelle espressioni if.

La tabella seguente descrive ciascun operatore e i tipi che supporta. Tutti gli operatori di confronto utilizzano il formato infisso.

Operatore	Tipi integrati supportati	Descrizione
`<`	`float` `int`	L'operatore `<` riesce quando l'operando di sinistra è minore di quello di destra. In caso contrario non riesce.
`<=`	`float` `int`	L'operatore `<=` riesce quando l'operando di sinistra è minore o uguale a quello di destra. In caso contrario non riesce.
`>`	`float` `int`	L'operatore `>` riesce quando l'operando di sinistra è maggiore di quello di destra. In caso contrario non riesce.
`>=`	`float` `int`	L'operatore `>=` riesce quando l'operando di sinistra è maggiore o uguale a quello di destra. In caso contrario non riesce.
`<>`	`float` `int` `logic` `string` `enum`	L'operatore `<>` riesce quando l'operando di sinistra è diverso dall'operando di destra. In caso contrario non riesce.
`=`	`float` `int` `logic` `string` `enum`	L'operatore `= riesce quando l'operando` di sinistra è uguale all'operando di destra. In caso contrario non riesce.

Sia <>che = sono supportati anche per istanze di array, map, tuple e class, ma con restrizioni. Le istanze array, map e tuple possono contenere solo tipi supportati e le istanze class sono supportate solo se contengono almeno un membro var.

Decisione

È possibile controllare il flusso con esito positivo e negativo con espressioni di decisione che utilizzano gli operatori not, and e or. Le espressioni di decisione sono fallibili, quindi è possibile utilizzare gli operatori di confronto solo in contesti di errore, come nelle espressioni if. È possibile utilizzare qualsiasi espressione che abbia esito positivo o negativo con gli operatori di decisione.

Operatore Not

L'operatore di decisione not nega l'esito positivo o negativo di un'espressione. L'operatore not utilizza il formato prefisso.

Ad esempio, quando expression non riesce, not expression ha esito positivo. Quando expression ha esito positivo, not expression ha esito negativo e gli effetti di expression non vengono mai confermati (come se l'espressione non fosse mai avvenuta).

Ad esempio, dopo l'esecuzione del seguente codice, Example avrà ancora il valore iniziale 0:

Verse

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

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

È possibile utilizzare not not expression per verificare se un'espressione avrà esito positivo, ma fare in modo che l'espressione non si verifichi mai.

Risultato dell'espressione p	Risultato dell'espressione non p	Risultato dell'espressione non non p
Ha esito positivo e il risultato è `p`	L'espressione non riesce e gli effetti di `p` non vengono confermati. Il risultato dell'espressione è nessun valore.	L'espressione ha esito positivo, ma gli effetti di `p` non vengono confermati. Il risultato dell'espressione è `vero`.
Non riesce e il risultato è nessun valore	L'espressione ha esito positivo. Il risultato dell'espressione è `vero`.	L'espressione non riesce. Il risultato dell'espressione è nessun valore.

Riferimento per l'operatore not che valuta un'espressione, rappresentato da p.

Operatori And / Or

L'operatore di decisione and utilizza il formato infisso ed è un'espressione fallibile che ha esito positivo se entrambi gli operandi hanno esito positivo o non riesce se almeno un operando non riesce.

L'operatore di decisione or utilizza il formato infisso ed è:

Contesto di errore per il primo operando.
Espressione fallibile solo se il secondo operando è fallibile.

L'operatore or salta la valutazione del secondo operando se il primo operando ha esitpo positivo.

La tabella seguente descrive i risultati di tutte le combinazioni di operandi con esito positivo o di errore per le espressioni di decisione utilizzando gli operatori and e or.

Risultato dell'espressione p	Risultato dell'espressione q	Risultato dell'espressione p e q	Risultato dell'espressione p o q
Ha esito positivo e il risultato è `p`	Ha esito positivo e il risultato è `q`	L'espressione ha esito positivo, quindi gli effetti di entrambi `p` e `q` vengono confermati. Il risultato dell'espressione è `q`.	L'espressione ha esito positivo e vengono confermati solo gli effetti di `p`. `q` non viene eseguito perché `p` ha avuto esito positivo. Il risultato dell'espressione è `p`.
Ha esito positivo e il risultato è `p`	Non riesce e il risultato è nessun valore	L'espressione non riesce e gli effetti di entrambi `p` e `q` non vengono confermati. Il risultato è nessun valore.	L'espressione ha esito positivo e vengono confermati solo gli effetti di `p`. `q` non viene eseguito perché `p` ha avuto esito positivo. Il risultato dell'espressione è `p`.
Non riesce e il risultato è nessun valore	Ha esito positivo e il risultato è `q`	L'espressione non riesce e gli effetti di entrambi `p` e `q` non vengono confermati. Il risultato è nessun valore.	L'espressione ha esito positivo e vengono confermati solo gli effetti di `q`. Il risultato dell'espressione è `q`.
Non riesce e il risultato è nessun valore	Non riesce e il risultato è nessun valore	L'espressione non riesce e gli effetti di entrambi `p` e `q` non vengono confermati. Il risultato è nessun valore.	L'espressione non riesce e gli effetti di entrambi `p` e `q` non vengono confermati. Il risultato dell'espressione è nessun valore.

Riferimento degli operatori and e or che valutano le espressioni, rappresentate da p e q.

Matematica

Con le espressioni matematiche puoi eseguire le quattro operazioni matematiche di base (addizione, sottrazione, moltiplicazione e divisione), con valori numerici, e sommare stringhe. Tutti gli operatori utilizzano il formato infisso, ad eccezione di + e - che possono anche essere un prefisso dei valori numerici. Esistono anche operatori di assegnazione, ad esempio set X += 10. Equivalgono a eseguire l'operazione e poi assegnare il risultato, set X = X + 10, la differenza è che X in questo caso viene valutato solo una volta. Il risultato di un operatore di assegnazione è il valore utilizzato per aggiornare la variabile.

La tabella seguente descrive ciascun operatore e i tipi che supporta.

Operatore	Tipi integrati supportati	Descrizione
`+`	`float` `int` `string` `array`	L'operatore `+` somma due valori numerici. Quando viene utilizzato con stringhe e array, i due valori vengono concatenati. Puoi anche utilizzare l'operatore `+` come prefisso di un numero, ad esempio `+6`, per allineare visivamente il codice, ma non cambierà il valore del numero.
`-`	`float` `int`	L'operatore `-` sottrae il secondo operando numerico dal primo. Puoi anche utilizzare l'operatore `-` come prefisso di un numero per negarne il valore, ad esempio `-3.2`.
`*`	`float` `int`	L'operatore `*` moltiplica due valori numerici.
`/`	`float` `int` (fallibile)	L'operatore `/` divide il primo numero operando per il secondo numero operando La divisione Intero è fallibile e restituisce il tipo `rational`. Per maggiori dettagli sulla divisione di intero, vedi int.
`set +=`	`float` `int` `string` `array`	Con questo operatore è possibile combinare l'addizione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile.
`set -=`	`float` `int`	Con questo operatore è possibile combinare la sottrazione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile.
`set *=`	`float` `int`	Con questo operatore è possibile combinare la moltiplicazione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile.
`set /=`	`float`	Con questo operatore è possibile combinare la divisione e l'assegnazione nella stessa operazione per aggiornare il valore di una variabile, a meno che la variabile non sia un numero intero. Per maggiori dettagli sulla divisione intero, vedi int.

Query

Le espressioni di query utilizzano l'operatore ? (query) e controllano se un valore logic è vero. In caso contrario, l'espressione non riesce. L'operatore ? (query) utilizza il formato postfisso.

Risultato dell'espressione p	Risultato dell'espressione p?
`vero`	Ha esito positivo e il risultato è `vero`.
`falso`	Non riesce e il risultato è nessun valore.

Riferimento per il ? (query) operatore che valuta le espressioni, rappresentato da p.

Ad esempio:

Verse

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

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