Zadania i struktury kontrolne w Lua

W poprzednich tutorialach widzieliśmy jak Lua umożliwia operowanie zarówno wartościami, jak i typami w sposób dynamiczny, zawsze wyróżniając się prostotą i wszechstronnością przy wykonywaniu tych operacji.
Ale to nie wszystko Lua oferty pod względem prostoty, umownie wspiera deklaracje, które możemy znaleźć w językach takich jak in C lub PascalTam, gdzie te deklaracje zawierają zarówno przypisania, jak i struktury kontrolne, możemy nawet natknąć się na niekonwencjonalne sposoby, takie jak wielokrotne przypisania i deklaracje lokalne.
Zadania w Lua Są niezwykle proste i pracują nad zmianą wartości zmiennej w określonym czasie w naszym programie, zobaczmy prosty przykład przy użyciu interaktywnej konsoli programu Lua, do którego możemy wpisać wpisując słowo zastrzeżone lua W terminalu:

Jak widać mamy kilka prostych przykładów przypisania, zmiany wartości zmiennych za pomocą operacji konkatenacji, arytmetyki lub po prostu przez zapisanie wartości. Poza tym, Lua umożliwia wielokrotne przypisanie, gdzie lista wartości jest przypisana do listy zmiennych, zawsze oddzielając te listy przecinkami dla poprawnego działania:

Jak mogliśmy zobaczyć zmienna1 otrzymał wartość liczbową i var2 wartość tekstowa, zgodnie z kolejnością wykonania przypisania. Jeśli jesteśmy obserwatorami, widzimy, jak możemy również zmieniać wartości obu zmiennych, co przydaje się podczas pracy z funkcjami.
Lua możesz nawet dostosować liczbę wartości do liczby obecnych zmiennych, na przykład jeśli lista wartości jest mniejsza niż lista zmiennych, dodatkowe zmienne otrzymują typ wartości zero domyślnie jako jego wartości, zobaczmy przykład tego procesu:

Jak widać, dwie pierwsze zmienne otrzymują odpowiadające im wartości, a ostatnia otrzymuje automatycznie zero jak wyjaśniamy. Należy wspomnieć, że wielokrotne przypisania nie zawsze są szybsze niż proste przypisania, ale pozwalają nam zebrać wiele zwrotów z wywołania funkcji, aby wymienić tylko kilka.
Oprócz zmiennych globalnych Lua Obsługuje zmienne lokalne, które w przeciwieństwie do globalnych mają ograniczony zakres, który jest zależny od bloku, w którym zostały zadeklarowane, zobaczmy jak deklarujemy zmienną lokalną:

Jak widzimy deklarację tych zmiennych, robimy je ze słowem zastrzeżonym lokalnyZmienne te działają w bloku, w którym zostały zadeklarowane, na przykład możemy powiedzieć, że blok może być strukturą kontrolną lub funkcją, zobaczmy poniższy przykład:

 x = 10 lokalnie i = 1 podczas gdy i <= x wykonaj lokalnie x = i * 2 drukuj (x) i = i + 1 end if i> 20 then local xx = 20 drukuj (x + 2) w przeciwnym razie drukuj (x) end druk (x) 

Jeśli wykonamy to samo w naszym terminalu, zobaczymy, że wynik może nie być taki, jakiego oczekujemy, a to dlatego, że mamy różne bloki, w których używamy zmiennych, zobaczmy wynik:

Chociaż kontrola naszego programu może być ograniczona, możemy użyć ograniczników zrobić-koniec Aby określić blok i wiedzieć, jak daleko nasze zmienne lokalne mają zasięg, zobaczmy przykład, w którym możemy to zrobić:

 do local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 end - Tutaj kończy się zakres var1 i var2 print (x, y) print (var1, var2)

Gdy wykonamy go w naszym terminalu, zobaczymy, że zmienne x i y są pokazywane bez problemu, ponieważ są globalne, ale dla zm1 i zm2 ich zakres kończy się blokiem zrobić-koniec, Zobaczmy:

Możemy podkreślić, że wykorzystanie zmiennych lokalnych w naszych programach jest dobrą praktyką, pomagają nam nie dotykać środowiska globalnego zbędnymi nazwami, a także, że dostęp do tych zmiennych jest znacznie szybszy niż gdybyśmy robili to za pomocą zmiennych globalnych i w końcu te zmienne znikają, gdy tylko kończy się ich zakres, zwalniając w ten sposób miejsce w pamięci, dlatego zalecamy ich używanie, gdy tylko jest to możliwe.
Struktury kontrolnePodobnie jak pozostałe języki programowania, Lua dostarcza nam zestaw struktur kontrolnych, które możemy wykorzystać w naszych programach, wykorzystując dobrze znane Jeśli radzić sobie z warunkami i podczas, powtarzać Tak dla dla pętli iteracyjnych, gdzie z wyjątkiem powtarzać który ma wyraźny terminator dopóki a inne kończące się na koniec.
Jak w większości języków programowania deklaracja Jeśli sprawdza warunek i wykonuje część następnie lub część w przeciwnym razie, gdzie to ostatnie może być opcjonalne, zobaczmy zestaw tych warunków, jak widać w naszych programach:

 if var1 <0 then var1 = 0 end if var1 max lines to pokaż () linie = 0 end

Tutaj mamy trzy rodzaje operacji, podstawowy z następnie, używając return do zwrócenia wartości zgodnie z warunkiem i nieco bardziej kompletnego fragmentu kodu, który wywołuje funkcję. Poza tym możemy pisać Jeśli zagnieżdżone przy użyciu elseif, co oszczędza nam konieczności wielokrotnego używania kończy się, zobaczmy jak to wygląda:

 if operacja == "+" then wynik = a + b elseif operacja == "-" then wynik = a - b elseif operacja == "*" then wynik = a * b elseif operacja == "/" then wynik = a / b inny błąd ("Nieprawidłowa operacja") end

Należy zauważyć, że jest to nie tylko bardziej optymalne, ale także konieczne, ponieważ Lua nie posiada deklaracji typu przełącznik więc ten typ warunków zagnieżdżonych będzie dość powszechny w naszych programach.
Podobnie jak w innych językach, Lua najpierw oceń stan podczas, jeśli warunek jest fałszywy, pętla się kończy, a w przeciwnym razie wykonywane są następujące wiersze kodu, a proces jest powtarzany, aż warunek będzie fałszywy, zobaczmy prosty przykład, aby to zilustrować:

 lokalne i = 1 podczas gdy zm1 [i] wypisuje (zmienna1 [i]) i = i + 1 end

To stwierdzenie w przeciwieństwie do podczas pozwala nam powtarzać kod wewnątrz warunku, aż będzie prawdziwy, gdzie nawet ten kod może być wykonany przynajmniej raz, ponieważ ocena warunku jest wykonywana na końcu, zobaczmy przykład:

 powtórz linię = os.read() aż linia ~ = "" print (line)

Odnośnie cykli iteracyjnych dla, Lua ma dwa warianty, dla liczb i ogólny dla. Spójrzmy na składnię liczb dla:

 dla var = exp1, exp2, exp3 do end

Ta pętla wykona coś dla każdej wartości var z exp1 dopóki exp2 za pomocą exp3 jako wartość zwiększającą lub zmniejszającą var, jeśli jej nie uwzględnimy Lua domyślnie zakłada, że ​​przebiega jeden po drugim, zobaczmy bardziej szczegółowy przykład tych cykli:

 for var = 1, f (x) do print (var) end dla var2 = 10,1, -1 do print (var2) end

Jak widzimy, jego zastosowanie jest dość proste i pozwala nam zaimplementować przydatne cykle iteracyjne w naszych programach, teraz zobaczmy składnię dla ogólny dla:

 for i, var in ipairs (array) do print (var) end

To, co robi ten cykl, to wykorzystanie funkcji, którą nam daje Lua połączenie ipary, który jest iteratorem tablic, gdzie dla każdej iteracji i pobieramy indeks, a var otrzymuje wartość skojarzoną z tym indeksem.
Jak widzimy stwierdzenia wewnątrz Lua Nie różnią się one zbytnio od innych języków, jednak język dodaje tę dodatkową prostotę, aby zapewnić nam znacznie szybszą naukę jego składni i znacznie bardziej efektywne wykorzystanie. Na tym kończymy ten samouczek, w którym poznaliśmy zadania i struktury kontrolne w ramach Lua, dodając w ten sposób kolejną warstwę wiedzy, jeśli chodzi o ten prosty, ale potężny język.