BUCLES

1. El bucle for es una estructura de control que se utiliza para repetir un bloque de código un
número específico de veces. Tiene la siguiente estructura:

for (inicialización; condición; incremento) {

// código a ejecutar en cada iteración
}

Donde:
• La inicialización se utiliza para establecer una variable de control y asignarle un
valor inicial antes de que comience el bucle.
• La condición es una expresión booleana que se evalúa antes de cada iteración. Si la
condición es verdadera, se ejecuta el bloque de código. Si es falsa, el bucle se detiene y la
ejecución continúa con la siguiente instrucción después del bucle.
• El incremento se utiliza para actualizar la variable de control después de cada iteración.
Puede ser un incremento ( i++ ) o decremento ( i-- ) de la variable, o cualquier otra
operación que modifique su valor.

USOS
1. Recorrer elementos de un arreglo:

const arreglo = [1, 2, 3, 4, 5];

for (let i = 0; i < [Link]; i++) {

[Link](arreglo[i]);
}

2. Obtener la posicion de los elemenos de un arreglo:

const arreglo = [10, 20, 30, 40, 50];

const elementoBuscado = 30;
let posicion = -1;

for (let i = 0; i < [Link]; i++) {

if (arreglo[i] === elementoBuscado) {
posicion = i;
break; // Si se encuentra el elemento, se sale del bucle
}
}
[Link]('El elemento', elementoBuscado, 'se encuentra en la posición', posicion);

1
 3. Recorrer caracteres de una cadena:

const cadena = 'Hola, mundo!';

for (let i = 0; i < [Link]; i++) {

[Link](cadena[i]); //SALIDA: imprimiía 1 letra en cada iteración
}
4. Recorrer las propiedades de un objeto:

const persona = {
nombre: 'Juan',
edad: 30,
profesion: 'Programador'
};

const propiedades = [Link](persona);

for (let i = 0; i < [Link]; i++) {

const propiedad = propiedades[i];

const valor = persona[propiedad];
[Link](propiedad + ': ' + valor);
}

En este caso, se utiliza el método [Link]() para obtener un array con las propiedades del
objeto persona . Luego, se recorre ese array utilizando un bucle for tradicional. En cada iteración,
se accede a la propiedad correspondiente mediante propiedades[i] y se obtiene su valor en el objeto
persona utilizando persona[propiedad] . Finalmente, se muestra la propiedad y su valor en la
consola.

2
[Link] bucle for...of se utiliza para recorrer elementos iterables, como arreglos,
cadenas de texto, conjuntos (Sets), mapas (Maps) y otros objetos que implementen el protocolo de
iteración.

La sintaxis básica del bucle for...of es la siguiente:

for (variable of iterable) {

// código a ejecutar en cada iteración
}

Donde:
• variable : Es una variable que se utiliza para almacenar el valor del elemento actual en cada
iteración. En cada iteración, el valor del elemento se asigna a esta variable para que puedas
acceder a él dentro del bloque del bucle. Puedes elegir cualquier nombre válido para esta
variable.

• iterable : Es el objeto iterable que se recorre. Un objeto iterable es aquel que puede ser
recorrido o iterado, como un arreglo, una cadena de texto, un conjunto (Set), un mapa
(Map), etc. El bucle for...of extraerá los elementos del iterable uno por uno y ejecutará el
bloque de código para cada elemento.

USOS

1. Iterar sobre los elementos de un arreglo:

const iterable = [1, 2, 3, 4, 5];

for (const elemento of iterable) {

// Código a ejecutar en cada iteración
[Link](elemento); //Salida [1, 2, 3, 4, 5]
}

Es importante tener en cuenta que el bucle for...of es útil cuando solo necesitas acceder a los
valores de los elementos y no te importa el índice o la clave de cada elemento. Si necesitas acceder
al índice o a las propiedades de un objeto, o si necesitas realizar una lógica más compleja, entonces
puedes considerar el uso del bucle for tradicional o el bucle for...in .

2. Recorrer las propiedades de un objeto junto con sus valores (con [Link]( )):

const objeto = {
nombre: 'Juan',
edad: 30,
profesion: 'Programador'
};

for (const [propiedad, valor] of [Link](objeto)) {

[Link](`${propiedad}: ${valor}`);

3
}
//SALIDA
nombre: Juan
edad: 30
profesion: Programador

3. Iterar sobre las posiciones de un objeto o arreglo con .entries( ):

const arreglo = [10, 20, 30, 40, 50];

for (const [indice, valor] of [Link]()) {

[Link](`Posición ${indice}: ${valor}`);
}
//SALIDA
Posición 0: 10
Posición 1: 20
Posición 2: 30
Posición 3: 40
Posición 4: 50

4. Iterar sobre cadenas de texto:

const cadena = "Hola";

for (const caracter of cadena) {

[Link](caracter);
}
//SALIDA
H
o
l
a

El bucle for...of es una forma conveniente de recorrer y operar individualmente sobre cada
elemento de una cadena de texto, ya que te permite acceder directamente a cada carácter sin tener
que utilizar índices o métodos adicionales.

