Introducción al curso

1

¡Alto! Tenemos una nueva versión de este curso para ti

2

Bienvenidos al Curso de Fundamentos de JavaScript

3

Repositorio de este curso de fundamentos de JS

Primeros pasos en JavaScript

4

Variables

5

Variables: Strings

6

Variables: Números

7

Funciones

8

El alcance de las funciones

9

Objetos

10

Desestructurar objetos

11

Parámetros como referencia o como valor

12

Comparaciones en JavaScript

Estructuras de Control y Funciones

13

Condicionales

14

Funciones que retornan valores

15

Arrow functions

16

Estructuras repetitivas: for

17

Estructuras repetitivas: while

18

Estructuras repetitivas: do-while

19

Condicional múltiple: switch

Arrays

20

Introducción a arrays

21

Filtrar un array

22

Transformar un array

23

Reducir un array a un valor

Programación Orientada a Objetos en JavaScript

24

Cómo funcionan las clases en JavaScript

25

Modificando un prototipo

26

El contexto de las funciones: quién es this

27

La verdad oculta sobre las clases en JavaScript

28

Clases en JavaScript

Asincronismo

29

Funciones como parámetros

30

Cómo funciona el asincronismo en JavaScript

31

Cómo funciona el tiempo en JavaScript

32

¿Qué pasó con swapi.co?

33

Callbacks

34

Haciendo múltiples requests

35

Manejando el Orden y el Asincronismo en JavaScript

36

Manejo de errores con callbacks

37

Promesas

38

Promesas Encadenadas

39

Múltiples promesas en paralelo

40

Async-await: lo último en asincronismo

Juego de HTML

41

Comenzando el juego

42

Generando una secuencia de números

43

Iluminando la secuencia de colores

44

Obteniendo el input del usuario

45

Agregando la verificación del color elegido

46

Agregando los estados finales del juego

47

Conclusiones del curso

Complementos

48

Diferencias entre var, let y const

49

Memoización: ahorrando cómputo

50

¿Hace cuántos días naciste?

51

Funciones recursivas

52

Entiende los closures de JavaScript

53

Estructuras de datos inmutables

54

Cambiando de contexto al llamar a una función

55

¿Cuándo hace falta poner el punto y coma al final de la línea?

No tienes acceso a esta clase

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

Estructuras repetitivas: while

17/55
Recursos

En esta clase estudiaremos otra estructura repetitiva llamada while. While se ejecuta únicamente mientras la condición que se está evaluando es verdadera.

En ocasiones nuestro código puede fallar por errores de syntaxis o errores lógicos. En caso de que quieras verificar tu código, debes utilizar un debugger. El código se detiene cada vez que lee esta palabra.

Aportes 293

Preguntas 43

Ordenar por:

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

Creo que en este punto se equivocaron, no pueden enseñar un concepto como los ciclos o las funciones y enseguida abreviarlas o utilizar la sintaxis que esta de moda y explicarla en unos cuantos segundos. Se que parte de programar es investigar y averiguar, pero si estoy pagando para que me lo expliquen, entonces alguien aquí se esta equivocando ( o yo al pagar o ustedes al explicar) si la intensión de cada clase es profundizar cada vez mas, entonces deberían tener cuidado con esas abreviaciones que muy seguramente solo lo utilizaran los programadores mas experimentados, esto para el que lo sabe sera muy fácil y muy tonto, pero para el que esta aprendiendo, le molesta y le cabrea por que fácilmente terminamos horas y horas tratando de averiguar que fue lo que hicieron en algún punto cuando si invierten algunos minutos explicándolo entonces no creo que a los mas avanzados les moleste, y si les molesta entonces que vayan y tomen un curso mas avanzado. Me recuerda en el colegio al álgebra, cuando si no entendías algo entonces ese punto te mareaba todo el resto del año por que se trataba siempre de avanzar sobre lo ya aprendido y esta muy bien; solo trato de que consideren explicar mejor las abreviaciones para por lo menos entender lo que trataron de hacer los que cambian las reglas del lenguaje y le agregan ese tipo de cosas por que luego simplemente terminas copiando y pegando lo que hizo el profesor. sinceramente la abreviación de la función me mareo, Ahora estoy tratando de averiguar por otro lado por que por mas que repito el vídeo y miro los comentarios no hallo una respuesta concreta por que simplemente explicar esas cosas toman algo de tiempo; luego me lo colocas en el siguiente vídeo del ciclo for y nuevamente en el ciclo while. y seguramente de aquí para adelante en todos los demás vídeos. ni modo, tendré que volver atrás nuevamente y buscar en otro lado. Y haber si no me salen con otro “esta de moda” y me terminan de cargar el curso. Por que eso de esta de moda, sera por que lo usan los mas experimentados. yo pienso continuar mi aprendizaje en java script, ¿no pueden ponerme estas abreviaciones en el curso definitivo?

Ciclo FOR Lo utilizamos cuando conocemos el número de repeticiones.
Ciclo While Lo utilizamos cuando desconocemos el numero de repeticiones.

como critica constructiva y sin tratar de hacer sentir mal a nadie, me parece que estaría bien que le dedicaran un poco más de tiempo a los cursos que hacen debido a que por ejemplo en particular este, hay veces que a mi parecer el profesor se confunde mucho, obviamente se que es difícil explicar al mismo tiempo que hacer pero por ello pienso que debería practicar más la grabación del mismo hasta que sea mas atendible, de igual forma me gustaría que no se dieran tantos términos técnicos durante las clases pues aquí no indica que haya que tener conocimientos previos y de repente se mencionan palabras que uno nunca había escuchado y no se toman el tiempo de que si darán un termino tecnico al menos adjuntar la información correspondiente, claro que depende de cada estudiante ser autodidacta e investigar por su cuenta pero no estaría mal que organicen mejor la información y las explicación si se esta dando un servicio.

Al principio Sacha se equivocó, no era hasta que se cumpla una condición si no mientras que se cumpla una condición ☝🏼

Todos los bucles son iguales, puesto que todos cumplen con la misma funcion y es, realizar una tarea repetitiva.

