Lua Academy · Lekcja

Wyszukiwanie i wyodrębnianie podciągów

Proszę stosować string.find i string.sub do lokalizowania i wyodrębniania tekstu.

Wyszukiwanie i wyodrębnianie podciągów 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.

Podstawy string.find

string.find(s, pattern, init, plain) wyszukuje wzorzec w s, zaczynając od pozycji init (domyślnie 1). Zwraca pozycję początkową i końcową dopasowania albo nil, jeśli go nie znaleziono. Przy plain=true wzorzec jest traktowany jak dosłowny napis (bez znaków specjalnych).

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

-- Plain search (literal string)
local i2, j2 = string.find("a+b=5", "+", 1, true)
print(i2, j2)  -- 2  2

-- Not found
print(string.find(s, "xyz"))  -- nil

string.sub do wyodrębniania fragmentów

string.sub(s, i, j) wyodrębnia podnapis od pozycji i do j (włącznie). Indeksy ujemne są liczone od końca: -1 oznacza ostatni znak. Jeśli j zostanie pominięte, domyślnie przyjmowany jest koniec napisu.

local s = "hello world"
print(string.sub(s, 1, 5))    -- hello
print(string.sub(s, 7))       -- world
print(string.sub(s, -5))      -- world
print(string.sub(s, 1, -7))   -- hello
print(s:sub(7, 11))           -- world (method syntax)

Łączenie find i sub

Połącz string.find i string.sub, aby znaleźć i wyodrębnić podnapisy. Najpierw znajdź separator, a następnie wyodrębnij fragmenty znajdujące się przed nim i za nim. To podstawowe podejście do dzielenia napisów.

local s = "key=value"
local i = string.find(s, "=")
if i then
  local key = string.sub(s, 1, i - 1)
  local val = string.sub(s, i + 1)
  print(key, val)   -- key  value
end

string.match do przechwytywania wzorców

string.match(s, pattern, init) zwraca podnapisy przechwycone podczas dopasowywania wzorca. Jeśli wzorzec nie zawiera przechwyceń, zwraca całe dopasowanie. Jeśli nic nie zostanie dopasowane, zwraca nil. Przechwycenia definiuje się za pomocą nawiasów we wzorcu.

local date = "2024-03-15"
local y, m, d = string.match(date, "(%d+)-(%d+)-(%d+)")
print(y, m, d)   -- 2024  03  15

-- No capture: returns the whole match
local num = string.match("price: 42.5 USD", "%d+%.%d+")
print(num)       -- 42.5

Znajdowanie ostatniego wystąpienia

Aby znaleźć ostatnie wystąpienie podnapisu, należy wyszukiwać w pętli, przesuwając pozycję początkową, albo wyszukiwać od końca. Standardowe podejście polega na wielokrotnym wywoływaniu string.find z pozycją tuż za poprzednim dopasowaniem, aż funkcja zwróci nil.

local function findLast(s, sub)
  local last_i, last_j
  local i, j = string.find(s, sub, 1, true)
  while i do
    last_i, last_j = i, j
    i, j = string.find(s, sub, j + 1, true)
  end
  return last_i, last_j
end

local i, j = findLast("a/b/c/d", "/")
print(i, j)   -- 6  6

Wyodrębnianie rozszerzeń plików

Praktyczne zastosowanie string.match: wyodrębnianie rozszerzenia z nazwy pliku. Wzorzec "([^%.]+)$" przechwytuje ostatnią sekwencję niebędącą kropką na końcu napisu, natomiast "%.([^%.]+)$" przechwytuje tylko sekwencję znajdującą się za ostatnią kropką.

local function getExt(filename)
  return string.match(filename, "%.([^%.]+)$")
end

print(getExt("photo.jpg"))        -- jpg
print(getExt("archive.tar.gz"))   -- gz
print(getExt("README"))           -- nil
print(getExt("config.lua.bak"))   -- bak

