0Pricing
Lua Academy · Leçon

Définir et appeler des fonctions

Découvrez la syntaxe de déclaration des fonctions, les conventions d’appel et les fonctions locales ou globales.

Définir et appeler des fonctions est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Lua Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Lua Academy comprend 4 leçons au total.

Syntaxe des fonctions

Les fonctions Lua se définissent avec le mot-clé function. Le corps est un bloc terminé par end. Les fonctions peuvent être globales ou locales. Vous appelez une fonction en ajoutant des parenthèses contenant les arguments. Si vous omettez des arguments, les paramètres manquants reçoivent nil.

function sayHello(name)
  print("Hello, " .. (name or "World") .. "!")
end

sayHello("Lua")   -- Hello, Lua!
sayHello()        -- Hello, World!

local function add(a, b)
  return a + b
end
print(add(3, 4))  -- 7

Valeurs de retour

Les fonctions renvoient des valeurs avec return. Contrairement à la plupart des langages, les fonctions Lua peuvent renvoyer plusieurs valeurs. Si vous n’utilisez pas return explicitement, la fonction ne renvoie rien (zéro valeur). Les valeurs de retour excédentaires sont ignorées lorsque l’appel n’est pas la dernière expression d’une liste.

local function minMax(t)
  local lo, hi = t[1], t[1]
  for i = 2, #t do
    if t[i] < lo then lo = t[i] end
    if t[i] > hi then hi = t[i] end
  end
  return lo, hi
end

local lo, hi = minMax({5,2,8,1,9})
print(lo, hi)  -- 1  9

Fonction comme valeur

Les fonctions sont des valeurs de première classe en Lua. Vous pouvez les stocker dans des variables, les transmettre comme arguments à d’autres fonctions et les renvoyer. Cela permet les rappels, les fonctions d’ordre supérieur et les modèles de programmation fonctionnelle.

local ops = {
  add = function(a, b) return a + b end,
  sub = function(a, b) return a - b end,
  mul = function(a, b) return a * b end,
}

local function apply(op, a, b)
  return op(a, b)
end

print(apply(ops.add, 10, 3))  -- 13
print(apply(ops.mul, 4, 5))   -- 20

Fonctions locales ou globales

Utilisez local function pour les fonctions utilitaires privées d’un module. Les fonctions globales encombrent l’espace de noms global et sont accessibles depuis n’importe où, ce qui peut provoquer des conflits de noms. Dans la plupart des cas, préférez les fonctions locales et n’exposez que ce qui est nécessaire via une table de module.

-- Bad: pollutes global namespace
function helper() end

-- Good: module-local
local function helper()
  return "I am local"
end

-- Module export pattern
local M = {}
function M.publicFunc()
  return helper()  -- can call local
end
return M

Méthodes avec la syntaxe deux-points

Lua fournit une syntaxe abrégée pour définir et appeler des méthodes sur des tables. obj:method(arg) équivaut à obj.method(obj, arg). La forme avec deux-points transmet implicitement la table comme premier argument, généralement nommé self.

local Dog = {}
Dog.__index = Dog

function Dog.new(name)
  return setmetatable({name=name}, Dog)
end

function Dog:speak()
  print(self.name .. " says: Woof!")
end

local d = Dog.new("Rex")
d:speak()   -- Rex says: Woof!

Modèle des paramètres facultatifs

Lua ne possède pas de paramètres facultatifs intégrés, mais vous pouvez les simuler avec des vérifications de nil. Transmettez une seule table d’options aux fonctions qui possèdent de nombreux paramètres facultatifs : cette solution est plus claire qu’une longue liste d’arguments.

local function createUser(name, opts)
  opts = opts or {}
  return {
    name = name,
    role = opts.role or "user",
    active = opts.active ~= false,
    score = opts.score or 0,
  }
end

local u = createUser("Alice", {role="admin", score=100})
print(u.name, u.role, u.score)

Appels terminaux

Un appel terminal est un appel de fonction placé en dernière position (la dernière action avant le retour). Lua applique une optimisation des appels terminaux : un véritable appel terminal n’utilise pas d’espace supplémentaire sur la pile. Cela permet une récursion profonde sans débordement de pile lorsque l’appel récursif est en position terminale.

local function factorial(n, acc)
  acc = acc or 1
  if n <= 1 then return acc end
  return factorial(n - 1, n * acc)  -- tail call!
end

print(factorial(10))  -- 3628800
-- Can handle very large n without stack overflow

Fonctions appelées immédiatement

Vous pouvez définir et appeler immédiatement une fonction : (function() ... end)(). Cela est utile pour créer une portée locale, exécuter une initialisation exactement une fois ou éviter de polluer la portée externe avec des variables temporaires.

local result = (function()
  local temp = 100
  local adjusted = temp * 1.5
  return math.floor(adjusted)
end)()

print(result)   -- 150
-- temp and adjusted not visible here

Stocker des fonctions dans des tables

Stocker des fonctions dans des tables est une pratique idiomatique pour concevoir des modules Lua. La table sert d’espace de noms. Vous définissez les fonctions en les affectant à des champs de la table ou en utilisant la notation avec point ou deux-points et le nom de la table.

local math2 = {}

function math2.clamp(val, lo, hi)
  return math.max(lo, math.min(hi, val))
end

function math2.lerp(a, b, t)
  return a + (b - a) * t
end

print(math2.clamp(150, 0, 100))  -- 100
print(math2.lerp(0, 10, 0.5))   -- 5.0

Fermetures comme rappels

Les fonctions d’ordre supérieur acceptent des fonctions de rappel. En Lua, les rappels sont simplement des valeurs de fonction. Les fermetures sont particulièrement utiles comme rappels, car elles capturent le contexte de l’appel sans qu’il soit nécessaire de transmettre des arguments supplémentaires à la fonction d’ordre supérieur.

local function forEach(t, fn)
  for i, v in ipairs(t) do
    fn(v, i)
  end
end

local sum = 0
forEach({10, 20, 30}, function(v)
  sum = sum + v
end)
print(sum)   -- 60

forEach({"a","b","c"}, function(v, i)
  print(i, v)
end)

Vérification rapide

Quel est le résultat de : local function f() return 1, 2, 3 end; local a, b = f() ?

Récapitulatif : Fonctions

Points essentiels :

  • Utilisez local function pour éviter de polluer les variables globales
  • Les fonctions sont des valeurs de première classe : stockez-les dans des variables ou des tables, et transmettez-les comme arguments
  • La syntaxe avec deux-points transmet implicitement self
  • Simulez les paramètres facultatifs avec opts or {}
  • Les appels terminaux évitent le dépassement de la pile lors d'une récursion profonde
  • Les fonctions appelées immédiatement créent des portées isolées

Questions Fréquemment Posées

La leçon « Définir et appeler des fonctions » est-elle gratuite ?

Oui — le texte complet de « Définir et appeler des fonctions » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Lua Academy, passe à CoddyKit PRO. Le cours Lua Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Définir et appeler des fonctions » ?

Découvrez la syntaxe de déclaration des fonctions, les conventions d’appel et les fonctions locales ou globales. Tu pratiques Lua Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Lua Academy ?

Aucune expérience préalable n'est requise. Lua Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Définir et appeler des fonctions » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Lua Academy ?

Oui. Chaque leçon Lua Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Définir et appeler des fonctions
  2. Valeurs de retour multiples
  3. Varargs et opérateur ...
  4. Récursivité en Lua
← Retour à Lua Academy