Ahora… la gran diferencia entre un while y un for radica en que, en el primero realizas un “hasta” y en el segundo realizas un “mientras” (respectivamente valiendo la redundancia), es decir, que la diferencia mas notoria es que el ciclo while podemos usarlo cuando no sabemos a ciencia cierta el termino de este mismo.

De un error intensional o no, salieron unos excelentes tips por parte de Sacha para hacer un debug a nuestro código.

debugger una excelente herramienta para evitar dolores de cabeza y teclados rotos

ESTRUCTURAS REPETITIVAS: while

La estructura while nos permite repetir un código, hasta que se cumpla una condición

Lo primera que vamos a hacer, será modificar nuestra estructura anterior de la siguiente manera

var angel = {
    nombre: 'Angel',
    apellido: 'Sulbaran',
    edad: 23,
    peso: 70

}

var pepe = {
    nombre: 'Pepe',
    apellido: 'Trueno',
    edad: 13
}

console.log(`anualmente al inicio ${angel.nombre} pesa ${angel.peso}kg`)

const INCREMENTO_DE_PESO = 0.3

const aumentarDePeso = persona => persona.peso += INCREMENTO_DE_PESO
const adelgazar = persona => persona.peso -= INCREMENTO_DE_PESO
const comeMucho = () => Math.random < 0.3
const realizaDeporte = () => Math.random < 0.4
var dias = 0

const META = angel.peso - 3

while (angel.peso > META) {
    debugger
    if(comeMucho()) {
        aumentarDePeso(angel)
    }
    if(realizaDeporte()) {
        adelgazar(angel)
    }
    dias += 1
}

console.log(`pasaron ${dias} dias hasta que ${angel.nombre} adelgazo 3kg`)

Lo primero que hacemos aca es borrar la estructura repetitiva “fot” y asignaremos while de la siguiente manera “while(){}” donde while será la condición para que el código termine de ejecutarse, por lo que mientras no llegue a la condición, no se terminara de ejecutar, siendo asi, las funciones que cumplirá para llegar a la condición, la colocaremos dentro de las llaves.
Nuestra meta aca es que angel rebaje kg, por lo que debemos crear la meta para que angel baje kg.

const META = angel.peso - 3

vamos a crear las funciones aleatorias para que angel aumente o rebaje de peso, de manera que;

const comeMucho = () => Math.random < 0.3
const realizaDeporte = () => Math.random < 0.4

asi que agregaremod esto a la estructura while de la siguiente manera

while (angel.peso > META) {
    debugger
    if(comeMucho()) {
        aumentarDePeso(angel)
    }
    if(realizaDeporte()) {
        adelgazar(angel)
    }
}

Donde colocaremos, dos condiciones que pueden pasar aleatoriamente, si come mucho o si realiza deporte, ahora para calcular los días que le tomara a angel llegar a la meta, crearemos una variable, “dias”, que debe ser agregada de la manera “var días = ” no podemos usar “const” debido a que es un valor sujeto a cambios por lo que si usamos const, nos dará error. Luego de creada la variable, la agregaremos de la siguiente manera

while (angel.peso > META) {
    debugger
    if(comeMucho()) {
        aumentarDePeso(angel)
    }
    if(realizaDeporte()) {
        adelgazar(angel)
    }
    dias += 1
}

Y por último agregaremos un cambio al último console.log;


console.log(`pasaron ${dias} dias hasta que ${angel.nombre} adelgazo 3kg`)

Ahora luego de hecho todo esto, veras que, no te va a funcionar, aca viene una parte muy importante de esta clase, que el debuggin. Usaremos “debugger”;

while (angel.peso > META) {
    debugger
    if(comeMucho()) {
        aumentarDePeso(angel)
    }
    if(realizaDeporte()) {
        adelgazar(angel)
    }
    dias += 1
}

Donde sea que queramos debuggear algo cuando estes probando cosas dentro del navegador, agregaras esto al código que quieres reparar/arreglar/hacer funcionar, como te apetezca decirle, el punto es que esto lo vas a usar en la consola, y te va a cancelar la ejecución del código cada vez que le agregues “debugger” a uno, ahora nos vamos a pestaña sources.

Revisar video de eestructuras while, para repasar en caso de que se olvide un detalle de como sirve esto, o ver un video en Youtube en su defecto.
Aca el bug es muy simple de ver, y es algo que probablemente se te olvido al momento de escribir las arrow functions, pero es algo muy básico que debemos siempre tener en cuenta

const comeMucho = () => Math.random() < 0.3
const realizaDeporte = () => Math.random() < 0.4

No puedes dejar colocar los paréntesis al crear la función, porque con esto es que llamas las funciones, al menos de este tipo, como lo es random.

De modo que nuestro código quedaría asi;

No es buena práctica declarar funciones dentro de un ciclo, porque cada vez se van a declarar una y otra vez hasta que se termine la condición del ciclo.

Por fin entendí como usar Debugger. Vaina como pude estudiar en la U sin eso.

Aca dejo un proyecto que vengo haciendo usando los ciclos
https://github.com/juanda103/Cubo-Rubik

Hola
¿Alguien sabe de alguna pagina donde pueda hacer ejercicios para practicar lo visto hasta hora en con JS?

Muchas gracias

En esta clase tenemos a while como otra alternativa de una estructura repetitiva, que sirve para repetir instrucciones las veces que se desee y tiene estas características.

  • while() Va con la palabra while entre paréntesis va la condición y entre llave sus instrucciones.

  • while( ) evalúa primero la condición, esto que quiere decir entra a ejecutar las instrucciones siempre y cuando la condición se cumpla.

Adicional a esto se aprendió a utilizar debugger, que si estamos en la consola del navegador nos permitirá ir paso a paso para verificar las instrucciones que se ejecuten, y verificar el error.

Hay un curso en Platzi, para aprender a usar el Debugging dDev Tools. Les dejo el enclace<<.

Con un ejemplo mas claro se entendería mas rápido…

/*

Mis principios de programacion:
1. Un programador divide problemas grandes en problemas chiquitos
2. Cada 4 lineas de codigo comento mi codigo
*/

//Imprimiendo algo en la consola
console.log("inicializando archivo");

/*Declaración de objetos
=========================================*/

//Creando el objeto persona
var daniel = {
	nombre: "Daniel",
	apellido: "Páez",
	edad: 18,	
	peso: 55
}

