Lua Academy · Les

Een client bouwen

Vraag gegevens op bij een server.

Les 2 van 413 stappen

Een client bouwen is een gratis Lua Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Lua Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Lua Academy bevat in totaal 4 lessen.

Levenscyclus van een client

Een TCP-client volgt een duidelijke levenscyclus: maak een socket, verbind met een server, wissel gegevens uit en sluit de socket.

In LuaSocket is elke stap één methodeaanroep en elke stap kan mislukken. Een goed geschreven client controleert elke retourwaarde en ruimt zijn socket op bij elk foutpad.

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

Veilig verbinden

Stel een time-out voor het verbinden in voordat je connect aanroept, zodat een onbereikbare host je programma niet laat vastlopen. Enkele seconden is gebruikelijk.

Als connect nil retourneert, leg je de fout vast in het logboek en breek je af. Ga er nooit van uit dat de handshake is geslaagd.

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

socket.connect gebruiken

Voor het gebruikelijke geval combineert socket.connect(host, port) het maken en verbinden. Het retourneert een gereed clientobject of nil en een fout.

Dit is beknopt, maar geeft je geen mogelijkheid om vóór de handshake een time-out in te stellen. Gebruik daarom de expliciete vorm op onbetrouwbare netwerken.

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

Een verzoek verzenden

Zodra je verbonden bent, schrijf je de bytes van je verzoek met send. Veel tekstprotocollen bakenen regels af met een terugloopteken plus een nieuwe regel (\r\n).

Omdat TCP een stroom is, moet je elk logisch bericht duidelijk beëindigen, zodat de server weet waar het eindigt.

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

Een regelantwoord lezen

Lees voor regelgebaseerde protocollen in een lus met het patroon "*l". Elke aanroep retourneert één regel zonder het afsluitende teken.

Controleer bij nil de fout: "closed" betekent dat de server de verbinding heeft verbroken, terwijl "timeout" betekent dat er niet op tijd gegevens zijn aangekomen.

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

Een volledig antwoord lezen

Verzoek-antwoordprotocollen lezen vaak alles totdat de server de verbinding sluit. Gebruik "*a" om de volledige inhoud vast te leggen.

Als je eerst je verzendkant half sluit met shutdown("send"), ziet de server het einde van de invoer en kan die zijn antwoord voltooien.

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

Berichten met vaste lengte afbakenen

Binaire protocollen zetten vaak de lengte vóór elk bericht. Lees eerst de lengtekop en lees daarna precies dat aantal bytes.

Als je een getal aan receive doorgeeft, blokkeert die aanroep totdat dat aantal bytes is aangekomen of de socket een fout geeft. Zo krijg je een precieze afbakening van de bytestroom.

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

Een complete echo-client

Dit is de volledige stroom: verbind, verzend een regel, lees de teruggestuurde regel en sluit. Dit is de kenmerkende vorm van een LuaSocket-client.

Elke aanroep die kan mislukken wordt hier voor de beknoptheid met assert beveiligd, maar een echte client zou fouten netjes afhandelen.

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()

Verbindingen verbreken afhandelen

Servers kunnen op elk moment verbindingen verbreken. Een send naar een gesloten tegenpartij kan nil, "closed" retourneren, en receive retourneert de gedeeltelijke gegevens plus de fout.

Behandel "closed" als een normale eindtoestand, niet als een crash. De logica voor opnieuw verbinden hoort in een wrapper voor opnieuw proberen rond de client.

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

Niet-blokkerende clients

Stel de time-out in op 0 voor een volledig niet-blokkerende client. Aanroepen retourneren dan onmiddellijk en geven "timeout" aan wanneer er geen voortgang mogelijk is.

Combineer dit met socket.select om efficiënt te wachten tot meerdere sockets gereed zijn, zonder een drukke lus te gebruiken.

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

Hostnamen omzetten

Als je verbinding maakt met een hostnaam, zet LuaSocket die voor je om. Als je de omzetting wilt inspecteren of cachen, roep je zelf socket.dns.toip of socket.dns.getaddrinfo aan.

Door de omzetting één keer uit te voeren en via het IP-adres te verbinden, voorkom je herhaalde DNS-zoekopdrachten in een krappe lus voor opnieuw verbinden.

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

Snelle controle

Kies de juiste manier om alles te lezen wat een server verzendt totdat die de verbinding sluit.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt end-to-end een TCP-client gebouwd: verbinden met een time-out, verzoeken afbakenen en verzenden, antwoorden als regels, op basis van een aantal bytes of als volledige stroom lezen, en netjes sluiten.

Je hebt ook gezien hoe je verbroken verbindingen afhandelt, de niet-blokkerende modus met select gebruikt en DNS-gegevens cachet. Vervolgens schrijf je de serverkant die deze clients beantwoordt.

Gratis beginnen

Leer Lua met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 40
Lessen: 159

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Een client bouwen” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “Een client bouwen”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Lua Academy bevat in totaal 4 lessen.

Wat leer ik in “Een client bouwen”?

Vraag gegevens op bij een server. Je oefent met Lua Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Lua Academy te beginnen?

Ervaring vooraf is niet nodig. Lua Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Een client bouwen”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Lua Academy?

Ja. Elke les over Lua Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Lua Academy