Fonctions

Fonctions sont blocs de code que vous pouvez exécuter plusieurs fois sur commande. Vous pouvez également les connecter à des événements ou les assigner comme callbacks.

Fonctions de base

Une définition de fonction comprend :

• La portée de la fonction : globale ou local (ou const pour une fonction locale dont le nom ne peut pas être réassigné).
• Le mot-clé function.
• Le nom de la fonction en camelCase.
• Les paramètres de la fonction entre parenthèses (()).
• Le bloc de code, ou "corps", de la fonction.
• Le mot-clé end.

Le corps de la fonction s'exécute lorsque vous appelez la fonction. Pour appeler une fonction, tapez son nom suivi de parenthèses. Vous pouvez définir une variable pour accepter la valeur de retour ou utiliser la valeur de retour à la place d'une variable.

-- Cette fonction n'a pas de paramètres et retourne nil
local function addOneAndTwo()
	local result = 1 + 2
	print(result)
end
-- Appel d'une fonction sans retour
addOneAndTwo() -- 3

Paramètres

Les paramètres sont des variables que vous mettez à disposition de la fonction et qui ne sont utilisées que dans la portée de la fonction. Les fonctions n'ont pas de paramètres par défaut. Si vous appelez une fonction avec plus de paramètres qu'elle n'en attend, Luau ignore les paramètres supplémentaires. Si vous appelez une fonction avec moins de paramètres qu'elle n'en attend, Luau passe nil pour tous les paramètres manquants.

-- Cette fonction a deux paramètres : num1 et num2
local function addNumbers(num1, num2)
	print(num1 + num2)
end

addNumbers(2, 3) -- 5
addNumbers(5, 6, 7) -- 11
addNumbers(9) -- tentative d'effectuer une opération arithmétique (addition) sur un nombre et nil

Retour

Dans le corps de la fonction, le mot-clé return renvoie un résultat d'un calcul. Vous pouvez renvoyer plusieurs valeurs d'une seule fonction. return met fin à l'exécution de la fonction, et Luau s'attend à ce que le mot-clé end suive les instructions return, donc écrire du code entre la commande return et la commande end génère une erreur.

-- Cette fonction retourne une valeur de retour
local function addNumbers(num1, num2)
	local result = num1 + num2
	return result
end

print(addNumbers(1, 2)) -- 3
local seven = addNumbers(3, 4)
print(seven) -- 7

-- Cette fonction retourne plusieurs valeurs : somme et différence
local function addAndSubtract(num1, num2)
	local sum = num1 + num2
	local difference = num1 - num2
	return sum, difference
end

-- Appel d'une fonction et attente de plusieurs valeurs de retour
local sum, difference = addAndSubtract(2, 3)
print(sum) -- 5
print(difference) -- -1

Méthodes

Les méthodes sont des fonctions qui sont membres d'un objet, tel qu'une classe ou une table. Elles s'attendent à ce que l'objet lui-même (self) soit le premier argument. Lorsque vous appelez une méthode, utilisez la notation de deux-points (:) au lieu de la notation par point (.) pour passer self comme premier argument automatiquement.

Tous les objets dans Roblox descendent de Instance et ont des méthodes couramment utilisées, y compris Instance:Destroy(), Instance:Clone(), et Instance:FindFirstChild().

local Workspace = game:GetService("Workspace")

-- Détruire une partie avec la notation par point (fonction)
local firstPart = Instance.new("Part")
firstPart.Parent = Workspace
print(firstPart.Parent) -- Workspace
firstPart.Destroy(firstPart)
print(firstPart.Parent) -- nil

-- Détruire une partie avec la notation de deux-points (méthode)
local secondPart = Instance.new("Part")
secondPart.Parent = Workspace
print(secondPart.Parent) -- Workspace
secondPart:Destroy()
print(secondPart.Parent) -- nil

Définir des méthodes

Pour créer une méthode dans une table, utilisez le nom de la méthode comme clé et la fonction de la méthode comme valeur. Dans la définition de la méthode, le paramètre self fait référence à la table parente de la méthode. Lorsque vous appelez une méthode en utilisant la notation de deux-points, vous passez la table elle-même comme premier argument. Vous pouvez définir des paramètres pour une méthode, mais vous devez les lister après le paramètre self.

Dans l'exemple suivant, la table testButton a une méthode comme valeur de la clé changeEnabled. Vous pouvez vérifier que self fait référence à la table parente de la méthode en imprimant la valeur de self.enabled.

local testButton = {
	enabled = true,
	changeEnabled = function(self, isEnabled)
		self.enabled = isEnabled
		print(self.enabled)
	end
}

print(testButton.enabled) -- true
-- Appeler la méthode
testButton:changeEnabled(false) -- false

Callbacks

Les callbacks sont des fonctions qui s'exécutent en réponse à une autre fonction ou processus.

Callbacks de base

Les fonctions peuvent être passées dans d'autres fonctions, par exemple, une fonction anonyme peut être utilisée pour implémenter un callback que table.sort() utilise ensuite pour trier une liste de Players provenant de Players.GetPlayers().

local Players = game:GetService("Players")
local sortedPlayers = Players:GetPlayers()

table.sort(sortedPlayers, function(a, b)
	-- Utiliser un callback anonyme pour trier les joueurs par nom
	return a.Name < b.Name
end)