/*Declaración de variables
=========================================*/
var diasDelAño = 365;
var incrementoPeso = 0.300 //0.300 gramos


/*Declaración de funciones
=========================================*/

/**/

/*MODIFICADORES DE MI PESO
=============================*/

//Funcion donde se aumenta el valor del peso del objeto persona
const aumentarDePeso = persona => persona.peso += incrementoPeso;

//Funcion donde se baja el valor del peso del objeto persona
const bajarDePeso = persona => persona.peso -= incrementoPeso;

//Arrow Funcion Come MMucho

const comeMucho = () => Math.random() < 0.30; //30% del tiempo come mucho

const realizaDeporte = () => Math.random() < 0.40;
 //40% del tiempo hace deporte


/*========================================*/

/* Nuestra persona Daniel fue al nutricionista y le dijeron vos tenes que
		bajar 3 kilos cuanto antes*/

	//Por lo tanto
	const META = daniel.peso - 3;
	var diasParaAdelgazar = 0;
	//var diasLimite = 1000;
		


function cambioPeso(persona) {

			//Mientras el peso de daniel sea mayor que su peso meta, ejecuta
			while (persona.peso > META /*|| diasParaAdelgazar < diasLimite*/) {

				//debugger

				if ( comeMucho() ) {
					//aumentar de peso
					aumentarDePeso(persona)
				}

				 if ( realizaDeporte() ) {
					//adelgazar
					bajarDePeso(persona)
				}

				diasParaAdelgazar += 1;
				//agrega un dia cada vez que se repita el ciclo
			}
		}




/*Consola y consultas
=========================================*/
console.log(`Al inicio del año ${daniel.nombre} pesa ${daniel.peso} kg`)	

/*Ejecución de funciones
=========================================*/
 cambioPeso(daniel)

if (daniel.peso <= META) {

	console.log(`AL FIN, Despues de ${diasParaAdelgazar} días ${daniel.nombre} pesa ${daniel.peso.toFixed(1)} kg`)
}

else {
	console.log(`ME RINDO, Despues de ${diasParaAdelgazar} días ${daniel.nombre} pesa ${daniel.peso.toFixed(1)} kg`)
}

/* 
IDEAS CLAVES
-------------
=> DEBUGGER
un salva vidas
 el primer boton hace que se siga ejecutando 
 hasta que termine o encuentre otro debugger

 la siguiente lo pasa a la siguiente linea

step te permite seguir al siguiente paso que ejecutara el codigo

los breakpoints te permiten crear mini debuggers

------------------------------*/

aprendiendo a utilizar el "debugger"

Debugger ❤️

Por acá dejo mi ejercicio:


var cosme = {
    name: "Cosme",
    lastName: "Fulanito",
    age: 28,
    weight: 75.1
};

const WEIGHT_VALUE = 0.2;
const DAYS_OF_YEAR = 365;
const GOAL = cosme.weight - 3;

var DAYS = 0;

// ARROW FUNCTIONS
const gainWeight = (person) => { return person.weight += WEIGHT_VALUE };
const loseWeight = (person) => { return person.weight -= WEIGHT_VALUE };
const eatingTooMuch = () => { return Math.random() < 0.3 };
const exercising = () => { return Math.random() < 0.4 };

console.log(`The initial weight of ${cosme.name} ${cosme.lastName} is ${cosme.weight} kg.`);
console.log(`And the GOAL is ${GOAL}.`);

while (GOAL < cosme.weight) {
    if (eatingTooMuch()) {
        gainWeight(cosme);
    }
    if (exercising()) {
        loseWeight(cosme);
    }
    DAYS += 1;
}

console.log(`Congrats ${cosme.name} ${cosme.lastName}!!! You achieved your goal in just ${DAYS} days.`);

No entiendo por qué Math.random < 0.4 quiere decir que menos del 40% de días realiza deporte. Tengo entendido que Math.random te da un número aleatorio entre cero y uno pero esto no quiere decir que el 40% de días realice deporte … o si?

Usando dos Math.random el número que viene es el mismo o cada random tiene un número diferente??
El segundo random al ser < 0.4 incluye el valor 0.3??
No entiendo por qué Sacha hace referencia a porcentajes, si random es un número aleatorio lo que entiendo yo es que si el numero aleatorio te da un número menor que 0.3 comeMucho y si el numero aleatorio asignado es menos que 0.4 realizaDeportes.

Se nota claramente que el profesor le falto preparación en sus clases

Mi versión del ejercicio:

//Cilo for
var sergio = {
    nombre: 'Sergio',
    apellido: 'Maury',
    edad: 23,
    peso: 90
}

const goal = 87
var days = 1
const bajarPeso = (persona, random) => persona.peso -= random

while (sergio.peso > goal) {
    var random = Math.random().toFixed(2)
    bajarPeso(sergio, random)
    days ++
}

console.log(`Felicitaciones ${sergio.nombre}, lograste bajar a ${goal} kilos en ${days} dias`)

while (condición) {
  
}

Al ser una simulación el los datos originales de la persona no deberían variar para que se puedan realizar muchas más simulaciones y ver los distintos resultados

var persona = {
	nombre: 'Bryam',
	apellido: 'Soto',
	edad: 23,
	peso: 68,
	programador: true,
	guitarrista: true,
	bailarin: false,
	juerguero: true,
	cocinero: false
}

/* Constantes */
const VARIACION_PESO = 0.3
const DIAS_ANIO = 365

/* Arrow functions */
const aumentarPeso = (persona) => persona.peso += VARIACION_PESO
const bajarPeso = (persona) => persona.peso -= VARIACION_PESO
const comeMucho = () => Math.random() < 0.3
const haceEjercicios = () => Math.random() < 0.4


/*	Estructura repetitiva while */

function simulacionWhile(persona){

	// Se crea una réplica del objeto para evitar que se modifique por referencia
	var persona = {
		...persona
	}
	
	console.log(`Peso inicial: ${persona.peso.toFixed(1)}`)

	const META = persona.peso - 3
	var dias = 0

	while(persona.peso > META){
		
		if(comeMucho()){
			aumentarPeso(persona)
		}
		
		if(haceEjercicios()){
			bajarPeso(persona)
		}

		dias++
	}

	console.log(`Peso final: ${persona.peso.toFixed(1)}`)
	console.log(`Pasaron ${dias} dias`)

}


