Lua Academy · Lekcja

Wiele wartości zwracanych

Proszę zwracać i przechwytywać wiele wartości w ramach jednego wywołania funkcji.

Wiele wartości zwracanych to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 2 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.

Zwracanie wielu wartości

W przeciwieństwie do większości języków funkcje Lua mogą natywnie zwracać wiele wartości za pomocą pojedynczej instrukcji return. Wiele wartości oddziela się przecinkami po return. Eliminuje to potrzebę używania obiektów opakowujących lub parametrów wyjściowych.

local function divmod(a, b)
  return math.floor(a / b), a % b
end

local quotient, remainder = divmod(17, 5)
print(quotient, remainder)   -- 3  2

Dostosowywanie zwracanych wartości

Lua dostosowuje zwracane wartości do liczby odbiorców. Nadmiarowe wartości są odrzucane, a brakujące przyjmują wartość nil. To dostosowanie zachodzi zawsze, gdy wywołanie funkcji nie jest ostatnim wyrażeniem na liście — w takiej pozycji zachowywana jest tylko pierwsza wartość.

local function triple()
  return 10, 20, 30
end

local a, b, c = triple()
print(a, b, c)      -- 10  20  30

local x, y = triple()
print(x, y)         -- 10  20  (30 discarded)

local p = triple()
print(p)            -- 10  (only first when 1 var)

Dostosowanie w środkowej pozycji

Gdy wywołanie funkcji znajduje się w środku listy wyrażeń, a nie na jej końcu, Lua skraca je do pojedynczej wartości. Tylko ostatnie wyrażenie na liście może zwracać wiele wartości.

local function pair()
  return 1, 2
end

-- pair() in middle: only 1 value used
local t = {pair(), pair()}
print(#t, t[1], t[2], t[3])  -- 3  1  1  2
-- first pair() gives just 1; last pair() gives 1,2

-- pair() at end: all values used
local t2 = {10, pair()}
print(#t2, t2[1], t2[2], t2[3])  -- 3  10  1  2

Nawiasy wymuszają pojedynczą wartość

Umieszczenie wywołania funkcji w nawiasach wymusza zwrócenie dokładnie jednej wartości. Jest to przydatne, gdy chce Pan/Pani uzyskać tylko pierwszą zwracaną wartość, niezależnie od tego, ile wartości zwraca funkcja.

local function coords()
  return 10, 20, 30
end

print(coords())    -- 10  20  30  (all three)
print((coords()))  -- 10  (parentheses: single value only)

local x = (coords())
print(x)           -- 10

Wartości zwracane przez string.find

Wiele funkcji biblioteki standardowej korzysta ze zwracania wielu wartości. string.find zwraca pozycje początkową i końcową dopasowania (oraz przechwycone fragmenty). math.modf zwraca część całkowitą i ułamkową. Zrozumienie tych wzorców pomaga swobodnie korzystać z biblioteki standardowej.

local s = "hello world"
local start, finish = string.find(s, "world")
print(start, finish)   -- 7  11

-- math.modf: integer and fractional parts
local int, frac = math.modf(3.75)
print(int, frac)       -- 3   0.75

Przechwytywanie za pomocą table.pack

table.pack(...) przechwytuje wszystkie argumenty (lub wartości zwracane za pomocą ...) w tabeli. Tabela zawiera pole n z całkowitą liczbą elementów, w tym wartości nil. Zachowuje to dokładną liczbę elementów, w przeciwieństwie do #, które zatrzymuje się na pierwszej luce.

local function getData()
  return "Alice", 30, nil, true
end

local t = table.pack(getData())
print(t.n)         -- 4
print(t[1])        -- Alice
print(t[2])        -- 30
print(t[3])        -- nil
print(t[4])        -- true

table.unpack do rozpakowywania

table.unpack(t, i, j) zwraca elementy tabeli jako osobne wartości. Jest odwrotnością table.pack. Można użyć go do przekazania zawartości tabeli jako argumentów funkcji lub do rozpakowania wartości w instrukcji return.

local args = {10, 20, 30}

local function sum3(a, b, c)
  return a + b + c
end

print(sum3(table.unpack(args)))  -- 60

-- Use in return
local function passThrough(t)
  return table.unpack(t)
end
print(passThrough({5, 6, 7}))   -- 5  6  7

Zwracanie w stylu obsługi błędów

Typowa konwencja w Lua polega na zwracaniu nil, errorMessage w razie niepowodzenia oraz wyniku w razie powodzenia. Kod wywołujący sprawdza pierwszą zwracaną wartość: jeśli jest równa nil, wystąpił błąd. Pozwala to uniknąć wyjątków w przypadku oczekiwanych niepowodzeń.

local function openConfig(path)
  local f = io.open(path, "r")
  if not f then
    return nil, "cannot open: " .. path
  end
  local content = f:read("*a")
  f:close()
  return content
end

local data, err = openConfig("config.lua")
if not data then
  print("Error:", err)
end

Zamiana wartości za pomocą wielu wartości zwracanych

Wiele wartości zwracanych elegancko rozwiązuje problem zamiany. Prawa strona jest obliczana przed przypisaniem, dlatego a, b = b, a poprawnie zamienia wartości bez używania zmiennej tymczasowej.

local a, b = 5, 10
print(a, b)   -- 5  10

a, b = b, a
print(a, b)   -- 10  5

-- Works for three-way rotation too
local x, y, z = 1, 2, 3
x, y, z = z, x, y
print(x, y, z)  -- 3  1  2

Konwencja wartości zwracanych przez pcall

pcall(f, ...) również korzysta z wielu wartości zwracanych: pierwsza wartość jest typu logicznego (true w razie powodzenia, false w razie błędu), a kolejne wartości to albo wartości zwrócone przez f, albo komunikat błędu. Zawsze należy sprawdzić pierwszą zwracaną wartość przed użyciem pozostałych.

local function risky(x)
  if x < 0 then error("negative input") end
  return math.sqrt(x)
end

local ok, result = pcall(risky, 16)
print(ok, result)   -- true  4.0

ok, result = pcall(risky, -1)
print(ok, result)   -- false  input:2: negative input

Szybkie sprawdzenie

Co wypisze print((string.find("hello", "ll")))?

Powtórzenie: wiele wartości zwracanych

Najważniejsze informacje:

Zwracaj wiele wartości: return a, b, c
Nadmiarowe wartości są odrzucane, a brakujące przyjmują wartość nil
Wywołania w środkowej pozycji są skracane do 1 wartości
(f()) wymusza dokładnie 1 wartość
table.pack/table.unpack służą do obsługi dynamicznych list wartości
Konwencja: w razie niepowodzenia zwracaj nil, errmsg

Często zadawane pytania

Czy lekcja „Wiele wartości zwracanych” jest bezpłatna?

Tak — pełny tekst „Wiele wartości zwracanych” 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 „Wiele wartości zwracanych”?

Proszę zwracać i przechwytywać wiele wartości w ramach jednego wywołania funkcji. Ć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 2 z 4.

Ile czasu zajmuje lekcja „Wiele wartości zwracanych”?

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