Lua/Функции

← Конструкции языка	Глава
Функции

В этой главе пойдет речь о функциях

О понятии функция

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

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

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

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

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

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

Функция в Lua

В Lua функция задается таким образом:

function func(a) 
    a = a + 1
    return a
end

То есть, функция (здесь ее зовут func) задается ключевым словом function и в нее передается аргумент а (та самая пшеница), после чего в функции ее значение увеличивается на 1 и из функции возвращается новая a. Тот код, который находится в функции, называется телом.

Как же нам понять, что вернет функция? Вызвать ее! Вы уже знакомы с функцией print() и вы прекрасно знаете, что она принимает в качестве аргументов и что делает. Попробуем воспользоваться прошлой функцией:

print(func(1)) --> 2

Она прибавит к нашему аргументу (равному 1) еще единицу и получит двойку. А мы хотим тройку:

print(func(func(1))) --> 3

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

Функции могут возвращать несколько значений. Например:

function func (a,b)
    a,b=b,a
    return a,b
end
print(func(15,5)) --> 5,15

Конечно же, эти значения можно присвоить переменным:

a,b = func (15,5) --> a = 5, b = 15
print(a,b) --> 5,15

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

function func (arg1,...)
    end

Здесь, многоточие - массив (в случае Lua - таблица) аргументов. Можно использовать и без аргумента arg1: мы лишь показали, что они могут использоваться вместе. Продемонстрируем пример использования:

function checker(...)
    for i in {...} do
        if i % 2 == 0 then 
            print(i) 
        end
    end
end

checker(1,2,3,4,5,6,7)

Заметьте, что для использования аргументов как таблицы их нужно помещать в скобки: {...}

Интересные особенности

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

print("15") как и print "15". Заметим, что нельзя аналогичным способом использовать 15(тут это число)
type({}) как и print {}

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

function func(a,b)
    print(a,b)
end 
func(1) --> 1 nil (то есть, а = 1, b = nil)
func(1,2,3) --> 1,2 (то есть 3 мы не использовали)

Аналогично работает и с возвращением значения функцией.

Тем не менее, мы не рекомендуем использовать эти особенности - они ухудшат читаемость кода и могут вас запутать. В свое время, первая особенность была убрана из Python(была в Python 2, но в Python 3 стали использовать скобки).

Функции могут заполнять списки значениями. Например:

function func ()
    a = 5
    b = 6
    return a,b
end

a = {func()}
print (a[1]) --> 5

← Конструкции языка