simulacionWhile(persona)
simulacionWhile(persona)
simulacionWhile(persona)
simulacionWhile(persona)

// La fuente de datos se mantiene pero los resultados varian


Quedate en casa chapulin!! 😃

Muy interesante lo del debugger

Había visto de manera general como usar el debbuger, pero en ejemplos controlados, en algo que ya se sabía que era error, en este caso fue algo “natural” y son errores comunes a la hora de escribir. Me gustó mucho esta clase

Este código lo que hace es escribir en la consola lo mismo que lo que se hizo en clase solo que escribe que paso cada dia, ej

El dia 1 martin subio 200 gramos
el dia 2 se mantuvo igual…

const aumentarDePeso = (persona) => persona.peso += 0.2;
const disminuirDePeso = (persona) => persona.peso -= 0.2;
var felix = {
  nombre: "Felix",
  edad: 12,
  peso: 54
}

console.log("Al principio del año " + felix.nombre + " pesaba " + felix.peso + " kilos");
for(var d = 1; d <= 365; d++){
  var random = Math.random();

  if(random < 0.25){
    aumentarDePeso(felix);
    console.log("El dia "+d+" Felix aumento 200 gramos");
  }else if (random < 0.5){
    disminuirDePeso(felix);
    console.log("El dia "+d+" Felix disminuyo 200 gramos");
  }else {
    console.log("El dia "+d+" Felix siguio igual que el dia anterior");
  }
}
console.log("Al final del año " + felix.nombre + " pesa " + felix.peso.toFixed(2) + " kilos");

Mi aporte en esta clase.

var persona = {
    nombre: 'Alejandro',
    apellidos: 'González Reyes',
    edad: 34,
    peso: 96
}

// La persona puede o no incrementar o bajar solo 2 gramos al día
const INC_DEC_PESO = 0.2
// La meta es que esta persona baje 3Kg 
const META = persona.peso - 3
// Contador de días que tarda la persona en lograr la meta
var dias = 1


// Funciones para incrementar o decrementar de peso a una persona
const aumentarPeso = persona => persona.peso += INC_DEC_PESO
const bajarPeso = persona => persona.peso -= INC_DEC_PESO
// Funciones para monitorear la masa corporal de la persona. Con base en ello se puede establecer si la persona subio de peso o bajo de peso en un día
const comeMucho = () => Math.random() > 0.7
const haceDeporte = () => Math.random() < 0.4


console.log(`${persona.nombre} ${persona.apellidos} comienza el año con un peso de ${persona.peso.toFixed(1)} Kg`)


// Iterador que permite derminar si la persona necesita un día más para lograr su meta. Este termina de repetirse hasta que peso de la persona no supere la meta establecida.
while(persona.peso > META) {
    
    // Para inspeccionar nuestro código en busca de errores, es necesario declarar el keyword debugger, en aquellos lugares donde el código se comporte de forma extraña o arroje resultados inesperados.
    
    // debugger
    
    if(comeMucho()) {
        aumentarPeso(persona)
    }
    if(haceDeporte()) {
        bajarPeso(persona)
    }
    dias++
}

console.warn(`Pasaron ${dias} dias para que ${persona.nombre} ${persona.apellidos} lograra la meta de bajar 3kg. Por tanto, pesa ahora ${persona.peso.toFixed(1)} Kg`)

Para el caso de la variable META, esta debería ser let y no const ya que depende de otra variable que puede ser distinta según la persona ingresada. Con respecto a esto mismo, creo que desde el comienzo se debió explicar la diferencia entre var, let, y const en cuanto a comportamiento, alcance, etc. ya que en todos los cursos y libros que he revisado con anterioridad este es un concepto que se introduce al comienzo. Esto también es valido para las distintas formas de definición de funciones, ya que es de vital importancia entender el alcance de estas según la forma en que se construyen.

Muy útil el debugger, no tenía conocimiento de este. 🙂

La explicación del debugger fue aterradora.Ni pio entendi…

/*
    En esta clase estudiaremos otra estructura repetitiva llamada while. While se ejecuta únicamente mientras la condición que se está evaluando es verdadera.

    En ocasiones nuestro código puede fallar por errores de syntaxis o errores lógicos. En caso de que quieras verificar tu código, debes utilizar un debugger. El código se detiene cada vez que lee esta palabra.
*/

//En el siguiente ejemplo haremos un ejercicio para descubrir cuantos dias tarda la persona en bajar 3 kilos.

var hugo = {
    nombre: 'Hugo',
    apellido: 'Barrera',
    edad: 30,
    peso: 80
}

console.log(`Al inicio del año ${hugo.nombre} pesa ${hugo.peso}kg`);

const INCREMENTO_PESO = 0.3;
const DECREMENTO_PESO = 0.3;
const DIAS_ANO = 365;

const aumentarDePeso = persona => persona.peso += INCREMENTO_PESO;
const adelgazar = persona => persona.peso -= DECREMENTO_PESO;
const comeMucho = () => Math.random() < 0.3; //() significa que no le pasamos ningun parametro.
const realizaDeporte = () => Math.random() < 0.4;

const META = hugo.peso - 3; //Se crea una variable const donde se le asignara la meta que debe llegar la persona.
var dias = 0;

while (hugo.peso > META) { //Lo que se encunetra en parentesis es una condicion, el codigo posterior al while no se ejecutara hasta que la condicion de falsa. Es decir, mientras que la condicion se este cumpliendo la ejecucion del codigo permanecera en el while.
    // debugger  //debugger nos ayuda con la reparacion de bugs, su funcion es detener el codigo donde quiera que se agregue y podremos ir revisando dentro de la herramienta de desarrollo en chroome->Source
    if (comeMucho()) {
        aumentarDePeso(hugo);
    }
    if (realizaDeporte()) {
        adelgazar(hugo);
    }
    dias += 1;
}

