Задания и структури за управление в Lua

В предишни уроци видяхме как Луа позволява боравенето както със стойностите, така и с типовете по динамичен начин, като винаги се откроява със своята простота и гъвкавост при извършване на тези операции.
Но това не е всичко Луа предлага по отношение на простотата, той конвенционално поддържа декларации, които можем да намерим в езиците, както в ° С или ПаскалКогато тези декларации включват присвоявания и структури за управление, можем дори да се натъкнем на някои нетрадиционни начини като множество присвоявания и локални декларации.
Задачите в Луа Те са изключително прости и работят за промяна на стойността на променлива в определен момент в рамките на нашата програма, нека видим прост пример, използвайки интерактивната конзола на Луа, които можем да въведем, като поставим запазената дума луа В терминала:

Както виждаме, имаме няколко прости примера за присвояване, променящи стойността на променливите с операции на конкатенация, аритметика или просто чрез записване на стойности. Освен това, Луа позволява множество присвоявания, където списък със стойности се присвоява на списък с променливи, като винаги се разделят тези списъци със запетаи за правилна работа:

Както видяхме var1 получи числовата стойност и var2 текстовата стойност, това според реда, в който е направено присвояването. Ако сме наблюдатели, виждаме как можем също да редуваме стойностите на двете променливи, нещо, което е полезно, когато работим с функции.
Луа можете дори да регулирате броя на стойностите за броя на наличните променливи, например ако списъкът със стойности е по -малък от списъка с променливи, на допълнителните променливи се дава тип стойност нула по подразбиране като негови стойности, нека видим пример за този процес:

Както виждаме, първите две променливи получават съответните им стойности, а последната от тях получава автоматично нула както обясняваме. Важно е да се спомене, че множествените присвоявания не винаги са по -бързи от обикновените, но ни позволяват да ни помогнат да съберем множество връщания от извикване на функция, за да назовем няколко.
В допълнение към глобалните променливи, Луа Той поддържа локални променливи, които за разлика от глобалните имат ограничен обхват, който зависи от блока, в който са декларирани, нека видим как декларираме локална променлива:

Както виждаме декларацията на тези променливи, ние ги правим със запазената дума местенТези променливи работят в блока, в който са декларирани, например можем да кажем, че блок може да бъде контролна структура или функция, нека видим следния пример:

 x = 10 local i = 1 while i <= x do local x = i * 2 print (x) i = i + 1 end if i> 20 then local xx = 20 print (x + 2) else print (x) end печат (x) 

Ако изпълним същото в нашия терминал, ще видим как резултатът може да не е това, което очакваме, и това е така, защото имаме различни блокове, в които използваме променливите, нека видим резултата:

Въпреки че контролът на нашата програма може да бъде ограничен, можем да използваме разделителите do-end За да посочим блок и да знаем докъде имат локални променливи обхват, нека видим пример, където можем да направим това:

 do local var1 = 16 local var2 = var1 + 20 x = 5 y = x + var1 end - Тук завършва обхвата на var1 и var2 print (x, y) print (var1, var2)

Когато го изпълним в нашия терминал, ще видим, че променливите x и y се показват без проблем, защото са глобални, но за var1 и var2 техният обхват завършва с блока do-end, да видим:

Можем да подчертаем, че използването на локални променливи в нашите програми е добра практика, те ни помагат да не докосваме глобалната среда с ненужни имена, също така, че достъпът до тези променливи е много по -бърз, отколкото ако го направихме с глобални променливи и накрая тези променливите изчезват веднага щом обхватът им приключи, като по този начин се освобождава място в паметта, затова препоръчваме използването им, когато е възможно.
Контролни структуриПодобно на останалите езици за програмиране, Луа ни предоставя набор от структури за управление, които да използваме в нашите програми, използвайки добре познатите ако да се справя с условията и докато, повторете Y за за итеративни цикли, където освен повторете който има изричен терминатор до и останалите, завършващи с край.
Както в повечето езици за програмиране, декларацията ако проверява условие и изпълнява частта от тогава или частта от иначе, където последното може да бъде по избор, нека видим набор от тези условия, както се вижда в нашите програми:

 ако var1 <0, тогава var1 = 0 край, ако var1 max редове, тогава покажете () редове = 0 край

Тук имаме три вида операции, основната с тогава, използвайки връщане, за да върне стойност според условието и малко по -пълна част от кода, която извиква функция. Освен това можем да напишем ако вложено с помощта иначе, което ни спестява от необходимостта да използваме няколко завършва, нека видим как изглежда:

 ако операция == " +", тогава резултат = a + b elsei операция == " -" тогава резултат = a - b elseif операция == " *" тогава резултат = a * b elseif операция == "/" тогава резултат = a / b else грешка ("Невалидна операция") край

Важно е да се отбележи, че това е не само по -оптимално, но и необходимо, тъй като Луа няма декларации за тип превключвател така че този тип вложени условия ще бъдат доста често срещани в нашите програми.
Както и в други езици, Луа първо оценете състоянието на докато, ако условието е невярно, цикълът завършва и в противен случай следните редове от код се изпълняват и процесът се повтаря, докато условието е невярно, нека да видим прост пример, който илюстрира това:

 local i = 1, докато var1 [i] прави печат (var1 [i]) i = i + 1 край

Това твърдение за разлика от докато ни позволява да повторим кода вътре в условието, докато не стане истина, където дори този код може да бъде изпълнен поне веднъж, тъй като оценката на условието е направена в края, нека видим пример:

 повторете ред = os.read () докато ред ~ = "" печат (ред)

Относно итеративните цикли за, Луа има два негови варианта, за числово и родово за. Нека да разгледаме синтаксиса на числовото за:

 за var = exp1, exp2, exp3 до край

Този цикъл ще изпълни нещо за всяка стойност на вар от exp1 до exp2 използвайки exp3 като стойност за увеличаване на var или намаляване, ако не го включим Луа приема по подразбиране, че върви един по един, нека да видим по -подробен пример за тези цикли:

 за var = 1, f (x) do print (var) end за var2 = 10,1, -1 do print (var2) end

Тъй като виждаме, че приложението му е доста просто и ни позволява да внедрим полезните итеративни цикли в нашите програми, сега нека видим синтаксиса за родово за:

 за i, var в ipairs (масив) да принтирам (var) край

Това, което прави този цикъл, е да използва функцията, която ни дава Луа обади се ipairs, който е итератор на масиви, където за всяка итерация i взема индекс, докато var получава стойността, свързана с този индекс.
Както виждаме изявленията вътре Луа Те не се различават много от другите езици, но езикът добавя тази допълнителна простота, за да ни даде много по -бързо изучаване на неговия синтаксис и много по -ефективно използване. С това завършваме този урок, където научихме задачите и контролните структури в него Луа, като по този начин добавя още един слой знания, когато става въпрос за този прост, но мощен език.