Dzielenie napisów

Lua nie ma wbudowanej funkcji dzielenia napisów, ale można ją zaimplementować za pomocą string.gmatch. Należy iterować po wszystkich sekwencjach znaków innych niż separator albo użyć wzorca przechwytującego fragmenty między separatorami.

local function split(s, sep)
  local result = {}
  local pattern = "([^" .. sep .. "]+)"
  for part in string.gmatch(s, pattern) do
    result[#result+1] = part
  end
  return result
end

local parts = split("one,two,three,four", ",")
for i, p in ipairs(parts) do
  print(i, p)
end
-- 1 one  2 two  3 three  4 four

Usuwanie białych znaków

Wiodące i końcowe białe znaki można usunąć, dopasowując je i pomijając. Wzorzec "^%s*(.-)%s*$" używa zachłannego kwantyfikatora .-, aby przechwycić minimalną zawartość między opcjonalnymi spacjami na początku i na końcu.

local function trim(s)
  return string.match(s, "^%s*(.-)%s*$")
end

print("|" .. trim("  hello  ") .. "|")  -- |hello|
print("|" .. trim("  \t\n") .. "|")    -- ||
print("|" .. trim("no spaces") .. "|")  -- |no spaces|

Wyodrębnianie liczb z tekstu

Użyj string.gmatch ze wzorcem liczby, aby wyodrębnić z napisu wszystkie liczby. Wzorzec %-?%d+%.?%d* dopasowuje opcjonalny znak minus, cyfry, opcjonalny separator dziesiętny i kolejne cyfry.

local text = "Revenue: $1,234.56 Expenses: $567.89 Net: $666.67"
local numbers = {}
for n in string.gmatch(text, "%d+%.?%d*") do
  numbers[#numbers+1] = tonumber(n)
end
for _, v in ipairs(numbers) do
  io.write(v .. " ")
end
print()  -- 1 234.0 56.0 567.89 666.67

Normalizacja pozycji w napisie

Ujemne indeksy w Lua pozwalają pracować od końca napisu. string.sub(s, -n) pobiera ostatnie n znaków. Połącz je z #s, aby obliczać pozycje. Zrozumienie zależności między indeksami dodatnimi i ujemnymi pomaga zapobiegać błędom przesunięcia o jeden.

local s = "abcdefgh"

-- Last 3 characters
print(s:sub(-3))     -- fgh

-- All but last 2
print(s:sub(1, -3))  -- abcdef

-- Character at position from end
print(s:sub(-1, -1)) -- h
print(s:sub(-4, -2)) -- efg

Szybkie sprawdzenie

Co zwraca string.sub("hello", 2, -2)?

Podsumowanie: znajdowanie i wyodrębnianie

Podsumowanie:

string.find(s, pat, init, plain) — zwraca początek i koniec dopasowania albo nil
string.sub(s, i, j) — wyodrębnia fragment według pozycji; ujemne indeksy są liczone od końca
string.match(s, pat) — zwraca przechwycenia albo całe dopasowanie
Użyj plain=true do wyszukiwania dosłownego (bez znaków specjalnych)
Dzielenie napisów można zaimplementować za pomocą string.gmatch
Usuwanie białych znaków: wzorzec "^%s*(.-)%s*$"

Często zadawane pytania

Czy lekcja „Wyszukiwanie i wyodrębnianie podciągów” jest bezpłatna?

Tak — pełny tekst „Wyszukiwanie i wyodrębnianie podciągów” 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 „Wyszukiwanie i wyodrębnianie podciągów”?

Proszę stosować string.find i string.sub do lokalizowania i wyodrębniania tekstu. Ć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 „Wyszukiwanie i wyodrębnianie podciągów”?

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

Podstawy ciągów znaków: konkatenacja i długość
Wyszukiwanie i wyodrębnianie podciągów
string.format do formatowania wyjścia
string.gsub i string.gmatch

← Powrót do Lua Academy