Operadores no Verse | Fortnite Documentação

Operadores são funções especiais definidas na linguagem de programação Verse que executam ações, como operações matemáticas, em seus operandos. Por exemplo, na expressão 1 + 2, o + é um operador, e 1 e 2 são operandos.

Você verá três formatos para operadores no Verse:

Prefix: há apenas um operando e o operador está antes do operando.
Infixo: existem dois operandos e o operador está entre os operandos.
Sufixo: existe apenas um operando e o operador está após o operando.

Esta página descreve todos os operadores que você pode usar no Verse, como eles funcionam e sua ordem de avaliação quando usados em combinação com outros operadores.

Lista de todos os operadores e a precedência do operador

Quando vários operadores são usados na mesma expressão, eles são avaliados na ordem de precedência da mais alta para a mais baixa. A tabela abaixo lista todos os operadores integrados no Verse e sua precedência.

Nome	Operador	Descrição	Formato do operador	Precedência de operadores	Exemplo
Consulta	`?`	O operador `?` verifica se um `valor lógico` é `verdadeiro`. Consulte Consulta para obter mais detalhes.	pós-fixação	9	`BossDefeated?`
Not	`not`	O operador `not` nega o sucesso ou falha de uma expressão. Consulte mais detalhes em Not.	Prefixo	8	`not BossDefeated?`
Positivo	`+`	Você pode usar o operador `+` como um prefixo para um número para ajudar a alinhar seu código visualmente, mas isso não mudará o valor do número. Consulte mais detalhes em Matemática.	Prefixo	8	`+MyScore`
Negativo	`-`	Você pode usar o operador `-` como um prefixo para um número para negar o valor do número. Consulte mais detalhes em Matemática.	Prefixo	8	`-MyScore`
Multiplicação	`*`	O `*` multiplica dois valores numéricos. Consulte mais detalhes em Matemática.	infixo	7	`MyScore * ScoreMultiplier`
Divisão	`/`	O operador `/` divide o primeiro operando numérico pelo segundo operando. A divisão de inteiros é falível. Consulte mais detalhes em Matemática.	infixo	7	`MyScore/ScorePenalty`
Adição	`+`	O operador `+` soma dois valores numéricos. Quando usado com strings e matrizes, os dois valores são concatenados. Consulte mais detalhes em Matemática.	infixo	6	`MyScore + ScoreBonus`
Subtração	`-`	O operador `-` subtrai o segundo operando numérico do primeiro operando. Consulte mais detalhes em Matemática.	infixo	6	`MyScore - ScorePenalty`
Atribuição de adição	`set +=`	Com este operador, você pode combinar adição e atribuição na mesma operação para atualizar o valor de uma variável. Consulte mais detalhes em Matemática.	infixo	5	`set MyScore += ScoreBonus`
Atribuição de subtração	`set -=`	Com esse operador, você pode combinar subtração e atribuição na mesma operação para atualizar o valor de uma variável. Consulte mais detalhes em Matemática.	infixo	5	`set MyScore -= ScorePenalty`
Atribuição de multiplicação	`set *=`	Com este operador, você pode combinar multiplicação e atribuição na mesma operação para atualizar o valor de uma variável. Consulte mais detalhes em Matemática.	infixo	5	`set MyScore *= ScoreMultiplier`
Atribuição de divisão	`set /=`	Com este operador, você pode combinar divisão e atribuição na mesma operação para atualizar o valor de uma variável, a menos que a variável seja um inteiro. Consulte mais detalhes em Matemática.	infixo	5	`set MyScore /= ScorePenalty`
Igual a	`=`	O operador `=` tem sucesso quando o operando esquerdo é igual ao operando direito. Caso contrário, falhará. Consulte mais detalhes em Comparação.	infixo	4	`MyScore = HighScore`
Not equal to	`<>`	O operador `<>` tem sucesso quando o operando esquerdo não é igual ao operando direito. Caso contrário, falhará. Consulte mais detalhes em Comparação.	infixo	4	`MyScore <> HighScore`
Menor que	`<`	O operador `<` tem sucesso quando o operando esquerdo é menor que o operando direito. Caso contrário, falhará. Consulte mais detalhes em Comparação.	infixo	4	`MyScore < HighScore`
Menor ou igual a	`<=`	O operador `<=` tem sucesso quando o operando esquerdo é menor ou igual ao operando direito. Caso contrário, falhará. Consulte mais detalhes em Comparação.	infixo	4	`MyScore <= HighScore`
Maior que	`>`	O operador `>` tem sucesso quando o operando esquerdo é maior que o operando direito. Caso contrário, falhará. Consulte mais detalhes em Comparação.	infixo	4	`MyScore > HighScore`
Maior ou igual a	`>=`	O operador `>=` tem sucesso quando o operando esquerdo é maior ou igual ao operando direito. Caso contrário, falhará. Consulte mais detalhes em Comparação.	infixo	4	`MyScore >= HighScore`
E	`and`	O operador `and` tem sucesso somente quando todos os operandos têm sucesso. Consulte mais detalhes em Operadores "and/or".	infixo	3	`BossDefeated? and TargetScoreReached?`
Or	`or`	O operador `or` tem sucesso se pelo menos um dos operandos tiver sucesso. Consulte mais detalhes em Operadores "and/or".	infixo	2	`BossDefeated? or TargetScoreReached?`
Inicialização de variável e constante	`: =`	Com este operador, você pode armazenar valores em uma constante ou variável. Consulte mais detalhes em Constantes e variáveis.	infixo	1	`MyScore : int = 42`
Atribuição de variáveis	`set =`	Com este operador, você pode atualizar os valores armazenados em uma variável. Consulte mais detalhes em Constantes e variáveis.	infixo	1	`set MyScore = 42`

