Saltar al contenido
wandres.dev
Iniciar sesión

Lua

Lua a fondo: tablas y metatablas, closures y upvalues, corrutinas, el recolector y la máquina virtual de registros, la API C, embeber el lenguaje y LuaJIT.

22 unidades · 106 temasEmpezar la ruta
  1. 00

    Nivel 0

    1 temas
    1. 01La ontología de Luahechoen curso
  2. 01

    Nivel 1

    5 temas
    1. 01De dónde sale Luahechoen curso
    2. 02La doctrina del tamañohechoen curso
    3. 03Dónde vive Luahechoen curso
    4. 04Las versiones y el cismahechoen curso
    5. 05El toolchain: intérprete, luac y LuaRockshechoen curso
  3. 02

    Nivel 2

    5 temas
    1. 01Los ocho tipos: el inventario cerrado de Luahechoen curso
    2. 02nil a fondo: la ausencia convertida en valorhechoen curso
    3. 03La verdad en Lua: solo nil y false son falsoshechoen curso
    4. 04Valor frente a referencia: qué se copia y qué se compartehechoen curso
    5. 05Coerciones: cuándo Lua convierte por ti y cuándo nohechoen curso
  4. 03

    Nivel 3

    5 temas
    1. 01El cisma de 5.3: cuando el número se partió en doshechoen curso
    2. 02Aritmética: dos divisiones, un módulo con carácterhechoen curso
    3. 03Los límites: 64 bits que dan la vuelta sin avisarhechoen curso
    4. 04Comparaciones e igualdad: cuando 0.1 más 0.2 no es 0.3hechoen curso
    5. 05Bits, conversión y formato: el número como patrónhechoen curso
  5. 04

    Nivel 4

    5 temas
    1. 01La cadena como valor inmutablehechoen curso
    2. 02El internamiento: cadenas cortas y cadenas largashechoen curso
    3. 03Sintaxis: comillas, escapes y corchetes dobleshechoen curso
    4. 04La biblioteca string sin patroneshechoen curso
    5. 05Unicode y memoria: utf8, Lua 5.5 y cadenas externashechoen curso
  6. 05

    Nivel 5

    5 temas
    1. 01Una estructura para todohechoen curso
    2. 02Constructores de tablahechoen curso
    3. 03Claves y valoreshechoen curso
    4. 04La biblioteca tablehechoen curso
    5. 05Idiomas fundamentales con tablashechoen curso
  7. 06

    Nivel 6

    5 temas
    1. 01La representación dual: toda tabla son dos tablashechoen curso
    2. 02El rehash: cuándo y cómo se redimensiona una tablahechoen curso
    3. 03El operador de longitud: una frontera, no un contadorhechoen curso
    4. 04Los arrays compactos de Lua 5.5hechoen curso
    5. 05Medir y razonar: la memoria real de una tablahechoen curso
  8. 07

    Nivel 7

    5 temas
    1. 01Las funciones son valores: declarar es asignarhechoen curso
    2. 02Retornos múltiples y las reglas de ajustehechoen curso
    3. 03La llamada: paso de argumentos, azúcares y dos puntoshechoen curso
    4. 04Varargs: los puntos suspensivos y las tablas con nombre de 5.5hechoen curso
    5. 05Llamadas de cola: la garantía que convierte la recursión en un buclehechoen curso
  9. 08

    Nivel 8

    5 temas
    1. 01Qué es un closure: la función y su entornohechoen curso
    2. 02Upvalues abiertos y cerrados: la implementación realhechoen curso
    3. 03Compartir estado: closures que ven la misma variablehechoen curso
    4. 04La trampa del bucle: capturar la variable o una copiahechoen curso
    5. 05Introspección: leer, escribir y fusionar upvalueshechoen curso
  10. 09

    Nivel 9

    5 temas
    1. 01Locales y bloques: el ámbito léxicohechoen curso
    2. 02El coste de un global: una lectura es un acceso a tablahechoen curso
    3. 03_ENV: la revelación de 5.2hechoen curso
    4. 04Entornos personalizados: la base de todo sandboxhechoen curso
    5. 05Globales declarados: la gran novedad de Lua 5.5hechoen curso
  11. 10

    Nivel 10

    5 temas
    1. 01La idea: una tabla que describe a otrahechoen curso
    2. 02__index: cuando la clave no existehechoen curso
    3. 03__newindex: interceptar la escriturahechoen curso
    4. 04El acceso crudo: rawget, rawset, rawequal y rawlenhechoen curso
    5. 05Valores por defecto y memoizaciónhechoen curso
  12. 11

    Nivel 11

    5 temas
    1. 01Aritmética y concatenación: el catálogo completo y la regla de selecciónhechoen curso
    2. 02Comparación: por qué __eq es tan tímido y qué pasa si tu orden no es totalhechoen curso
    3. 03Objetos que se llaman, se imprimen y se miden: __call, __tostring y __lenhechoen curso
    4. 04Ciclo de vida: __gc como finalizador y __close como cierre garantizadohechoen curso
    5. 05Protección y metatablas: __metatable, __name y el patrón del tipo opacohechoen curso
  13. 12

    Nivel 12

    5 temas
    1. 01Los dos puntos y selfhechoen curso
    2. 02El idioma de la clasehechoen curso
    3. 03Herencia: encadenar metatablashechoen curso
    4. 04Encapsulación real y su preciohechoen curso
    5. 05Alternativas a los objetoshechoen curso
  14. 13

    Nivel 13

    5 temas
    1. 01Qué es un módulo en Luahechoen curso
    2. 02require paso a pasohechoen curso
    3. 03Las rutas: package.path y package.cpathhechoen curso
    4. 04Escribir un módulo bienhechoen curso
    5. 05Recargar y aislar móduloshechoen curso
  15. 14

    Nivel 14

    5 temas
    1. 01El modelo: dos funciones y ningún bloquehechoen curso
    2. 02error y assert: lanzar, y decidir a quién se culpahechoen curso
    3. 03pcall y xpcall: el manejador corre antes de desenrollarhechoen curso
    4. 04El idioma del nulo y el mensajehechoen curso
    5. 05Errores en la práctica: envolver, propagar y no tragarse nadahechoen curso
  16. 15

    Nivel 15

    5 temas
    1. 01Qué es una corrutina: una pila propia que cede el controlhechoen curso
    2. 02El ciclo: create, resume, yield y los cuatro estadoshechoen curso
    3. 03El paso de valores: cuatro canales y una doble direcciónhechoen curso
    4. 04Errores en una corrutina: resume como pcall implícito, wrap y closehechoen curso
    5. 05Corrutinas frente a hilos: sin paralelismo, pero sin carrerashechoen curso
  17. 16

    Nivel 16

    5 temas
    1. 01Generadores: la secuencia que nunca se construyehechoen curso
    2. 02Productor y consumidor: quién manda en cada pasohechoen curso
    3. 03Async sin async: el await que te fabricashechoen curso
    4. 04Escribir un planificador: la cola, el bucle y los relojeshechoen curso
    5. 05Los límites: ceder a través de una frontera de Chechoen curso
  18. 17

    Nivel 17

    5 temas
    1. 01El `for` genérico por dentro: la tripleta que gobierna el buclehechoen curso
    2. 02`pairs` e `ipairs`: qué devuelve realmente cada unohechoen curso
    3. 03Iteradores sin estado: cuando la posición cabe en la tripletahechoen curso
    4. 04Iteradores con estado: closures que recuerdan la posiciónhechoen curso
    5. 05Personalizar la iteración: `__pairs`, corrutinas y composiciónhechoen curso
  19. 18

    Nivel 18

    5 temas
    1. 01El inventario completohechoen curso
    2. 02io: el modelo de ficheroshechoen curso
    3. 03os y math: tiempo, sistema y azarhechoen curso
    4. 04Lo que no trae y por quéhechoen curso
    5. 05El ecosistema: LuaRocks y el criterio de dependenciahechoen curso
  20. 19

    Nivel 19

    5 temas
    1. 01La diferencia: por qué Lua no incluye expresiones regulareshechoen curso
    2. 02Clases de caracteres y cuantificadoreshechoen curso
    3. 03Capturas: simples, de posición, anidadas y hacia atráshechoen curso
    4. 04Las cuatro funciones que consumen patroneshechoen curso
    5. 05Los límites: sin alternancia, sin grupos, y cuándo rendirsehechoen curso
  21. 20

    Nivel 20

    5 temas
    1. 01load: compilar una cadena en ejecuciónhechoen curso
    2. 02El entorno del chunk: cargar con su propio _ENVhechoen curso
    3. 03Generar Lua desde Lua: plantillas y despachohechoen curso
    4. 04Introspección: getinfo, hooks y un profilerhechoen curso
    5. 05Serialización: una tabla convertida en Luahechoen curso
  22. 21

    Nivel 21

    5 temas
    1. 01Marcado y barrido: las raíces, los tres colores y el fin de los cicloshechoen curso
    2. 02Incremental: trocear el ciclo, la barrera de escritura y el precio de no pararhechoen curso
    3. 03Generacional y el gran cambio de Lua 5.5: las mayores también son incrementaleshechoen curso
    4. 04collectgarbage: medir, forzar, detener y afinar sin romper nadahechoen curso
    5. 05Tablas débiles y finalizadores: cachés que sueltan, efímeros y resurrecciónhechoen curso