0Pricing
Lua Academy · Aula

Definição e chamada de funções

Aprenda a sintaxe de declaração de funções, as convenções de chamada e a diferença entre funções locais e globais.

Definição e chamada de funções é uma aula grátis de Lua Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Lua Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Lua Academy inclui 4 aulas no total.

Sintaxe de funções

As funções em Lua são definidas com a palavra-chave function. O corpo é um bloco terminado por end. As funções podem ser globais ou locais. Para chamar uma função, acrescente parênteses com os argumentos. Se os argumentos forem omitidos, os parâmetros ausentes recebem nil.

function sayHello(name)
  print("Hello, " .. (name or "World") .. "!")
end

sayHello("Lua")   -- Hello, Lua!
sayHello()        -- Hello, World!

local function add(a, b)
  return a + b
end
print(add(3, 4))  -- 7

Valores de retorno

As funções retornam valores com return. Diferentemente da maioria das linguagens, as funções em Lua podem retornar vários valores. Se você não usar return explicitamente, a função não retornará nada (zero valores). Os valores de retorno excedentes são descartados quando a chamada não é a última expressão de uma lista.

local function minMax(t)
  local lo, hi = t[1], t[1]
  for i = 2, #t do
    if t[i] < lo then lo = t[i] end
    if t[i] > hi then hi = t[i] end
  end
  return lo, hi
end

local lo, hi = minMax({5,2,8,1,9})
print(lo, hi)  -- 1  9

Função como valor

As funções são valores de primeira classe em Lua. Você pode armazená-las em variáveis, passá-las como argumentos para outras funções e retorná-las. Isso permite usar retornos de chamada, funções de ordem superior e padrões de programação funcional.

local ops = {
  add = function(a, b) return a + b end,
  sub = function(a, b) return a - b end,
  mul = function(a, b) return a * b end,
}

local function apply(op, a, b)
  return op(a, b)
end

print(apply(ops.add, 10, 3))  -- 13
print(apply(ops.mul, 4, 5))   -- 20

Funções locais versus globais

Use local function para auxiliares privados de um módulo. As funções globais poluem o espaço de nomes global e podem ser acessadas de qualquer lugar, o que pode causar conflitos de nomes. Na maioria dos casos, prefira funções locais e exponha por meio de uma tabela de módulo apenas o que for necessário.

-- Bad: pollutes global namespace
function helper() end

-- Good: module-local
local function helper()
  return "I am local"
end

-- Module export pattern
local M = {}
function M.publicFunc()
  return helper()  -- can call local
end
return M

Métodos com sintaxe de dois-pontos

O Lua oferece uma forma abreviada de sintaxe para definir e chamar métodos em tabelas. obj:method(arg) é equivalente a obj.method(obj, arg). A forma com dois-pontos passa implicitamente a tabela como primeiro argumento, convencionalmente chamado de self.

local Dog = {}
Dog.__index = Dog

function Dog.new(name)
  return setmetatable({name=name}, Dog)
end

function Dog:speak()
  print(self.name .. " says: Woof!")
end

local d = Dog.new("Rex")
d:speak()   -- Rex says: Woof!

Padrão de parâmetros opcionais

O Lua não tem parâmetros opcionais integrados, mas você pode simulá-los verificando nil. Passe uma única tabela de opções para funções com muitos parâmetros opcionais — isso é mais claro do que uma lista longa de argumentos.

local function createUser(name, opts)
  opts = opts or {}
  return {
    name = name,
    role = opts.role or "user",
    active = opts.active ~= false,
    score = opts.score or 0,
  }
end

local u = createUser("Alice", {role="admin", score=100})
print(u.name, u.role, u.score)

Chamadas em cauda

Uma chamada em cauda é uma chamada de função na posição final (a última ação antes do retorno). O Lua realiza otimização de chamadas em cauda: uma chamada em cauda adequada não usa espaço adicional na pilha. Isso permite uma recursão profunda sem estouro de pilha quando a chamada recursiva está na posição final.

local function factorial(n, acc)
  acc = acc or 1
  if n <= 1 then return acc end
  return factorial(n - 1, n * acc)  -- tail call!
end

print(factorial(10))  -- 3628800
-- Can handle very large n without stack overflow

Funções chamadas imediatamente

Você pode definir e chamar uma função imediatamente: (function() ... end)(). Isso é útil para criar um escopo local, executar um código de configuração exatamente uma vez ou evitar poluir o escopo externo com variáveis temporárias.

local result = (function()
  local temp = 100
  local adjusted = temp * 1.5
  return math.floor(adjusted)
end)()

print(result)   -- 150
-- temp and adjusted not visible here

Armazenando funções em tabelas

Armazenar funções em tabelas é uma prática idiomática na criação de módulos Lua. A tabela funciona como um espaço de nomes. Você define funções atribuindo-as a campos da tabela ou usando a notação de ponto ou de dois-pontos com o nome da tabela.

local math2 = {}

function math2.clamp(val, lo, hi)
  return math.max(lo, math.min(hi, val))
end

function math2.lerp(a, b, t)
  return a + (b - a) * t
end

print(math2.clamp(150, 0, 100))  -- 100
print(math2.lerp(0, 10, 0.5))   -- 5.0

Fechamentos como retornos de chamada

Funções de ordem superior aceitam retornos de chamada. Em Lua, retornos de chamada são simplesmente valores de função. Os fechamentos são especialmente úteis como retornos de chamada porque capturam o contexto da chamada sem exigir que argumentos extras sejam passados pela função de ordem superior.

local function forEach(t, fn)
  for i, v in ipairs(t) do
    fn(v, i)
  end
end

local sum = 0
forEach({10, 20, 30}, function(v)
  sum = sum + v
end)
print(sum)   -- 60

forEach({"a","b","c"}, function(v, i)
  print(i, v)
end)

Verificação rápida

Qual é a saída de: local function f() return 1, 2, 3 end; local a, b = f()?

Recapitulação: Funções

Pontos principais:

  • Use local function para evitar poluir as variáveis globais
  • As funções são valores de primeira classe: armazene-as em variáveis e tabelas ou passe-as como argumentos
  • A sintaxe com dois-pontos passa self implicitamente
  • Simule parâmetros opcionais com opts or {}
  • As chamadas em cauda evitam o estouro da pilha em recursões profundas
  • Funções invocadas imediatamente criam escopos isolados

Perguntas Frequentes

A aula “Definição e chamada de funções” é grátis?

Sim — o texto completo de “Definição e chamada de funções” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Lua Academy, atualize para CoddyKit PRO. O curso de Lua Academy inclui 4 aulas no total.

O que vou aprender em “Definição e chamada de funções”?

Aprenda a sintaxe de declaração de funções, as convenções de chamada e a diferença entre funções locais e globais. Você pratica Lua Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Lua Academy?

Nenhuma experiência prévia é necessária. Lua Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Definição e chamada de funções”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Lua Academy?

Sim. Cada aula de Lua Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Definição e chamada de funções
  2. Múltiplos valores de retorno
  3. Argumentos variáveis e o operador ...
  4. Recursão em Lua
← Voltar para Lua Academy