Se houver operadores com a mesma precedência na mesma expressão, eles serão avaliados da esquerda para a direita. Por exemplo, na expressão 3*2/4, ambos os operadores * e / têm a mesma precedência, então 3*2 é avaliado primeiro e seu resultado se torna o operando esquerdo para o operador /.

Você pode alterar a ordem na qual os operadores são avaliados agrupando expressões com (). Por exemplo, (1+2)*3 e 1+(2*3) não são avaliados para o mesmo resultado. Consulte mais detalhes em Agrupamento.

Comparação

Você pode controlar o fluxo de sucesso e falha com expressões de comparação, que usam os operadores de desigualdade e igualdade. As expressões de comparação são falíveis, portanto você só pode usar operadores de comparação em contextos de falha, como em expressões if.

A tabela abaixo descreve cada operador e quais tipos são compatíveis. Todos os operadores de comparação usam o formato infixo.

Operador	Tipos integrados compatíveis	Descrição
`<`	`float` `int`	O operador `<` tem sucesso quando o operando esquerdo é menor que o operando direito. Caso contrário, falhará.
`<=`	`float` `int`	O operador `<=` tem sucesso quando o operando esquerdo é menor ou igual ao operando direito. Caso contrário, falhará.
`>`	`float` `int`	O operador `>` tem sucesso quando o operando esquerdo é maior que o operando direito. Caso contrário, falhará.
`>=`	`float` `int`	O operador `>=` tem sucesso quando o operando esquerdo é maior ou igual ao operando direito. Caso contrário, falhará.
`<>`	`float` `int` `logic` `string` `enum`	O operador `<>` tem sucesso quando o operando esquerdo não é igual ao operando direito. Caso contrário, falhará.
`=`	`float` `int` `logic` `string` `enum`	O operador `=` tem sucesso quando o operando esquerdo é igual ao operando direito. Caso contrário, falhará.

Tanto <> quanto = também são compatíveis com instâncias de array, map, tuple e class, mas com restrições. As instâncias de array, map e tuple só podem conter tipos suportados, e instâncias class só são compatíveis se contiverem pelo menos um membro var.

Decisão

Você pode controlar o fluxo de sucesso e falha com expressões de decisão, que usam os operadores not, and e or. As expressões de decisão são falíveis, portanto você só pode usar operadores de comparação em contextos de falha, como em expressões if. Você pode usar quaisquer expressões que tenham sucesso ou falhem com operadores de decisão.

Operador Not

O operador de decisão not nega o sucesso ou falha de uma expressão. O operador not (negação) usa o formato de prefixo.

Por exemplo, quando a expressão falha, a expressão not terá sucesso. Quando a expressão tiver sucesso, a expressão not falhará e os efeitos da expressão nunca serão confirmados (como se a expressão nunca tivesse acontecido).

Por exemplo, depois que o código a seguir for executado, Example ainda terá o valor inicial 0:

Verse

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

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

Você pode usar a expressão not not como uma forma de verificar se uma expressão terá sucesso, mas fazer com que a expressão nunca aconteça.

Resultado da expressão p	Resultado da expressão not p	Resultado da expressão not not p
Tem sucesso e o resultado é `p`	A expressão falha, e os efeitos de `p` não são confirmados. O resultado da expressão é nenhum valor.	A expressão tem sucesso, mas os efeitos de `p` não são confirmados. O resultado da expressão é `true`.
Falha e não retorna nenhum valor	A expressão tem sucesso. O resultado da expressão é `true`.	A expressão falhará. O resultado da expressão é nenhum valor.

Referência para o operador not (negação) que avalia uma expressão, representada por p.

Operadores And/Or

