0Pricing
Lua Academy · Lezione

Cicli while e repeat-until

Utilizzi while e repeat-until per l'iterazione basata su condizioni.

Cicli while e repeat-until è una lezione Lua Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Lua Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Lua Academy include 4 lezioni in totale.

Il ciclo while

Un ciclo while ripete il proprio corpo finché la condizione è vera. La condizione viene verificata prima di ogni iterazione. Se inizialmente è falsa, il corpo non viene mai eseguito. Si assicuri sempre che il ciclo avanzi verso la condizione di uscita, per evitare cicli infiniti.

local count = 1

while count <= 5 do
  print(count)
  count = count + 1
end
-- prints 1 through 5

Ciclo repeat-until

Il ciclo repeat...until è l'equivalente Lua del ciclo do-while. Il corpo viene eseguito almeno una volta e la condizione viene verificata dopo ogni iterazione. Il ciclo si arresta quando la condizione diventa vera (il contrario di while). Le variabili dichiarate all'interno del corpo sono visibili nella condizione.

local n = 1

repeat
  print(n)
  n = n * 2
until n > 100
-- prints: 1, 2, 4, 8, 16, 32, 64

Cicli infiniti con break

Utilizzi while true do per i cicli degli eventi o i tentativi ripetuti, insieme a break per uscire quando viene soddisfatta una condizione. Questo schema è comune nei cicli principali dei videogiochi e nei server di rete che vengono eseguiti continuamente.

local attempts = 0
local MAX = 3

while true do
  attempts = attempts + 1
  print("Attempt " .. attempts)
  if attempts >= MAX then
    print("Max attempts reached")
    break
  end
end

Conto alla rovescia con while

I cicli while funzionano altrettanto bene per contare all'indietro. L'aspetto fondamentale è aggiornare la variabile in modo che prima o poi soddisfi la condizione di uscita. Dimenticare di aggiornare il contatore è una causa comune dei cicli infiniti.

local i = 10

while i > 0 do
  io.write(i .. " ")
  i = i - 1
end
print()   -- newline
-- output: 10 9 8 7 6 5 4 3 2 1

repeat-until per la convalida dell'input

Lo schema repeat-until è ideale per la convalida dell'input: si richiede il valore una volta e lo si verifica dopo. In questo schema, il corpo viene sempre eseguito almeno una volta, in accordo con il normale flusso «chiedere, poi convalidare».

-- Simulated input validation
local inputs = {-1, 0, 5}  -- pretend user input
local idx = 0
local value

repeat
  idx = idx + 1
  value = inputs[idx]
  print("Got: " .. value)
until value > 0

print("Valid value: " .. value)  -- 5

Le variabili dei cicli sono locali

Le variabili dichiarate con local all'interno del corpo di un ciclo vengono ricreate a ogni iterazione. Questo è importante quando si acquisiscono variabili del ciclo nelle closure: ogni closure acquisisce una propria copia. Le variabili dichiarate all'esterno del ciclo persistono tra le iterazioni.

local callbacks = {}

for i = 1, 3 do
  local captured = i        -- local per iteration
  callbacks[i] = function() return captured end
end

print(callbacks[1]())  -- 1
print(callbacks[2]())  -- 2
print(callbacks[3]())  -- 3

Schema dell'accumulatore

Un caso d'uso comune dei cicli while consiste nell'accumulare un risultato. Somme, prodotti, concatenazioni di stringhe e costruzione di tabelle seguono tutti lo schema dell'accumulatore: inizializzare prima del ciclo, aggiornare all'interno e utilizzare il risultato dopo.

local numbers = {3, 1, 4, 1, 5, 9, 2, 6}
local sum = 0
local i = 1

while i <= #numbers do
  sum = sum + numbers[i]
  i = i + 1
end

print("Sum:", sum)     -- 31
print("Avg:", sum / #numbers)  -- 3.875

Cicli annidati

I cicli possono essere annidati. Ogni ciclo mantiene il proprio contatore. Utilizzi nomi descrittivi per le variabili, così da rendere il codice più chiaro. L'istruzione break esce solo dal ciclo più interno che la contiene: per uscire da più livelli potrebbe essere necessaria una variabile flag o goto (Lua 5.2+).

local found = false
local target = 6

local i = 1
while i <= 3 and not found do
  local j = 1
  while j <= 3 do
    if i * j == target then
      print(i .. " * " .. j .. " = " .. target)
      found = true
      break
    end
    j = j + 1
  end
  i = i + 1
end

goto per uscire da più livelli

Lua 5.2+ ha introdotto goto per saltare a una posizione contrassegnata da un'etichetta. Sebbene sia generalmente sconsigliato, è appropriato per uscire in modo ordinato da cicli annidati senza una variabile flag. Le etichette vengono definite con ::name::.

for i = 1, 5 do
  for j = 1, 5 do
  -- goto only valid approach for nested break in Lua
    if i * j > 10 then
      goto done
    end
    io.write(i*j .. " ")
  end
end
::done::
print()
print("Stopped early")

Confronto tra while e repeat: vantaggi e svantaggi

while: lo utilizzi quando potrebbero essere necessarie zero iterazioni: la condizione viene verificata prima. repeat-until: lo utilizzi quando è necessaria almeno un'iterazione: la verifica avviene dopo. Preferisca while per la maggior parte dei cicli. Utilizzi repeat-until per menu, richieste e cicli di nuovi tentativi in cui l'azione deve avvenire prima della verifica.

-- while: may execute zero times
local ready = false
while ready do
  print("never prints")
end

-- repeat-until: always executes at least once
local done = false
repeat
  print("runs once even though done=false")
  done = true
until done

Verifica rapida

Quando viene verificata la condizione in un ciclo repeat...until?

Riepilogo: while e repeat-until

Punti chiave:

  • while cond do ... end — verifica prima; potrebbe non essere eseguito affatto
  • repeat ... until cond — verifica dopo; viene eseguito almeno una volta
  • break esce dal ciclo più interno
  • goto ::label:: può uscire da cicli annidati (Lua 5.2+)
  • Le variabili locali del ciclo vengono ricreate a ogni iterazione
  • Utilizzi lo schema dell'accumulatore per costruire risultati

Domande Frequenti

La lezione «Cicli while e repeat-until» è gratuita?

Sì — il testo completo di «Cicli while e repeat-until» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Lua Academy, passa a CoddyKit PRO. Il corso Lua Academy include 4 lezioni in totale.

Cosa imparerò in «Cicli while e repeat-until»?

Utilizzi while e repeat-until per l'iterazione basata su condizioni. Eserciti Lua Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Lua Academy?

Non è richiesta alcuna esperienza precedente. Lua Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Cicli while e repeat-until»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Lua Academy?

Sì. Ogni lezione Lua Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Istruzioni if, elseif ed else
  2. Cicli while e repeat-until
  3. Ciclo for numerico
  4. for generico e break
← Torna a Lua Academy