1
var idade int = 30      // tipo explícito
2
nome := "Ana"           // tipo inferido (só dentro de funções)
3
const Pi = 3.14         // constante de compilação
4
var contador int        // sem valor: recebe o zero value (0)

1
let idade = 30;         // pode reatribuir
2
const nome = "Ana";     // não pode reatribuir
3
var antigo = true;      // evite: escopo de função e hoisting
4
let vazio;              // undefined

1
idade = 30              # não existe declaração: atribuir cria a variável
2
nome: str = "Ana"       # type hint (documentação, não é checado ao rodar)
3
PI = 3.14               # "constante" por convenção (MAIÚSCULAS), nada impede mudar

1
local idade = 30        -- sempre use local
2
nome = "Ana"            -- sem local vira GLOBAL (quase sempre um bug)
3
local vazio             -- nil

1
int idade = 30;
2
const double PI = 3.14;
3
char nome[] = "Ana";    // string é um array de char terminado em '\0'
4
int lixo;               // variável local sem valor: conteúdo indefinido!

1
int idade = 30;
2
var nome = "Ana";       // inferido, mas continua sendo string para sempre
3
const double Pi = 3.14;
4
int semValor;           // ler antes de atribuir é erro de compilação

1
var idade = 30;               // inferido como int
2
final nome = 'Ana';           // atribuído uma vez, em tempo de execução
3
const pi = 3.14;              // constante de compilação
4
String? apelido;              // o "?" permite null; sem ele, null não entra
5
late String carregadoDepois;  // "prometo inicializar antes de usar"

1
if 0 then print("em Lua, 0 é verdadeiro!") end
2

3
local lista = {}
4
if #lista == 0 then print("vazia") end  -- teste o tamanho explicitamente

1
// Go só tem uma palavra-chave para loops: for
2
for i := 0; i < 5; i++ { }          // clássico
3
for i := range 5 { }                // Go 1.22+: de 0 a 4
4

5
frutas := []string{"maçã", "uva"}
6
for i, fruta := range frutas { }    // índice e valor
7

8
for condicao { }                    // é o "while" do Go

1
for (let i = 0; i < 5; i++) { }
2

3
const frutas = ["maçã", "uva"];
4
for (const fruta of frutas) { }     // of = valores
5
for (const i in frutas) { }         // in = CHAVES ("0", "1"), como strings
6
frutas.forEach((fruta, i) => { });
7

8
while (condicao) { }

1
for i in range(5):                  # 0 a 4
2
    pass
3

4
frutas = ["maçã", "uva"]
5
for fruta in frutas:
6
    pass
7
for i, fruta in enumerate(frutas):  # índice e valor
8
    pass
9

10
while condicao:
11
    pass

1
for i = 1, 5 do end                 -- de 1 a 5, INCLUSIVO
2

3
local frutas = {"maçã", "uva"}
4
for i, fruta in ipairs(frutas) do   -- listas (começa em 1)
5
end
6
for chave, valor in pairs(tabela) do  -- qualquer tabela, sem ordem garantida
7
end
8

9
while condicao do end
10
repeat until condicao               -- executa ao menos uma vez

1
for (int i = 0; i < 5; i++) { }
2

3
int numeros[] = {10, 20, 30};
4
int tamanho = sizeof(numeros) / sizeof(numeros[0]);
5
for (int i = 0; i < tamanho; i++) { }  // não há foreach: o array não sabe o próprio tamanho
6

7
while (condicao) { }
8
do { } while (condicao);

1
for (int i = 0; i < 5; i++) { }
2

3
var frutas = new List<string> { "maçã", "uva" };
4
foreach (var fruta in frutas) { }
5

6
while (condicao) { }
7
do { } while (condicao);

1
for (var i = 0; i < 5; i++) {}
2

3
final frutas = ['maçã', 'uva'];
4
for (final fruta in frutas) {}
5
frutas.forEach((fruta) {});
6

7
while (condicao) {}
8
do {} while (condicao);

1
func dividir(a, b float64) (float64, error) {
2
  if b == 0 {
3
    return 0, errors.New("divisão por zero")
4
  }
5
  return a / b, nil
6
}
7

8
resultado, err := dividir(10, 2)
9
if err != nil {
10
  log.Fatal(err)
11
}

1
function dividir(a, b) {
2
  if (b === 0) throw new Error("divisão por zero");
3
  return a / b;
4
}
5

6
const dobrar = (x) => x * 2;              // arrow function
7
const saudar = (nome = "visitante") => `Olá, ${nome}`;  // parâmetro padrão
8

9
try {
10
  dividir(10, 0);
11
} catch (e) {
12
  console.error(e.message);
13
}

1
def dividir(a: float, b: float) -> float:
2
    if b == 0:
3
        raise ValueError("divisão por zero")
4
    return a / b
5

6
def saudar(nome="visitante", *, formal=False):  # após *, só por nome
7
    return f"Prezado {nome}" if formal else f"Olá, {nome}"
8

9
saudar("Ana", formal=True)
10

11
try:
12
    dividir(10, 0)
13
except ValueError as e:
14
    print(e)

1
local function dividir(a, b)
2
  if b == 0 then
3
    return nil, "divisão por zero"   -- múltiplos retornos, como em Go
4
  end
5
  return a / b
6
end
7

8
local function saudar(nome)
9
  nome = nome or "visitante"         -- o jeito Lua de ter parâmetro padrão
10
  return "Olá, " .. nome             -- .. concatena strings
11
end
12

