lua комментарии в коде

Очень подробно разжёвано для чайников по LUA часть1!

Скрипты на языке Lua

Написанный на Lua скрипт не имеет какой-либо специальной функции, с которой начиналось бы его выполнение. Скрипт можно рассматривать просто как набор команд (инструкций), который выполняется, начиная с первой инструкции.

Скрипт может быть как очень простым, состоящим всего из одной команды, так и весьма сложным, содержащим десятки, сотни и даже тысячи инструкций. Следующие друг за другом инструкции могут разделяться точкой с запятой (;). Однако это требование не является обязательным, поэтому весь приведённый ниже код является корректным с точки зрения синтаксиса:

Работа с переменными в Lua

Переменные используются для хранения значений в процессе выполнения скрипта.

Имена переменных в Lua

Именами (идентификаторами) переменных в Lua могут быть любые последовательности из букв, цифр и символа подчеркивания, начинающиеся не с цифры.

Язык Lua различает регистр символов, поэтому abc, Abc, ABC являются различными именами.

В таблице ниже приведены слова, которые зарезервированы языком Lua и не могут использоваться в именах переменных:

and break do else elseif

end false for function if

in local nil not or

repeat return then true until

Кроме того, все имена, начинающиеся с символа подчеркивания, за которым идут заглавные буквы (например, _VERSION) также являются зарезервированными.

Какие переменные бывают в Lua?

Переменные в Lua могут быть глобальными и локальными. Если переменная не объявлена явно как локальная, она считается глобальной.

Глобальные переменные Lua

Глобальная переменная появляется в момент присваивания ей первого значения. До присваивания первого значения обращение к глобальной переменной даёт nil.

Глобальная переменная существует до тех пор, пока существует среда исполнения скрипта и доступна любому Lua-коду, выполняемому в этой среде.

При необходимости удалить глобальную переменную можно явным образом, просто присвоив ей значение nil.

g = 1 — создаем глобальную переменную g со значением 1

g = nil — удаляем глобальную переменную g

Все глобальные переменные являются полями обычной таблицы, называемой глобальным окружением. Эта таблица доступна через глобальную переменную _G. Поскольку полями глобального окружения являются все глобальные переменные (включая саму _G), то _G._G == _G.

Локальные переменные Lua

Любые локальные переменные должны быть объявлены явно с использованием ключевого слова local. Объявить локальную переменную можно в любом месте скрипта. Объявление может включать в себя присваивание переменной начального значения. Если значение не присвоено, переменная содержит nil.

local a — объявляем локальную переменную a

local b = 1 — объявляем локальную переменную b, присваиваем ей значение 1

local c, d = 2, 3 — объявляем локальные переменные c и d, присваиваем им значения 2 и 3

Область видимости локальной переменной начинается после объявления и продолжается до конца блока.

Областью видимости переменной называется участок кода программы, в пределах которого можно получить доступ к значению, хранящемуся в данной переменной.

Под блоком понимается:

тело управляющей конструкции (if-then, else, for, while, repeat);

фрагмент кода, заключённый в ключевые слова do. end.

Если локальная переменная определена вне какого-либо блока, её область видимости распространяется до конца скрипта.

a = 5 — глобальная переменная a

local i = 1 — переменная i локальна в пределах скрипта

while i 1, 4, 9, 16, 25

local a — переменная а локальна внутри then

local a = 20 — переменная а локальна внутри do-end

Когда возможно, рекомендуется использовать локальные переменные вместо глобальных. Это позволит избежать «засорения» глобального пространства имён и обеспечит лучшую производительность (поскольку доступ к локальным переменным в Lua выполняется несколько быстрее, чем к глобальным).

Типы данных Lua

Какие типы данных поддерживает язык Lua?

Lua поддерживает следующие типы данных:

1. Nil (ничего). Соответствует отсутствию у переменной значения. Этот тип представлен единственным значением — nil.

2. Boolean (логический). К данному типу относятся значения false (ложь) и true (истина).

При выполнении логических операций значение nil рассматривается как false. Все остальные значения, включая число 0 и пустую строку, рассматриваются как true.

3. Number (числовой). Служит для представления числовых значений.