Dans l'API Roblox, les callbacks font référence à un membre de fonction en écriture seule, les callbacks se bloquent jusqu'à ce qu'ils retournent. Les callbacks largement utilisés incluent :

• MarketplaceService.ProcessReceipt, qui gère les achats de produits pour développeurs.
• BindableFunction.OnInvoke, qui appelle la fonction lorsque un script appelle BindableFunction:Invoke(...).
• RemoteFunction.OnClientInvoke, qui appelle la fonction lorsque le serveur appelle RemoteFunction:FireClient(player, ...) ou RemoteFunction:FireAllClients(...).
• RemoteFunction.OnServerInvoke, qui appelle la fonction lorsque un client appelle RemoteFunction:InvokeServer(...).

Pour définir un callback, assignez-lui une fonction. Par exemple, BindableFunction.OnInvoke est un callback de BindableFunction. Vous pouvez y définir une fonction nommée ou anonyme, et vous pouvez appeler (invoker) cette fonction en appelant la méthode :Invoke() sur le callback. Les arguments que vous passez à :Invoke() sont transmis au callback, et la valeur de retour de la fonction callback retourne à l'appelant de :Invoke().

local bindableFunction = Instance.new("BindableFunction")

bindableFunction.OnInvoke = function(number)
	return 2 * number
end

print(bindableFunction:Invoke(42)) -- 84

Techniques de fonction

Gestionnaires d'événements

Vous pouvez assigner une fonction, connue sous le nom de gestionnaire d'événements, pour s'exécuter lorsqu'un événement se déclenche. Par exemple, vous pouvez créer une fonction appelée onPlayerAdded() pour l'événement Players.PlayerAdded afin d'imprimer le nom de tout joueur qui rejoint. Pour plus d'informations, voir Événements.

local Players = game:GetService("Players")

local function onPlayerAdded(player)
	print(player.Name .. " a rejoint le jeu !")
end

Players.PlayerAdded:Connect(onPlayerAdded)

Fonctions anonymes

Vous pouvez créer des fonctions sans noms, connues sous le nom de fonctions anonymes, à utiliser comme callbacks et gestionnaires d'événements. Comme les fonctions nommées, les fonctions anonymes doivent commencer et se terminer par les mots-clés function et end, mais vous n'avez pas besoin du mot-clé local pour indiquer la portée locale car elles ont toujours une portée locale.

Dans l'exemple suivant, le callback pour la fonction task.delay() et le gestionnaire d'événements pour l'événement Players.PlayerAdded sont tous deux des fonctions anonymes.

-- Fonction anonyme dans un callback à task.delay()
task.delay(2, function(exactTimeElapsed)
	print(exactTimeElapsed) -- 2.0064592329945
end)

-- Fonction anonyme dans un gestionnaire d'événements
local Players = game:GetService("Players")
Players.PlayerAdded:Connect(function(player)
	print(player.Name .. " a rejoint le jeu !")
end)

Fonctions dans des scripts de module

Vous pouvez réutiliser des fonctions à travers plusieurs scripts en les stockant dans ModuleScripts. Les fonctions sont un type de données Luau, donc vous pouvez les stocker dans des tables avec d'autres données.

Fonctions variadiques

Une fonction variadique accepte un nombre quelconque d'arguments. Par exemple, Globals.LuaGlobals.print() est une fonction variadique.

print(2, "+", 2, "=", 2 + 2) --2 + 2 = 4
print(string.format("Le %s est un %s !", "gâteau", "mensonge")) -- Le gâteau est un mensonge !
print(string.char(115, 101, 99, 114, 101, 116)) -- secret

Définir des fonctions variadiques

Pour définir une fonction variadique, vous utilisez le token ... comme dernier ou seul paramètre (à ne pas confondre avec .., l'opérateur de concaténation). Vous pouvez mettre les valeurs ... dans une table pour plus de facilité d'utilisation.

local function variadic(named, ...)
	local arguments = {...} -- empaqueter les arguments supplémentaires dans une table
	print("Argument nommé =", named)
	for i, value in arguments do
		print("Entrée No.", i, "=", value)
	end
end

variadic(10, "Salut", 20, "Fonction Variadique")
--[[ Résultat :
Argument nommé = 10
Entrée No. 1 = Salut
Entrée No. 2 = 20
Entrée No. 3 = Fonction Variadique
]]

Transmettre des arguments

Vous pouvez définir des fonctions variadiques comme des wrappers autour d'autres fonctions pour transmettre, ou faire suivre, des arguments du wrapper aux autres fonctions.

local function printAround(functionToPrintAround, ...)
	print("Avant")
	functionToPrintAround(...)
	print("Après")
end

local function addNumbers(x, y, z)
	print("x =", x)
	print("y + z =", y + z)
end

printAround(addNumbers, 1, 2, 3)
--[[ Résultat :
Avant
x = 1
y + z = 5
Après
]]

Appeler une fonction variadique avec des tableaux

Si vous souhaitez passer un tableau de valeurs à une fonction variadique globale, comme print(), vous pouvez utiliser la fonction globale unpack() pour passer les valeurs du tableau au lieu du tableau lui-même.

local squares = {1, 4, 9, 16, 25}
print("Les cinq premiers nombres carrés sont :", unpack(squares))
-- Les cinq premiers nombres carrés sont 1 4 9 16 25