Lua Academy · Lekcja

Varargs i operator ...

Proszę obsługiwać listy argumentów o zmiennej długości za pomocą ... i select().

Varargs i operator ... to bezpłatna lekcja Lua Academy na CoddyKit. To lekcja 3 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.

Argumenty zmiennej długości

Funkcja Lua może przyjmować zmienną liczbę argumentów za pomocą ... (trzech kropek) na liście parametrów. Wewnątrz funkcji ... reprezentuje dodatkowe argumenty. Można używać go w wyrażeniach, przekazywać do innych funkcji lub konwertować na tabelę.

local function sum(...)
  local total = 0
  for _, v in ipairs({...}) do
    total = total + v
  end
  return total
end

print(sum(1, 2, 3))        -- 6
print(sum(10, 20, 30, 40)) -- 100

select() dla argumentów zmiennej długości

select(n, ...) zwraca argumenty od pozycji n wzwyż. select("#", ...) zwraca całkowitą liczbę argumentów, w tym wartości nil. Jest to bezpieczniejsze niż #{...}, które zatrzymuje się na pierwszej luce oznaczonej wartością nil.

local function inspect(...)
  local n = select("#", ...)
  print("count:", n)
  for i = 1, n do
    print(i, select(i, ...))
  end
end

inspect("a", "b", nil, "d")
-- count: 4
-- 1  a
-- 2  b
-- 3  nil
-- 4  d

Przekazywanie ... do innej funkcji

Argumenty zmiennej długości można bezpośrednio przekazać do innej funkcji za pomocą f(...). Gdy ... występuje jako ostatni argument wywołania, przekazywane są wszystkie argumenty zmiennej długości. Jest to przydatne przy opakowywaniu funkcji lub logowaniu.

local function log(level, ...)
  io.write("[" .. level .. "] ")
  print(...)
end

log("INFO", "Server started on port", 8080)
log("ERROR", "File not found:", "config.lua")
-- [INFO] Server started on port  8080
-- [ERROR] File not found:  config.lua

table.pack i table.unpack

Argumenty zmiennej długości można przekonwertować na tabelę za pomocą table.pack(...), które zapisuje również ich liczbę w polu n. Tabelę można z powrotem przekonwertować na argumenty zmiennej długości za pomocą table.unpack(t, i, j). Razem funkcje te zapewniają pełną kontrolę nad listami argumentów zmiennej długości.

local function pack_and_show(...)
  local packed = table.pack(...)
  print("n =", packed.n)
  for i = 1, packed.n do
    print(i, packed[i])
  end
end

pack_and_show(10, nil, 30)
-- n = 3
-- 1  10
-- 2  nil
-- 3  30

Połączenie argumentów stałych i zmiennej długości

Funkcja może mieć zarówno parametry stałe, jak i zmienne. Parametry stałe występują jako pierwsze, a ... przechwytuje pozostałe argumenty. Parametry stałe są przypisywane przed przekazaniem reszty do ....

local function printf(fmt, ...)
  io.write(string.format(fmt, ...))
end

printf("Hello, %s! You are %d years old.\n", "Alice", 30)
printf("Pi is approximately %.4f\n", math.pi)

local function firstAndRest(first, ...)
  print("first:", first)
  print("rest count:", select("#", ...))
end
firstAndRest(1, 2, 3, 4)

Argumenty zmiennej długości w konstruktorze tabeli

Argumenty zmiennej długości można bezpośrednio rozpakować w konstruktorze tabeli: {...}. Gdy są użyte jako ostatni element, uwzględniane są wszystkie argumenty. Jednak luki zawierające nil mogą powodować niejednoznaczność operatora # — jeśli potrzebuje Pan/Pani dokładnej liczby elementów, proszę użyć table.pack.

local function toArray(...)
  return {...}  -- collect all args as array
end

local arr = toArray("x", "y", "z")
for i, v in ipairs(arr) do
  print(i, v)
end
-- 1  x
-- 2  y
-- 3  z

