Fonctions en Lua : comment assembler le code en « briques » et arrêter de copier-coller 🧩

Ctrl+C → Ctrl+V → Ctrl+C → Ctrl+V → « Pourquoi rien ne fonctionne ?! » — ça vous dit quelque chose ? Alors, bienvenue.

Tu n'es pas un programmeur, tu es un copieur 😤

Soyons honnêtes. Chacun de nous a commencé comme ceci :

print("Hi Vasya!")
print("You are 20 years old")
print("----------")

print("Hi Masha!")
print("You are 22 years old")
print("----------")

print("Hi Dima!")
print("You are 19 years old")
print("----------")

25 lignes. Trois fois la même chose. Et quelque part, un remaniement pleure.

Imaginez maintenant que vous avez besoin de 50 de ces salutations. Ou 500. Ou le client dit le vendredi soir : « Et si on remplaçait ---------- sera ==========?». Et vous êtes assis, vous changez 500 séparateurs à la main.

Spoiler : il y a une meilleure façon. Et elle s'appelle - fonctions.

La fonction est votre petit assistant 🤖

Une fonction est un morceau de code auquel vous donnez un nom et que vous pouvez appeler autant de fois que vous le souhaitez. Une fois écrit, vous l'utilisez partout. Principe DRY en action (Don't Repeat Yourself — ne vous répétez pas).

Syntaxe de base :

function имяФункции()
  -- тут кодend

Nous réécrivons notre honte :

function greet(name, age)
  print("Hi, " .. name .. "!")
  print("To you " .. age .. " years")
  print("----------")
end

greet("Vasya", 20)
greet("Masha", 22)
greet("Dima", 19)

Il y avait 25 lignes — il y en a 9. Et si vous avez besoin de changer le séparateur ? On change en un seul endroit. UN SEUL. C'est beau.

Arguments : apprenons à la fonction à obéir 🎯

Les arguments (ou paramètres) sont ce que vous passez à la fonction pour qu'elle sache avec quoi travailler. C'est comme commander dans un café : vous ne dites pas simplement « faire de la nourriture », mais vous spécifiez — « un hamburger avec du fromage et sans oignons ».

function makeOrder(dish, extra, remove)
  print("Order: " .. dish)
  print("Add: " .. extra)
  print("Remove: " .. remove)
  print("---")
end

makeOrder("Burger", "cheese", "onion")
makeOrder("Pizza", "mushrooms", "anchovies")

Que s'est-il passé ici :

