Operadores e Precedência

Operadores são os "verbos" da linguagem: combinam e comparam valores. Entender a precedência (qual opera primeiro) evita resultados surpreendentes.

Aritméticos

cria soma = 10 + 5     // 15
cria sub = 10 - 5      // 5
cria mult = 10 * 5     // 50
cria div = 10 / 5      // 2
cria resto = 10 % 3    // 1
cria pot = 2 ** 3      // 8

Por que existe o módulo (%)?

O resto da divisão parece inútil até você perceber que ele responde "esse número é par?" (n % 2 == 0) e "esse ano é bissexto?" (ano % 4 == 0). É a ferramenta de divisibilidade.

Precedência — a ordem importa

Da mesma forma que 2 + 3 * 4 é 14 (multiplicação primeiro), XanaScript respeita a ordem matemática:

cria r = 2 + 3 * 4    // 14, NÃO 20
cria r2 = (2 + 3) * 4 // 20, parênteses forçam a ordem

Regra de ouro: quando a precedência não for óbvia, use parênteses. Código claro vale mais que código "esperto".

Comparação

10 == 10    // verdadeiro (igual)
10 != 5     // verdadeiro (diferente)
10 > 5      // verdadeiro
10 < 5      // falso
10 >= 10    // verdadeiro
10 <= 9     // falso

Estrito vs solto: == e ===

== compara o valor (e pode converter tipos). === compara valor e tipo:

1 == "1"      // verdadeiro (converte)
1 === "1"     // falso (tipos diferentes)

Use === por padrão pra evitar bugs de conversão implícita. A igualdade estrita é a que não surpreende.

Regex

O operador ~= testa se o texto casa com uma expressão regular:

"ana" ~= "^a"   // verdadeiro
"bob" ~= "^a"   // falso

Lógicos

verdadeiro && falso   // falso (e)
verdadeiro || falso   // verdadeiro (ou)
!verdadeiro           // falso (não)

O segredo do && e ||: short-circuit

&& e || param de avaliar quando já sabem a resposta:

falso && fazAlgo()    // fazAlgo NUNCA roda (já é falso)
verdadeiro || fazAlgo()  // fazAlgo NUNCA roda (já é verdadeiro)

Isso é útil pra guardas:

se-pah (usuario && usuario.ativo) { ... }

Null coalescing e optional chaining

cria x = nulo ?? "padrão"   // "padrão" (se esquerda for nulo, usa direita)
cria y = obj?.campo         // nulo se obj for nulo (sem quebrar)

O ?? é o "fallback": dá um valor padrão quando o primeiro é nulo. O ?. é o "acesso seguro": navega sem estourar erro se o objeto não existir. Juntos eliminam a dor de cabeça "não pode ler propriedade de nulo".

Atribuição composta

cria n = 10
n += 5    // 15
n -= 2    // 13
n *= 2    // 26
n /= 13   // 2
n %= 2    // 0
n++       // 1
n--       // 0

n += 5 é açúcar sintático de n = n + 5: mais curto e menos propenso a erro de digitação.

Ternário

cria status = idade >= 18 ? "maior" : "menor"

O ternário é um se-pah em formato de expressão: retorna um valor de um dos dois lados. Use pra escolhas simples de uma linha.

Spread

cria a = [1, 2]
cria b = [...a, 3]    // [1, 2, 3]

O ... "espalha" os elementos de um array dentro de outro — o jeito mais seguro de copiar e combinar listas sem mutar a original.