Lua Academy · Lección

Crear un cliente

Solicite datos a un servidor

Crear un cliente es una lección gratuita de Lua Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Lua Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Lua Academy incluye 4 lecciones en total.

Ciclo de vida del cliente

Un cliente TCP sigue un ciclo de vida claro: crear un socket, conectarse a un servidor, intercambiar datos y, finalmente, cerrar la conexión.

En LuaSocket, cada paso es una llamada a un método y cualquiera de ellas puede fallar. Un cliente bien implementado comprueba cada valor devuelto y cierra su socket en cualquier ruta de error.

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

Conexión segura

Establezca un tiempo de espera para la conexión antes de llamar a connect, de modo que un host inactivo no bloquee el programa. Unos segundos es lo habitual.

Si connect devuelve nil, registre el error y cancele la operación. Nunca dé por hecho que el handshake se ha completado correctamente.

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

Uso de socket.connect

Para el caso habitual, socket.connect(host, port) combina la creación y la conexión. Devuelve un objeto cliente listo para usar o nil y un error.

Esta forma es concisa, pero no permite establecer un tiempo de espera antes del handshake, por lo que conviene usar la forma explícita en redes poco fiables.

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

Envío de una solicitud

Una vez establecida la conexión, escriba los bytes de la solicitud con send. Muchos protocolos de texto delimitan las líneas con retorno de carro + salto de línea (\r\n).

Como TCP es un flujo, termine claramente cada mensaje lógico para que el servidor sepa dónde acaba.

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

Lectura de una respuesta por línea

En los protocolos basados en líneas, lea en un bucle utilizando el patrón "*l". Cada llamada devuelve una línea sin su terminador.

Si devuelve nil, examine el error: "closed" significa que el servidor cerró la conexión, mientras que "timeout" indica que no llegaron datos a tiempo.

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

Lectura de una respuesta completa

Los protocolos de solicitud y respuesta suelen leer todos los datos hasta que el servidor cierra la conexión. Use "*a" para capturar el cuerpo completo.

Si cierra parcialmente el lado de envío primero mediante shutdown("send"), el servidor detectará el fin de la entrada y podrá terminar su respuesta.

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

Enmarcado de longitud fija

Los protocolos binarios suelen anteponer a cada mensaje su longitud. Lea primero el encabezado de longitud y, después, exactamente esa cantidad de bytes.

Pasar un número a receive bloquea la ejecución hasta que llegan esa cantidad de bytes o se produce un error en el socket, lo que proporciona un enmarcado preciso sobre el flujo de bytes.

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

Un cliente de eco completo

Este es el flujo completo: conectarse, enviar una línea, leer la línea repetida y cerrar la conexión. Esta es la estructura canónica de un cliente de LuaSocket.

Observe que, para abreviar, cada llamada que puede fallar está protegida con assert, pero un cliente real gestionaría los errores correctamente.

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

Gestión de desconexiones

Los servidores pueden cerrar las conexiones en cualquier momento. Un send dirigido a un par cerrado puede devolver nil, "closed", y receive devuelve los datos parciales junto con el error.

Trate "closed" como un estado terminal normal, no como un fallo del programa. La lógica de reconexión debe estar en un contenedor de reintentos alrededor del cliente.

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

Clientes no bloqueantes

Establezca el tiempo de espera en 0 para crear un cliente completamente no bloqueante. Las llamadas devolverán los resultados de inmediato e indicarán "timeout" cuando no sea posible avanzar.

Combine esto con socket.select para esperar eficazmente a que varios sockets estén listos, sin usar un bucle activo.

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

Resolución de nombres de host

Si se conecta mediante un nombre de host, LuaSocket lo resuelve automáticamente. Para inspeccionar o almacenar en caché la resolución, llame directamente a socket.dns.toip o socket.dns.getaddrinfo.

Resolver el nombre una sola vez y conectarse mediante la IP evita búsquedas DNS repetidas en un bucle rápido de reconexión.

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

Comprobación rápida

Elija la forma correcta de leer todo lo que envía un servidor hasta que cierre la conexión.

Resumen

Ha creado un cliente TCP de principio a fin: se ha conectado con un tiempo de espera, ha preparado y enviado solicitudes, ha leído respuestas por línea, por cantidad de bytes o del flujo completo, y ha cerrado la conexión correctamente.

También ha visto cómo gestionar desconexiones, usar el modo no bloqueante con select y almacenar en caché las resoluciones DNS. A continuación escribirá el lado del servidor que responde a estos clientes.

Preguntas frecuentes

¿La lección «Crear un cliente» es gratis?

Sí — el texto completo de «Crear un cliente» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Lua Academy, actualiza a CoddyKit PRO. El curso de Lua Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Crear un cliente»?

Solicite datos a un servidor Practicas Lua Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Lua Academy?

No se requiere experiencia previa. Lua Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Crear un cliente»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Lua Academy?

Sí. Cada lección de Lua Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Lua Academy