В числовых константах можно указывать необязательную дробную часть и необязательный десятичный порядок, задаваемый символами «e» или «E». Целочисленные числовые константы можно задавать в шестнадцатеричной системе, используя префикс 0x.

Примеры допустимых числовых констант: 3, 3.0, 3.1415926, 314.16e-2, 0xff.

4. String (строковый). Служит для представления строк.

Строковые значения задаются в виде последовательности символов, заключённой в одинарные или двойные кавычки:

b = ‘это вторая строка’

Строки, заключённые в двойные кавычки, могут интерпретировать C-подобные управляющие последовательности (escape-последовательности), начинающиеся с символа «\» (обратный слэш):

\t (горизонтальная табуляция),

Символ в строке также может быть представлен своим кодом с помощью escape-последовательности:

где ddd — последовательность из не более чем трёх цифр.

Кроме кавычек для определения строки могут также использоваться двойные квадратные скобки:

local a = [[Компания «Кронос»]]

Определение строки с помощью двойных квадратных скобок позволяет игнорировать все escape-последовательности, т. е. строка создаётся полностью так, как описана:

При определении строки с помощью двойных квадратных скобок учитываются символы табуляции и переноса.

Двойные скобки могут быть вложенными. Для того чтобы их не перепутать, между скобками вставляется символ«равно» (=):

local a = [=[определение строки [[string]] в Lua]=]

— будет срока: «определение строки [[string]] в Lua»

5. Function (функция). Функции в Lua могут быть записаны в переменные, переданы как параметры в другие функции ивозвращены как результат выполнения функций.

6. Table (таблица). Таблица представляет собой набор пар «ключ» — «значение», которые называют полями илиэлементами таблицы. Как ключи, так и значения полей таблицы могут иметь любой тип, за исключением nil. Таблицы не имеют фиксированного размера: в любой момент времени в них можно добавить произвольное число элементов.

Подробнее — в статье «Создание таблиц в Lua»

7. Userdata (пользовательские данные). Является особым типом данных. Значения этого типа не могут быть созданы или изменены непосредственно в Lua-скрипте.

Userdata используется для представления новых типов, созданных в вызывающей скрипт программе или в библиотеках, написанных на языке С. Например, библиотеки расширений Lua для «CronosPRO» используют этот тип для представления таких объектов, как:

банки данных (класс Bank);

базы данных (класс Base);

записи (класс Record) и т. п.

8. Thread (поток). Соответствует потоку выполнения. Эти потоки никаким образом не связаны с операционной системой и поддерживаются исключительно средствами самого Lua.

Как в Lua задать тип переменной?

Lua не предусматривает явного задания типа переменной. Тип переменной устанавливается в момент присвоения переменной значения. Любой переменной может быть присвоено значение любого типа (вне зависимости от того, значение какого типа она содержала ранее).

a = 123 — переменная a имеет тип number

a = «123» — теперь переменная a имеет тип string

a = true — теперь переменная a имеет тип boolean

a = <> — теперь переменная a имеет тип table

Переменные типа table, function, thread и userdata не содержат самих данных, а хранят ссылки на соответствующие объекты. При присваивании, передачи в функцию в качестве аргумента и возвращении из функции в качестве результата копирования объектов не происходит, копируются только ссылки на них.

a = <> — создаем таблицу. В переменную a помещается ссылка на таблицу

b = a — переменная b ссылается на ту же таблицу, что и a

a[1] = 10 — элементу таблицы с индексом 1 присвоено значение 10

Остальные данные являются непосредственными значениями.

Как в Lua получить тип переменной?

Тип значения, сохранённого в переменной, можно выяснить при помощи стандартной функции type. Эта функция возвращает строку, содержащую название типа («nil», «number», «string», «boolean», «table», «function», «thread», «userdata»).

t = type («это строка») — t равно «string»

t = type (123) — t равно «number»

t = type (type) — t равно «function»

t = type (true) — t равно «boolean»

t = type (nil) — t равно «nil»

t = type (CroApp.GetBank()) — t равно «userdata»

Как в Lua преобразовать тип переменной?

