Lua Academy · Les

TCP-basisprincipes

Maak verbinding en verstuur gegevens.

Les 1 van 413 stappen

TCP-basisprincipes is een gratis Lua Academy-les op CoddyKit. Dit is les 1 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.

Wat is LuaSocket?

LuaSocket is de feitelijke netwerkbibliotheek voor Lua. De bibliotheek biedt directe TCP- en UDP-sockets en helpers op een hoger niveau voor HTTP, SMTP en FTP.

Het is een externe C-module en maakt dus geen deel uit van standaard-Lua. Je installeert de module via LuaRocks en laadt deze met require.

Geen van de fragmenten in deze cursus werkt in een gewone oefenomgeving, omdat ze het netwerk gebruiken.

local socket = require("socket")
print(socket._VERSION)

Een TCP-socket maken

Het belangrijkste object is de TCP-hoofdsocket, die je maakt met socket.tcp(). Een nieuwe hoofdsocket is niet verbonden en niet gebonden.

Vanaf een hoofdsocket kun je ofwel connect gebruiken om er een clientobject van te maken, of bind+listen gebruiken om er een serverobject van te maken.

De meeste aanroepen geven een waarde terug of nil plus een foutmelding. Sla daarom altijd beide op.

local socket = require("socket")
local tcp, err = socket.tcp()
if not tcp then error(err) end

De adresfamilie

TCP werkt via IPv4 of IPv6. socket.tcp() kiest de familie pas wanneer dat nodig is, terwijl socket.tcp4() en socket.tcp6() er één afdwingen.

Gebruik socket.dns.toip(host) om een hostnaam om te zetten naar een numeriek adres voordat je verbinding maakt, als je expliciete controle nodig hebt.

local socket = require("socket")
local ip, info = socket.dns.toip("example.com")
print(ip)

Verbinding maken met een host

conn:connect(host, port) voert de drievoudige TCP-handshake uit. Bij succes geeft de functie 1 terug; bij een fout geeft ze nil en een foutmelding terug, zoals "connection refused" of "timeout".

De handige functie socket.connect(host, port) maakt in één aanroep een socket en brengt de verbinding tot stand.

local socket = require("socket")
local conn, err = socket.connect("example.com", 80)
if not conn then print("failed:", err) end

Gegevens verzenden

conn:send(data) schrijft bytes naar de socket. De functie geeft de index van de laatst verzonden byte terug. Bij een blokkerende socket is dat meestal de volledige lengte van data.

TCP is een bytestroom en geen berichtenprotocol. Eén send kan onderweg worden opgesplitst of samengevoegd. Je moet je eigen berichtenindeling definiëren.

local request = "GET / HTTP/1.0\r\n\r\n"
local sent, err = conn:send(request)
print("bytes sent:", sent)

Gegevens ontvangen

conn:receive(pattern) leest uit de stroom. Het standaardpatroon "*l" leest één regel zonder de regeleinde. "*a" leest totdat de verbinding wordt gesloten.

Je kunt ook een getal doorgeven om precies zoveel bytes te lezen. Bij een fout geeft de functie nil, een fouttekenreeks en eventueel gedeeltelijk ontvangen gegevens terug.

local line, err = conn:receive("*l")
local chunk = conn:receive(512)
local all = conn:receive("*a")

De verbinding sluiten

Roep altijd conn:close() aan wanneer je klaar bent om de bestandsdescriptor vrij te geven en een TCP FIN te verzenden.

Je kunt de verbinding gedeeltelijk sluiten met conn:shutdown("send") om het einde van de gegevensstroom aan te geven terwijl je nog steeds het antwoord van de andere kant leest. Dit is handig voor aanvraag-antwoordprotocollen die "*a" gebruiken.

conn:shutdown("send")
local reply = conn:receive("*a")
conn:close()

Time-outs zijn belangrijk

Sockets blokkeren standaard voor onbepaalde tijd. conn:settimeout(seconds) begrenst hoelang een aanroep wacht. Met de waarde 0 maak je de socket niet-blokkerend.

Wanneer een time-out optreedt, geeft de aanroep nil en de tekenreeks "timeout" terug. Stel in productie altijd een time-out in om vastgelopen verbindingen te voorkomen.

conn:settimeout(5)
local data, err = conn:receive("*l")
if err == "timeout" then print("too slow") end

TCP versus UDP

TCP is verbindingsgericht, geordend en betrouwbaar: bytes komen één keer en in de juiste volgorde aan, ten koste van handshake-uitwisselingen en hertransmissies.

UDP (socket.udp()) is verbindingsloos en onbetrouwbaar, maar lichtgewicht en geschikt voor telemetrie of games. Deze cursus richt zich op TCP, omdat het de basis vormt voor HTTP.

Gedeeltelijk verzenden en lussen

Op niet-blokkerende sockets kan send slechts een deel van je buffer verzenden. Het retourneert nil, "timeout" en de index van de laatste byte die tot nu toe is geschreven.

Een betrouwbare verzender gebruikt een lus en gaat verder bij de byte na de laatst verzonden byte totdat de hele buffer is verzonden.

local i = 1
while i <= #data do
  local sent, err, last = conn:send(data, i)
  i = (sent or last) + 1
  if err and err ~= "timeout" then break end
end

De verbinding inspecteren

conn:getpeername() retourneert het externe IP-adres en de poort, terwijl conn:getsockname() het lokale uiteinde retourneert. Dit helpt bij logregistratie en foutopsporing.

conn:setoption("keepalive", true) en conn:setoption("tcp-nodelay", true) stemmen het gedrag van de onderliggende socket af.

local ip, port = conn:getpeername()
print("connected to", ip, port)
conn:setoption("tcp-nodelay", true)

Snelle controle

Controleer je begrip van de ontvangstssemantiek van TCP.

Samenvatting

Je hebt het TCP-hoofdobject van LuaSocket leren kennen, geleerd hoe je sockets maakt, verbindt, gegevens verzendt en ontvangt en sockets sluit, en gezien hoe time-outs en halfsluiting het gedrag bepalen.

Onthoud dat TCP een bytestroom is, dat elke aanroep nil, err kan retourneren en dat een socket in productie altijd een time-out instelt. Vervolgens voeg je deze onderdelen samen tot een werkende client.

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

Veelgestelde vragen

Is de les “TCP-basisprincipes” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Lua Academy, waaronder “TCP-basisprincipes”, 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 “TCP-basisprincipes”?

Maak verbinding en verstuur gegevens. 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 1 van 4.

Hoe lang duurt de les “TCP-basisprincipes”?

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

  1. TCP-basisprincipes
  2. Een client bouwen
  3. Een server bouwen
  4. HTTP-requests
← Terug naar Lua Academy