console.log(`Pasaron ${dias} días, hasta que ${hugo.nombre} adelgazo 3kg`);```

😮 El debugger si funciona 😄

password = prompt('ingrese la contraseña: ')

while(password != 'pepito'){
    alert('CONTRASEÑA INCORRECTA \n VUELVA A INTENTARLO')
    password = prompt('ingrese la contraseña: ')
}

alert('WELCOME TO THE MATRIX')
var ender = {
  nombre: "Ender",
  apellido: "Peña",
  edad: 38,
  peso: 108
}

console.log(`Al inicio del año ${ender.nombre} ${ender.apellido} pesa ${ender.peso}Kg`);

const INCREMENTO_DE_PESO = 0.3;
const DIAS_DEL_ANO = 365;

const aumentaDePeso = persona => persona.peso += INCREMENTO_DE_PESO;
const adelgazarPeso = persona => persona.peso -= INCREMENTO_DE_PESO;

const comeMucho = () => Math.random() < 0.3

const haceDeporte = () => Math.random() < 0.4

const META = ender.peso -3
var dias = 0

while(ender.peso > META){
  if(comeMucho()){
    aumentaDePeso(ender)
  }

  if(haceDeporte()){
    adelgazarPeso(ender)
  }
  dias += 1
}

console.log(`Pasaron ${dias} hasta que ${ender.nombre} ${ender.apellido} adelgazo 3Kg`);```

Ejecuto el código y queda cargando sin que pueda acceder a la consola, imagino que entra en un ciclo infinito, utilizo el debugger y no encuentro nada aparentemente incorrecto. Alguien me podría decir si me estoy equivocando en algo? Gracias!

var doug = {
    nombre: "Douglas",
    edad: "31 años",
    peso: 83
};

console.log(`Al inicio del año ${doug.nombre} pesa ${doug.peso} kilogramos`);

const INCREMENTO_PESO = 0.3;

const aumentoDePeso = persona => persona.peso += INCREMENTO_PESO;
const bajoDePeso = persona => persona.peso -= INCREMENTO_PESO;

const META = doug.peso - 3;

const realizaDeporte = () => Math.random() < 0.3
const comeMucho = () => Math.random() < 0.4

var dias = 0;

while (doug.peso > META) {
    
    if (realizaDeporte()) {
        bajoDePeso(doug);
    }
    if (comeMucho()) {
        aumentoDePeso(doug);
    }
    dias += 1;
}

console.log(`${doug.nombre} bajó 3 kilos en ${dias} días`);

Google Dev Tools creo se convertirá en el mejor amigo de muchos.

Lo logramos

<script>
        var Paul = {
            nombre:'Paul',
            apellido :'Vargas',
            edad : 28,
            peso : 75 //kilogramos
        }

        console.log(`Al inicio del año ${Paul.nombre} pesa ${Paul.peso.toFixed(1)}kg` )

        const DIAS_DEL_AÑO = 365
        const INCREMENTO = 0.1

        const aumentoDePeso = persona => persona.peso += INCREMENTO
        const adelgaza = persona => persona.peso -= INCREMENTO

        const comeMucho = persona => Math.random() < 0.3
        const ejercicio = persona => Math.random() < 0.4

        const META = Paul.peso - 3
        var dias = 0

        while (Paul.peso > META) {
            if (comeMucho()){
                aumentoDePeso(Paul)
            }
            if (ejercicio){
                adelgaza(Paul)
            }

            dias += 1
        }

        console.log(`${Paul.nombre} se demoro ${dias} dias en bajar 3 kg` )
    </script>
    😷 #QuedateEnCasa

While para condiciones
For para rangos de numeros

Una curiosidad:

Si al final del código aplican un console.log() así:

console.log(` Despues de ${dias} dias, ${sacha.nombre} pesa ${sacha.peso} kg`)

// Console
//  Despues de 93 dias, juan pesa 41.70000000000003 kg

Se darán cuenta que gracias a que se resta un decimal, Javascript falla con el resultado.

Cómo solucionarlo? Podemos escribir una variable que contenga el peso de Sacha, pero con un Math.floor() para eliminar el problema

        var pesoDeSacha = Math.floor(sacha.peso)

        console.log(` Despues de ${dias} dias, ${juan.nombre} pesa ${pesoDeSacha} kg`)

//Console
//  Despues de 93 dias, Sacha pesa 41 kg

Mmms le di recargar a la pagina y se queda cargando jaja

No entendí del todo como funciona el debbuger! :C
Mis apuntes:

//WHILE
var natanael = {
   nombre: 'natanael',
   apellido: 'león',
   edad: 30,
   peso: 98
}
 
console.log(`Al inicio del año ${natanael.nombre} pesa ${natanael.peso}kg`)
 
   const INCREMETO_PESO = .300
   const DIAS_DEL_AÑO = 365
   //usamos arrow function
   const aumentarPeso = persona => persona.peso += INCREMETO_PESO
   /*qué es lo mismo que
   function aumentarPeso (persona) {
      return persona.peso += .200
   }*/
   const adelgazar = persona => persona.peso -= INCREMETO_PESO
   const META = natanael.peso -3
   const comeMucho = () => Math.random() < 0.3
   const realizaDeporte = () => Math.random() < 0.4
   var dias = 0
/*Como funciona While: el código que esta entre llaves se va a repetir mientras el código dentro de los paréntesis se cumpla dicha condición (true), cuando se false continua con el código*/
   while(natanael.peso > META){
       /*detiene la ejecución del programa cada vez que lea debugger*/
       if (comeMucho()){
           aumentarPeso(natanael)
       }
       if (realizaDeporte()){
           adelgazar(natanael)
       }
       dias += 1
   }
console.log(`Pasaron ${dias} días hasta que ${natanael.nombre} adelgazo 3kg`)

Buenas tardes, una duda ¿Por que si pongo en el segundo condicional dentro del while un else if, en vez de un if solamente se me queda en un bucle infinito?

Agradezco me ayuden con esa duda, segun lo que tengo entendido es valido lo que estoy haciendo.

var isay = {
	nombre : 'Isay',
	apellido : 'Gonzalez',
	edad: 28,
	peso: 70
}

const DIAS_DEL_ANIO = 365;

const BAJA_DE_PESO = 0.300; 

const META_EN_KILOS = isay.peso - 3; 