Lua при необходимости автоматически преобразует числа в строки и наоборот. Например, если строковое значение является операндом в арифметической операции, оно преобразуется в число. Аналогично числовое значение, встретившееся в том месте, где ожидается строковое, будет преобразовано в строку.

a = «10» + 2 — a равно 12

a = «10» + 2 — a равно «10 + 2»

a = «строка» + 2 — Ошибка! Невозможно преобразовать «строка» в число

Значение любого типа можно явным образом преобразовать в строку с помощью стандартной функции tostring.

a = tostring (10) — a равно «10»

a = tostring (true) — a равно «true»

a = tostring (nil) — a равно «nil»

a = tostring (<[1] = «это поле 1»>) — a равно «table: 06DB1058»

Из предыдущего примера видно, что содержимое таблиц функцией tostring не преобразуется. Выполнить такое преобразование можно с помощью функции render.

a = render (10) — a равно «10»

a = render (true) — a равно «true»

a = render (nil) — a равно «nil»

Для явного преобразования значения в число можно использовать стандартную функцию tonumber. Если значение является строкой, которую можно преобразовать в число (или уже является числом), функция возвращает результат преобразования, в противном случае возвращает nil.

a = tonumber («10») — a равно «10»

a = tonumber («10»..».5″) — a равно 10.5

a = tonumber (true) — a равно «nil»

a = tonumber (nil) — a равно «nil»

Расстановка комментариев в Lua

Комментарий в Lua начинается двумя знаками «минус» (—) и продолжается до конца строки.

local a = 1 — однострочный комментарий

Если непосредственно после символов «—» идут две открывающие квадратные скобки ([[), комментарий являетсямногострочным и продолжается до двух закрывающих квадратных скобок (]]).

