Lua Academy · Leçon

Varargs et opérateur ...

Gérez des listes d’arguments de longueur variable à l’aide de ... et de select().

Varargs et opérateur ... est une leçon Lua Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Arguments variables

Une fonction Lua peut accepter un nombre variable d'arguments en utilisant ... (trois points) dans la liste des paramètres. À l'intérieur de la fonction, ... représente les arguments supplémentaires. Vous pouvez l'utiliser dans des expressions, le transmettre à d'autres fonctions ou le convertir en table.

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

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

select() pour les arguments variables

select(n, ...) retourne les arguments à partir de la position n. select("#", ...) retourne le nombre total d'arguments, y compris les valeurs nil. Cette méthode est plus sûre que #{...}, qui s'arrête au premier trou contenant nil.

local function inspect(...)
  local n = select("#", ...)
  print("count:", n)
  for i = 1, n do
    print(i, select(i, ...))
  end
end

inspect("a", "b", nil, "d")
-- count: 4
-- 1  a
-- 2  b
-- 3  nil
-- 4  d

Transmettre ... à une autre fonction

Vous pouvez transmettre directement les arguments variables à une autre fonction avec f(...). Lorsque ... apparaît comme dernier argument d'un appel, tous les arguments variables sont transmis. Cela est utile pour envelopper des fonctions ou pour la journalisation.

local function log(level, ...)
  io.write("[" .. level .. "] ")
  print(...)
end

log("INFO", "Server started on port", 8080)
log("ERROR", "File not found:", "config.lua")
-- [INFO] Server started on port  8080
-- [ERROR] File not found:  config.lua

table.pack et table.unpack

Convertissez les arguments variables en table avec table.pack(...), qui enregistre également leur nombre dans le champ n. Reconvertissez une table en arguments variables avec table.unpack(t, i, j). Ensemble, ces fonctions vous donnent un contrôle total sur les listes d'arguments variables.

local function pack_and_show(...)
  local packed = table.pack(...)
  print("n =", packed.n)
  for i = 1, packed.n do
    print(i, packed[i])
  end
end

pack_and_show(10, nil, 30)
-- n = 3
-- 1  10
-- 2  nil
-- 3  30

Arguments fixes et variables combinés

Une fonction peut avoir à la fois des paramètres fixes et variables. Les paramètres fixes viennent en premier ; ... capture le reste. Les paramètres fixes sont affectés avant que le reste ne soit placé dans ....

local function printf(fmt, ...)
  io.write(string.format(fmt, ...))
end

printf("Hello, %s! You are %d years old.\n", "Alice", 30)
printf("Pi is approximately %.4f\n", math.pi)

local function firstAndRest(first, ...)
  print("first:", first)
  print("rest count:", select("#", ...))
end
firstAndRest(1, 2, 3, 4)

Arguments variables dans un constructeur de table

Vous pouvez déployer directement les arguments variables dans un constructeur de table : {...}. Lorsqu'il est utilisé comme dernier élément, tous les arguments sont inclus. Cependant, les trous contenant nil peuvent fausser # — préférez table.pack lorsque vous avez besoin d'un nombre exact.

local function toArray(...)
  return {...}  -- collect all args as array
end

local arr = toArray("x", "y", "z")
for i, v in ipairs(arr) do
  print(i, v)
end
-- 1  x
-- 2  y
-- 3  z

Expressions avec arguments variables

... peut apparaître à n'importe quelle position d'une expression. Dans une affectation multiple, il se développe en toutes ses valeurs. Dans une expression arithmétique, seule la première valeur est utilisée. Comprendre ce comportement évite les erreurs subtiles lors du mélange de ... avec d'autres expressions.

local function first(...)
  local x = ...
  return x
end

print(first(10, 20, 30))  -- 10  (only first)

local function addFirst(n, ...)
  local x = ...
  return n + x
end
print(addFirst(5, 3, 99)) -- 8  (3 is first ...)

print() utilise des arguments variables

La fonction intégrée print() de Lua est elle-même une fonction à nombre variable d'arguments. Elle accepte un nombre quelconque d'arguments, convertit chacun en chaîne et les sépare par des tabulations. Comprendre cela vous aide à écrire des fonctions utilitaires similaires.

-- print is vararg
print(1, 2, 3)           -- 1  2  3
print("a", nil, "b")     -- a  nil  b
print()                  -- (empty line)

-- Reimplementing a simple print-like function
local function myprint(...)
  local parts = {}
  for i = 1, select("#", ...) do
    parts[i] = tostring(select(i, ...))
  end
  io.write(table.concat(parts, "\t") .. "\n")
end
myprint(10, nil, 30)

Transmettre des arguments avec pcall

Combinez pcall avec des arguments variables pour créer une enveloppe générique d'appel sécurisé. L'enveloppe accepte une fonction et un nombre quelconque d'arguments, l'appelle via pcall et retourne les résultats ou une erreur.

local function safeCall(fn, ...)
  local ok, result = pcall(fn, ...)
  if ok then
    return result
  else
    print("Error:", result)
    return nil
  end
end

local function divide(a, b)
  assert(b ~= 0, "division by zero")
  return a / b
end

print(safeCall(divide, 10, 2))   -- 5.0
print(safeCall(divide, 10, 0))  -- Error: ...

Modèle d'accumulation des arguments variables

Un modèle courant avec les arguments variables consiste à parcourir tous les arguments et à accumuler un résultat. Vous pouvez le faire avec une table locale ou en effectuant directement une somme avec select. Les deux approches sont valides ; l'approche avec une table est plus claire pour un grand nombre d'arguments.

local function average(...)
  local n = select("#", ...)
  if n == 0 then return 0 end
  local total = 0
  for i = 1, n do
    total = total + select(i, ...)
  end
  return total / n
end

print(average(10, 20, 30, 40))  -- 25.0
print(average(5))               -- 5.0

Vérification rapide

Que retourne select("#", 1, nil, 3) ?

Récapitulatif : arguments variables

Résumé :

function f(...) — accepte des arguments variables
select("#", ...) — compte de façon sûre, y compris les valeurs nil
select(n, ...) — valeurs à partir de la position n
table.pack(...) — convertit les arguments variables en table avec le nombre .n
table.unpack(t) — convertit une table en arguments variables
... en dernière position se développe complètement ; en position intermédiaire, il fournit une valeur

Questions Fréquemment Posées

La leçon « Varargs et opérateur ... » est-elle gratuite ?

Oui — le texte complet de « Varargs et opérateur ... » 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 « Varargs et opérateur ... » ?

Gérez des listes d’arguments de longueur variable à l’aide de ... et de select(). 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 3 sur 4.

Combien de temps prend la leçon « Varargs et opérateur ... » ?

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