console.log(`Al inicio del año ${isay.nombre} pesa ${isay.peso} kg.`)

const aumentarDePeso = persona => persona.peso += BAJA_DE_PESO;

const adelgazar = persona => persona.peso -= BAJA_DE_PESO;

const comeMucho = () => Math.random() < 0.3
//Modifiqué el porcentaje porque con 0.4 lo ejecutaba bien la primer vez pero las siguientes se quedaba colgado
const realizaDeporte = () => Math.random() < 0.6

var dias = 0;

while (isay.peso > META_EN_KILOS){
	if(comeMucho()){
		//AumentarDePeso
		aumentarDePeso(isay);
	}else if(realizaDeporte()){
		//adelgazar
		adelgazar(isay);
	}
	dias += 1;
}

console.log(`Pasaron ${dias} para que ${isay.nombre} logrará bajar 3 kilos.`)```

mi codigo esta igual que el de Sacha, solo que lo entinedo mejor poniendo las llaves:
const aumentoDePeso = (persona) => {persona.peso += INCREMENTO_PESO}
const disminuyaDePeso = (persona) => {persona.peso -= INCREMENTO_PESO}
const comeMucho = () => { Math.random() < 0.3 }
const realizaDeporte = () =>{ Math.random() < 0.4 }

sin embargo al dejarlo asi no funciona, pero cuando le quito las llaves a la ultima linea
const realizaDeporte = () => Math.random() < 0.4
si funciona… alguien sabe por que sucede esto???

Mi aporte

//Programa encuentra la varación de peso anual

var Carmen ={
    nombre: 'Carmen',
    apellido: 'Villalobos',
    edad: 25,
    peso: 60
}

//Peso al inicio de año
console.log(`Al inicio del año ${Carmen.nombre} tiene ${Carmen.peso} kilos`)

//denifimos las constantes del problema
const VARIACION_DE_PESO = 0.1
const DIAS_DEL_ANNO = 365

//Definimos las funciones de aumento y disminución de peso
const aumentarDePeso = persona => persona.peso += VARIACION_DE_PESO
const disminuirDePeso = persona => persona.peso -= VARIACION_DE_PESO

const comeMucho = () => Math.random() < 0.3
const realizaDeporte = () => Math.random() > 0.4
var dias = 0

//Meta, bajer de peso 3 kg
const META = Carmen.peso - 1

//Loop
while (Carmen.peso > META) {
   // debugger
    if (comeMucho()) {
        //aumenta de peso
        aumentarDePeso(Carmen)
    }
    if (realizaDeporte()) {
        //disminuye peso
        disminuirDePeso(Carmen)
    } 
    dias +=1
}

//Cuando completo la menta
console.log(` ${Carmen.nombre} ha logrado su meta en  ${dias} dias`)```

wowwwww! metio un 2x1!!! GRACIAS SACHAAAAA, AHORA SE COMO HACER DEBUGGER!

El ciclo while difiere del for en que en este debemos determinar de una forma un poco mas manual cuado finaliza el ciclo

var johan = {
    nombre: "Johan",
    apellido: "Echeverri",
    edad: 29,
    peso: 82
}
console.log(`Al inicio de año ${johan.nombre} pesa ${johan.peso}kg`);


const INCREMENTO_PESO = 0.3;
const DIAS_DEL_ANO = 365;

const aumentarDePeso = persona => persona.peso += INCREMENTO_PESO;
const adelgazar = persona => persona.peso -= INCREMENTO_PESO;
const comeMucho = () => Math.random() < 0.3;
const realizaDeporte = () => Math.random() < 0.4;
var dias = 0;

const META = johan.peso - 3;

while (johan.peso > META) {
    
    if (comeMucho()) {
        aumentarDePeso(johan)
    }
    if (realizaDeporte()) {
        adelgazar(johan);
    }
    dias++ 
}
/* el ciclo while difiere del for en que en este debemos determinar de una forma un poco mas manual cuado finaliza el ciclo */
console.log(`Pasaron ${dias} dias hasta que ${johan.nombre} adelgazo 3kg`)

Bien ahí 💪🏼, while, for e if/else aprendidos papa, esto es divertido, vamos por massss

Así quedó el ejercicio:

El profesor se equivoco por no seguir la sintaxis de Javascript, me pueden decir que se puede omitir un punto y coma ; o un parentesis () pero creo que es mejor seguir con la sintaxis estricta asi nos podemos evitar errores de este tipo…

No hagas esto

while(true)
{
console.log('No hacer esto')
}

Ya que no me carga el video termine el ejercicio del profe a mi manera 😛

var sasha = {
  nombre: "Sasha",
  apellido: "Hobs",
  edad: 28,
  peso: 70,
};

console.log(`Al inicio del año ${sasha.nombre} pesa ${sasha.peso}kg.`);

const INCREMENTO_PESO = 0.2;
const DECREMENTO_PESO = 0.3;

const aumentarPeso = (persona) => (persona.peso += INCREMENTO_PESO);
const adelgazar = (persona) => (persona.peso -= DECREMENTO_PESO);

const META_PESO = sasha.peso - 3;
var dias_meta = 1;

while (sasha.peso >= META_PESO) {
  var random = Math.random();
  if (random < 0.25) {
    aumentarPeso(sasha);
  } else {
    adelgazar(sasha);
  }
  dias_meta += 1;
}
sasha.peso = sasha.peso.toFixed(2);
// console.log(`Al final del año ${sasha.nombre} pesa ${sasha.peso}kg`);
console.log(
  `Al final del año ${sasha.nombre} cumplio la meta de ${META_PESO}kg en ${dias_meta} dias.`
);
console.log(`${sasha.nombre} termino la meta con  ${sasha.peso}kg.`);

Lo mejor de esta clase es el haber aprendido a como usar el debugger

Mi ansiedad al ver que Sacha no cierra la pestaña con el loop infinito 📈

Opciones para debuggear en la misma pestaña sources

Disfruten mi codigo

var joseph = {
    nombre: 'Joseph',
    apellido: 'Estrada',
    edad: 25,
    peso: 75
}

console.log(`Al inicio del año ${joseph.nombre} pesa ${joseph.peso} kg`)