O operador de decisão and usa o formato infixo e é uma expressão passível de falha que tem sucesso se ambos os operandos forem bem-sucedidos ou falha se pelo menos um dos operandos falhar.

O operador de decisão or usa o formato infixo e é:

Um contexto de falha para o primeiro operando.
Uma expressão falível somente se o segundo operando for falível.

O operador or pula a avaliação do segundo operando se o primeiro operando tiver sucesso.

A tabela abaixo descreve os resultados de todas as combinações de operandos de sucesso e falha para expressões de decisão usando os operadores and e or.

Resultado da expressão p	Resultado da expressão q	Resultado da expressão p e q	Resultado da expressão p ou q
Tem sucesso e o resultado é `p`	Tem sucesso e o resultado é `q`	A expressão tem sucesso, portanto os efeitos de `p` e `q` são confirmados. O resultado da expressão é `q`.	A expressão tem sucesso, e apenas os efeitos de `p` são confirmados. `q` não é executado porque `p` teve sucesso. O resultado da expressão é `p`.
Tem sucesso e o resultado é `p`	Falha e não retorna nenhum valor	A expressão falha, e os efeitos de `p` e `q` não são confirmados. O resultado não tem valor.	A expressão tem sucesso, e apenas os efeitos de `p` são confirmados. `q` não é executado porque `p` teve sucesso. O resultado da expressão é `p`.
Falha e não retorna nenhum valor	Tem sucesso e o resultado é `q`	A expressão falha, e os efeitos de `p` e `q` não são confirmados. O resultado não tem valor.	A expressão tem sucesso, e apenas os efeitos de `q` são confirmados. O resultado da expressão é `q`.
Falha e não retorna nenhum valor	Falha e não retorna nenhum valor	A expressão falha, e os efeitos de `p` e `q` não são confirmados. O resultado não tem valor.	A expressão falha, e os efeitos de `p` e `q` não são confirmados. O resultado da expressão é nenhum valor.

Referência para os operadores "and" e "or" que avaliam expressões, representadas por p e q.

Matemática

Com as expressões matemáticas, você pode fazer as quatro operações matemáticas básicas (adição, subtração, multiplicação e divisão) com valores numéricos e adicionar strings. Todos os operadores usam o formato infixo, exceto + e -, que também podem ser um prefixo para valores numéricos. Existem também operadores de atribuição, por exemplo, set X += 10. Eles são quase o mesmo que fazer a operação e depois atribuir o resultado, set X = X + 10, a diferença é que o X neste caso é avaliado apenas uma vez. O resultado de um operador de atribuição é o valor usado para atualizar a variável.

A tabela abaixo descreve cada operador e quais tipos ele suporta.

Operador	Tipos integrados compatíveis	Descrição
`+`	`float` `int` `string` `matriz`	O operador `+` soma dois valores numéricos. Quando usado com strings e matrizes, os dois valores são concatenados. Você também pode usar o operador `+` como prefixo de um número, por exemplo, `+6`, para ajudar a alinhar seu código visualmente, mas isso não alterará o valor do número.
`-`	`float` `int`	O operador `-` subtrai o segundo operando numérico do primeiro operando. Você também pode usar o operador `-` como um prefixo para um número para negar o valor do número, por exemplo `-3,2`.
`*`	`float` `int`	O `*` multiplica dois valores numéricos.
`/`	`float` `int` (falível)	O operador `/` divide o primeiro operando numérico pelo segundo operando numérico. A divisão de números inteiros é falível e retorna o tipo `rational`. Para obter mais detalhes sobre divisão de números inteiros, consulte int.
`set +=`	`float` `int` `string` `matriz`	Com este operador, você pode combinar adição e atribuição na mesma operação para atualizar o valor de uma variável.
`set -=`	`float` `int`	Com esse operador, você pode combinar subtração e atribuição na mesma operação para atualizar o valor de uma variável.
`set *=`	`float` `int`	Com este operador, você pode combinar multiplicação e atribuição na mesma operação para atualizar o valor de uma variável.
`set /=`	`float`	Com este operador, você pode combinar divisão e atribuição na mesma operação para atualizar o valor de uma variável, a menos que a variável seja um inteiro. Para obter mais detalhes sobre divisão de números inteiros, consulte int.

Consulta

As expressões de consulta usam o operador ? Faça uma consulta e verifique se um valor logic é true. Caso contrário, a expressão falhará. O operador ? (consulta) usa o formato sufixo.

Resultado da expressão p	Resultado da expressão p?
`true`	Tem sucesso e o resultados é `true`.
`false`	Falha e não retorna nenhum valor.

Referência para o operador ? Operador de consulta que avalia expressões, representadas por p.

Por exemplo:

Verse

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

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