Lua Academy · Leçon

Construire un client

Demandez des données à un serveur.

Construire un client 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.

Cycle de vie d'un client

Un client TCP suit un cycle de vie clair : créer un socket, se connecter à un serveur, échanger des données, puis fermer la connexion.

Dans LuaSocket, chaque étape correspond à un appel de méthode, et chacune peut échouer. Un client bien écrit vérifie chaque valeur renvoyée et nettoie son socket sur chaque chemin d'erreur.

local socket = require("socket")
local client = assert(socket.tcp())

Se connecter en toute sécurité

Définissez un délai d'attente de connexion avant d'appeler connect afin qu'un hôte indisponible ne bloque pas votre programme. Quelques secondes constituent une valeur habituelle.

Si connect renvoie nil, consignez l'erreur et abandonnez. Ne supposez jamais que la poignée de main a réussi.

client:settimeout(5)
local ok, err = client:connect("127.0.0.1", 8080)
if not ok then
  client:close()
  error("connect failed: " .. err)
end

Utiliser socket.connect

Dans le cas courant, socket.connect(host, port) regroupe la création et la connexion. Il renvoie un objet client prêt à l'emploi, ou nil et une erreur.

Cette forme est concise, mais elle ne vous permet pas de définir un délai d'attente avant la poignée de main. Préférez donc la forme explicite sur les réseaux peu fiables.

local socket = require("socket")
local client, err = socket.connect("example.com", 13)
if not client then error(err) end

Envoyer une requête

Une fois connecté, écrivez les octets de votre requête avec send. De nombreux protocoles textuels délimitent les lignes par un retour chariot suivi d'un saut de ligne (\r\n).

Comme TCP est un flux, terminez clairement chaque message logique afin que le serveur sache où il se termine.

local msg = "PING\r\n"
local sent, err = client:send(msg)
if not sent then error("send failed: " .. err) end

Lire une réponse ligne par ligne

Pour les protocoles fondés sur des lignes, lisez en boucle avec le motif "*l". Chaque appel renvoie une ligne sans son terminateur.

En cas de nil, examinez l'erreur : "closed" signifie que le serveur a fermé la connexion, tandis que "timeout" signifie qu'aucune donnée n'est arrivée à temps.

client:settimeout(5)
local line, err = client:receive("*l")
if line then
  print("server said:", line)
else
  print("recv error:", err)
end

Lire une réponse complète

Les protocoles requête/réponse lisent souvent toutes les données jusqu'à ce que le serveur ferme la connexion. Utilisez "*a" pour capturer le corps complet.

Si vous fermez d'abord partiellement votre côté émission avec shutdown("send"), le serveur détecte la fin des données reçues et peut terminer sa réponse.

client:send("GET DATA\r\n")
client:shutdown("send")
local body, err = client:receive("*a")
print(#(body or ""), "bytes received")

Délimitation par longueur fixe

Les protocoles binaires préfixent souvent chaque message par sa longueur. Lisez d'abord l'en-tête de longueur, puis lisez exactement le nombre d'octets indiqué.

Le fait de passer un nombre à receive bloque jusqu'à la réception de cette quantité ou jusqu'à ce qu'une erreur de socket survienne, ce qui permet une délimitation précise dans le flux d'octets.

local header = client:receive(4)
local len = string.unpack(">I4", header)
local payload = client:receive(len)

Un client d'écho complet

Voici le déroulement complet : se connecter, envoyer une ligne, lire la ligne renvoyée, puis fermer la connexion. C'est la structure canonique d'un client LuaSocket.

Notez que chaque appel susceptible d'échouer est protégé par assert pour rester concis, mais qu'un véritable client gérerait les erreurs avec élégance.

local socket = require("socket")
local c = assert(socket.connect("127.0.0.1", 8080))
assert(c:send("hello\r\n"))
print(c:receive("*l"))
c:close()

Gérer les déconnexions

Les serveurs peuvent interrompre les connexions à tout moment. Un send vers un pair fermé peut renvoyer nil, "closed", et receive renvoie les données partielles accompagnées de l'erreur.

Traitez "closed" comme un état terminal normal, et non comme un plantage. La logique de reconnexion doit se trouver dans un wrapper de nouvelle tentative autour du client.

local data, err, partial = client:receive("*a")
if err == "closed" then
  print("peer closed, got", #partial, "bytes")
end

Clients non bloquants

Définissez le délai d'attente sur 0 pour obtenir un client entièrement non bloquant. Les appels renvoient alors immédiatement un résultat et signalent "timeout" lorsqu'aucun progrès n'est possible.

Combinez cette configuration avec socket.select pour attendre efficacement que plusieurs sockets soient prêts, sans effectuer de boucle active.

client:settimeout(0)
local r = socket.select({client}, nil, 5)
if #r > 0 then print(client:receive("*l")) end

Résoudre les noms d'hôte

Si vous vous connectez à l'aide d'un nom d'hôte, LuaSocket le résout pour vous. Pour examiner ou mettre en cache cette résolution, appelez vous-même socket.dns.toip ou socket.dns.getaddrinfo.

Résoudre le nom une seule fois et se connecter par adresse IP évite de répéter les recherches DNS dans une boucle de reconnexion serrée.

local socket = require("socket")
local ip = assert(socket.dns.toip("example.com"))
local c = assert(socket.connect(ip, 80))

Vérification rapide

Choisissez la bonne manière de lire tout ce qu'un serveur envoie jusqu'à ce qu'il ferme la connexion.

Récapitulatif

Vous avez créé un client TCP de bout en bout : vous connecter avec un délai d'attente, délimiter et envoyer des requêtes, lire des réponses ligne par ligne, selon un nombre d'octets ou jusqu'à la fin du flux, puis fermer proprement la connexion.

Vous avez également vu la gestion des déconnexions, le mode non bloquant avec select et la mise en cache DNS. Vous allez maintenant écrire la partie serveur qui répond à ces clients.

Questions Fréquemment Posées

La leçon « Construire un client » est-elle gratuite ?

Oui — le texte complet de « Construire un client » 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 « Construire un client » ?

Demandez des données à un serveur. 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 « Construire un client » ?

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