5. Obtener las posiciones de cada letra

const cadena = "Hola";

for (const [indice, caracter] of [Link]()) {
[Link](`Posición ${indice}: ${caracter}`);
}
//SALIDA
Posición 0: H
Posición 1: o
Posición 2: l
Posición 3: a

Se usa .entries( ) igual que antes.

4
3. El bucle for...in se utiliza para recorrer las propiedades enumerables de un objeto.
A diferencia de los bucles for...of y for , el bucle for...in está diseñado específicamente
para iterar sobre las propiedades de un objeto, no sobre elementos de una secuencia ordenada como
un arreglo o una cadena de texto.
La sintaxis básica del bucle for...in es la siguiente:

for (variable in objeto) {

// Bloque de código a ejecutar
}
USOS

1. Itera sobre las propiedades de un objeto:

const persona = {
nombre: "Juan",
edad: 30,
profesion: "Programador"
};

for (let propiedad in persona) {

[Link](`${propiedad}: ${persona[propiedad]}`);
}

//SALIDA
nombre: Juan
edad: 30
profesion: Programador

2. Iteraa sobre los indices de un arreglo:

const array = [10, 20, 30, 40, 50];

for (let indice in array) {

[Link](indice);
}
//SALIDA
0
1
2
3
4

3. Iterar sobre los elementos de un arreglo:

const array = [10, 20, 30, 40, 50];

for (let indice in array) {

const elemento = array[indice];
[Link](elemento); } // SALIDA 10 20 30 40 50

5
Recuerda que, si bien esto funciona para iterar sobre los elementos de un array, se recomienda
utilizar el bucle for...of o los métodos de array ( forEach , map , reduce , filter etc.) para iterar sobre
arrays de manera más segura y predecible.

4. El bucle while es una estructura de control en JavaScript que se utiliza para ejecutar un
bloque de código repetidamente mientras se cumpla una condición especificada. La sintaxis básica
del bucle while es la siguiente:

while (condición) {
// código a ejecutar en cada iteración
}
En primer lugar, se evalúa la condición. Si la condición es verdadera, el bloque de código dentro del
bucle se ejecuta. Después de cada iteración, la condición se vuelve a evaluar. Si la condición sigue
siendo verdadera, el bloque de código se ejecutará nuevamente. El bucle continuará ejecutándose
mientras la condición sea verdadera. Si en algún momento la condición se evalúa como falsa, el
bucle se detiene y el control del programa pasa a la siguiente línea de código después del bucle. Por
ejemplo:

let contador = 0;

while (contador < 5) {

[Link]("El contador es: " + contador);
contador++;
}
//SALIDA
El contador es: 0
El contador es: 1
El contador es: 2
El contador es: 3
El contador es: 4

Para evitar bucles infinitos en el bucle while , debes asegurarte de que en cada iteración la
condición del bucle se modifique de alguna manera para que eventualmente se evalúe como falsa y
el bucle se detenga

1. Actualizar la variable de control: Asegúrate de que la variable que controla la condición del
bucle se modifique dentro del bucle en cada iteración. Esto puede ser incrementando o
decrementando su valor, cambiando su estado, o cualquier otra acción que haga que la
condición eventualmente se evalúe como falsa.

let contador = 1;
while (contador <= 5) {
[Link]("Número: " + contador);
contador++;} // Incrementar el contador en cada iteración

6
 2. Utilizar una condición lógica compleja: Puedes combinar múltiples condiciones lógicas
utilizando operadores lógicos como && (y) o || (o). Asegúrate de que estas condiciones
lógicas se actualicen adecuadamente en cada iteración para evitar un bucle infinito.

let contador = 1;
let condicion = true;

