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.
ใน JavaScript จะใช้ลูปเพื่อทำงานซ้ำๆ ตามเงื่อนไข โดยทั่วไปเงื่อนไขจะส่งคืน "จริง" หรือ "เท็จ" เมื่อประเมิน การวนซ้ำจะดำเนินการต่อไปจนกว่าเงื่อนไขจะส่งกลับ "เท็จ" ประเภทของลูปที่พบบ่อยที่สุดสามประเภทคือ: - ``for`` - `` While`` - ``do... While`` ## ``for`` Loop ``for`` loop ใน Javascript ประกอบด้วย สามสำนวนและหนึ่งประกาศ ไวยากรณ์มีดังนี้: ```js for (การกำหนดค่าเริ่มต้น; เงื่อนไข; การแสดงออกขั้นสุดท้าย) { // คำสั่ง } ``` - การกำหนดค่าเริ่มต้น: เกิดขึ้นก่อนการประมวลผลลูปครั้งแรก นิพจน์นี้มักใช้เพื่อสร้างตัวนับ ตัวแปรที่สร้างขึ้นมีขอบเขตจำกัดอยู่ที่เนื้อหาของลูป เมื่อวนซ้ำเสร็จสิ้น ตัวแปรจะถูกทำลาย - เงื่อนไข: นิพจน์ที่ได้รับการประเมินก่อนดำเนินการวนซ้ำแต่ละครั้ง หากละเว้น นิพจน์นี้จะประเมินเป็นจริง หากส่งคืน "true" คำสั่งในส่วนเนื้อหาของลูปจะถูกดำเนินการ หากส่งคืน `` false`` การวนซ้ำจะหยุดลง - นิพจน์สุดท้าย: นิพจน์ที่ดำเนินการหลังจากการวนซ้ำแต่ละครั้ง โดยปกติจะใช้เพื่อเพิ่มตัวนับ แต่ก็สามารถใช้เพื่อลดตัวนับได้เช่นกัน - ประโยคหรือการประกาศ: รหัสที่จะถูกดำเนินการซ้ำ ๆ โดยการวนซ้ำ ตัวอย่างเช่น หากต้องการวนจำนวนเต็ม 1 ถึง 11 โดยใช้ ``for`` bucke เราสามารถทำได้ดังต่อไปนี้: ```js for (var i = 1; i < 12; i++) { console.log(i) ; } ``` > ``for`` ลูปมักใช้เพื่อนับจำนวนการวนซ้ำเพื่อทำซ้ำคำสั่ง คุณสามารถใช้คำสั่ง ``break`` เพื่อแยกออกจากลูปก่อนที่นิพจน์เงื่อนไขจะส่งคืน ``false`` ## `` while`` วนซ้ำ `` while`` วนซ้ำเริ่มต้นด้วยการประเมินเงื่อนไข หากเงื่อนไขเป็นจริง (ส่งคืน `` จริง `` ) คำสั่งดังกล่าวก็จะถูกดำเนินการ หากเงื่อนไขเป็นเท็จ (ส่งคืน ``false``) คำสั่งจะไม่ถูกดำเนินการ จากนั้นการวนซ้ำก็สิ้นสุดลง ไวยากรณ์มีดังนี้: ```js while (เงื่อนไข) { // คำสั่ง; } ``` - คำสั่ง: คำสั่งคือรหัสที่ถูกดำเนินการหากเงื่อนไขคืนค่าเป็นจริง ( true ) - เงื่อนไข: เป็นนิพจน์บูลีนที่ได้รับการประเมินก่อนแต่ละขั้นตอน (การวนซ้ำ) ผ่านการวนซ้ำ หากเงื่อนไขนี้ประเมินเป็นจริง คำสั่งต่างๆ จะถูกดำเนินการ เมื่อเงื่อนไขประเมินเป็นเท็จ (``เท็จ``) การดำเนินการจะดำเนินต่อไปด้วยคำสั่งถัดไปหลังจากลูป `` While`` ตัวอย่างเช่น หากต้องการวนซ้ำจากจำนวนเต็ม 1 ถึง 11 โดยใช้ลูป `` while`` เราสามารถทำได้ดังต่อไปนี้: ```js var i = 1; ในขณะที่ (i <12) { console.log(i); ฉัน++; // i=i+1 นี่จะเหมือนกัน } ``` ## ``do... While`` ลูป ``do... While`` ลูปมีความสัมพันธ์อย่างใกล้ชิดกับลูป `` While`` . ในลูป `` ทำ... ในขณะที่`` เงื่อนไขจะได้รับการประเมินในตอนท้าย นี่คือไวยากรณ์ของลูป ``do... While``: ```js do { //statement(s); } ในขณะที่ (เงื่อนไข); ``` - คำสั่ง: คำสั่งจะถูกดำเนินการอย่างน้อยหนึ่งครั้งก่อนที่จะประเมินเงื่อนไขหรือนิพจน์บูลีน และจะดำเนินการอีกครั้งในแต่ละครั้งที่เงื่อนไขส่งคืน ``true`` - เงื่อนไข: ในที่นี้เงื่อนไขคือนิพจน์บูลีน หากนิพจน์บูลีนประเมินเป็น "จริง" คำสั่งจะถูกดำเนินการอีกครั้ง เมื่อนิพจน์บูลีนส่งคืน "false" การวนซ้ำจะสิ้นสุดลง ตัวอย่างเช่น หากต้องการวนซ้ำจากจำนวนเต็ม 1 ถึง 11 โดยใช้ลูป ``do... While`` เราสามารถทำได้ดังต่อไปนี้: ```js var i = 0; ทำ { i = i + 1; console.log(i); } ในขณะที่ (i < 11); ``` ในทุกกรณี โค้ดภายในลูปจะถูกดำเนินการซ้ำๆ ตราบใดที่ตรงตามเงื่อนไขของลูป สิ่งสำคัญคือต้องแน่ใจว่าสามารถตรงตามเงื่อนไขของลูปได้ ณ จุดใดจุดหนึ่ง ไม่เช่นนั้นลูปจะทำงานอย่างไม่มีที่สิ้นสุด
spam fails_task lang_mismatch pii not_appropriate hate_speech sexual_content quality toxicity humor helpfulness creativity violence