Cuando no hay manera de establecer al incio del proceso iterativo el número de repeticiones que serán necesarias se deberá establecer, al igual que en los procedimientos recursivos una condición de prueba que determine la conclusión del ciclo. Para ello disponemos de la función WHILE.

WHILE

Evalúa una expresión de prueba y, si ésta no da como resultado nil, evalúa otras expresiones para volver de nuevo a la expresión de prueba

(while expr_prueba expr...) 

La función while continúa hasta que expr_prueba es nil . Entonces devuelve el valor más reciente de la última expresión.

Ejemplos de Iteraciones con WHILE:

CONTEO DE ENTIDADES:

Un caso lo tendríamos en una función que tuviera como propósito el contar las entidades que forman parte de un dibujo. Para acceder de manera secuencial a las entidades que forman parte de un dibujo tenemos la función ENTNEXT. Si establecemos un contador que se incremente por cada entidad del dibujo tendríamos, al llegar a la última entidad, el número total de entidades. La función concluirá en el momento que la variable ent evalúe como NIL , es decir, cuando ENTNEXT ya no devuelva más ninguna entidad por haber alcanzado el final de la base da datos del dibujo.

;;;Función iterativa para conteo simple
;;;de las entidades en un dibujo
;;;Se establece la variable cont como contador 
;;;y la variable ent para guardar el nombre de 
;;;cada entidad leída
(defun CuentaEntidades ( / cont ent)
  (setq	cont 1
	ent  (entnext)           ;la función entnext sin argumentos 
                          ;devuelve la primera entidad del dibujo
  ) ;_ fin de setq
  (while ent
    (setq 
      cont (1+ cont)
	     ent  (entnext ent)  ;devuelve la entidad que le sigue a ent
    ) ;_ fin de setq
  ) ;_ fin de while
  cont                    ;devuelve el valor final del contador
) ;_ fin de defun

Más adelante utilizaremos este procedimiento para desarrollar funciones más sofisticadas dirigidas a inventariar los objetos contenidos en un dibujo.

PREDICADO PALINDROMOP OPTIMIZADO:

La versión anterior del predicado PALINDROMOP no resulta muy eficiente, pues comprueba de manera exhaustiva todos los caracteres de la cadena, cuando bastaría con detectar una primera desigualdad para decidir que no se trata de un palíndromo. Una solución más eficaz debería interrumpir la evaluación en ese momento. Eso lo podemos lograr mediante un ciclo condicional usando WHILE con dos condiciones encerradas en un AND (que devolverá NIL en cuanto una de ellas deje de ser cierta): que no se hubiera alcanzado el número de repeticiones determinado por (/ (strlen cadena) 2), y que el valor de resultado sea T. En cuanto se encuentre una pareja de caracteres desigual resultado pasará a ser NIL, con lo cual se detendrá el ciclo.

(defun palindromop (cadena / cont resultado)
  (setq
    cont 0
    resultado t
  ) ;_ fin de setq
  (while (and (<= cont (/ (strlen cadena) 2)) resultado)
    (if	(not
	  (equal
	    (substr cadena (1+ cont) 1)
	    (substr cadena (- (strlen cadena) cont) 1)
	  ) ;_ fin de equal
	) ;_ fin de not
      (setq resultado nil)
    ) ;_ fin de if
    (setq cont (1+ cont))
  ) ;_ fin de while
  resultado
) ;_ fin de defun

No basta que un programa alcance los resultados deseados. Debe hacerlo de manera rápida y eficaz. Este es un principio que no debe olvidarse.