13
local resultado, erro = dividir(10, 0)
14
if not resultado then print(erro) end

1
// Retorna 0 em sucesso e -1 em erro; o resultado sai pelo ponteiro
2
int dividir(double a, double b, double *resultado) {
3
    if (b == 0) {
4
        return -1;
5
    }
6
    *resultado = a / b;
7
    return 0;
8
}
9

10
double r;
11
if (dividir(10, 2, &r) != 0) {
12
    fprintf(stderr, "divisão por zero\n");
13
}

1
static double Dividir(double a, double b)
2
{
3
    if (b == 0) throw new DivideByZeroException();
4
    return a / b;
5
}
6

7
static string Saudar(string nome = "visitante") => $"Olá, {nome}";
8

9
static (int min, int max) Extremos(int[] xs) => (xs.Min(), xs.Max());  // tupla
10

11
Func<int, int> dobrar = x => x * 2;  // lambda

1
double dividir(double a, double b) {
2
  if (b == 0) throw ArgumentError('divisão por zero');
3
  return a / b;
4
}
5

6
int dobrar(int x) => x * 2;  // corpo de uma expressão só
7

8
// Parâmetros nomeados ficam entre chaves
9
String saudar({required String nome, bool formal = false}) =>
10
    formal ? 'Prezado $nome' : 'Olá, $nome';
11

12
saudar(nome: 'Ana', formal: true);

1
// Go não tem classes: tem structs com métodos
2
type Conta struct {
3
  Titular string   // maiúscula = público
4
  saldo   float64  // minúscula = privado ao pacote
5
}
6

7
func NovaConta(titular string) *Conta {  // "construtor" é só uma função
8
  return &Conta{Titular: titular}
9
}
10

11
// (c *Conta) é o receptor: o equivalente ao this/self
12
func (c *Conta) Depositar(valor float64) error {
13
  if valor <= 0 {
14
    return errors.New("valor inválido")
15
  }
16
  c.saldo += valor
17
  return nil
18
}
19

20
func (c *Conta) Saldo() float64 { return c.saldo }

1
class Conta {
2
  #saldo = 0;  // # = privado de verdade
3

4
  constructor(titular) {
5
    this.titular = titular;
6
  }
7

8
  depositar(valor) {
9
    if (valor <= 0) throw new Error("valor inválido");
10
    this.#saldo += valor;
11
  }
12

13
  get saldo() {
14
    return this.#saldo;
15
  }
16
}
17

18
const c = new Conta("Ana");
19
c.depositar(100);
20
console.log(c.saldo); // 100

1
class Conta:
2
    def __init__(self, titular: str):
3
        self.titular = titular
4
        self._saldo = 0.0  # _ = "privado" por convenção
5

6
    def depositar(self, valor: float) -> None:
7
        if valor <= 0:
8
            raise ValueError("valor inválido")
9
        self._saldo += valor
10

11
    @property
12
    def saldo(self) -> float:
13
        return self._saldo
14

15
c = Conta("Ana")
16
c.depositar(100)
17
print(c.saldo)  # 100.0

1
-- Lua não tem classes: tem tabelas e metatables
2
local Conta = {}
3
Conta.__index = Conta  -- métodos não achados no objeto são buscados em Conta
4

5
function Conta.new(titular)
6
  local self = setmetatable({}, Conta)
7
  self.titular = titular
8
  self.saldo = 0
9
  return self
10
end
11

12
-- O ":" passa o próprio objeto como primeiro argumento (self)
13
function Conta:depositar(valor)
14
  if valor <= 0 then error("valor inválido") end
15
  self.saldo = self.saldo + valor
16
end
17

18
local c = Conta.new("Ana")
19
c:depositar(100)
20
print(c.saldo)  -- 100

1
// C não tem classes nem métodos: tem structs e funções que recebem ponteiros
2
typedef struct {
3
    char titular[50];
4
    double saldo;
5
} Conta;
6

7
void conta_iniciar(Conta *c, const char *titular) {
8
    snprintf(c->titular, sizeof c->titular, "%s", titular);
9
    c->saldo = 0;
10
}
11

12
int conta_depositar(Conta *c, double valor) {
13
    if (valor <= 0) return -1;
14
    c->saldo += valor;
15
    return 0;
16
}
17

18
Conta c;
19
conta_iniciar(&c, "Ana");
20
conta_depositar(&c, 100);
21
printf("%.2f\n", c.saldo);  // 100.00

1
public class Conta
2
{
3
    public string Titular { get; }
4
    public decimal Saldo { get; private set; }  // leitura pública, escrita privada
5

6
    public Conta(string titular) => Titular = titular;
7

8
    public void Depositar(decimal valor)
9
    {
10
        if (valor <= 0) throw new ArgumentException("valor inválido");
11
        Saldo += valor;
12
    }
13
}
14

15
var c = new Conta("Ana");
16
c.Depositar(100);
17
Console.WriteLine(c.Saldo); // 100

1
class Conta {
2
  final String titular;
3
  double _saldo = 0;  // _ = privado à biblioteca (arquivo)
4

5
  Conta(this.titular);  // atalho: atribui o parâmetro direto ao campo
6

7
  double get saldo => _saldo;
8

9
  void depositar(double valor) {
10
    if (valor <= 0) throw ArgumentError('valor inválido');
11
    _saldo += valor;
12
  }
13
}
14

15
final c = Conta('Ana');  // sem "new"
16
c.depositar(100);
17
print(c.saldo); // 100.0