map, filter, reduce
Zbuduje Pan/Pani funkcje pomocnicze wyższego rzędu.
map, filter, reduce 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.
Wielka trójka
Mapowanie, filtrowanie i redukcja to podstawowe narzędzia funkcyjnego przetwarzania list. Każde z nich przyjmuje listę i funkcję, a następnie zwraca wynik bez konieczności ręcznego pisania pętli.
Lua nie udostępnia ich wbudowanych wersji, ale można je krótko napisać, a przy okazji lepiej zrozumieć działanie funkcji wyższego rzędu.
Mapowanie: przekształcanie każdego elementu
Mapowanie stosuje funkcję do każdego elementu i zbiera wyniki w nowej liście. Oryginalna lista pozostaje niezmieniona.
Przekazana funkcja określa sposób przekształcenia, więc jedno map obsługuje podwajanie, podnoszenie do kwadratu i dowolne zmiany poszczególnych elementów.
local function map(t, f)
local out = {}
for i, v in ipairs(t) do
out[i] = f(v)
end
return out
end
local r = map({1, 2, 3}, function(x) return x * x end)
print(table.concat(r, ", "))Mapowanie zachowuje długość
Mapowanie zawsze zwraca listę zawierającą tyle samo elementów co lista wejściowa. Każdy element jest mapowany dokładnie na jeden element wyjściowy.
Jeśli trzeba usunąć elementy, służy do tego filtrowanie, a nie mapowanie.
local function map(t, f)
local out = {}
for i, v in ipairs(t) do out[i] = f(v) end
return out
end
local names = {"ada", "lin", "sam"}
local caps = map(names, string.upper)
print(table.concat(caps, " "))
print(#caps)Filtrowanie: zachowywanie wybranych elementów
Filtrowanie zachowuje tylko te elementy, dla których predykat zwraca wartość true. Predykat to funkcja zwracająca wartość logiczną.
Wynikiem jest nowa lista, która może być krótsza od oryginalnej, ale nigdy nie będzie od niej dłuższa.
local function filter(t, pred)
local out = {}
for _, v in ipairs(t) do
if pred(v) then out[#out + 1] = v end
end
return out
end
local evens = filter({1,2,3,4,5,6}, function(x) return x % 2 == 0 end)
print(table.concat(evens, ", "))Filtrowanie zachowuje kolejność
Filtrowanie przechodzi po liście w kolejności i dopisuje każdy zachowany element, więc pozostające elementy zachowują swoją pierwotną kolejność.
Użycie #out + 1 jako indeksu tworzy tablicę wynikową bez luk, którą Lua traktuje jako prawidłową sekwencję.
local function filter(t, pred)
local out = {}
for _, v in ipairs(t) do
if pred(v) then out[#out + 1] = v end
end
return out
end
local long = filter({"hi", "hello", "yo", "howdy"},
function(s) return #s > 2 end)
print(table.concat(long, ", "))Redukcja: łączenie w jedną wartość
Redukcja, nazywana też składaniem, przekształca listę w pojedynczą wartość. Przechowuje akumulator i łączy go z każdym elementem za pomocą przekazanej funkcji.
Podajesz wartość początkową i funkcję łączącą, a redukcja przekazuje akumulator przez wszystkie elementy.
local function reduce(t, f, acc)
for _, v in ipairs(t) do
acc = f(acc, v)
end
return acc
end
local sum = reduce({1,2,3,4}, function(a, x) return a + x end, 0)
print(sum)Elastyczność redukcji
Zmieniając funkcję łączącą i wartość początkową, można za pomocą redukcji sumować i mnożyć wartości, znajdować maksimum lub tworzyć napis.
W tym przykładzie akumulator zaczyna od wartości 1 i jest mnożony, tworząc iloczyn podobny do silni.
local function reduce(t, f, acc)
for _, v in ipairs(t) do acc = f(acc, v) end
return acc
end
local product = reduce({1,2,3,4,5}, function(a, x) return a * x end, 1)
print(product)Znajdowanie maksimum za pomocą redukcji
Redukcja nie ogranicza się do działań arytmetycznych. Funkcja łącząca może porównywać wartości i na każdym kroku zachowywać większą z nich.
Rozpoczęcie od pierwszego elementu albo od bardzo małej liczby pozwala przejrzyście znaleźć maksimum za pomocą redukcji.
local function reduce(t, f, acc)
for _, v in ipairs(t) do acc = f(acc, v) end
return acc
end
local max = reduce({3, 8, 2, 11, 6},
function(a, x) if x > a then return x else return a end end, -math.huge)
print(max)Łączenie operacji
Prawdziwa siła ujawnia się przy połączeniu tych trzech operacji. Filtrowanie zawęża dane, mapowanie je przekształca, a redukcja podsumowuje.
Każdy etap jest małym, przejrzystym krokiem, a razem zastępują skomplikowaną ręcznie napisaną pętlę.
local function filter(t, p) local o={} for _,v in ipairs(t) do if p(v) then o[#o+1]=v end end return o end
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local function reduce(t, f, a) for _,v in ipairs(t) do a=f(a,v) end return a end
local nums = {1,2,3,4,5,6}
local r = reduce(map(filter(nums, function(x) return x%2==0 end),
function(x) return x*x end), function(a,x) return a+x end, 0)
print(r)Oryginały pozostają bez zmian
Mapowanie i filtrowanie zawsze tworzą nowe tabele i nigdy nie modyfikują danych wejściowych. Dzięki temu potoki są przewidywalne: wcześniejsze dane pozostają dostępne po każdym etapie.
Redukcja również pozostawia listę bez zmian, zwracając tylko połączony wynik.
Uniwersalność dla każdej listy
Ponieważ funkcja jest parametrem, narzędzia te działają na dowolnych danych. To samo map może zamieniać napisy na wielkie litery, przeliczać ceny lub formatować rekordy.
Jednokrotne napisanie pętli i przekazywanie różnych funkcji to właśnie powód, dla którego funkcje pierwszej klasy są tak użyteczne.
local function map(t, f) local o={} for i,v in ipairs(t) do o[i]=f(v) end return o end
local prices = {10, 20, 30}
local withTax = map(prices, function(p) return p * 1.18 end)
print(table.concat(withTax, ", "))Szybki test
Zastanów się, jak te operacje wpływają na długość listy.
Podsumowanie
Mapowanie przekształca każdy element i zachowuje długość listy, filtrowanie zachowuje elementy spełniające predykat, a redukcja składa listę do jednej wartości za pomocą akumulatora.
Łączenie filtrowania, mapowania i redukcji tworzy przejrzyste potoki danych bez ręcznego pisania pętli, a oryginalne tabele pozostają niezmienione.
Ucz się Lua dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 40
- Lekcje
- 159
Często zadawane pytania
Czy lekcja „map, filter, reduce” jest bezpłatna?
Tak — pełny tekst „map, filter, reduce” 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 „map, filter, reduce”?
Zbuduje Pan/Pani funkcje pomocnicze wyższego rzędu. Ć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 „map, filter, reduce”?
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
- Funkcje jako wartości
- map, filter, reduce
- Częściowe zastosowanie
- Komponowanie funkcji