local a = 1 — [[ многострочный

Двойные скобки в комментариях могут быть вложенными. Для того чтобы их не перепутать, между скобками вставляется знак равенства (=):

local a = [[Компания «Кронос»]] — [=[

local a = [[Компания «Кронос»]]

Количество символов «=» определяет вложенность:

local a = [=[определение некоторой строки [[string]] в языке Lua]=]

Операции, применяемые в Lua

В выражениях, написанных на Lua, могут применяться следующие виды операций:

1. Арифметические операции.

Lua поддерживает следующие арифметические операции:

^ (возведение в степень);

% (остаток от деления).

Арифметические операции применимы как к числам, так и к строкам, которые в этом случае преобразуются в числа.

2. Операции сравнения.

В Lua допустимы следующие операции сравнения величин:

Операции сравнения всегда возвращают логическое значение true или false.

Правила преобразования чисел в строки (и наоборот) при сравнениях не работают, т. е. выражение «0» == 0 даёт в результате false.

3. Логические операции.

К логическим операциям относятся:

Операция and возвращает свой первый операнд, если он имеет значение false или nil. В противном случае, операция возвращает второй операнд (причём этот операнд может быть произвольного типа).

a = (nil and 5) — a равно nil

a == (false and 5) — a равно false

a == (4 and 5) — a равно 5

Операция or возвращает первый операнд, если он не false и не nil, иначе он возвращает второй операнд.

a == (4 or 5) — a равно 4

a == (false or 5) — a равно 5

Логические операции and и or могут возвращать значения любых типов.

Логические операции and и or вычисляют значение второго операнда только в том случае, если его нужно вернуть. Если этого не требуется, второй операнд не вычисляется. Например:

a == (4 or f()) — вызова функции f() не произойдет

Операция not всегда возвращает true или false.

4. Операция конкатенации.

Для конкатенации (объединения) строк служит операция… (две точки).

a = «Кронос»..»-«..«Информ» — переменная a получит значение «Кронос-Информ»

Если один или оба операнда являются числами, выполняется их преобразование в строки.

a = 0..1 — переменная a получит значение «01»

5. Операция получения длины.

В Lua определена операция длины #, которую можно использовать для получения длины строки.

len = #a — len равно 6

len = #«ещё строка» — len равно 10

Приоритет операций в Lua

В языке Lua выполнение операций осуществляется в соответствии со следующим приоритетом (в порядке убывания):

Вызов скриптов из форм

С каждой формой (включая вложенные формы) связан отдельный скрипт, который обычно содержит функции, выполняющие обработку событий формы и её элементов.

Когда форма запускается, её скрипт загружается в глобальное окружение. При возникновении события формы или её элемента система вызывает сопоставленную этому событию функцию-обработчик.

Необходимо отметить, что скрипт формы, хотя и не содержит вызова функции module, фактически является модулем. Это означает, что переменные, объявленные в скрипте формы без ключевого слова local, не выносятся в глобальное окружение и доступны только внутри этого скрипта. Если необходимо сделать какое-либо значение доступным для скриптов других форм, его следует явным образом определить в глобальной таблице _G:

Другой скрипт форм сможет прочитать это значение следующим образом:

Блоки операторов (инструкций)

К основным операторам Lua относятся:

операторы для организации циклов.

Группа операторов может быть объединена в блок (составной оператор) при помощи конструкции do… end.

Блок открывает новую область видимости, в которой можно определять локальные переменные.

a = 5 — глобальная переменная a

local a = 20 — внутри do-end определяется локальная переменная а

Оператор присваивания в Lua

Присваивание изменяет значение переменной или поля таблицы. В простейшем виде присваивание может выглядеть так:

a = 1 — переменной a присвоено значение 1

a = b + c — переменной a присвоена сумма значений переменных b и с

a = f(x) — переменной a присвоено значение, возвращённое функцией f(x)

В Lua допускается так называемое множественное присваивание, когда несколько переменных, находящихся слева от оператора присваивания, получают значения нескольких выражений, записанных справа от оператора присваивания:

a, b = 1, 5*c — a равно 1; b равно 5*c

Если переменных больше чем значений, «лишним» переменным присваивается nil.

a, b, c = 1, 2 — a равно 1; b равно 2; c равно nil

Если значений больше чем переменных, «лишние» значения игнорируются.

a, b = 1, 2, 3 — a равно 1; b равно 2; значение 3 не использовано

Множественное присваивание можно использовать для обмена значениями между переменными:

a = 10; b = 20 — a равно 10, b равно 20

a, b = b, a — теперь a равно 20, b равно 10

Условный оператор (if) в Lua

Оператор if проверяет истинность заданного условия. Если условие является истинным, выполняется часть кода, следующая за ключевым словом then (секция then). В противном случае, выполняется код, следующий за ключевым словом else (секция else).

return a — если a больше b, вернуть a

return b — в противном случае — вернуть b

Секция else является необязательной.

Перед каждой итерацией цикла проверяется условие :

если условие ложно, цикл завершается и управление передаётся первому оператору, следующему за оператором while;

если условие истинно, выполняется тело цикла, после чего все действия повторяются.

while i > 0 do — цикл от 10 до 1

Для выхода из цикла до его завершения можно использовать оператор break.

while i > 0 do — ищем в массиве отрицательное значение

MsgBox («Индекс отрицательного значения: »..i)

MsgBox («Массив не содержит отрицательных значений»)

Подробнее об особенностях использования оператора break — в статье «Операторы break и return»

Цикл с постусловием (repeat) в Lua

Оператор repeat предназначен для организации циклов с постусловием и имеет следующий вид:

Тело цикла выполняется до тех пор, пока условие не станет истинным. Проверка условия осуществляется после выполнения тела цикла, поэтому в любом случае тело цикла выполнится хотя бы один раз.

— суммируем значения массива a, пока сумма не превысит 10

MsgBox («Сложено »..i..» элементов. Сумма равна «..sum)

Для выхода из цикла до его завершения можно использовать оператор break.

Подробнее об особенностях использования оператора break — в статье «Операторы break и return»

Циклы с оператором for в Lua

Оператор for предназначен для организации циклов и допускает две формы записи:

простую (числовой for);

расширенную (универсальный for).

Простая форма оператора for

Простая форма оператора for имеет следующий вид:

for var = exp1, exp2, exp3 do

Тело цикла выполняется для каждого значения переменной цикла (счётчика) var в интервале от exp1 до exp2, с шагом exp3.

Шаг может не задаваться. В этом случае он принимается равным 1.

for i = 1, 10 do — цикл от 1 до 10 с шагом 1

Выражения exp1, exp2 и exp3 вычисляются всего один раз, перед началом цикла. Так, в примере ниже, функция f(x) будет вызвана для вычисления верхнего предела цикла только один раз:

for i = 1, f(x) do — цикл от 1 до значения, возвращенного функцией f()

Переменная цикла является локальной для оператора цикла и по его окончании не определена.

for i = 1, 10 do — цикл от 1 до значения, возвращенного функцией f()

MsgBox («После выхода из цикла i равно »..i) — Неверно! i равно nil

Значение переменной цикла нельзя изменять внутри цикла: последствия такого изменения непредсказуемы.

Для выхода из цикла до его завершения используется оператор break.

for i = 1,#a do — ищем в массиве отрицательное значение

Источник

Синтаксис языка lua

Начиная с этой главы мы будем касаться уже непосредственно самого программирования, поэтому постарайтесь не пролистывать текст, а внимательно вчитываться. Иногда будем забегать вперёд, без этого никак, так что если будет что-то совсем непонятно, то в дальнейшем это будет подробно изложена.

Перед тем как начать изучать новый язык программирования, необходимо узнать правила, которые нужно соблюдать при написании кода. Синтаксис многих языков программирования очень схож и язык lua не является исключением, Так что если вы ранее программировали хотя бы на каком-то языке, например thinkScript изложенный на моём сайте, то вам будет немного легче. Но даже если это ваш первый язык программирования, то у вас скорее всего не возникнет никаких проблем, так как сверх сложно в этом ничего нет.

Синтаксис — это некие правила, по которым пишется программа. Я для себя разделяю правила на строгие и нестрогие, вы же можете не делать этого разделение, а я просто поясню какие правила я считаю строгими, а какие нет.

Под строгими правилами я понимаю такие правила, которые нарушать нельзя, иначе компьютер меня не поймет и программа работать не будет. Примером может выступать объявление переменной. Для меня будет удобно объявлять переменные следующей строкой

Для меня будет удобно писать таким образом, так как я много пишу программ на языке C#, но это будет совершенно неправильно при программирование на lua. Я должен соблюдать синтаксис, иначе ничего хорошего не получится.

К не строгим правилам я отношу по большей части правила форматирования. Хоть такие правила и не являются обязательными, но их желательно соблюдать. Так как если ваш код будет читать другой программист, то ему будет намного легче разобраться, и вам тоже будет легче читать чужие коды. Приведу пример на той же самой строке с объявлением переменной. Как вы можете видеть в конце установлен символ «;», в языке lua этот символ ставить не обязательно, но его установка не приводит к ошибке, поэтому данное правило я отношу к не строгим правилам.

В части нестрогих правил я оставляю за вами решение, хотите придерживайтесь этих правил, а хотите нет. Сами правила я описывать не буду, но вы их можете видеть в моих примерах, которые я буду приводить на этом сайте.

Комментарии в языке lua

Начнём мы пожалуй с комментариев. Комментарии это части кода которые никаким образом не воспринимаются компьютером, они предназначены лишь только для человека, помогают нам ориентироваться в программе при написании. Комментарии бывает однострочные и многострочные.
Однострочный комментарий — это строка которая начинается с определённых символов и заканчивается знаком переноса на новую строку. Такая строка будет полностью проигнорирована компьютером при выполнение написанного кода.
Однострочный комментарий начинается с двух символов тире в начале строки.

Многострочные комментарии состоят из нескольких строк. Начинается многострочный комментарий символами —[[ и заканчивается символами ]]

Все приведенные в примере строки будут проигнорирование при выполнении кода программы. Хочу обратить особое внимание на начало строки, символы —[[ должны быть неразрывными, не допускается устанавливать пробелы. Например код указанный ниже уже приводит к ошибке

Как видите я установил пробел между символами — и [[ это уже НЕ многострочный комментарий. Будьте внимательны при написании.

Также бывают случаи когда мы хотим вложить в многострочный комментарий ещё дополнительно комментарий. Компьютеру абсолютно всё равно, он игнорирует все строки комментариев, но при неправильном вложении комментариев происходит сбой, что приводит к ошибке при выполнении программы. Для того чтобы в многострочных комментариях использовать дополнительно многострочные комментарии необходимо писать таким образом

Думаю принцип вы поняли.
На этом с комментариями мы закончили.

Регистр букв в языке lua

Не менее важным является регистр, который мы используем при написании программ. Дело в том что язык lua является регистрозависимый, это означает что одно и тоже слово написанное с использованием разного регистра, означает абсолютно разные значения. Приведу пример.

В этом примере я объявил 3 переменных и присвоил им значения. Называются эти переменные абсолютно одинаково, но это три отдельные независимые переменные, они никак не связаны между собой. В строках 4 и 5 я также объявляю переменные, но в строке 4, значение переменной является сумма всех трёх ранее объявленных переменных. А вот стройка 5 написана с ошибкой, в ней я обратился к переменным которых не существует. Если вы попытаетесь выполнить такой код, то получите ошибку

attempt to perform arithmetic on global ‘NAme’ (a nil value)

А если уберете строку с ошибкой, то получите сообщение в котором будет написано число 37, то есть сумма всех трех переменных.

Регистр необходимо соблюдать всегда, а не только при объявлении переменных. Например если вы напишете слово local с заглавной буквы (Local) или все буквы сделать заглавными (LOCAL), то это приведет к ошибке.

Конечно в данном коде многое для вас сейчас может оказаться непонятно, что такое local, message, tostring … но не переживайте, всему этому будут посвящены отдельные главы на сайте.

Источник

Lua комментарии в коде

Комментарии в Lua (да и в любом языке программирования в принципе) — это та часть кода, которая не читается языком. Чтобы там ни находилось, язык это не прочтёт. Для него этого в принципе не существует.
Обычно применяется для описания скрипта, чтобы другие знали, что он из себя представляет, а также для создания пометок, чтобы можно было быстро найти скрипт среди тысяч строк кода.
А также полезен для того, чтобы можно было убрать часть скрипта при этом с возможностью возврата.

§1.1. Строчные комментарии.

В Lua выглядят следующим образом: два дефиса, стоящие друг к другу, — «—».

§1.2. Многострочные комментарии.

По названию всё ясно — при помощи них можно комментировать сразу несколько строк. Начало — «—[[», а конец — «]]».

Так ведь намного быстрее, не правда ли?

§1.3. Комментирование части строки.

Иногда бывает полезно сделать и такое. А сделать это можно при помощи многострочных комментариев.

Для тестирования эта вещь достаточно полезная. В интерпретаторе это функция print.

Достаточно элементарно.
—========================
§3. Типы данных в Lua.

Их всего восемь:
1. nil — абсолютное ничего. Означает отсутствие данных. Иногда появление nil может быть чревато ошибками.
2. boolean — логический тип данных. К нему относятся true (истина) и false (ложь). При выполнении логических операций false равнозначен nil.
3. number — и так всё прекрасно понятно. Десятичный разделитель в Lua — точка. В остальном проблем не должно возникнуть.
4. string — строка. Это отдельные параграф.
5. function — функция. Также отдельный параграф.
6. table — таблица. И снова отдельный параграф.
7. userdata — пользовательские данные.
8. thread — поток.

§3.1. Определение типов данных.

Принудительно этого делать не надо — Lua сам поймёт, что это за тип данных. Но иногда появляется необходимость понять, какой же тип данных использует та или иная переменная. Для этого придумали функцию type().

Все возможные строки, которые эта функция возвращает: «nil» (как строка, а не значение nil), «number», «string», «boolean», «table», «function», «thread» и «userdata».
—========================
§4. Несколько полезных базовых функций Lua.

dofile() — открывает файл по указанному пути и выполняет его содержимое как Lua задачу.
В скобках в кавычках должен быть написан путь до файла, его имя и, конечно же, расширение, потому что расширение файла может быть не *.lua, а любым другим, но при этом внутри него будут коды на Lua.
Путь должен должен быть записан в кавычках.

tonumber() — преобразует переменную в число. Не очень понимаю, как это работает. Если параметр уже является числом или строкой, конвертируемой в число, то tonumber() возвращает это число, иначе возвращает nil.
Основание может быть любым целым числом в диапазоне от 2 до 36 включительно.
Если основание больше 10, то символ «A» (как в верхнем, так и в нижнем регистре) представляет 10, «B» представляет 11 и так далее, символ «Z» представляет 35. При основании 10 (по умолчанию),
число может быть представлено в экспоненциальной форме.
Для других оснований можно указывать только беззнаковые целые числа.

_VERSION — глобальная переменная (не функция), возвращающая строку с версией интерпретатора.

Их здесь всего не четыре, как учили в школе, а шесть:
+
—
*
/
% (остаток от деления)
^ (возведение в степень)

Для более корректных вычислений можно применять скобки.
—========================
§6. Логические выражения.
Предисловие.

Логические выражения выполняют действие (или не одно), если вы полнилось какое-то другое действие (или, опять же, не одно).

§6.1. Логические операторы.

Прежде чем переходить к изучению логических выражений (по-простому — условий), надо бегло пройтись по условным операторам. Вот все они:

Не стоит ничего объяснять — на примере всё станет понятно:

Запись «if a then» эквивалентна «if a

= nil then» (если «а» не равна nil). То есть просто идёт проверка на существование переменной в принципе.

«else» выполняет другое действие, если условие c «if» не выполнилось.
Пример:

Важно знать, что блок «else» всегда один (то есть два и более else не допустимы) и всегда ставится в конце других условий.

§6.4. Условия с «elseif».

Блок «elseif» выполняет ряд других условий (или только одно), если предыдущие (или только одно) не выполнились.

Хотя в данном примере лучше not a > 4 заменить на a if not a then
.
end

Здесь проверятся несуществование переменной a. В данном случае эта переменная не указана, соответственно, условие выполнится.

§6.6. Несколько условий в одном if/elseif.

Для этого есть операторы and и or:

Ни a, ни b, ни c не должны быть равны nil в данном примере. Если хоть одна переменная окажется равной nil, условие не выполнится.

Условие не выполнится только в том случае, если все три переменные окажутся равны nil. Если хотя бы одна переменная окажется не равной nil, то условие выполнится.

Также бывают случаи, когда необходимо исключить из условия сразу несколько переменных, например a и c. Можно конечно сделать так:

Но есть более упрощённый вариант — использовать скобки:

Так же можно поступить и с or:

С подобными вполне конструкциями можно поэкспериментировать.

А с elseif всё абсолютно идентично.

§6.7. Функция rawequal.

Дополнительная функция, поверяющая равенство двух переменных. Возвращает тип данных boolean.

200?’200px’:»+(this.scrollHeight+5)+’px’);»> a = 1;
b = 1;

200?’200px’:»+(this.scrollHeight+5)+’px’);»> a = 1;
b = 1;

§7.1. Глобальные переменные.

Это присваивание переменной какого-либо значения до тех пор, пока ей не присвоится какое-либо другое значение:

Можно записывать сразу несколько переменных:

200?’200px’:»+(this.scrollHeight+5)+’px’);»> a = 1;
b = 2;

if a == 1 then
a = b;
end

§7.2. Локальные переменные.

Отличаются от глобальных тем, что локальная переменная может принимать любое значение, а для глобального присвоение присваиваемое значение должно при этом существовать как переменная.
Также присваивание теряется, дойдя до ближайшего end либо else, либо elseif. Если объявить переменную вне всяких выражений, она останется навсегда. Объявляется с помощью оператора local:

Не следует забывать, что перед знаком равно пишется значение, которое присваивается переменной, а после — сама переменная.

К этому оператору ещё вернёмся.

Как уже было сказано выше, локальные переменные объявляются на время скрипта:

Таким образом, одну и ту же переменную можно объявлять много раз в разных скриптах.

По возможности лучше всегда использовать локальные переменные — они помогают избежать хаоса в скриптах, лишних имён и прочего.
Да и длинные обращения можно урезать до одной буквы, тогда это сильно сэкономит время.

Продолжение следует.Категория: Программирование | Добавил: TranZIt (27 Июня 2016)Просмотров: 28122 | Комментарии: 6 | Рейтинг: 4.6/30 |
—>Теги : туториал, для новичков, уроки, язык программирования, программирование, кратко и понятно, основы, Скриптование, с подробными примерами, LUAДополнительные опции: