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

Оператор for в расширенной форме имеет те же особенности, что и числовой for:

переменные цикла var1, var2, ..., varN являются локальными для оператора цикла и по его окончании не определены;

значения переменных цикла нельзя изменять внутри цикла.

В качестве примера использования расширенной формы оператора for рассмотрим типичный код, выполняющий обход всех полей таблицы.

for key, val in pairs(t) do

   MsgBox («key == »..key.."; val == "..val)

end

Список переменных в данном примере включает два элемента — key и val. На каждом шаге цикла переменная keyполучает ключ очередного поля таблицы t, а переменная val — соответствующее ключу значение поля. В список выражений входит только один элемент — вызов функции-фабрики итераторов pairs.

Работает расширенный оператор for следующим образом:

Вызывает функцию pairs(t), от которой принимает три значения:

стандартную функцию next в качестве итератора;

таблицу, которую требуется обойти (t), в качестве состояния;

nil в качестве начального значения управляющей переменной цикла.

Вызов функции pairs выполняется только один раз.

Оператор for приступает к выполнению, собственно, итераций цикла:

вызывает функцию-итератор next с двумя параметрами: таблицей t и nil. Функция next, вызванная с этими параметрами, возвращает начальный ключ таблицы и соответствующее ему значение (при условии, что таблица не пуста);

вновь вызывает функцию next, передавая ей таблицу t и ключ, полученный на первой итерации. Функция nextвозвращает следующую пару ключ-значение. Этот процесс продолжается до тех пор, пока функция next не вернётnil.

Описываемые действия можно представить в виде следующего кода:

do

   local f, s, next_key = pairs(t)

   while true do

      local key, val = f(s, next_key)

      next_key = key

      if next_key == nil then break end

      MsgBox(«key == »..key.."; val == "..val)

   end

end

Выполняющий все описанные действия цикл for можно реализовать и без использования функции pairs. Известно, чтоpairs возвращает функцию next и таблицу, которую следует обойти. Поэтому вызов pairs можно заменить списком соответствующих переменных:

for key, val in next, t do

   MsgBox («key == »..key.."; val == "..val)

end

Примечание

Помимо pairs, стандартные библиотеки Lua предоставляют ещё несколько функций-фабрик итераторов. Так, для перебора элементов массива предусмотрена функция ipairs, а для итерирования по строкам файла — функция io.lines.

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

Операторы break и return в Lua

Оператор break прерывает цикл (while, repeat или for), в теле которого встречается. В результате выполнения оператора break управление передаётся первой инструкции, следующей непосредственно за оператором цикла.

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

   if a[i] < 0 then — если найдено...

      index = i — сохраняем индекс найденного значения...

      break — и прерываем цикл

   end

end

Оператор return возвращает результаты из функции (или блока).

function f (x)

   return x^2

end

Оператор return может просто завершать работу функции (блока), не возвращая никаких результатов.

Обратите внимание

Операторы break и return могут быть только последними операторами блока (иначе следующие за ними операторы никогда не выполнятся). Если действительно необходимо вставить return или break в середину блока, например, чтобы временно отключить выполнение части кода функции, эти операторы следует заключить в свой блок do–end.

function f1 (x)

return — НЕВЕРНО!

<другие операторы>

end

function f2 (x)

   do return end — Правильно

   <другие операторы>

end

Создание таблиц в Lua. Работа с полями

Создать пустую таблицу можно следующим образом:

t = {}

Для доступа к полю таблицы используется запись вида:

имя_переменной[ключ]

t = {} — создаем пустую таблицу

t[1] = «first» — новое поле таблицы, с ключом 1 и значением «first»                               

t[2] = 20 — новое поле, с ключом 2 и значением 20

k = «name»

t[k] = «Jane» — новое поле, с ключом «name» и значением «Jane»

a = t[1] — переменная a получает значение «first»

b = t[2] — переменная b получает значение 20

c = t[«name»] — переменная c получает значение «name»

В случае строковых ключей вместо записи t[«name»] можно использовать запись t.name:

t.name = «name» — эквивалентно t[«name»] = «name»

a = t.name — эквивалентно a = t[«name»]

Обратите внимание

Выражение t.name не равнозначно t[name]. Первое выражение представляет поле таблицы, ключом которого являетсястрока «name» (то есть эквивалентно t[«name»]). Второе выражение представляет поле, ключом которого является значение переменной name. Различия между этими выражениями показаны в следующем примере:

t = {}

name = «somebody»

t[name] = «Jane» — в поле «somebody» помещено значение «Jane»

a = t[name] — переменная a получает значение поля «somebody» («Jane»)

b = t.name — поля «name» не существует, переменная b получает nil

c = t.somebody — переменная c получает значение поля «somebody» («Jane»)

Если поля таблицы с заданным ключом не существует, обращение к нему дает nil:

t = {}

a = t.name — переменная a получает значение nil

Для удаления поля таблицы достаточно присвоить ему nil:

t.second = nil

Таблицу можно заполнить значениями непосредственно при создании. Для этого в фигурных скобках следует перечислить ключи и значения элементов таблицы (в формате [ключ]=значение). Элементы отделяются друг от друга запятыми (,) или точками с запятой (;):

t = {[«red»]=«красный», [«green»]=«зеленый», [«blue»]=«синий»}

Приведённая запись эквивалентна следующему коду:

t = {}

t.red = «красный»; t.green = «зеленый»; t.blue = «синий»

В случае строковых ключей квадратные скобки (и двойные кавычки) можно не указывать:

t = {red=«красный», green=«зеленый», blue=«синий»}

Если необходимо создать таблицу, поля которой также являются таблицами, это можно сделать следующим образом:

points = {

            a = {x=20, y=1},

            b = {x=40, y=2}

         }

Приведённая запись эквивалентна следующему коду:

points = {}

p.a = {x=20, y=1},

p.b = {x=40, y=2}

Работа с массивами в Lua

Массив — это таблица, ключами которой являются целые положительные числа. Чтобы создать массив, достаточно перечислить в фигурных скобках значения его элементов:

t = {«красный», «зеленый», «синий»}

Это выражение эквивалентно следующему коду:

t = {[1]=«красный», [2]=«зеленый», [3]=«синий»}

Обратите внимание

В Lua массивы индексируются, начиная с 1 (а не с 0, как в некоторых языках программирования).

Оператор получения длины #, применённый к массиву, возвращает его максимальный индекс (или размер):

t = {«красный», «зеленый», «синий»}

n = #t — n равно 3

В примере ниже приведён ряд типичных для Lua синтаксических конструкций (идиом), основанных на использовании оператора #:

a = t[#t] — присвоим переменной a значение последнего элемента массива t

t[#t] = nil — удалим последний элемент массива t

t[#t+1] = a — добавим значение переменной a в конец массива t

Обратите внимание

При работе с массивами следует учитывать важную особенность оператора #. Этот оператор рассматривает любой неинициализированный (имеющий значение nil) элемент массива как признак конца массива. Поэтому, например, для таблицы:

t = {[1]=«first», [3]=«third»} — элемент с индексом 2 отсутствует (t[2]==nil)

оператор получения длины вернёт 1, а не 2 или 3. Таким образом, для корректной работы оператора # необходимо, чтобы массив не содержал «пустых» элементов.

Если таблица не содержит целочисленных ключей (либо элемент с индексом 1 равен nil), оператор # возвращает 0:

t = {red=«красный», green=«зеленый», blue=«синий»}

n = #t — n равно 0

t = {[2]=«красный», [3]=«зеленый», [4]=«синий»}

n = #t — n равно 0 (поскольку t[1] имеет значение nil)

Обход элементов таблицы в Lua

Для обхода всех элементов таблицы обычно используют расширенную форму оператора for совместно со стандартной функцией pairs.

t = { name = «Евгений»,

      surname = «Степанов»,

      age = 12

    }

for key, val in pairs(t) do

   MsgBox(key..": "..val)

end

На каждом шаге цикла переменная key получает ключ очередного поля таблицы t, а переменная val — соответствующее ключу значение поля. Цикл выполняется по всем полям таблицы.

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

t = { «Иванов», «Степанов», «Петров» }

for i, val in ipairs(t) do

   MsgBox("№"..i..": "..val)

end

На каждом шаге цикла переменная i получает числовой индекс очередного поля таблицы t, а переменная val— соответствующее индексу значение поля. Цикл продолжается до первого целого ключа, отсутствующего в таблице.

Примечание

При обходе массива необходимость в получении индекса зачастую отсутствует. В этом случае переменную i можно не вводить, заменив её символом подчеркивания (_).

t = { «Иванов», «Степанов», «Петров» }

for _, val in ipairs(t) do

MsgBox(val)

end

Обойти массив можно и с помощью обычного числового for.

t = { «Иванов», «Степанов», «Петров» }

for i = 1, #t do

   MsgBox(«Значение элемента №»..i..": "..t[i])

end

Определение функций в Lua

Типичное определение функции выглядит следующим образом:

function f(x,y)

   return x*y — тело функции

end

Как видно из этого примера, определение функции состоит из следующих элементов:

ключевого слова function;

имени (f в данном примере);

заключённого в круглые скобки списка аргументов функции (возможно, пустого);

тела функции, размещённого между закрывающей скобкой и ключевым словом end.

Приведённое выше определение функции является просто более удобным способом записи следующего выражения:

f = function (x,y)

   return x*y — тело функции

end

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

Создаёт объект типа «функция» (это делает выражение function (x,y)… end).

Помещает ссылку на созданную функцию в переменную или поле таблицы (в нашем примере — в переменную f).

Обратите внимание

Имя f принадлежит переменной, в которую помещена ссылка на функцию, но не самой функции. Любые функции в Lua анонимны, то есть не имеют имён. Когда говорят об имени функции, например, «функция f», на самом деле подразумевают переменную f, содержащую ссылку на эту функцию. У переменных, содержащих ссылки на функции, нет жёсткой привязки к самим функциям; работа с такими переменными осуществляется точно так же, как и с любыми другими переменными.

function f(x,y) return x*y end — создаем функцию, переменная f содержит ссылку на эту функцию

MsgBox(f(2,3))--> 6

s = f — переменная s ссылается на ту же функцию, что и f

MsgBox(s(2,3))--> 6

t = {}

t.sqr = f — поле sqr таблицы t ссылается на ту же функцию, что и f

MsgBox((t.sqr(2,3))--> 6

f = MsgBox — f теперь «превратилась» в функцию MsgBox

f(«Привет, мир!») --> «Привет, мир!»

Несмотря на то, что обычно ссылка на созданную функцию присваивается переменной, такое присваивание не является обязательным. В приведённом ниже примере создаётся безымянная функция, которая сразу передаётся в качестве параметра в функцию table.sort:

table.sort (t, function (a, b) return (a > b) end)

Вызов функций в Lua

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

a = f(2,3) — вызов функции f с двумя аргументами: 2 и 3

           — возвращаемое функцией значение помещается в переменную a

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

require «myscript» — то же самое, что и require («myscript»)

MsgBox [[Это многострочное значение]] — то же самое, что и MsgBox([[Это многострочное значение]])

render {x=1, y=2} — то же самое, что и render({x=1, y=2})

Ссылка на функцию может быть полем таблицы. В этом случае вызов функции будет выглядеть так:

t.f() — вызов функции, на которую ссылается поле f таблицы t

В Lua имеется возможность вызова функции в объектно-ориентированном стиле:

t:f() --эквивалентно t.f(t)

Таким образом, конструкция t:f() вызывает функцию, на которую ссылается поле f таблицы t, и эта же таблица передаётся в функцию в качестве неявного первого аргумента.

В качестве аргументов функция может принимать несколько значений. Если при вызове функции последние значения не заданы, им присваивается nil. Если значений больше, чем аргументов, «лишние» значения отбрасываются. Аргументы функции являются локальными переменными внутри функции.

function f(x, y) — определение функции

   MsgBox («x=»..tostring(x).."; "..«y=»..tostring(y))

end

f() — вызов функции. x, y равны nil

f(1) — вызов функции. x = 1, y равен nil

f(1, 2) — вызов функции. x = 1, y = 2

f(1, 2, 3) — вызов функции. x = 1, y = 2, 3 — лишний параметр

Функции с переменным числом аргументов в Lua

Функция может принимать переменное число параметров. Для этого список аргументов в определении функции должен заканчиваться многоточием (...).

function f(x, y, ...)

end

Все значения, скрытые за многоточием, передаются функции через локальную таблицу arg. Поле n этой таблицы содержит число переданных аргументов. Поэтому значения переданных в функцию аргументов можно получить, например, так:

function f(...)

   for i = 1, arg.n do

      MsgBox (tostring(arg[i]))

   end

end

f (1,2,3)

Возврат значений из функции Lua

Функции могут возвращать одно или несколько значений, а также не возвращать значений вообще.

function f0() — функция f0 не возвращает значений

   MsgBox («Вызвана функция f0»)

end

function f1()

   MsgBox («Вызвана функция f1»)

   return 1 — функция f1 возвращает одно значение

end

function f3()

   MsgBox («Вызвана функция f3»)

   return 1, 2, 3 — функция f3 возвращает три значения

end

f0() — вызов функции f0

a = f1() — вызов функции f1. a = 1

a, b, c = f3() — вызов функции f3. a = 1, b = 2, c = 3

Если количество возвращаемых функцией значений превышает число переменных, которым эти значения должны быть присвоены, «лишние» значения отбрасываются. Если возвращаемых значений меньше, чем переменных, отсутствующие значения заменяются nil.

a = f3() — a = 1, значения 2 и 3 отброшены

a, b, c = f3() — a = 1, b = 2, значение 3 отброшено

a, b, c = f0() — a = nil, b = nil, c = nil

a, b, c = f1() — a = 1, b = nil, c = nil

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

f3() — значения, возвращенные функцией f3, отброшены

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

local a, b, c = f3()

Как не задавать лишних имён переменных?

Здесь общепринятым способом является использование переменной с именем «_» (символом подчёркивания). Это упрощает внешний вид выражения и указывает на реально используемые переменные.

local _, _, c = f3() — нам нужно только третье возвращаемое значение

В данном случае, переменная «_» принимает первое, а потом второе возвращаемое значение.

Такой же подход часто используется в работе с итераторами:

for _, value in pairs() do

… — нам нужно только очередное значение, ключ будет присвоен переменной _

end

Обратите внимание

Переменная с именем «_» является обычной переменной. При использовании этой переменной в других выражениях, она будет переопределяться, т. е. содержать то значение, которое было ей присвоено в последний раз:

local _, _, c = f3() — переменная _ будет содержать второй параметр

...

f4(_, true) — первым параметром функуции f4 будет не пустое значение,

а значение содеражащееся в переменной _

Возврат значений при множественном присваивании

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

a, b, c, d = 5, f3() — a = 5, b = 1, c = 2, d = 3

a, b, c, d = f3(), 5 — a = 1, b = 5, c = nil, d = nil

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

t = {5, f3()} — t = {5, 1, 2, 3}

t = {f3(), 5} — t = {1, 5}

func (5, f3()) — вызов функции func с аргументами 5, 1, 2, 3

func (f3(), 5) — вызов функции func с аргументами 1, 5

return 5, f3() — возврат значений 5, 1, 2, 3

return f3(), 5 — возврат значений 1, 5

Возврат функций из функций

Функции можно возвращать из функций. Например:

function outer()

   function inner()

      return 1

   end

   return inner

end

local i = outer() — значение переменной i равно функции inner

local a = i() — вызываем функцию i, значение переменной a равно 1

Базовая библиотека стандартных функций Lua

Функции базовой библиотеки Lua

Функции базовой библиотеки Lua размещаются в глобальном контексте.

В базовую библиотеку входят следующие функции:

Имя функции — Описание

assert- Генерирует ошибку с необязательным сообщением об ошибке, если значение первого аргумента false или nil.

collectgarbage -Обеспечивает интерфейс к сборщику мусора. Первый аргумент определяет выполняемое действие (остановка, запуск сборщика мусора, выполнение сборки мусора и др.).

error- Завершает выполнение последней функции, вызванной в защищённом режиме, с заданным сообщением об ошибке.

getfenv — Возвращает таблицу контекста заданной функции. Аргумент, определяющий функцию, может быть как, собственно, Lua-функцией, так и числом, определяющим уровень стека, на котором расположена функция. Если он равен 0, возвращается глобальный контекст.

getmetatable- Если объект не имеет метатаблицы, возвращает nil. Иначе, если в метатаблице есть поле __metatable, возвращает значение этого поля. В противном случае возвращает метатаблицу объекта.

ipairs — Возвращает итератор, таблицу и 0. Возвращаемый итератор проходит таблицу по целочисленным индексам от значения 1 до первого индекса со значением nil. Итератор возвращает текущий индекс и соответствующее ему значение.

next- Возвращает следующий (после заданного) индекс в таблице и соответствующее ему значение. Позволяет последовательно получить все поля таблицы.

pairs — Возвращает итератор next(), таблицу и nil. Возвращаемый итератор проходит таблицу по всем значениям индекса. Итератор возвращает текущий индекс и соответствующее ему значение.

pcall — Вызывает заданную функцию с аргументами в защищённом режиме. Возвращает статус успешности выполнения.

rawequal — Сравнивает два объекта, без вызова каких-либо метаметодов. Возвращает значение типа boolean.

rawget- Возвращает реальное значение с заданным индексом из таблицы, без вызова каких-либо метаметодов.

rawset — Помещает значение в поле таблицы с заданным индексом, без вызова каких-либо метаметодов.

select — Если первый аргумент функции имеет числовое значение, возвращаются все аргументы, следующие за аргументом с этим номером. Если первый аргумент — строка ’#’, возвращается общее число полученных аргументов.

setfenv — Устанавливает таблицу в качестве контекста для заданной функции. Аргумент, задающий функцию, может быть числом, определяющим положение функции на стеке вызовов. Если он равен 0, устанавливается глобальный контекст текущего потока.

setmetatable — Устанавливает (удаляет) метатаблицу для данной таблицы. Если метатаблица содержит поле __metatable, генерирует ошибку.

tonumber — Пытается конвертировать аргумент в число. Если конвертирование не удаётся, возвращает nil.

tostring — Преобразует аргумент любого типа в строку.

type — Возвращает тип аргумента в виде строки.

unpack- Возвращает элементы из заданной таблицы.

xpcall — Вызывает заданную функцию в защищённом режиме. В отличие от pcall, позволяет установить обработчик ошибок. Не поддерживает передачу аргументов в функцию.

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

Помимо функций, базовая библиотека предоставляет также следующие глобальные переменные:

Имя переменной  Описание

_G  Таблица, содержащая глобальное окружение скрипта.

_M  Таблица, содержащая текущий модуль.

Библиотека для работы со строками Lua

Все функции для работы со строками собраны в таблице string. Поэтому для вызова функций используется запись вида:

string.имя_функции(...)

Например:

string.trim(s)

Поддерживается также объектно-ориентированная форма записи. Например:

s:trim() — эквивалентно string.trim(s)

В библиотеку для работы со строками входят следующие стандартные функции:

Имя функции- Описание

len- Возвращает длину строки.

rep — Возвращает строку, содержащую указанное число копий исходной строки.

lower — Заменяет все прописные буквы в строке на строчные.

upper — Заменяет в строке все строчные буквы на прописные.

reverse — Возвращает строку, в которой символы исходной строки расположены в обратном порядке.

format- Генерирует строку по форматной строке и аргументам по правилам, принятым в языке C.

byte — Возвращает числовые коды символов строки.

char — Преобразует набор числовых кодов символов в строку.

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

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

gmatch- Возвращает итератор, который на каждой итерации возвращает подстроку, соответствующую заданному шаблону.

sub — Возвращает подстроку исходной строки.

gsub — Возвращает копию исходной строки, в которой все вхождения шаблона заменены на строку, заданную третьим аргументом. Этот аргумент может быть строкой, таблицей или функцией.

dump- Возвращает строку, содержащую двоичное представление функции Lua с заданным именем.

Библиотека для работы с таблицами Lua

Все функции для работы с таблицами собраны в таблице table. Для вызова функций используется запись вида:

table.имя_функции(...)

Например:

table.maxn(t)

В данную библиотеку включены следующие стандартные функции:

Имя функции- Описание

insert- Вставляет элемент в заданную позицию таблицы, сдвигая остальные элементы таблицы вправо.

remove — Удаляет заданный элемент таблицы, сдвигая остальные элементы влево. Возвращает значение удалённого элемента.

sort- Сортирует элементы таблицы в заданном порядке. Вторым аргументом может быть задана функция, которая будет использована вместо стандартного оператора «<» для сравнения элементов в процессе сортировки.

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

maxn- Возвращает наибольший положительный числовой индекс в таблице. Возвращает 0, если таблица не имеет положительных числовых индексов.

Математическая библиотека Lua

Функции математической библиотеки Lua

Математические функции собраны в таблице math. Для вызова функций используется запись вида:

math.имя_функции(...)

Например:

math.abs(x)

В данную библиотеку включены следующие стандартные функции:

Имя функции- Описание

abs — Возвращает модуль числа.

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

floor- Возвращает наибольшее целое число, меньшее или равное заданному (выполняет округление «вниз»).

max- Возвращает максимальный из аргументов.

min- Возвращает минимальный из аргументов.

fmod- Возвращает остаток от деления одного числа на другое.

modf- Возвращает целую и дробную части исходного числа.

frexp- Возвращает нормализованную мантиссу и показатель аргумента.

ldexp- Строит число по мантиссе и показателю.

pow- Возводит число в степень. Вместо вызова функции возможно использование выражения вида x^y.

sqrt- Вычисляет квадратный корень числа. Вместо вызова функции возможно использование выражения вида x^0.5.

exp- Возвращает ex.

log- Вычисляет натуральный логарифм.

log10- Вычисляет логарифм по основанию 10.

cos- Вычисляет косинус угла, заданного в радианах.

sin- Вычисляет синус угла, заданного в радианах.

tan- Вычисляет тангенс угла, заданного в радианах.

cosh- Вычисляет гиперболический косинус.

sinh- Вычисляет гиперболический синус.

tanh- Вычисляет гиперболический тангенс.

acos- Вычисляет арккосинус (в радианах).

asin- Вычисляет арксинус (в радианах).

atan- Вычисляет арктангенс (в радианах).

atan2- Возвращает арктангенс x/y (в радианах), но использует знаки обоих параметров для вычисления «четверти» на плоскости. Также корректно обрабатывает случай когда y равен нулю.

deg- Переводит величину угла из радиан в градусы.

rad- Переводит величину угла из градусов в радианы.

random- Функция, вызванная без аргументов, возвращает псевдослучайное число из интервала [0, 1). Эта же функция, вызванная с аргументом n, возвращает целое псевдослучайное число из интервала [1, n]. Эта же функция, вызванная с двумя аргументами l, u возвращает целое псевдослучайное число из интервала [l, u].

randomseed     Устанавливает стартовое число генератора псевдослучайных чисел.

Переменные математической библиотеки Lua

Таблица math предоставляет следующие переменные:

Имя переменной — Описание

huge- Наибольшее представимое число.

pi- Число пи.

Библиотека ввода/вывода в Lua

Библиотека ввода-вывода предоставляет два различных «стиля» для работы с файлами.

Использование неявных дескрипторов файлов

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

Для вызова функций используется запись вида:

io.имя_функции(...)

Например:

io.close()

Ниже приведён список стандартных функций ввода/вывода, предоставляемых таблицей io:

Имя функции — Описание

open- Открывает файл в заданном режиме.

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

output- Аналогична io.input, но работает со стандартным файлом вывода.

close- Закрывает файл. Эквивалентна file:close. Вызванная без параметра, закрывает стандартный файл вывода.

read- Аналогична io.input():read.

lines- Открывает файл с заданным именем в режиме чтения и возвращает функцию-итератор (iterator function), которая при каждом последующем вызове возвращает новую строчку из файла. При обнаружении функцией-итератором конца файла, она возвращает nil (для окончания цикла) и автоматически закрывает файл. Вызов io.lines без указания имени файла эквивалентен io.input():lines(); таким образом, он обрабатывает строки стандартного файла ввода. В этом случае файл по окончанию итераций не закрывается автоматически.

write- Эквивалентна io.output():write.

flush- Сохраняет все данные, записанные в стандартный поток вывода. Эквивалентна file:flush для стандартного потока вывода.

tmpfile- Возвращает дескриптор для временного файла. Этот файл открывается в режиме изменения и автоматически удаляется при завершении программы.

type- Проверяет, является ли объект, переданный функции в качестве параметра, корректным дескриптором файла. Возвращает строку «file», если объект является открытым дескриптором файла; строку «closed file» — если объект является закрытым дескриптором файла; nil — если объект не является дескриптором файла.

Использование явных дескрипторов файлов

При использовании явных файловых дескрипторов сначала создаётся объект-дескриптор file (для этого используется функция io.open), после чего все операции с файлом выполняются при помощи методов данного дескриптора.

Для вызова методов используется запись вида:

handle: имя_метода(...),

где handle — имя переменной, содержащей объект-дескриптор.

Ниже приведён список стандартных функций ввода/вывода, предоставляемых объектом file:

Имя функции- Описание

read- Читает данные из файла в соответствии с заданными форматами.

lines- Возвращает функцию-итератор, которая при каждом вызове возвращает новую строку из файла. В отличие от io.lines, эта функция не закрывает файл по окончании цикла (т. е. достижении конца файла). При вызове функции без параметров, возвращает текущий файл ввода по умолчанию. В случае ошибок, данная функция возбуждает ошибку вместо того, чтобы возвратить код ошибки.

write- Записывает в файл значения всех своих аргументов.

flush- Сохраняет все данные, записанные в файл.

setvbuf- Устанавливает режим буферизации для выходного файла.

seek- Устанавливает текущую позицию в файле.

close- Закрывает файл.

Библиотека для доступа к средствам операционной системы в Lua

Функции, обеспечивающие доступ к средствам операционной системы, собраны в таблице os. Для вызова функций используется запись вида:

os.имя_функции(...)

Например:

os.clock()

В данную библиотеку включены следующие стандартные функции:

Имя функции- Описание

clock- Возвращает примерное количество времени (в секундах), которое программа выполнялась на CPU.

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

difftime- Возвращает число секунд, прошедшее от времени t1 до времени t2.

execute- Передаёт заданную команду на исполнение оболочке операционной системы.

getenv- Возвращает значение заданной переменной окружения или nil, если переменная не определена.

remove- Удаляет файл или папку с заданным именем. Папки должны быть пусты.

rename-  Переименовывает файл или папку.

time- Возвращает текущее время при вызове без аргументов, или время и дату, указанные в передаваемой таблице. Эта таблица должна иметь поля year, month, и day, и может иметь поля hour, min, sec, и isdst.

tmpname- Возвращает строку с именем файла, который может быть использован в качестве временного файла. Файл должен быть явно открыт до использования и явно удалён, если больше не будет 

www.cronos.ru/kb-cronospro-lua.html