const INCREMENTO_PESO = 0.3
const DIAS_DEL_ANNO =365

const aumentarDePeso = persona => persona.peso += INCREMENTO_PESO
const adelgazar = persona => persona.peso -= INCREMENTO_PESO
const comeMucho = () => Math.random() < 0.3
const realizaDeporte = () => Math.random() < 0.7
var dias = 0 
const META = joseph.peso - 15


while (joseph.peso > META) {
     
    if (comeMucho()) {
        aumentarDePeso(joseph)
    }
    if (realizaDeporte()) {
        adelgazar(joseph)
    }
    dias += 1
}

console.log(`Pasarán ${dias} días hasta que  ${joseph.nombre} adelgaze 15 kg`)```
var fernando = {
  nombre: 'Fernando',
  apellido: 'Galdos',
  edad: 36,
  peso: 85
}

console.log(`Al inicio del annio ${fernando.nombre} pesa ${fernando.peso}Kg`)

// function aumentarDePeso (persona) {
//   return persona.pes =+ 200
// }

const INCREMENTO_PESO = 0.3
const DIAS_DEL_ANNIO = 365

const aumentarDePeso = persona => persona.peso += INCREMENTO_PESO

const adelgazar = persona => persona.peso -= INCREMENTO_PESO

const comeMucho = () => Math.random() <  0.3
const realizaDeporte = () => Math.random() < 0.4

const META = fernando.peso - 3
var dias = 0 

while (fernando.peso > META) {

  if (comeMucho()) {
    aumentarDePeso(fernando)
  }
  if (realizaDeporte()) {
    adelgazar(fernando)
  }
  dias += 1
}

console.log(`Pasaron ${dias} dias hasta que ${fernando.nombre} adelgazo 3Kg`)```

Mi código antes de ver el video 😂

const NUMERO_MAXIMO = 5
const NUMERO_MINIMO = -5

const ALEATORIOS = (NUMERO_MINIMO, NUMERO_MAXIMO) =>
    Math.round(Math.random() * NUMERO_MAXIMO +  Math.random() * NUMERO_MINIMO)
    // Si no se pone round sale algo así 0.3994152569019116

var nicoll = {
    nombre :  "nicoll",
    edad: 19,
    peso: 75
} 

console.log("Nicoll pesaba", nicoll.peso)

const incrementoPesoPersona = (persona, incremento) => persona.peso += incremento
const DIAS_DEL_AÑO = 365

const META = nicoll.peso - 3
let DIAS = 1
while(nicoll.peso > META){
    incremento = ALEATORIOS(NUMERO_MINIMO, NUMERO_MAXIMO)
    incrementoPesoPersona(nicoll, incremento)
    // console.log(incremento, nicoll.peso)
    DIAS ++
}

console.log("Al final del año nicoll peso ", nicoll.peso, "en", DIAS, "días")

Hata bueno que se presentara ese error de Math.random para empezar a empaparse de terminos como debugging

var yo = {
nombre: Kike,
edad: 34,
kilos: 64.500
}

console.log(Al inicio del año, ${yo.nombre} pesa ${yo.kilos} kg.)

const INCREMENTO_PESO = 0.35
const DIAS_DEL_ANO = 365

function aumentar(persona) {
return persona.kilos += INCREMENTO_PESO
}
function disminuir(persona) {
return persona.kilos -= INCREMENTO_PESO
}
const comer = () => Math.random() < 0.3
const ejercicio = () => Math.random() > 0.4

//for (var i = 1; i <= DIAS_DEL_ANO; i++) { // Esto es un CONTADOR.
// var random = Math.random()
// if (random < 0.25) {
// aumentar(yo)
// } else if (random < 0.5) {
// disminuir(yo)
// }
//}

const META = yo.kilos - 3
var dias = 0

while (yo.kilos > META) {
if (comer()) {
aumentar(yo)
} if (ejercicio()) {
disminuir(yo)
}
dias += 1
}

//console.log(Al final del año, ${yo.nombre} pesa ${yo.kilos.toFixed(3)} kg.)

console.log(Pasaron ${dias} dias y ahora ${yo.nombre} pesa 3 kilos menos.)

¿por que nombra como constantes las arrow functions aumentarDePeso, adelgarzar, comeMucho, etc, ?
los valores que retorna son variables, pero y si son constantes, ¿por qué no los nombra en mayusculas?
es una sencilla duda.

El cuidado con el While es que podemos crear sin querer un bucle infinito.

La teoría la entiendo pero al momento de realizar un ejercicio veo todo difícil y me cuesta entenderlo.
Diosssss que frustración.!!!

Cuando la condición del while se vuelve falsa, continúa ejecutándose el resto del código, es decir, pasa a ejecutar la siguiente línea.

Mientras la condición sea verdadera, while se ejecutará.

Aquí mi aporte! Espero que no esté enredado 😄

Me gustan las clases de Sacha, son super fáciles de entender

Como debugguear en JavaScript

Estructura del ciclo WHILE en JS:

while(persona.peso > META){
    //debugger
    if(comeMucho()){
        aumentardePeso(persona)
    }
    if(realizaDeporte()){
        adelgazar(persona)
    }
    dias+=1
}

Se puede cerrar una ventana que este bloqueada si vamos a

Navegador > Ventana > Administrador de Tareas

Podemos cerrar únicamente la ventana que falla para no cerrar el navegador.

En todas las clases de introduccion a javascript que he tomado jamás habia visto el empleo de debbuger para ayudarte a debuggear tu codigo. Interesante.

Vamos

Muy buena clase.

Tengan en cuenta que para programar cada quien tiene su lógica, las sentencias pueden estar diferentes pero todas llevan al mismo resultado, quizás unos mas óptimos y otros menos óptimos pero es el mismo resultado!

buenas comunidad, en la consola no me muestra la condicion de mi codigo

const ComePoco=1
const ComeMucho=3
var total=1
const randomlunch=()=>Math.round(Math.random()*(ComeMucho-ComePoco)+ComePoco)

while(total<=10)
{
total++
if (randomlunch()>=3) 
{
console.log(`persona almorzo ${randomlunch()} veces hoy y esta satisfecho`)

}
else if (randomlunch()<=1) 
{
	console.log(`persona almorzo ${randomlunch()} veces hoy y esta ambriento`)
}}

