for - print en lua

¿Por qué usar un bloque do-end en Lua?

Question

Sigo tratando de encontrar respuestas para esto, pero no lo hago. Quería saber para qué se usa realmente el bloque do-end? Simplemente dice que los valores se usan cuando es necesario en mi libro, así que, ¿cómo podría usar esto?

¿Lo uso para reducir el alcance de las variables locales al colocar una función en un bucle do-end y colocar las variables locales fuera de la función pero dentro de este bloque do-end y la función verá las variables? Pero entonces, ¿se puede seguir llamando la función?

Lo siento por ser muy vago. Espero que tenga sentido. Tal vez un ejemplo ilustrado podría ser útil ^^

Answer 1

Además de las buenas respuestas ya dadas, quiero mencionar la posibilidad de compartir una variable privada entre dos o más funciones:

do

  local i = 0

  function inc()
    i = i + 1
    return i
  end

  function dec()
    i = i - 1
    return i
  end

end

Answer 2

Los bloques do-end tienen que ver con el problema del alcance variable. Esencialmente, cuando usas un identificador, ¿qué valor tiene? Por ejemplo, ¿qué números se imprimirán cuando escribamos el siguiente programa?

local x = 10
if x > 0 then
    local x = 17
    print(x)
end
print(x)

Cuando se trata de variables locales, Lua utiliza el alcance léxico estándar, como se explica en la sección 4.2 del libro Programación en Lua. El alcance léxico es muy útil por un par de razones:

• La variable de alcance es estática. Con solo mirar el código fuente, qué variables y funciones corresponden a cada identificador en su código. Esto se opone al alcance dinámico que se encuentra en Bash o el envío indirecto a través de llamadas a métodos o búsquedas de matrices, donde debe pensar en el flujo de ejecución del programa para saber con qué valor terminará.

• El alcance variable es limitado, lo que ayuda a la legibilidad y evita algunos errores:

  • Si declara una variable solo cuando va a necesitar usarla, puede declararla e inicializarla al mismo tiempo. Por otro lado, si declara todas sus variables en la parte superior de la función, podría terminar usando una antes de inicializarla.

  • Si define una variable dentro de un ámbito interno, no puede usarla accidentalmente en ámbitos externos.

• El alcance léxico permite algunos modismos muy expresivos cuando se combina con funciones anidadas (cierres).

Por lo general, no es necesario preocuparse por la especificación de los ámbitos de las variables. Las funciones, los bucles y los condicionales introducen automáticamente nuevos ámbitos y normalmente serán suficientes para dar a sus variables un ámbito bien restringido. Dicho esto, de vez en cuando, es posible que desee introducir algunos alcances adicionales de la nada y podemos usar do-end para eso. Programación Lua tiene el siguiente ejemplo en el que desea calcular las soluciones de una ecuación cuadrática y el cálculo tiene algunos temporales:

do
  local a2 = 2*a
  local d = sqrt(b^2 - 4*a*c)
  x1 = (-b + d)/a2
  x2 = (-b - d)/a2
end          -- scope of `a2'' and `d'' ends here
print(x1, x2)

Sin el bloque do-end, a2 y d podrían terminar siendo utilizados accidentalmente después de que ya no sean necesarios:

local a2 = 2*a
local d = sqrt(b^2 - 4*a*c)
x1 = (-b + d)/a2
x2 = (-b - d)/a2
print(x1, x2)

print(a2) -- OOPS! I wanted to say "print(a)"

Dicho esto, do-end no necesita ser usado tan a menudo. Si el bloque de código es pequeño, hay menos necesidad de ocultar las variables locales y si el bloque de código es grande, a menudo es un mejor método para colocar el bloque de código en una subrutina propia. Los momentos en los que encuentro que el Do-End brilla es cuando solo necesita hacer el cálculo una vez, las funciones pueden ser llamadas muchas veces, pero si usa un bloque Do-End, deja claro que solo está ejecutando esa parte del código. una vez.

Answer 3

Sí, el bloque do end puede usarse para limitar el alcance de las variables; para mantener visible la función que usa esas variables, tiene varias opciones

1. Localice la variable que mantiene la función fuera del bloque:

   local func    
   do
     local a = 0
     func = function(inc)
       a = a + inc
       return a
     end
   end

2. Utilice una función global:

   do
     local a = 0
     function func(inc)
       a = a + inc
       return a
     end
   end

3. Utilice un método:

   local tbl = {}
   do
     local a = 0
     function tbl:func(inc)
       a = a + inc
       return a
     end
   end

En los tres casos, aún puede llamar a func() después de que se cierre el bloque, pero a solo se puede visible desde esa función y no en ningún otro lugar.