Functions in Luau

Defining and Calling Functions

In Luau, functions are reusable blocks of code that can be defined and executed when needed. To define a function, use the function keyword followed by the function name and parentheses. Here's a simple example:

function greet()
    print("Hello, world!")
end

To call the function, simply use its name followed by parentheses:

greet()  -- Output: Hello, world!

Parameters and Return Values

Functions can accept parameters, which are values passed into the function. You can define parameters by adding them inside the parentheses when defining the function. Here's an example:

function add(a, b)
    return a + b
end

In this case, a and b are parameters. You can call this function with arguments like this:

local sum = add(5, 3)  -- sum will be 8

Functions can also return values. In the example above, the add function returns the sum of a and b.

Multiple Returns

Luau functions can return multiple values. This is useful when you want to return more than one piece of information. Here's how to do it:

function divide(a, b)
    return a / b, a % b  -- Returns quotient and remainder
end

You can capture multiple return values like this:

local quotient, remainder = divide(10, 3)
print(quotient)  -- Output: 3.3333
print(remainder)  -- Output: 1

Anonymous Functions

An anonymous function is a function that does not have a name. You can create anonymous functions and assign them to variables or pass them as arguments. Here's an example:

local square = function(x)
    return x * x
end

print(square(4))  -- Output: 16

Anonymous functions are often used for callbacks or in higher-order functions, such as:

local numbers = {1, 2, 3, 4}
local doubled = {}  

for i, v in ipairs(numbers) do
    doubled[i] = function() return v * 2 end
end

print(doubled[1]())  -- Output: 2

Methods and Colon Syntax

In Luau, methods are functions that belong to tables. You can define a method using the colon syntax, which automatically passes the table as the first argument (commonly referred to as self). Here's an example:

local Dog = {}

function Dog:bark()
    print("Woof!")
end

local myDog = Dog
myDog:bark()  -- Output: Woof!

In this case, the bark method is defined for the Dog table, and when called, it can access the table's properties if needed.

Conclusion

Functions are a fundamental part of programming in Luau. Understanding how to define, call, and utilize parameters and return values will enhance your scripting skills. By mastering anonymous functions and methods using colon syntax, you can write more organized and efficient code in your Roblox projects.