Introducción a JavaScript

1

¿Por qué aprender JavaScript?

2

¡Hola Mundo! en Mac

3

¡Hola Mundo! en Windows

4

Anatomía de una variable

5

Tipos de datos en JavaScript

6

Creación de strings

7

Operadores aritméticos

8

Conversión de tipos: Type Casting y Coerción

9

Conversión de tipos explícita e implícita

Estructuras de Control y Lógica

10

Operadores de comparación

11

Operadores lógicos

12

Ejecución condicional: if

13

Ejercicio: Adivina el número

14

Ejecución condicional: switch

15

Loop: for

16

Loop: for of

17

Loop: for in

18

Loop: while

19

Loop: do while

Funciones y This

20

Anatomía de una función

21

Funciones vs Métodos

22

Funciones puras e impuras

23

Arrow function y enlace léxico

24

Contextos de ejecución y scope chain

25

¿Qué es Closure?

26

Preguntas a Desarrolladores Senior: ¿Por qué aprender Desarrollo Web?

Manipulación de Arrays

27

Introducción a Arrays

28

Mutabilidad e inmutabilidad de Arrays

29

Modificación básica del final con push( ), pop( )

30

Iteración con map( ) y forEach( )

31

Filtrado y reducción con filter( ) y reduce( )

32

Búsqueda de elementos con find( ) y findIndex( )

33

Crear copias con slice( )

34

Spread operator: casos de uso

Programación Orientada a Objetos

35

Anatomía de un Objeto

36

Trabajando con objetos en JavaScript

37

Función constructora

38

¿Qué es una clase?

39

Prototipos y herencias

40

Herencia en la práctica

41

Prototipos en la práctica

42

this en JavaScript

43

Proyecto: Crea una red social

44

Proyecto: Crea una red social parte 2

Asincronía en JavaScript

45

¿Cómo funciona el JavaScript Engine?

46

Promesas en JavaScript

47

Usando Async y await en JavaScript

48

For await of

49

¿Cómo funciona la web?

50

¿Cómo funciona HTTP?

51

Método GET en JavaScript

52

Método POST en JavaScript

53

Método DELETE en JavaScript

54

Importancia del id en el método DELETE

55

ECMAScript 6 y tus siguientes pasos

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Loop: do while

19/55
Recursos

Aportes 12

Preguntas 0

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

* `for` **loop**: Usado cuando conoces el número de iteraciones. * `while` **loop**: Usado cuando quieres repetir mientras una condición sea verdadera. * `do...while` **loop**: Similar al `while` loop, pero se ejecuta al menos una vez. * `for...in` **loop**: Usado para iterar sobre propiedades enumerables de un objeto. * `for...of` **loop**: Usado para iterar sobre elementos de objetos iterables.
resumen de las clases de código iterativo ![](https://static.platzi.com/media/user_upload/image-eb7e78c1-b2c0-4611-af1b-f2da40e152f8.jpg) ![](https://static.platzi.com/media/user_upload/image-b6913915-d684-4e94-be47-7f0cf5aee139.jpg)
Aqui se ve claramente que el do while primero ejecuta el codigo y luego evalua la condicion.![](https://static.platzi.com/media/user_upload/Screenshot%20from%202024-07-25%2000-06-27-57e16594-4c9d-47aa-8d7a-f98237a5ee39.jpg)
me encanta que platzi siempre escucha antes dejaba muchos enlaces pero genial que ya no dejen los enlaces en cada clase y dejan los enlaces importantes solo al principio del curso
El bucle `do { código } while (condición)` es una estructura de control que: 1. Ejecuta el bloque de código dentro de las llaves `{}` al menos una vez. 2. Después de cada ejecución, evalúa la condición entre paréntesis. 3. Si la condición es verdadera, repite el ciclo. Si es falsa, termina. La diferencia clave con un bucle while normal es que el código siempre se ejecuta una vez antes de evaluar la condición.
Iterando y haciendo uso del do...while pero con decrementos: . ```js let i = -1 // iterator declaration and initialization do { console.log(i + 2*i) // code → formulae for negative odd numbers i -= 1 // iterator increment (or decrement in this case) } while (i > -10) // condition /* -3 -6 -9 -12 -15 -18 -21 -24 -27 */ ```
* `for`**:** Úsalo cuando sabes cuántas veces quieres que el bucle se ejecute. * `for...of`**:** Úsalo cuando quieras iterar sobre los valores de un iterable (como un array). * `for...in`**:** Úsalo cuando necesites iterar sobre las claves de un objeto o índices de un array. * `while`**:** Úsalo cuando no sabes cuántas veces se ejecutará el bucle, pero tienes una condición clara. * `do...while`**:** Úsalo cuando quieras que el bucle se ejecute al menos una vez, independientemente de la condición.
![](https://static.platzi.com/media/user_upload/image-75d03c3a-656b-4e7d-8a76-a206e9ffa8f2.jpg)
```js do { code } while (condition) ```
## Resumen de la clase! A diferencia del ciclo `while`, el ciclo que aprendimos hoy, `do... while`, ejecutará primero nuestro bloque de código y luego de ello evalua la condición, y ya al igual que `while`, ejecuta nuestro código. Esto puede resultar bastante útil cuando queremos asegurarnos de que un ciclo se ejecute como mínimo una vez. **OJO 👀** Al igual que el `while`, debemos especificar una condición que en algún momento detenga nuestro ciclo, de lo contrario nos enfrentaremos a un **loop infinito ♾**! > 💡 [Aquí puedes leer la documentación de este ciclo](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/do...while)
***While:*** El bucle `while` ejecuta un bloque de código mientras una condición especificada es verdadera. La condición se evalúa antes de que se ejecute el bloque de código. ```js let numero = 1; while (numero <= 5) { console.log(numero); numero++; } ``` ***Do while:*** El bucle `do...while` ejecuta un bloque de código una vez antes de verificar la condición. Luego, se repite mientras la condición especificada sea verdadera. ```js let numero = 1; do { console.log(numero); numero++; } while (numero <= 5); ``` ***Diferencias:*** La principal diferencia entre `while` y `do...while` es cuándo se evalúa la condición: * En un bucle `while`, la condición se evalúa antes de ejecutar el bloque de código. Si la condición es falsa desde el principio, el bloque de código no se ejecutará ni una sola vez. * En un bucle `do...while`, el bloque de código se ejecuta al menos una vez antes de que se evalúe la condición. Esto garantiza que el bloque se ejecute al menos una vez, independientemente de si la condición es verdadera o falsa desde el principio.
![]()![](https://static.platzi.com/media/user_upload/image-dc3c4b27-9bda-45c1-a650-733fdde478a0.jpg)