esto un ejemplo lo que me muestra en la consola
persona almorzo 3 veces hoy y esta ambriento
persona almorzo 2 veces hoy y esta satisfecho

donde persona si almorzo 3 veces tendria que salirme satisfecho alguna ayuda

No había visto el while y do while en javascript

¿por qué no usó en el segundo IF un IF ELSE ?

Muy importante la función de debugger.

Super!!

Hola, tengo una pregunta…

Por que razon cuando se ejecuta el codigo de la siguiente manera queda en un bucle?

Pero si dejo el codigo sin las llaves y que quede en una sola linea me funciona normal

const comeMucho = () => {
    Math.random() < 0.3
}

const reDeporte = () => {
    Math.random() < 0.4
}

La clase del WHILE

var KarlxS = {
    nombre: '**KarlxS**',
    apellido: 'Guzman',
    edad: 23,
    peso: 75
}

console.log(`Al inicio del año ${KarlxS.nombre} pesa ${KarlxS.peso}kg`)

const INCREMENTO_PESO=0.3

const aumentarDePeso = persona =>persona.peso += INCREMENTO_PESO
const adelgazar = persona =>persona.peso -= INCREMENTO_PESO
const comeMucho = () => Math.random() < 0.3
const realizaDeporte = () => Math.random() <0.4

const META=KarlxS.peso - 3
var dias = 0

while (KarlxS.peso>META){
    if (comeMucho()) aumentarDePeso(KarlxS)
    if(realizaDeporte()) adelgazar(KarlxS)
    dias += 1
}

console.log(`Pasarn ${dias} dias hasta que ${KarlxS.nombre} adelgazo 3kg`)
Muy buen aporte lo del debugger, like si eres de los que siempre usaba console.log() para todo
/*

Mis principios de programacion:
1. Un programador divide problemas grandes en problemas chiquitos
2. Cada 4 lineas de codigo comento mi codigo
*/

//Imprimiendo algo en la consola
console.log("inicializando archivo");

/*Declaración de objetos
=========================================*/

//Creando el objeto persona
var daniel = {
	nombre: "Daniel",
	apellido: "Páez",
	edad: 18,	
	peso: 55
}

/*Declaración de variables
=========================================*/
var diasDelAño = 365;
var incrementoPeso = 0.300//0.300 gramos


/*Declaración de funciones
=========================================*/

/**/

/*MODIFICADORES DE MI PESO
=============================*/

//Funcion donde se aumenta el valor del peso del objeto persona
const aumentarDePeso = persona => persona.peso += incrementoPeso;

//Funcion donde se baja el valor del peso del objeto persona
const bajarDePeso = persona => persona.peso -= incrementoPeso;

//Arrow Funcion Come MMucho

const comeMucho = () => Math.random() < 0.30; //30% del tiempo come mucho

const realizaDeporte = () => Math.random() < 0.40;
 //40% del tiempo hace deporte


/*========================================*/

/* Nuestra persona Daniel fue al nutricionista y le dijeron vos tenes que
		bajar 3 kilos cuanto antes*/

	//Por lo tanto
	const META = daniel.peso - 3;
	var diasParaAdelgazar = 0;
	//var diasLimite = 1000;
		


functioncambioPeso(persona) {

			//Mientras el peso de daniel sea mayor que su peso meta, ejecuta
			while (persona.peso > META /*|| diasParaAdelgazar < diasLimite*/) {

				//debugger

				if ( comeMucho() ) {
					//aumentar de peso
					aumentarDePeso(persona)
				}

				 if ( realizaDeporte() ) {
					//adelgazar
					bajarDePeso(persona)
				}

				diasParaAdelgazar += 1;
				//agrega un dia cada vez que se repita el ciclo
			}
		}




/*Consola y consultas
=========================================*/
console.log(`Al inicio del año ${daniel.nombre} pesa ${daniel.peso} kg`)	

/*Ejecución de funciones
=========================================*/
 cambioPeso(daniel)

if (daniel.peso <= META) {

	console.log(`AL FIN, Despues de ${diasParaAdelgazar} días ${daniel.nombre} pesa ${daniel.peso.toFixed(1)} kg`)
}

else {
	console.log(`ME RINDO, Despues de ${diasParaAdelgazar} días ${daniel.nombre} pesa ${daniel.peso.toFixed(1)} kg`)
}

/* 
IDEAS CLAVES
-------------
=> DEBUGGER
un salva vidas
 el primer boton hace que se siga ejecutando 
 hasta que termine o encuentre otro debugger

 la siguiente lo pasa a la siguiente linea

step te permite seguir al siguiente paso que ejecutara el codigo

los breakpoints te permiten crear mini debuggers

------------------------------*/
var sacha = {
    nombre: 'Sacha',
    apellido: 'Lifszyc',
    altura: 1.72,
    cantidadDeLibros: 111
}

var alan = {
    nombre: 'Alan',
    apellido: 'Perez',
    altura: 1.86,
    cantidadDeLibros: 78
}

var martin = {
    nombre: 'Martin',
    apellido: 'Gomez',
    altura: 1.85,
    cantidadDeLibros: 132
}

var dario = {
    nombre: 'Dario',
    apellido: 'Juarez',
    altura: 1.71,
    cantidadDeLibros: 90
}

var vicky = {
    nombre: 'Vicky',
    apellido: 'Zapata',
    altura: 1.56,
    cantidadDeLibros: 91
}

var paula = {
    nombre: 'Paula',
    apellido: 'Barros',
    altura: 1.76,
    cantidadDeLibros: 182
}

const reducer = (acum, { cantidad de libros }) =>  acum +  cantidadDeLibros ;

var totalDeLibros = personas.reduce(reducer, 0)

console.log('En total todos tienen ${totalDeLibros} libros')

const esAlta = ({altura}) => altura >= 1.8
const esBaja = ({altura}) => !esAlta(altura)

var personas = [sacha, alan, martin, dario, vicky, paula]

var personasAltas = personas.filter(esAlta)
var personasBajas = personas.filter(esBaja)

console.log(personasAltas)
console.log(personasBajas)```

Muy interesante

while con el do while es diferente