Lua Academy · Leçon

Valeurs de retour multiples

Renvoyez et récupérez plusieurs valeurs à partir d’un seul appel de fonction.

Valeurs de retour multiples est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Retourner plusieurs valeurs

Contrairement à la plupart des langages, les fonctions Lua peuvent retourner nativement plusieurs valeurs à partir d'une seule instruction return. Les valeurs multiples sont séparées par des virgules après return. Cela évite d'avoir recours à des objets enveloppes ou à des paramètres de sortie.

local function divmod(a, b)
  return math.floor(a / b), a % b
end

local quotient, remainder = divmod(17, 5)
print(quotient, remainder)   -- 3  2

Ajuster les valeurs de retour

Lua ajuste les valeurs de retour pour correspondre au nombre de récepteurs. Les valeurs supplémentaires sont supprimées ; les valeurs manquantes deviennent nil. Cet ajustement a lieu lorsqu'un appel de fonction n'est pas la dernière expression d'une liste — à cette position, seule la première valeur est conservée.

local function triple()
  return 10, 20, 30
end

local a, b, c = triple()
print(a, b, c)      -- 10  20  30

local x, y = triple()
print(x, y)         -- 10  20  (30 discarded)

local p = triple()
print(p)            -- 10  (only first when 1 var)

Ajustement en position intermédiaire

Lorsqu'un appel de fonction apparaît au milieu d'une liste d'expressions (et non en dernière position), Lua le tronque à une seule valeur. Seule la dernière expression de la liste peut produire plusieurs valeurs.

local function pair()
  return 1, 2
end

-- pair() in middle: only 1 value used
local t = {pair(), pair()}
print(#t, t[1], t[2], t[3])  -- 3  1  1  2
-- first pair() gives just 1; last pair() gives 1,2

-- pair() at end: all values used
local t2 = {10, pair()}
print(#t2, t2[1], t2[2], t2[3])  -- 3  10  1  2

Les parenthèses imposent une seule valeur

Placer un appel de fonction entre parenthèses force celui-ci à retourner exactement une valeur. Cela est utile lorsque vous ne voulez que la première valeur de retour, quel que soit le nombre de valeurs produites par la fonction.

local function coords()
  return 10, 20, 30
end

print(coords())    -- 10  20  30  (all three)
print((coords()))  -- 10  (parentheses: single value only)

local x = (coords())
print(x)           -- 10

Valeurs retournées par string.find

De nombreuses fonctions de la bibliothèque standard utilisent plusieurs valeurs de retour. string.find retourne les positions de début et de fin d'une correspondance (ainsi que les captures). math.modf retourne les parties entière et fractionnaire. Comprendre ces modèles vous aide à utiliser la bibliothèque standard avec aisance.

local s = "hello world"
local start, finish = string.find(s, "world")
print(start, finish)   -- 7  11

-- math.modf: integer and fractional parts
local int, frac = math.modf(3.75)
print(int, frac)       -- 3   0.75

Capturer avec table.pack

table.pack(...) capture tous les arguments (ou toutes les valeurs de retour via ...) dans une table. La table contient un champ n indiquant le nombre total d'éléments, y compris les valeurs nil. Cela préserve le nombre exact, contrairement à #, qui s'arrête au premier trou.

local function getData()
  return "Alice", 30, nil, true
end

local t = table.pack(getData())
print(t.n)         -- 4
print(t[1])        -- Alice
print(t[2])        -- 30
print(t[3])        -- nil
print(t[4])        -- true

table.unpack pour déployer les valeurs

table.unpack(t, i, j) retourne les éléments d'une table sous forme de valeurs individuelles. C'est l'inverse de table.pack. Utilisez-le pour transmettre le contenu d'une table comme arguments à une fonction ou pour déployer des valeurs dans une instruction de retour.

local args = {10, 20, 30}

local function sum3(a, b, c)
  return a + b + c
end

print(sum3(table.unpack(args)))  -- 60

-- Use in return
local function passThrough(t)
  return table.unpack(t)
end
print(passThrough({5, 6, 7}))   -- 5  6  7

Retours de type erreur

Une convention courante en Lua consiste à retourner nil, errorMessage en cas d'échec et le résultat en cas de réussite. Le code appelant vérifie la première valeur de retour : si elle vaut nil, une erreur s'est produite. Cela évite les exceptions dans les cas d'échec prévus.

local function openConfig(path)
  local f = io.open(path, "r")
  if not f then
    return nil, "cannot open: " .. path
  end
  local content = f:read("*a")
  f:close()
  return content
end

local data, err = openConfig("config.lua")
if not data then
  print("Error:", err)
end

Échanger des valeurs avec plusieurs retours

Les valeurs de retour multiples résolvent élégamment le problème de l'échange. Le membre de droite est évalué avant l'affectation, de sorte que a, b = b, a échange correctement les valeurs sans variable temporaire.

local a, b = 5, 10
print(a, b)   -- 5  10

a, b = b, a
print(a, b)   -- 10  5

-- Works for three-way rotation too
local x, y, z = 1, 2, 3
x, y, z = z, x, y
print(x, y, z)  -- 3  1  2

Convention de retour de pcall

pcall(f, ...) utilise lui-même plusieurs valeurs de retour : la première est un booléen (true en cas de réussite, false en cas d'erreur), et les suivantes sont soit les valeurs retournées par f, soit le message d'erreur. Vérifiez toujours la première valeur de retour avant d'utiliser les autres.

local function risky(x)
  if x < 0 then error("negative input") end
  return math.sqrt(x)
end

local ok, result = pcall(risky, 16)
print(ok, result)   -- true  4.0

ok, result = pcall(risky, -1)
print(ok, result)   -- false  input:2: negative input

Vérification rapide

Que produit print((string.find("hello", "ll"))) ?

Récapitulatif : plusieurs valeurs de retour

À retenir :

Retourner plusieurs valeurs : return a, b, c
Les valeurs supplémentaires sont supprimées ; les valeurs manquantes deviennent nil
Les appels en position intermédiaire sont tronqués à 1 valeur
(f()) force exactement 1 valeur
table.pack/table.unpack permettent de gérer des listes de valeurs dynamiques
Convention : retourner nil, errmsg en cas d'échec

Questions Fréquemment Posées

La leçon « Valeurs de retour multiples » est-elle gratuite ?

Oui — le texte complet de « Valeurs de retour multiples » 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 « Valeurs de retour multiples » ?

Renvoyez et récupérez plusieurs valeurs à partir d’un seul appel de fonction. 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 2 sur 4.

Combien de temps prend la leçon « Valeurs de retour multiples » ?

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

← Retour à Lua Academy