Como se hace un loop en javascript
En JavaScript los bucles (loops) son utilizados para realizar tareas repetitivas con base en una condición. Las condiciones típicamente devuelven ``true`` (verdadero) o ``false`` (falso) al ser evaluados. El bucle continuará ejecutándose hasta que la condición devuelva ``false``.

Los tres tipos más comunes de bucles son:
- ``for``
- ``while``
- ``do...while``

## Bucle ``for``

El bucle ``for`` en Javascript consiste de tres expresiones y una declaración. La sintaxis es la siguiente:

```js
for (initializacion; condicion; expresion-final) {
   // sentencia(s)
}
```
- Inicialización: Sucede antes de la primera ejecución del bucle. Esta expresión es comúnmente utilizada para crear contadores. Las variables creadas tienen un alcance (scope) limitado al cuerpo del bucle. Una vez que el bucle ha terminado su ejecución las variables son destruidas.
- Condición: Expresión que es evaluada antes de la ejecución de cada iteración. Si se omite, esta expresión es evaluada como verdadera. Si devuelve ``true``, la sentencia del cuerpo del bucle se ejecuta. Si devuelve ``false``, el bucle se detiene.
- Expresión-final: Expresión que se ejecuta luego de cada iteración. Usualmente es utilizada para incrementar un contador. Pero también puede ser utilizada para decrementar el contador.
- Sentencia o declaración: Código que será ejecutado repetidamente por el bucle.

Por ejemplo, para iterar a través de los enteros 1 al 11 usando el bucke ``for`` podemos hacer lo siguiente:
```js
for (var i = 1; i < 12; i++) {
   console.log(i);
}
```

> Los bucles ``for`` son comúnmente utilizados para contar un cierto número de iteraciones para repetir una sentencia. Puedes utilizar una sentencia ``break`` para salir del bucle antes que la expresión de condición devuelva ``false``.

## Bucle ``while``

El bucle ``while`` empieza por evaluar la condición. Si la condición es verdadera (devuelve ``true``), entonces las sentencias son ejecutadas. Si la condición es falsa (devuelve ``false``), entonces las sentencias no son ejecutadas. Luego el bucle finaliza. La sintaxis es la siguiente:

```js
while (condicion) {
  // sentencia(s);
}
```

- Sentencia(s): Una sentencia es código que se ejecuta si la condición devuelve verdadero ( true ).

- Condición: Es una expresión booleana (Boolean) que es evaluada antes de cada paso (iteración) por el bucle. Si esta condición evalúa a verdadero (``true``), las sentencias son ejecutadas. Cuando la condición evalúa a falso (``false``), la ejecución continúa con la siguiente sentencia luego del bucle ``while``.

Por ejemplo, para iterar de los enteros 1 al 11 usando el bucle ``while`` podemos hacer lo siguiente:
```js
var i = 1;
    while (i < 12) 
    {
      console.log(i);
       i++; // i=i+1 esto sería lo mismo 
    }
```

## Bucle ``do...while``

El bucle  ``do...while`` está cercanamente relacionado al bucle ``while``. En el bucle ``do...while``, la condición se evalúa al final. Aquí la sintaxis para el bucle ``do...while``:

```js
do {
   //sentencia(s);
} while (condicion);
```

- Sentencia(s): Una sentencia es ejecutada por lo menos una vez antes de que la condición o expresión booleana sea evaluada y es re-ejecutada cada vez que la condición devuelve ``true``.

- Condición: Aquí la condición es una expresión booleana. Si la expresión booleana evalúa a ``true``, las sentencias son ejecutadas de nuevo. Cuando la expresión booleana devuelve ``false``, el bucle finaliza.

Por ejemplo, para iterar de los enteros 1 al 11 usando el bucle ``do...while`` podemos hacer lo siguiente:
```js
var i = 0;

do {
  i = i + 1;
  console.log(i);
} while (i < 11);
```

En todos los casos, el código dentro del loop se ejecutará repetidamente mientras se cumpla la condición del loop. Es importante asegurarse de que la condición del loop se pueda cumplir en algún momento o de lo contrario, el loop se ejecutará infinitamente.