• dish, extra, remove — paramètres (slots variables à l'intérieur de la fonction)

• "Burger", "cheese", "onion" — arguments (valeurs spécifiques que nous transmettons)

Beaucoup de gens confondent ces deux mots. Techniquement, les paramètres sont dans la définition, les arguments sont dans l'appel. Mais si vous dites « argument » au lieu de « paramètre » lors d'un entretien, le monde ne s'effondrera pas. Très probablement.

Return : une fonction qui ne fait pas que donner, mais qui donne 📦

Parfois, la fonction ne doit pas seulement imprimer quelque chose, mais retourner le résultat. Pour cela, il y a return :

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

local result = add(5, 3)
print(result) -- 8

C'est comme la différence entre un cuisinier qui cuisine et mange lui-même le plat (fonction avec print) et un cuisinier qui vous donne une assiette (fonction avec return).

return rend la fonction réutilisable. Le résultat peut être enregistré dans une variable, transmis à une autre fonction, utilisé dans une condition :

function isAdult(age)
  return age >= 18end

if isAdult(20) thenprint("Welcome!")
elseprint("Wait a couple of years 😅")
end

Une nuance importante : après return la fonction se termine. Code après return jamais ne sera pas exécuté :

function test()
  return 42print("This line is a ghost 👻") -- никогда не выполнитсяend

Astuce Lua : plusieurs valeurs de retour 🤯

Contrairement à de nombreuses langues, Lua peut retourner plusieurs valeurs de la fonction. C'est vraiment pratique :

function getUser()
  return "Alexey", 25, "developer"end

local name, age, role = getUser()
print(name)  -- Алексейprint(age)   -- 25print(role)  -- developer

C'est comme si le coursier vous apportait non pas un colis, mais trois à la fois. Lua peut le faire, et c'est génial.

Fonctions locales : mettre de l'ordre 🧹

Dans Lua, les fonctions sont des valeurs régulières. Elles peuvent être affectées à une variable, transmises comme argument, et oui, elles peuvent être locales:

local function square(x)
  return x * x
end

print(square(5))  -- 25

Pourquoi local ? Pour que la fonction n'encombre pas l'espace de noms global. Dans les grands projets, les variables globales sont comme des chaussettes éparpillées dans la pièce. Cela semble fonctionner, mais trouver la bonne est un problème.

Règle de bon ton : toujours rendre les fonctions locales si elles ne doivent pas être accessibles de l'extérieur.

Fonctions anonymes : quand le nom est superflu 🥷

Parfois, une fonction n'a pas besoin d'un nom. Par exemple, si vous la passez comme argument :

local numbers = {3, 1, 4, 1, 5, 9}

table.sort(numbers, function(a, b)
  return a > b  -- сортировка по убываниюend)

for _, v in ipairs(numbers) doprint(v)
end-- 9, 5, 4, 3, 1, 1

Une fonction anonyme est comme un gobelet jetable. Utilisé et oublié. Pas besoin d'inventer un nom, pas besoin de le stocker dans une variable.

Fermetures (closures) : la magie du niveau « middle+ »

La fermeture est une fonction qui « se souvient » des variables de son environnement :

function createCounter()
  local count = 0return function()
    count = count + 1
    return count
  endend

local counter = createCounter()
print(counter())  -- 1print(counter())  -- 2print(counter())  -- 3

Que s'est-il passé ? La fonction interne a capturé la variable count de la fonction externe. Et même après que createCounter soit terminé, count continue de vivre à l'intérieur de la fermeture.

C'est comme si vous quittiez le café, mais que le serveur se souvienne encore de votre commande. C'est un peu effrayant, mais utile.

Où est-ce nécessaire ? Par exemple, pour créer des variables privées, des fabriques, des callbacks, et en général, c'est la base de la programmation fonctionnelle.

Vararg : quand vous ne savez pas combien d'arguments viendront 🎲

Parfois, vous ne savez pas à l'avance combien d'arguments seront transmis à la fonction. Pour cela, Lua a ... :

function sum(...)
  local args = {...}
  local total = 0for _, v in ipairs(args) do
    total = total + v
  endreturn total
end

print(sum(1, 2, 3))        -- 6print(sum(10, 20, 30, 40))  -- 100

... — c'est comme un buffet d'arguments. Prenez-en autant que vous voulez.

Erreurs fréquentes : le tableau de bord du débutant

1. J'ai oublié les parenthèses lors de l'appel

function sayHi()
  print("Hi!")
end

sayHi   -- ничего не произойдёт, это просто ссылка на функциюsayHi() -- вот так правильно!

2. Type d'argument incorrect

function double(n)
  return n * 2end

print(double("five")) -- ошибка! строку нельзя умножить

3. J'ai oublié le retour

function add(a, b)
  a + b  -- посчитал, но никуда не вернулend

local result = add(2, 3)
print(result) -- nil 😭

Cette erreur est le champion absolu. Vous pensez que la fonction renvoie quelque chose, mais elle calcule simplement en silence et jette le résultat dans le vide.

Refactoring : des spaghettis au chef-d'œuvre 🍝 → 🏗️

Imaginons que nous écrivons un mini-jeu. Voici le code «avant»:

-- Игрок атакует монстраlocal playerDamage = 10 + math.random(5)
local monsterHp = 50 - playerDamage
print("The player inflicted " .. playerDamage .. " damage")
print("Monster " .. monsterHp .. " HP")

-- Монстр атакует игрокаlocal monsterDamage = 5 + math.random(3)
local playerHp = 100 - monsterDamage
print("Monster inflicted " .. monsterDamage .. " damage")
print("Player " .. playerHp .. " HP")

Et voici « après » :

local function calcDamage(baseDamage, randomRange)
  return baseDamage + math.random(randomRange)
end

local function attack(attacker, target, baseDmg, randomRange, targetHp)
  local damage = calcDamage(baseDmg, randomRange)
  local remainingHp = targetHp - damage
  print(attacker .. " applied " .. damage .. " damage")
  print("U " .. target .. " " .. remainingHp .. " HP")
  return remainingHp
end

local monsterHp = attack("Player", "monster", 10, 5, 50)
local playerHp = attack("Monster", "player", 5, 3, 100)

Le code est devenu réutilisable, lisible et extensible. Voulez-vous ajouter un coup critique ? Vous changez une fonction, pas dix endroits.

📱 Vous voulez vous entraîner à Lua (et pas seulement) en pratique ?

La théorie, c'est bien, mais sans pratique, elle s'évapore de la tête en quelques jours. Vous connaissez ça, non ?

Nous avons créé une application Code — un endroit où vous pouvez apprendre la programmation avec un tas de tâches pratiques. Pas de théorie sèche de 500 pages, seulement des explications claires et des tâches qui vous font vraiment progresser. Ouvrez-le, résolvez les problèmes sur le chemin du travail, et vous êtes déjà un peu meilleur qu'hier.

Et nous avons aussi Chaîne Telegram pour les développeurs 💬 — messages utiles, analyses, aide-mémoire et mèmes (où sans eux). Plus de 2 000 développeurs sont déjà là : abonnez-vous, lisez dans un endroit pratique et répétez le matériel sans stress. 💪

Aide-mémoire : tout en un seul endroit 📋

Total

Les fonctions ne sont pas seulement « quelque chose dans un manuel ». C'est fondation code normal. Sans eux, vous écrivez une feuille, avec eux, vous construisez une architecture.

Rappelez-vous trois règles :

1. Si vous copiez le code plus de deux fois, mettez-le dans la fonction

2. La fonction doit faire une chose et la faire bien

3. Donnez des noms compréhensibles aux fonctions — calcDamage, et non f1 ou doStuff

Maintenant, allez refactoriser votre dernier projet. Nous savons tous les deux qu'il y a quelque chose à mettre dans les fonctions. 😏

Vous avez aimé l'article ? Partagez-le avec un ami qui fait encore du copier-coller. Il a besoin d'aide.