Wyrażenia z argumentami zmiennej długości

... może występować w dowolnej pozycji wyrażenia. W przypadku wielokrotnego przypisania rozwija się do wszystkich swoich wartości. W wyrażeniu arytmetycznym używana jest tylko pierwsza wartość. Zrozumienie tego zachowania zapobiega trudnym do wykrycia błędom przy łączeniu ... z innymi wyrażeniami.

local function first(...)
  local x = ...
  return x
end

print(first(10, 20, 30))  -- 10  (only first)

local function addFirst(n, ...)
  local x = ...
  return n + x
end
print(addFirst(5, 3, 99)) -- 8  (3 is first ...)

print() używa argumentów zmiennej długości

Wbudowana funkcja Lua print() sama jest funkcją przyjmującą argumenty zmiennej długości. Przyjmuje dowolną liczbę argumentów, konwertuje każdy z nich na ciąg znaków i oddziela je tabulatorami. Zrozumienie tego pomaga pisać podobne funkcje pomocnicze.

-- print is vararg
print(1, 2, 3)           -- 1  2  3
print("a", nil, "b")     -- a  nil  b
print()                  -- (empty line)

-- Reimplementing a simple print-like function
local function myprint(...)
  local parts = {}
  for i = 1, select("#", ...) do
    parts[i] = tostring(select(i, ...))
  end
  io.write(table.concat(parts, "\t") .. "\n")
end
myprint(10, nil, 30)

Przekazywanie argumentów za pomocą pcall

Połączenie pcall z argumentami zmiennej długości pozwala utworzyć uniwersalną funkcję opakowującą do bezpiecznego wywoływania. Funkcja opakowująca przyjmuje funkcję i dowolne argumenty, wywołuje ją za pomocą pcall, a następnie zwraca wyniki albo błąd.

local function safeCall(fn, ...)
  local ok, result = pcall(fn, ...)
  if ok then
    return result
  else
    print("Error:", result)
    return nil
  end
end

local function divide(a, b)
  assert(b ~= 0, "division by zero")
  return a / b
end

print(safeCall(divide, 10, 2))   -- 5.0
print(safeCall(divide, 10, 0))  -- Error: ...

Wzorzec akumulowania argumentów zmiennej długości

Typowy wzorzec wykorzystujący argumenty zmiennej długości polega na iterowaniu po wszystkich argumentach i akumulowaniu wyniku. Można to zrobić za pomocą lokalnej tabeli albo bezpośrednio sumować wartości z użyciem select. Oba podejścia są poprawne, jednak podejście z tabelą jest czytelniejsze przy dużej liczbie argumentów.

local function average(...)
  local n = select("#", ...)
  if n == 0 then return 0 end
  local total = 0
  for i = 1, n do
    total = total + select(i, ...)
  end
  return total / n
end

print(average(10, 20, 30, 40))  -- 25.0
print(average(5))               -- 5.0

Szybkie sprawdzenie

Co zwraca select("#", 1, nil, 3)?

Powtórzenie: argumenty zmiennej długości

Podsumowanie:

function f(...) — przyjmuje argumenty zmiennej długości
select("#", ...) — bezpiecznie zlicza argumenty, w tym wartości nil
select(n, ...) — zwraca wartości od pozycji n
table.pack(...) — konwertuje argumenty zmiennej długości na tabelę z liczbą elementów w polu .n
table.unpack(t) — konwertuje tabelę na argumenty zmiennej długości
... na ostatniej pozycji rozwija się w całości, a na środkowej pozycji daje jedną wartość

Często zadawane pytania

Czy lekcja „Varargs i operator ...” jest bezpłatna?

Tak — pełny tekst „Varargs i operator ...” 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 „Varargs i operator ...”?

Proszę obsługiwać listy argumentów o zmiennej długości za pomocą ... i select(). Ć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 3 z 4.

Ile czasu zajmuje lekcja „Varargs i operator ...”?

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