Lua Academy · Lekcja

Definiowanie i wywoływanie funkcji

Proszę poznać składnię deklarowania funkcji, konwencje wywołań oraz różnice między funkcjami lokalnymi i globalnymi.

Definiowanie i wywoływanie funkcji to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Lua Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Lua Academy zawiera 4 lekcji w sumie.

Składnia funkcji

Funkcje w Lua definiuje się za pomocą słowa kluczowego function. Ich treść jest blokiem zakończonym przez end. Funkcje mogą być globalne lub lokalne. Funkcję wywołuje się, dopisując nawiasy z argumentami. Jeśli argumenty zostaną pominięte, brakujące parametry otrzymają wartość 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

Wartości zwracane

Funkcje zwracają wartości za pomocą return. W przeciwieństwie do większości języków funkcje Lua mogą zwracać wiele wartości. Jeśli funkcja nie zawiera jawnego return, nie zwraca niczego (zero wartości). Nadmiarowe wartości zwracane są odrzucane, gdy wywołanie nie jest ostatnim wyrażeniem na liście.

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

Funkcja jako wartość

Funkcje są w Lua wartościami pierwszej klasy. Możesz przechowywać je w zmiennych, przekazywać jako argumenty innych funkcji oraz zwracać je z funkcji. Umożliwia to stosowanie callbacków, funkcji wyższego rzędu i wzorców programowania funkcyjnego.

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

Funkcje lokalne a globalne

Używaj local function do definiowania pomocniczych funkcji prywatnych dla modułu. Funkcje globalne zaśmiecają globalną przestrzeń nazw i są dostępne z dowolnego miejsca, co może powodować konflikty nazw. W większości przypadków preferuj funkcje lokalne i udostępniaj przez tabelę modułu tylko to, co jest potrzebne.

-- 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

Metody ze składnią dwukropka

Lua udostępnia skróconą składnię do definiowania i wywoływania metod tabel. obj:method(arg) jest równoważne obj.method(obj, arg). Forma z dwukropkiem niejawnie przekazuje tabelę jako pierwszy argument, zwyczajowo nazywany 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!

Wzorzec opcjonalnych parametrów

Lua nie ma wbudowanej obsługi opcjonalnych parametrów, ale można je symulować za pomocą sprawdzania wartości nil. W funkcjach z wieloma opcjonalnymi parametrami przekazuj pojedynczą tabelę opcji — jest to czytelniejsze niż długa lista argumentów.

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)

Wywołania ogonowe

Wywołanie ogonowe to wywołanie funkcji znajdujące się w pozycji ogonowej (jest ostatnim działaniem przed zwróceniem wyniku). Lua wykonuje optymalizację wywołań ogonowych: poprawne wywołanie ogonowe nie zajmuje dodatkowego miejsca na stosie. Umożliwia to głęboką rekurencję bez przepełnienia stosu, gdy wywołanie rekurencyjne znajduje się w pozycji ogonowej.

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

Funkcje wywoływane natychmiast

Możesz zdefiniować i natychmiast wywołać funkcję: (function() ... end)(). Jest to przydatne do utworzenia lokalnego zakresu, wykonania kodu inicjalizującego dokładnie raz lub uniknięcia zaśmiecania zewnętrznego zakresu tymczasowymi zmiennymi.

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

Przechowywanie funkcji w tabelach

Przechowywanie funkcji w tabelach jest idiomatycznym sposobem projektowania modułów Lua. Tabela pełni funkcję przestrzeni nazw. Funkcje definiuje się, przypisując je do pól tabeli lub używając notacji kropkowej albo dwukropkowej z nazwą tabeli.

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

Domknięcia jako callbacki

Funkcje wyższego rzędu przyjmują callbacki. W Lua callbacki są po prostu wartościami będącymi funkcjami. Domknięcia są szczególnie przydatne jako callbacki, ponieważ przechwytują kontekst wywołania bez konieczności przekazywania dodatkowych argumentów przez funkcję wyższego rzędu.

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)

Szybkie sprawdzenie

Jaki będzie wynik działania: local function f() return 1, 2, 3 end; local a, b = f()?

Powtórzenie: funkcje

Najważniejsze informacje:

Używaj local function, aby nie zaśmiecać zmiennych globalnych
Funkcje są obiektami pierwszej klasy: można przechowywać je w zmiennych i tabelach oraz przekazywać jako argumenty
Składnia z dwukropkiem niejawnie przekazuje self
Parametry opcjonalne można symulować za pomocą opts or {}
Wywołania ogonowe zapobiegają przepełnieniu stosu przy głębokiej rekurencji
Funkcje wywoływane natychmiast tworzą odizolowane zakresy

Często zadawane pytania

Czy lekcja „Definiowanie i wywoływanie funkcji” jest bezpłatna?

Tak — pełny tekst „Definiowanie i wywoływanie funkcji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Lua Academy, przejdź na CoddyKit PRO. Kurs Lua Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Definiowanie i wywoływanie funkcji”?

Proszę poznać składnię deklarowania funkcji, konwencje wywołań oraz różnice między funkcjami lokalnymi i globalnymi. Ćwiczysz Lua Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Lua Academy?

Nie wymagamy żadnego doświadczenia. Lua Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Definiowanie i wywoływanie funkcji”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Lua Academy?

Tak. Każda lekcja Lua Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Lua Academy