while (contador <= 5 && condicion) {

[Link]("Número: " + contador);
contador++; // Incrementar el contador en cada iteración
// Modificar la condición lógica
if (contador === 4) {
condicion = false; // Terminar el bucle cuando contador sea igual a 4
}

3. Utilizar sentencias de control: Puedes utilizar sentencias de control como break o

return para salir del bucle en un momento específico, rompiendo así el ciclo de
ejecución.

let contador = 1;

while (true) {
[Link]("Número: " + contador);
contador++; // Incrementar el contador en cada iteración

if (contador > 5) {
break; // Salir del bucle cuando contador sea mayor que 5
}
}

7
Las sentencias de control break y return funcionan así:

1. break :

• break es una instrucción que se utiliza en bucles ( for , while , do...while ,

switch ) para interrumpir la ejecución del bucle y salir de él.

• Cuando se encuentra la declaración break dentro de un bucle, el programa salta

inmediatamente fuera del bucle y continúa con la siguiente instrucción después del
bucle.
• break es útil cuando se cumple una condición y se desea terminar el bucle antes de
que se haya completado por completo.
• Es importante tener en cuenta que break solo afecta al bucle más cercano en el
que se encuentra.

Ejemplo:
let i = 0;
while (i < 10) {
[Link](i);
if (i === 5) {
break;
}
i++;
}
La salida sería: 0 1 2 3 4 5

8
 [Link] :

• return se utiliza en una función para finalizar su ejecución y devolver un valor

opcionalmente.
• Cuando se encuentra la declaración return , la función se detiene inmediatamente
y devuelve el valor especificado o undefined si no se especifica ningún valor.

• return se utiliza para devolver un resultado de la función y puede estar

acompañado de una expresión o variable que represente el valor de retorno.
• Después de que se ejecuta una declaración return , el código restante dentro de la
función no se ejecuta.

Ejemplo:
function suma(a, b) {
return a + b;
}

const resultado = suma(3, 4);

[Link](resultado); // muestra 7

Recuerda que break y return son instrucciones distintas con propósitos diferentes. break se
utiliza para salir de un bucle y continuar con la ejecución del código que sigue después del bucle. ,
mientras que return se utiliza para devolver un valor y finalizar la ejecución de una función.

9
5. El bucle do...while es similar al bucle while , pero con una diferencia clave: la
condición se evalúa después de que el bloque de código se haya ejecutado al menos una vez. Esto
significa que el bloque de código se ejecutará al menos una vez, sin importar si la condición es
verdadera o falsa. La sintaxis del bucle do...while es la siguiente:

do {
// bloque de código a ejecutar
} while (condición);
Funcionamiento:

• El bloque de código dentro de las llaves {} se ejecuta primero, antes de verificar la

condición.
• Después de que el bloque de código se haya ejecutado, se evalúa la condición.
• Si la condición es verdadera, el bucle se repite y el bloque de código se ejecuta nuevamente.
• Si la condición es falsa, el bucle se detiene y la ejecución continúa con las instrucciones
siguientes al bucle.

Es importante tener en cuenta que, al igual que con otros bucles, es posible usar las declaraciones
break y continue dentro del bucle do...while para controlar el flujo de ejecución.

Ejemplo:
let contador = 0;
do {
[Link]("El contador es: " + contador);
contador++;
} while (contador < 5);
//SALIDA
El contador es: 0
El contador es: 1
El contador es: 2
El contador es: 3
El contador es: 4
El bucle do...while es útil cuando quieres asegurarte de que un bloque de código se ejecute al
menos una vez, independientemente de la condición. Después, la condición se verifica para
determinar si se debe repetir el bucle.

Dentro de los bucles en JavaScript, puedes utilizar las siguientes declaraciones:

10
 1. break : Se utiliza para salir del bucle de forma prematura. Cuando se encuentra la
instrucción break dentro de un bucle, el flujo del programa salta inmediatamente fuera
del bucle y se continúa con la siguiente línea de código después del bucle. Es útil cuando se
alcanza una condición específica y se desea interrumpir la ejecución del bucle. El uso de
break en un bucle for , while o do...while finaliza el bucle por completo.

2. continue : Se utiliza para pasar a la siguiente iteración del bucle sin ejecutar el resto del
código dentro del bucle para la iteración actual. Cuando se encuentra la instrucción
continue , el flujo del programa salta al inicio del bucle y se continúa con la siguiente
iteración. Es útil cuando se desea omitir ciertas iteraciones del bucle basado en una
condición.
3. return : No es una declaración específica de los bucles, sino una declaración de función.
Sin embargo, se puede utilizar dentro de un bucle para salir del bucle y de la función que lo
contiene. Cuando se encuentra la instrucción return dentro de un bucle, no solo se sale
del bucle, sino que también se sale de la función actual y se devuelve un valor (opcional) si
es necesario.

Bucle Uso Principal

for Usado para iterar sobre una secuencia de valores conocida.
for...of Usado para iterar sobre elementos de un objeto iterable (como un array) o secuencia
de valores.
for...in Usado para iterar sobre propiedades enumerables de un objeto.

while Usado cuando se necesita ejecutar un bloque de código mientras se cumpla una
condición específica.
do... Usado cuando se necesita ejecutar un bloque de código al menos una vez y luego
while repetirlo mientras se cumpla una condición específica.
Aquí hay algunas pautas generales:

• Si conoces la cantidad exacta de iteraciones y deseas iterar sobre una secuencia de valores
conocida, utiliza un bucle for .
• Si deseas iterar directamente sobre los elementos de un objeto iterable (como un array),
utiliza un bucle for...of .
• Si deseas iterar sobre las propiedades enumerables de un objeto, utiliza un bucle
for...in .
• Si deseas ejecutar un bloque de código mientras se cumpla una condición específica, utiliza
un bucle while .
• Si deseas ejecutar un bloque de código al menos una vez y luego repetirlo mientras se
cumpla una condición específica, utiliza un bucle do...while .

INDICE
11
Loop for…………………………………………………………………………………………….1-2
Loop for...of………………………………………………………………………………………...3-4
Loop for...in………………………………………………………………………………………...5-6
Loop while…………………………………………………………………………………………6-9
Loop do...while……………………………………………………………………………………..10
Declaraciones: return – break – continue…………………………………………………………...11

LOOPS

12