Fonctions sont des blocs de code que vous pouvez exécuter plusieurs fois sur commande. Vous pouvez également les connecter à des événements ou les assigner en tant que callbacks.
Fonctions de base
Une définition de fonction comprend :
- La portée de la fonction (globale ou locale).
- 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 rendez disponibles à la fonction et qui ne sont utilisés que dans la portée de la fonction. Par défaut, les fonctions n'ont pas de paramètres. 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 (somme) 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 est 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 attentes 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 des membres d'un objet, tel qu'une classe ou 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 deux-points (:) au lieu de la notation 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().
L'instruction table:Method() est fonctionnellement identique à table.Method(table), et lors de la définition d'une méthode, function table:Method() est identique à function table.Method(self). Ce comportement s'étend aux méthodes de Instance, car elles sont également dérivées de tables.
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 parent de la méthode. Lorsque vous appelez une méthode en utilisant la notation 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 parent 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 à un 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 à partir 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 les plus couramment utilisés incluent :
- MarketplaceService.ProcessReceipt, qui gère les achats de produits pour les développeurs.
- BindableFunction.OnInvoke, qui appelle la fonction lorsqu'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 lorsqu'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 de 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, à 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 du 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 nom, 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 finir avec 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 les scripts de module
Vous pouvez réutiliser des fonctions à travers plusieurs scripts en les stockant dans ModuleScripts. Les fonctions sont un type de donnée Luau, vous pouvez donc 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.
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é.
Le token variadique ... ne peut être utilisé que dans les fonctions définies comme variadiques ; les fonctions ou callbacks définis dans une fonction variadique ne peuvent pas utiliser le même ..., même s'ils sont eux-mêmes variadiques.
... ne se comporte pas comme une variable ordinaire et ne peut être passé dans d'autres fonctions, renvoyé ou mis dans une table.
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")
--[[ Sortie résultante :
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 passer, 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)
--[[ Sortie résultante :
Avant
x = 1
y + z = 5
Après
]]
Appeler une fonction variadique avec des tableaux
Si vous souhaitez passer un tableau d'valeurs à une fonction variadique globale, comme print(), vous pouvez utiliser la fonction globale unpack() pour passer les valeurs du tableau plutôt que le tableau lui-même.