0Pricing
Lua Academy · Leçon

Notions de base sur les chaînes : concaténation et longueur

Utilisez .. pour la concaténation, # pour la longueur, ainsi que string.rep/reverse.

Notions de base sur les chaînes : concaténation et longueur 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.

Concaténation de chaînes avec ..

Lua utilise .. (deux points) pour concaténer des chaînes. Cela fonctionne avec les chaînes et les nombres (les nombres sont convertis automatiquement). Contrairement à + dans de nombreux langages, + est uniquement arithmétique en Lua : utiliser + sur des chaînes provoque une erreur.

local first = "Hello"
local second = "World"
print(first .. ", " .. second .. "!")  -- Hello, World!

-- Numbers auto-converted
local age = 30
print("Age: " .. age)   -- Age: 30

-- Bad: print("x" + "y")  ERROR: arithmetic on string

Opérateur de longueur #

L’opérateur # renvoie la longueur d’une chaîne en octets. Pour les chaînes ASCII, elle correspond au nombre de caractères. Pour les chaînes UTF-8 à plusieurs octets, # compte les octets et non les caractères : un emoji UTF-8 compte pour 4. Utilisez une bibliothèque UTF-8 pour obtenir des longueurs exactes en caractères.

print(#"hello")        -- 5
print(#"")             -- 0
print(#"café")         -- 5 (c,a,f,é=2bytes)

local s = "Lua"
for i = 1, #s do
  io.write(string.byte(s, i) .. " ")
end
print()  -- 76 117 97

string.rep et string.reverse

string.rep(s, n, sep) répète la chaîne s exactement n fois, avec un séparateur facultatif. string.reverse(s) inverse l’ordre des octets de la chaîne. Les deux fonctions renvoient de nouvelles chaînes : les chaînes Lua sont immuables.

print(string.rep("ab", 3))       -- ababab
print(string.rep("ha", 3, "-"))  -- ha-ha-ha
print(string.rep("x", 0))        -- (empty)
print(string.reverse("hello"))   -- olleh
print(string.reverse("12345"))   -- 54321

string.upper et string.lower

string.upper(s) et string.lower(s) convertissent les caractères ASCII. Ils ne gèrent pas Unicode : les caractères non ASCII restent inchangés. Pour une comparaison insensible à la casse, convertissez les deux chaînes en lower avant de les comparer.

print(string.upper("hello"))     -- HELLO
print(string.lower("WORLD"))     -- world
print(string.upper("Lua 5.4!"))  -- LUA 5.4!

-- Case-insensitive comparison
local a = "Hello"
local b = "hello"
print(a:lower() == b:lower())    -- true

Syntaxe des méthodes avec deux-points

Les fonctions de manipulation des chaînes peuvent être appelées avec la syntaxe à deux-points sur les valeurs chaîne : s:upper() au lieu de string.upper(s). Cela fonctionne parce que les chaînes possèdent une métatable avec __index = string ; toutes les fonctions de la bibliothèque de chaînes sont donc accessibles comme méthodes sur n’importe quelle chaîne.

local s = "  hello world  "
print(s:upper())         -- HELLO WORLD
print(s:len())           -- 15
print(s:rep(2, "|"))     -- same as string.rep(s,2,"|")

-- Chain calls
print(("lua"):upper():reverse())  -- AUL

Immuabilité des chaînes

Les chaînes Lua sont immutables. Vous ne pouvez pas modifier leurs caractères sur place. Chaque opération sur une chaîne crée une nouvelle chaîne. Pour les concaténations intensives dans des boucles, utilisez une table pour accumuler les morceaux, puis table.concat à la fin : c’est bien plus efficace que des .. répétés.

-- Efficient string building
local parts = {}
for i = 1, 5 do
  parts[i] = "item" .. i
end
local result = table.concat(parts, ", ")
print(result)  -- item1, item2, item3, item4, item5

-- Slow! Creates 5 intermediate strings:
-- local s = ""
-- for i = 1, 5 do s = s .. "item" .. i end

table.concat pour joindre des éléments

table.concat(t, sep, i, j) assemble les éléments d’un tableau en une chaîne en utilisant un séparateur. Cette fonction ne fonctionne qu’avec des valeurs chaîne et nombre : les tables ou les booléens provoquent une erreur. C’est la manière la plus rapide de construire des chaînes à partir de nombreux morceaux.

local parts = {"one", "two", "three", "four"}
print(table.concat(parts, ", "))          -- one, two, three, four
print(table.concat(parts, " | ", 2, 3))  -- two | three

-- Building CSV
local row = {1, "Alice", 95, true}
-- Need tostring for non-string values:
for i, v in ipairs(row) do row[i] = tostring(v) end
print(table.concat(row, ","))

Comparaison de chaînes

Les chaînes sont comparées lexicographiquement selon la valeur de leurs octets. En ASCII, les lettres majuscules précèdent les minuscules (A=65, a=97), donc "Z" < "a" est vrai. Utilisez string.lower des deux côtés pour un classement insensible à la casse.

print("abc" < "abd")    -- true
print("abc" < "abcd")   -- true (shorter)
print("Z" < "a")        -- true (Z=90, a=97)
print("10" < "9")       -- true (lexicographic!)
print(10 < 9)           -- false (numeric)

-- Sort strings case-insensitively
local words = {"Banana","apple","Cherry"}
table.sort(words, function(a,b) return a:lower()<b:lower() end)
print(table.concat(words,", "))

tostring et tonumber

tostring(v) convertit toute valeur en sa représentation sous forme de chaîne. tonumber(s, base) analyse une chaîne pour la convertir en nombre. tonumber renvoie nil si l'analyse échoue, contrairement à de nombreux langages qui lèvent une exception. La base peut être comprise entre 2 et 36 pour l'analyse d'entiers.

print(tostring(42))        -- 42
print(tostring(true))      -- true
print(tostring(nil))       -- nil
print(tostring({1,2}))     -- table: 0x...

print(tonumber("3.14"))    -- 3.14
print(tonumber("0xff"))    -- 255 (hex)
print(tonumber("11",2))    -- 3 (binary)
print(tonumber("abc"))     -- nil (invalid)

Internement des chaînes

Lua interne les chaînes courtes : les chaînes dont le contenu est identique partagent le même objet en mémoire. Ainsi, l'opérateur == appliqué aux chaînes revient effectivement à comparer des pointeurs après une vérification de hachage — c'est très rapide. L'internement entraîne également un léger surcoût lors de la création d'une chaîne (calcul du hachage), mais les chaînes répétées ne coûtent rien.

local s1 = "hello"
local s2 = "hel" .. "lo"

-- Same content, interned to same object
print(s1 == s2)   -- true
print(#s1)        -- 5

-- Long strings may not be interned
-- They are still compared correctly by value
local long1 = string.rep("x", 1000)
local long2 = string.rep("x", 1000)
print(long1 == long2)  -- true

Vérification rapide

Quelle est la manière la plus efficace de construire une longue chaîne à partir de nombreuses petites parties en Lua ?

Récapitulatif : notions de base sur les chaînes

Points essentiels :

  • .. effectue une concaténation ; n'utilisez jamais + pour les chaînes
  • #s compte les octets (et non les caractères Unicode)
  • s:upper(), s:lower(), s:rep(n, sep), s:reverse()
  • Les chaînes sont immuables : chaque opération renvoie une nouvelle chaîne
  • Construisez les chaînes volumineuses avec une table et table.concat
  • tostring/tonumber servent à convertir les types

Questions Fréquemment Posées

La leçon « Notions de base sur les chaînes : concaténation et longueur » est-elle gratuite ?

Oui — le texte complet de « Notions de base sur les chaînes : concaténation et longueur » 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 « Notions de base sur les chaînes : concaténation et longueur » ?

Utilisez .. pour la concaténation, # pour la longueur, ainsi que string.rep/reverse. 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 « Notions de base sur les chaînes : concaténation et longueur » ?

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. Notions de base sur les chaînes : concaténation et longueur
  2. Rechercher et extraire des sous-chaînes
  3. string.format pour la sortie
  4. string.gsub et string.gmatch
← Retour à Lua Academy