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: for

16/55
Recursos

En esta clase estudiaremos una de las estructuras básicas de control. El bucle for, se utiliza para repetir una o más instrucciones un determinado número de veces.

Para escribir un bucle for se coloca la palabra for seguida de paréntesis y llaves.
Ej. for( ){ }. Dentro de los paréntesis irán las condiciones para ejecutar el bucle, y dentro las llaves irán las instrucciones que se deben repetir.

En este ejemplo la variable i la utilizamos como contador.

Aportes 324

Preguntas 62

Ordenar por:

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

Un codigo ordenado…

/*

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.200 //0.200 gramos


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

/**/

//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;


function cambioPeso(persona) {

	//este codigo se ejecutara TODOS LOS DIAS DEL AÑO
	for(var i = 1; i <= diasDelAño ; i++) {

		var ramdom = Math.random();
		//una variable guarda un numero aleatorio entre 0 y 1

		//este codigo se ejecutara el 25% de las veces
		if( ramdom <= 0.25) {
			//aumenta de peso
			aumentarDePeso(persona)
		}

		else if (ramdom <= 0.50 ) {
			//baja de peso
			bajarDePeso(persona)
		}

	}

}



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

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

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

/* 
IDEAS CLAVES
-------------
=> 
------------------------------*/

¡Entendido!

Muy buena clase en general, les recomiendo visual studio code completamente. Los colores ayudan mucho a distinguir si tu código va bien o no 😃

Dias del an… jajajajajja

los que no sepan hacer las comillas invertidas presionen ALT + 96

La explicación del bucle for esta perfecto, pero el aumento de peso no se ejecuta el 25% de los días ni adelgazar el 25% de los días como decís. El random va a tener un valor aleatorio de 0(incluido) a 1(no icluido), entonces si por ejemplo el valor random entre 0 y 0,25 sale 200 veces ya es mayor a 25% de los días. Quiero decir no tiene nada que ver con el porcentaje o la cantidad de días. Saludos!

RESUMEN:
Los ciclos o bluces For nos permite realizar tareas repetitivas.
Crea un bucle que consiste en tres expresiones opcionales, encerradas en paréntesis y separadas por puntos y comas, seguidas de una sentencia ejecutada en un bucle.
For ([expresion-inicial]; [condicion]; [expresion-final-o incremento])sentencia

Adjunto el código de esta clase:


var solucion ={
    hidroxilos: 7,
    hidrogenion:7,
    pH:'Neutro'
}

const AUMENTO_IONICO = 1
console.log( `Inicialmente el pH de esta solución es ${solucion.pH}`);

//Se crean las funciones de varaición de iones para la solución.
const añadirHidrogenion = variacion => variacion. hidrogenion+= AUMENTO_IONICO
const añadirHidroxilo = variacion => variacion.hidroxilos-= AUMENTO_IONICO


for (var i = 1; i <= 14; i++ ){
    var random = Math.random()
    if(random <0.25){
        //Se añaden hidrogeniones
        añadirHidrogenion(solucion)

    }else if(random<0.5){
        // Se añaden hidroxilos
        añadirHidroxilo(solucion)
    }
   
}

if(solucion.hidroxilos<solucion.hidrogenion){
    solucion.pH="Ácida"
}else{
    solucion.pH="Básica"
}
console.log( `Al pasar de los días, las medidciones de pH para iones [OH-] fue de ${solucion.hidroxilos}  y de [H+] fue de  ${solucion.hidrogenion},  el pH de esta solución ahora es: ${solucion.pH}`);

img 1 mira el output al final de la imagen es correcto

sin embargo en la segunda imagen el output me da incorrecto, me ayudan a entender por que? por favor

Va el ejercicio:

let oscar = {
  nombre: "Oscar",
  apellido: "Mercado",
  edad: 28,
  peso: 80,
};

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

const INCREMENTO_PESO = 0.2;
const DIAS_DEL_ANO = 365;

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

for (var i = 1; i <= DIAS_DEL_ANO; i++) {
  var random = Math.random();

  if (random < 0.25) {
    aumentarDePeso(oscar);
  } else if (random < 0.5) {
    adelgazar(oscar);
  }
}

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

Como colocar como comentario //. a un bloque de código. SIN ir de linea en linea en ATOM ?

En este código lo único diferente qué hice fue poner el “FOR” dentro de una función para calcular el peso de cada usuario.

var Sacha = {
    nombre: "Sacha",
    apellido: "Lopez",
    edad: 28,
    peso: 55,
};

var Dario = {
    nombre: "Dario",
    apellido: "Lopez",
    edad: 17,
    peso:54,
};

const DIAS_DEL_ANO = 365;
const INCREMENTO_PESO= 0.25;

const AUMENTO_PESO = persona => persona.peso += INCREMENTO_PESO;
const REDUCE_PESO = persona => persona.peso -= INCREMENTO_PESO;

const CALCULAR_PESO = persona =>{
    for(var i=0; i <= DIAS_DEL_ANO; i++){
        var random = Math.random();
    
        if(random < 0.25){
            AUMENTO_PESO(persona);
        }else if(random < 0.50){
            REDUCE_PESO(persona);
        }
    }
}

const showWeight = persona => console.log(`${persona.nombre} ahora pesa ${persona.peso} kg`);
const WEIGHT_END_YEAR = persona => console.log(`${persona.nombre} a fin de año pesara ${persona.peso.toFixed(2)} kg`);
showWeight(Sacha);
showWeight(Dario);

CALCULAR_PESO(Sacha);
CALCULAR_PESO(Dario);

WEIGHT_END_YEAR(Sacha);
WEIGHT_END_YEAR(Dario);



La estructura for ayudará para repetir instrucciones las veces que queramos y se escribe de la siguiente manera

  • la plalabra for seguida de paréntesis y entre llaves va las instruciones que deseemos.
for () 
{
}

En los parentesis se escribe las siguientes instrucciones en una sóla línea:

  1. Lo primero será la variable que se inicializa es decir desde cuando queremos que empiece la instrucción (var i=1), luego de esto irá punto y coma ;

  2. Luego escribiremos hasta dónde queremos que se repita la instrucción (i<=365) luego de esto irá punto y coma ;

  3. Posterior a eso irá cuánto será el incremento con que se deba repetir ejemplo (i++, i=i+2,i=i+3)

Quedando así:

for (var i=1; i<=365;i++)
{

}

NO ME MUESTRA EL VALOR DE persona.nombre alguien tuvo este problema?
var persona = {
nombre: 'oscar ',
apellidos: ‘ordoñez izquierdo’,
edad : 28,
peso : 75
}

console.log(‘mi nombre es: ${persona.nombre}’);

Para todos. Por convención, las magnitudes se escriben mediante el sistema internacional de medidas. Por ejemplo metros es “m”, segundos de es “s”. En el caso de kilo gramos la “k” es en minúsculas.

Ya que en la programación es fundamental seguir convenciones para poder compartir código de manera legible. También es bueno seguir el sistema internacional de medidas a la hora de representar mediciones.

Como se hace para comentar 3 lineas al mismo tiempo como hace Sacha? 😄

Comparto solución alternativa al profe usando un ARROW FUNCTION

var Gonza = {
  nombre: "Gonzalo",
  apellido: "Vidal",
  edad: 31,
  peso: 75
  }

console.log(`Al inicio del 2020 ${Gonza.nombre} pesa ${Gonza.peso} kg`)

const VARIACION_PESO=0.200;

const variacionDePeso = (persona) => random < 0.25 ? persona.peso += VARIACION_PESO : random < 0.5 ? persona.peso -= VARIACION_PESO : 0;

for(var i = 1; i<=365 ; i++){
  var random = Math.random();
  variacionDePeso(Gonza);
}

console.log(`Al final del 2020 ${Gonza.nombre} pesa ${Gonza.peso.toFixed(1)} kg`)

//Al inicio del 2020 Gonzalo pesa 75 kg
//Al final del 2020 Gonzalo pesa 73.0 kg

Este codigo lo escribi pensando en no alterar a la persona, si se les ocurre algo mas simple o si les sirve dejenmelo saber. a también me esta pasando que las comillas invertidas no me están funcionando como deberían si alguien me puede responder el porque estaría muy agradecido

<
console.log(`iniciando la simulacion $(sacha.nombre) pesa $(sacha.peso)`);
const weigthchange=0.2;
function weightSimutaltion(persona){
    var temp = persona.peso;
for(var i=1;i<=365;i++){
    var random=Math.random();
    if(random<0.25){
        temp += weigthchange;

    }else if (random<0.75){
        temp -= weigthchange;
    }
}
return {
    ...persona,
    peso: temp,
    nombre:persona.nombre,
    edad:persona.edad+1
}

}
>

mejorando al codigo

<const humano = {
  name: `whangeda`,
  apellido: `jordan`,
  edad: `18`,
  peso: 75,
};
const azarPeso = ({ name, peso }) => {
  let ramdom = Math.round(Math.random() * 20);
  let acumulador = 0;
  for (let i = 0; i < ramdom; i++) {
    ramdom;
    if (ramdom <= 5) {
      peso += 1;
      acumulador += 1;
    }
    if (ramdom >= 6) {
      peso -= 1;
      acumulador -= 1;
    }
  }
  if (peso === 75) {
    console.log(`no subiste  ni bajaste de peso`);
  }
  peso < 75
    ? console.log(` ${name} Bajaste ${acumulador} kilos de peso 
        y haora  pesas ${peso} kilos`)
    : console.log(` ${name} Subiste ${acumulador} kilos de peso 
  y haora  pesas ${peso} kilos`);
};
//llamada de la fuction
azarPeso(humano);>

Hice el reto y agregue mi toque dando el porcentaje de aumento o deceso del peso.

// Objeto persona
var persona = {
    nombre: "José",
    edad: 19,
    peso: 100
}

// Declaracion de variables 
var dias = 365
var incremento_peso = Math.floor(Math.random() * 100) + 1 ;


// Funciones 

// Funcion de aumentar el peso mediante el incremento_peso
const aumentarPeso = persona => persona.peso += incremento_peso

// Funcion de bajar el peso mediante el incremento_peso
const BajarPeso = persona => persona.peso -= incremento_peso


// Funcion donde se cambiara el peso del objeto

function CambioDePeso(persona) {
    for(i = 0; i <= dias; i++) {
        var numeroAleatorio = Math.random();
    }

    if(numeroAleatorio <= 100) {
        aumentarPeso(persona);
    }

    else if(numeroAleatorio <= 500) {
        BajarPeso(persona);
    }
}


// Mostrar en consola el inicio del año 
console.log(`${persona.nombre} al inicio de este año pesa ${persona.peso} kg`);

var peso_persona = persona.peso

// Iniciar la funcion para bajar de peso
CambioDePeso(persona)

// Porcentaje de bajada de peso 

var porcentaje = ((peso_persona / persona.peso) * 100)

// Numero entero del porcentaje
var intPorcentaje = Math.round(porcentaje);

// Mostrar en consola el final del año
console.log(`Al final del año ${persona.nombre} pesa ${persona.peso.toFixed(2)} kg  un porcentaje de ${intPorcentaje}%`)


Para que redondee el peso se usa la función ‘Math.round(persona.peso)’

Recuerden que dentro del bucle for no deben usar var para declarar la variable i, lo correcto es usar let

Repetitive Structures FOR

Espero que sirva mi aporte.

var juan = {
    nombre:'juan',
    apellido:'ospina',
    edad:24,
    peso:90
}

var random = 0;

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

const INCREMENTO_PESO = 0.2

const DIAS_DE_ANNO = 365

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

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

const peso = persona => random < 0.35 ? aumentarPeso(persona) : random < 0.7 ? disminuirPeso(persona) : persona

for(var i = 1 ; i <= DIAS_DE_ANNO ; i ++){
    random = Math.random();
    peso(juan)
}

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

Mi Aporte:

var sacha = {
  nombre: 'Sacha',
  apellido: 'Lifszyc',
  edad: 28,
  peso: 75
}

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


const INCREMENTO_PESO = 0.9
const DIAS_DEL_ANO = 365

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

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

const NUM_MAX = 1
const NUM_MIN = 0

for (var i = 1; i <= DIAS_DEL_ANO; i++) {
//var random = Math.random()
var numRandom = (NUM_MAX,NUM_MIN) => Math.round(Math.random()*(NUM_MAX-NUM_MIN)+NUM_MIN)

var z= numRandom(NUM_MAX,NUM_MIN)

//return numRandom

  if (z == 1) {
    aumentarDePeso(sacha)
  } else if (z == 0) {
    adelgazar(sacha)
  }

  console.log(`${i} es ${numRandom(NUM_MAX,NUM_MIN)} ${sacha.peso.toFixed(2)} ${z}`)

}

console.log(`Al final del año ${sacha.nombre} pesa ${sacha.peso.toFixed(2)}kg`)

Que odiosos los que se la pasan usando const por todo 😃

tengo una duda referente a los arrow functions. Siempre hay que hacerlos con las constantes.?

Le agregue datos como cuanto subió cada día

const CALORIAS_DONAS = 0.1;

var subio = sujeto => sujeto.peso += CALORIAS_DONAS;
var bajo = sujeto => sujeto.peso -= CALORIAS_DONAS;

function dieta(sujeto)
{

for (var i = 1; i <= 365; i++)
{

    var random = Math.random();
    if(random >= 0.80)
    {
      subio(sujeto);
      console.log(`dia${i} subio! ${sujeto.peso.toFixed(2)}`)
    } else {
      bajo(sujeto)
      console.log(`dia${i} bajo! ${sujeto.peso.toFixed(2)}`)
    }
}
return sujeto.peso.toFixed(2);
}

function imprimir(sujeto) {
  console.log(`al final quedaste con ${dieta(sujeto)} kg`)
}

variables

var julio =
{
  nombre: "Julio",
  años: 20,
  peso: 70
}


Quedate en casa 😃

There is my code. In each day shows how much increased or decreased.

var fabian =
{
nombre: 'Fabian',
apellido: 'Garzon',
edad: 19,
peso: 78
}
const INCREMENTO_PESO = 0.5
const DIAS_ANO = 365
const aumentaPeso = persona => persona.peso += INCREMENTO_PESO
const adelgazar = persona => persona.peso -= INCREMENTO_PESO

function bascula (persona)
{ 
  console.log(`Empezaste con ${persona.peso}kg, ${persona.nombre}`);
  for (var i=1; i <= DIAS_ANO; i++)
  {
    var random = Math.random()
      if (random <= 0.5) 
      {
        aumentaPeso(persona);
        console.log(`En el día ${i} ${persona.nombre}, AUMENTÓ a ${persona.peso.toFixed(2)}kg`);
      } else
      {
        adelgazar(persona)
        console.log(`En el día ${i} ${persona.nombre}, DISMINUYÓ a ${persona.peso.toFixed(2)}kg`);        
      }
  }
    return console.log(`Terminaste con ${persona.peso} Kilitos`); 
}```

Incorporé código de clases pasadas para saber si subió o bajó de peso al final del año. Les comparto mi código:

var CristobalDelPasado = {
  ...Cristobal
}

const comoLefue = (pesoAlInicio, pesoAlFinal) => {
  if (pesoAlInicio < pesoAlFinal){
    console.log('Bajó de peso');
  }
  if (pesoAlInicio > pesoAlFinal) {
    console.log('Subió de peso');
  }
}

comoLefue(Cristobal.peso, CristobalDelPasado.peso)

var Cristobal = {
  nombre: 'Cristobal',
  apellido: 'Vega',
  edad: 23,
  peso: 75
}

var CristobalDelPasado = {
  ...Cristobal
}

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

const INCREMENTO_PESO = 0.2
const DIAS_DEL_AÑO = 365

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

// Simulación del transcurso de un año.
for (var i = 1; i <= DIAS_DEL_AÑO; i++) {
  var random = Math.random(0, 1)
  if (random < 0.25) {
    // aumentarDePeso
    aumentarDePeso(Cristobal)
  } else if (random < 0.5){
    // diminuirDePeso
    diminuirDePeso(Cristobal)
  }
}

const comoLefue = (pesoAlInicio, pesoAlFinal) => {
  if (pesoAlInicio < pesoAlFinal){
    console.log('Bajó de peso');
  }
  if (pesoAlInicio > pesoAlFinal) {
    console.log('Subió de peso');
  }
}

comoLefue(Cristobal.peso, CristobalDelPasado.peso)

console.log(
  `Al final del año ${Cristobal.nombre} pesa ${Cristobal.peso.toFixed(0)} kg`
);

Esta clase en particular no me gustó. Se trató mas de un ejercicio de funciones que de cómo es que opera el bucle for. Habría sido interesante desmenuzar que es lo que un for.

Después de que en el curso de Programación Básica no me quedara muy claro lo de los ciclos “for”, ahora me he enterado.
P.D. Lo del curso de Programación Básica es mi culpa, no del profesor.

// clase 13 Estructuras repetitivas: for
var persona ={
    nombre: 'jose',
    apellido: 'Calvano',
    edad: 23,
    peso: 75
}

const CAMBIO_PESO = 0.200
const DIAS_AÑO = 365

console.log(`Al comienzo del año ${persona.nombre} pesa ${persona.peso}Kg`)
//Simulamos el proceso del año

const aumentarPeso = (persona,incremento) => persona.peso += incremento

const decrementarPeso = (persona, decremento) => persona.peso -= decremento


//Parametros del for(variable ; condicion de fin ; incremento)
for(var i = 1; i<=DIAS_AÑO; i++ ) {
    var random = Math.random()
    if(random <= 0.25){
            aumentarPeso(persona,CAMBIO_PESO)
    } else if(random <= 0.50){
            decrementarPeso(persona,CAMBIO_PESO)
    }
}

console.log(`Al final del año ${persona.nombre} pesa ${persona.peso.toFixed(2)}Kg`)

console.log(typeof persona.peso) ```

SI dentro de una función modificamos ese objeto, ese objeto se va a ver modificado fuera de la función también. Si no queremos que eso ocurra tendremos que crear un nuevo objeto desglosando el objeto original.

Comparto ejercicio

var sacha =
{
    nombre: 'Sacha',
    apellido: 'Lifszyc',
    edad: 28,
    peso: 75
}

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

const INCREMENTO_PESO = 0.2
const DIAS_DEL_ANO = 365

const aumentarDePeso = (persona) => persona.peso += INCREMENTO_PESO
const adelgazar = persona => persona.peso -= INCREMENTO_PESO


for (var i = 1; i <= DIAS_DEL_ANO; i++)
{
    var random = Math.random()
    
    if (random < 0.25)
    {
        //aumenta de peso
        aumentarDePeso(sacha)
    }else if (random < 0.5){
        //baja de peso
        adelgazar(sacha)
    }
}


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

Mis apuntes con algunas mejoras y corrección al error del 25% de año aumenta y el otro sube y el resto 50% permanece estable

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

// Estas constantes nos ayudan a ser mas explicitos con el significado de algunos números que se prodrían declarar magicamente....
const TOTAL_DIAS_ANIO = 365
const GRAMOS = 0.2

// Esta función es equivalente a las siguentes arrow function
/* function peso(persona) {
    persona.peso += GRAMOS
} */

// Si bien la declaración de estas arrow function retornan un valor al no estar presentes sus paréntesis, nosotros no nos interesa dicho dato, puesto que al invocarlas, no asignamos estas funciones a una variable para recuperar el valor.  Solo nos interesa modificar el objeto
const aumentarPeso = persona => persona.peso += GRAMOS
const bajarPeso = persona => persona.peso -= GRAMOS


console.log(`Al inicio de año ${persona.nombre} ${persona.apellidos} pesaba ${persona.peso.toFixed(1)}kg.`)

// Recorremos cada dia del año
// Es necesario establecer un punto de inicio, un punto de llegada y un incremento
for(var i = 1; i <= TOTAL_DIAS_ANIO; i++) {
    // Generamos un aleatorio entre 0 y 1 para determinar si su masa corporal tiende a subir o bajar
    var random = Math.random()

    // El 25% del año esta persona tiende a bajar de peso por el calentamiento global
    // pero siempre y cuando su densidad muscular este por debajo del 0.15
    if( i < Math.ceil(TOTAL_DIAS_ANIO * 0.25) ) {
        if(random <= 0.15) {
            // Al pasar un objeto a una función se gace por referencia. Por tanto, es responsabilidad de la función si internamnte muta el objeto o retorna uno nuevo 
            bajarPeso(persona)
        }
    }

    // El otro 25% del año esta persona tiende a subir de peso por las vacaciones de verano
    // pero siempre y cuando su densidad muscular este por encima del 0.85
    if( i < Math.ceil(TOTAL_DIAS_ANIO * 0.50) ) {
        if(random >= 0.85) {
            aumentarPeso(persona)
        }
    }

    // El 50% restante del año...
    // Su organizmo permanece estable. entonces no sube ni baja
}

console.warn(`Al fin de año ${persona.nombre} ${persona.apellidos} pesa ${persona.peso.toFixed(1)}kg.`)
<var franco = {
  nombre: 'Franco',
  apellido: 'Ybarrola',
  edad: 19,
  peso: 65
}

console.log(`${franco.nombre} al comienzo del año pesa ${franco.peso}kg`)

const INCREMENTO_PESO = 0.2
const DAYS_YEAR = 365

const subePeso = (persona) => persona.peso += INCREMENTO_PESO
const bajaPeso = (persona) => persona.peso -= INCREMENTO_PESO

for(i = 1 ; i <= DAYS_YEAR, i++){

  var random = Math.random()

  if(random < 0.25){
    subePeso(franco)

  }else if(random < 0.5){
    bajaPeso(franco)
  }

}

console.log(`${franco.nombre} al final del año pesa ${franco.peso}kg`)
>

Alguien sabe porque no me funciona el codigo ?

<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.2

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

        for (var i = 1; i <= DIAS_DEL_AÑO ; i++){
            var r = Math.random()

            if (r < 0.25) {
                aumentoDePeso (Paul)
            } else if (r < 0.5) {
                adelgaza (Paul)
            }
        }

        console.log(`Al final del años ${Paul.nombre} pesa ${Paul.peso.toFixed(1)}Kg` )
    </script>
    😷 #QuedateEnCasa

“Mashic Number”

ESTRUCTURAS REPETITIVAS: for

El “for” nos permite realizar cierta tarea de manera repetitiva para eso vamos con el siguiente ejemplo

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

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

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

console.log (`al final del año ${angel.nombre} pesa ${angel.peso}kg`)

Iniciaremos con estos objetos que teníamos y agregaremos estos console.logs uno al inicio y otro al final del año

Ahora bien, agregaremos for de la siguiente manera:
var angel = {
nombre: ‘Angel’,
apellido: ‘Sulbaran’,
edad: 23,
peso: 75
}

var pepe = {
nombre: “Pepe”,
apellido: ‘Trueno’,
edad: 13,
peso: 54
}

console.log (al inicio del año ${angel.nombre} pesa ${angel.peso}kg)

for () {

}

console.log (al final del año ${angel.nombre} pesa ${angel.peso}kg)

for dentro de la llaves de for vamos a colocar el código que queremos que se repita, y el for entre los paréntesis va a tener tres partes, la parte inicial, la parte de la condición y la parte del incremento.
Ahora lo que queremos hacer es ejecutar este código unas 365 veces y como se hace para llevar la cuenta? Para eso se una un contador y generalmente en un ciclo for ese contador cuenta con el nombre de “i” por lo que denro del paréntesis agregamos “var i” y luego lo inicializamos en 1 es decir “var i = 1” de esta manera le vamos a decir que el contador va a empezar en el valor 1ahora aca si colocamos un “;” aca si es obligatorio ponerlo, luego de la inicialización colocamos la condicion, “i <= 365” aca le estamos diciendo que la condición es que “i” sea menor o igual que 365 porque cada vez que se ejecute este código vamos a ir incrementando el contador, para marcar las veces que se a repetido hasta que llegue a 365 y cuando llegue a 366 la ejecución va a parar porque la condición se vuelve falsa y por ultimo en la ultima parte del contador después de otro “;” ponemos “i++” para incrementar el contador cada vez que termina de ejecutar el código.

console.log (al inicio del año ${angel.nombre} pesa ${angel.peso}kg)

for ( var i = 1; i <= 365; i++) {

}

console.log (al final del año ${angel.nombre} pesa ${angel.peso}kg)

ahora, la premisa es que la persona suba o baje de peso, para simular eso ;

console.log (al inicio del año ${angel.nombre} pesa ${angel.peso}kg)

const INCREMENTO_PESO = 0.2

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

for ( var i = 1; i <= 365; i++) {
var random = Math.random()
if (random < 0.25){
aumentarDePeso(angel)
} else if (random < 0.5){
adelgazar(angel)
}
}

console.log (al final del año ${angel.nombre} pesa ${angel.peso.toFixed(1)}kg)

Hola, alguien sabe por que no me funciona la forma de invocar variables dentro de un string usando ${}, cuando lo imprimo en la consola me sale:

Al inicio del año ${daniel.nombre} pesa ${daniel.peso}kg

agradezco su ayuda.

Excelente clase Sacha así me quedo al revisar en el navegador

La variable i es el iterador.

Con este código consigo que el peso que se incrementa o decrementa también sea aleatorio.

var persona = {
    nombre: 'Luis',
    apellido: 'Viñas',
    edad: 24,
    peso: 76
}

console.log(`El peso de ${persona.nombre} ${persona.apellido} al iniciar el año fue ${persona.peso}Kg`)

const DIAS_AÑO = 365

const incremento = (persona, incremento) => persona.peso += incremento
const decremento = (persona, decremento) => persona.peso -= decremento

for (i = 1; i <= DIAS_AÑO; i++) {
    var rand = Math.random()

    if (rand <= 0.3) {

        incremento(persona, rand)

    } else if (rand <= 0.55) {
        var pesoDecremento = rand / 2

        decremento(persona, pesoDecremento)
    }
}

console.log(`El peso de ${persona.nombre} ${persona.apellido} al finalizar el año es ${persona.peso.toFixed(2)}Kg`)```

Espero les funcione. 

A mi tambien me dió al principio 6525, curioso, cuantas probabilidades (Eso quiero pensar jaja)

Duda: Que sucede al dejar las “const” dentro de mismo for? que afecta si las dejo (ya que solo vivirán dentro del FOR)? no es mejor así, que estar modificando las variables globales?

apuntes:

//FOR
var natanael = {
    nombre: 'natanael',
    apellido: 'león',
    edad: 30,
    peso: 98
}

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

/*El for entre los parentesis va a tener 3 partes la parte inicial(declaramos i), la parte de la condición y la parte del incremento, el ";" aquí es obligatorio ponerlo */
for(var i= 1; i <= 365; i++){
    /*entre las llaves va el codigo que quiero que se repita*/
    const INCREMETO_PESO = .200
    const DIAS_DEL_AÑO=365
    //usamos arrow function
    const aumentarPeso = persona => persona.peso += INCREMETO_PESO
    /*que es lo mismo que 
    function aumentarPeso (persona) {
       return persona.peso += .200
    }*/
    const adelgazar = persona => persona.peso -= INCREMETO_PESO

    var ramdom = Math.random()
    if (ramdom < 0.25){
        aumentarPeso(natanael)
    }else if (ramdom < 0.5){
        adelgazar(natanael)
    }
}

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

var goku={
nombre:“Goku”,
apellido:“son”,
edad:100,
peso:80
}
var pesoInicial=80
var newPeso=pesoInicial
var aumentarPeso=pesoInicial
console.log('inicio año ‘+goku.peso+’ pesa ‘+goku.peso)
for(var i=1;i<=365; i++){
var nuevopeso=0.200
var sumarPeso=0.200
newPeso=newPeso-nuevopeso
aumentarPeso=aumentarPeso+sumarPeso
document.write(‘dia’+i+’ inicio año ‘+aumentarPeso+’ pesa '+newPeso+"</br>")
}

Comprendido muy bien el concepto y practicado. muchas gracias!

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.2
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


//Definimos la variacion anual
for(var i = 1; i <= DIAS_DEL_ANNO; i++){
    var random = Math.random()

    if(random < 0.25){
        aumentarDePeso(Carmen)
    }else if (random >0.75){
        disminuirDePeso(Carmen)
    }
}
//Peson al final de año
console.log(`Al final  del año ${Carmen.nombre} tiene ${Carmen.peso.toFixed(1)} kilos`)```

Sintaxis del ciclo for
Dentro de los paréntesis del for hay tres partes:

  1. parte inicial var i = 1
  2. parte de la condición i <= 20
  3. parte del incremento i++

Hasta este punto quiero hacer una aclaración ha este maestro le hace falta explicar mas las cosas nomas las hace pero no explica como en el curso de programación básica que Freddy realmente explicaba muy pero muy bien …!! Le hace falta muchísimo a este profesor

Me desespera y me da una frustacion tan grande de ver como estos profesores nomas hacen the fucking things pero ni siquiera las explica no explica el por que o porque sucede esto paso a paso nomas dice “ vamos a poner esto y va a ocurrir esto” si esto son los professionales que contracta Platzi la verdad 🤬😒

Alguien me puede decir como save que tiene que poner 0.25 y 0.5 por que pone estos números?? Por que los pone con em decimales y el numero entero en 0?? Por que no poner 5 y 25??

Tengo una observación y creo que es correcta.
Del minuto 7 al 8 hay validaciones en relación al random, diciendo que si es menor a 0,25 aumenta de peso y en el otro 0,75 de las veces pasa la condición del else.

como es math.random, puede darse un caso de que las 365 veces del ciclo for 5 veces sean menor a 0,25 y eso no es necesariamente el 25%. Considero que es un escenario que se puede dar ya que es aleatorio.

Debería decir que si es menor a 0,25 disminuye y ya, pero no hacer referencia al 25% de las veces.

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

/* function aumentarDePeso(persona) {
    return persona.peso += 200;
} */

const INCREMENTO_PESO = 0.4;
const DIAS_DEL_ANO = 365;

const aumentarDePeso = persona => persona.peso += INCREMENTO_PESO;
const adelgazar = persona => persona.peso -= INCREMENTO_PESO;

for (var i = 1; i <= DIAS_DEL_ANO; i++) {
    var random = Math.random();
    /* nos da un numero aleatorio entre 0 y 1 */
    if(random < 0.25) {
        aumentarDePeso(johan);
    } else if (random < 0.5) {
        adelgazar(johan);
    }
}
/* el ciclo for inicia con una variable i que funciona como contador, luego una condicion que mientras se cumpla se seguira ejecutando el ciclo y por ultimo un incrementado del contador el cual ayudara aque el ciclo se termine invrementando el valor del contador en 1 cada vez que se ejecute un ciclo */

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

Muy buena clase!, jugué un poco con el codigo y lo hice para que me dijera cuanto peso en diferentes edades mayores a mi edad actual, es decir algo como, “Luis a los 22 años pesaba 80kg” y “Ahora Luis a los 40 pesa 60kg”

Lo hice colocando el ciclo for para que solo se ejecutara tantas veces como cantidad de años pasaran entre mi edad actual y la edad aleatoria que me elegiria el programa

aqui les dejo el codigo

var luis = {
    nombre:'Luis',
    edad:22,
    peso: 80
}

var contador = 0

console.log(`${luis.nombre} a los ${luis.edad} años pesaba ${luis.peso}kg`)

nuevaEdad = Math.round(Math.random() * (99 - luis.edad) + luis.edad)

const aumentarPeso = (luis) => {
    cantidadKg = Math.round(Math.random() * (3 - 1) + 1)
    luis.peso += cantidadKg
} 

const bajarPeso = (luis) => {
    cantidadKg = Math.round(Math.random() * (3 - 1) + 1)
    luis.peso -= cantidadKg
} 

for(i=luis.edad; i<= nuevaEdad ; i++){
    var random = Math.random()

    if(random < 0.25){
        //aumenta de peso
        aumentarPeso(luis)
    }else{
        //baja de peso
        bajarPeso(luis)
    }

    contador++
}

console.log(`${contador} debe ser igual a ${nuevaEdad - luis.edad + 1}`)
console.log(`Ahora ${luis.nombre} a los ${nuevaEdad} años pesa ${luis.peso}kg`)

Tambien le coloque un contador para contar las iteraciones del ciclo for y asi verificar que concordaran la diferencia de años entre ambas edades.

aca les dejo el resultado

Aqui esta mi codigo del for. Copialo y pegalo en la consola de chrome para ver la magia

function person(name, lastName, age, weight){
    this.name = name;
    this.lastName = lastName;
    this.age = age;
    this.weight = weight;
}

var irving = new person("Irving", "Juarez", 19, 57.3)
var daysOfTheYear = 365

console.log(`The weight of ${irving.name} at the beginning of the year was ${irving.weight}`)

function decrease(object, num){
    return object.weight -= 1 + (num/10)
}

function increase(object, num){
    return object.weight += 1 +(num/10)
}

for(var i = 1; i <= daysOfTheYear; i++){
    var random = Math.round((Math.random() * 10))
    if(random <= 5){
        decrease(irving, random)
    }else{
        increase(irving, random)
    }
}

console.log(`The weight of ${irving.name} at the end of the year was ${irving.weight.toFixed(1)}`)

Un pequeño ejemplo que hice


var persona = {
		nombre: 'victor',
		edad: 18,
		peso: 80
	};


const numRandom = (numMax , numMin) => Math.round(Math.random() * (numMax - numMin) + numMin)

var	comidas = ["carne", "pollo", "nada"];

var comida = {
	carne : 1.5,
	pollo : 0.5,
	nada : 0.0
};

function peso(){
	 for(var persona_peso = persona.peso ; persona.peso <= 150; persona_peso++){
	 comidita = comidas[numRandom(comidas.length -1 ,0)]
   persona.peso = persona.peso  +	comida[comidita]
	 console.log(`${persona.nombre} está pesando ${persona.peso}, por haber comido : ${comidita}`)
	 }
}

Una variante del Ejercicio.

Si omito las llaves JS interpreta que quiero un return. En mi caso si es obligatorio el return?

console.log(`Iniciando el año ${Christian.nombre} pesa ${Christian.peso}kg`);

const Engordar = (persona, incremento) => { //Si no hay llaves implicitamente hay un return
    incremento = 0.2;
    return persona.peso += incremento;
}

const Adelgazar = (persona, decremento) => {
    decremento = 0.2;
    return persona.peso -= decremento; 
}

for(i = 1; i <= 365; i++) {
    let numRandom = Math.random() //Math.round(Math.random() * ) Tomaría como valores 0 o 1

    if(numRandom < 0.25)
        Engordar(Christian);
    else if ( numRandom < 0.5){ 
        Adelgazar(Christian);
    }
}
                                       //.toFixed(2) Tomará 2 decimales
console.log(`Finalizando el año ${Christian.nombre} pesa ${Christian.peso.toFixed(2)}kg`);

var jairo = {
    name: "Jairo",
    last_name: "Merea",
    age: 30,
    weight: 71
}

console.log (`At the beginning of the year ${jairo.name} weighed ${jairo.weight} Kg`);

const INCREASED_WEIGHT = 0.2;
const gainWeight = person => person.weight += INCREASED_WEIGHT 
const loseWeight = person => person.weight -= INCREASED_WEIGHT 

for (var i = 1; i <= 365; i++) {
    var random = Math.random()
    if (random < 0.25) {
        gainWeight(jairo)
    } else if (random < 0.50) {
        loseWeight(jairo)
    }
}

console.log (`At the end of the year ${jairo.name} wheighed ${jairo.weight.toFixed(1)} Kg`)

Hola, chicos.

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

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

const INCREMENTO_PESO = 0.2

function aumentar(persona) {
return persona.kilos += INCREMENTO_PESO
}
function disminuir(persona) {
return persona.kilos -= INCREMENTO_PESO
}

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

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

Hola aqui les comparto mi code 😃

Solo para dejarlo claro, la sintaxis que usamos de “i++” es lo mismo que si pusieramos i += 1, o i = i + 1

Algo curioso de las estructuras for es que puedes poner más variables y más condiciones, es decir, podrías tener algo como:

for(let i = 0, j = 0; i < 10 && j < 20; i++, j += 2) {

    // do something

}

Y funcionaría, no se suele hacer pero es bueno saberlo

Y otra cosa más, for tiene dos variantes, for…in y for…of

for…in
Itera sobre un arreglo u objeto y te pasa su key:

var personas = ["Sacha", "Pepe", "Juan"]
for(index in personas) {

    // index en este caso sería el índice del arreglo y personas es el arreglo tal cual
    var persona = personas[index]
    console.log(persona)

}

for…of
Itera sobre un arreglo y te pasa su valor:

var personas = ["Sacha", "Pepe", "Juan"]
for(persona of personas) {

    // persona en este caso sería el valor del arreglo y personas es el arreglo tal cual
    console.log(persona)

}

Usualmente en Javascript es el uso del for mostrado es poco utilizado, en vez de esto se utilizan otras estructuras como el forEach, for in, y el for of…

var sacha = {
  nombre: 'Sacha',
  apellido: 'Lifszyc',
  edad: 28,
  peso: 75
}

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

const INCREMENTO_PESO = 0.2
const DIAS_DEL_ANO = 365

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

for (var i = 1; i <= DIAS_DEL_ANO; i++) {
  var random = Math.random()

  if (random < 0.25) {
    aumentarDePeso(sacha)
  } else if (random < 0.5) {
    adelgazar(sacha)
  }
}

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

¿Porque la siguiente declaracion arrow function esta mal?

const PESO_AUMENTA_DISMINUYE = 0.2

const aumentarPeso = ({peso}) => peso += PESO_AUMENTA_DISMINUYE
const reducirPeso = ({peso}) => peso -= PESO_AUMENTA_DISMINUYE

Tengo que volver aver este video como unas 100 veces más, entiendo muchas osas pero hay otras donde me pierdo. 🥺💪

No entiendo este error

lo he echo igual que Sacha

¿Es recomendable crear la variable randow dentro del bucle for? Por tiempo, por procesamiento no es mejor dejarla fuera de él o es indiferente? Gracias

CODIGO DE CLASE

var fernando = {
  nombre:'Fernando',
  apellido:'Huaman',
  edad:18,
  peso:80
}

console.log(`Al inicio de año ${fernando.nombre} pesa ${fernando.peso}Kg`)

const DIAS_DEL_ANO = 365

const INCREMENTO_PESO = 0.2

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

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

for (var i = 1; i <= DIAS_DEL_ANO; i++) {
  var random = Math.random()
  if(random < 0.25){
     aumentarDePeso(fernando)
  }else if (random < 0.5){
     adelgazar(fernando)
  }
}

cual es el mayor y cual es el con la funcion if

Muy buena clase.

Bucles e iteración

esta un poco confuso el asunto

Excelente…!! Voy Muy Bieen.!!

const isTeenager = user => !isAdult(user)
<var pablo = {
    nombre: 'pablo',
    apellido: 'martinez',
    edad: 32,
    peso: 86
}

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

const INCREMENTO_PESO = 0.2
const DIAS_DEL_AÑO = 365


const AumentarDePeso = (persona) => persona.peso += INCREMENTO_PESO
const Adelgazar = (persona) => persona.peso -+ INCREMENTO_PESO
    

for (var i = 1; i <= DIAS_DEL_AÑO; i++) {
    var random = Math.random()

    if(random < 0.25){
        AumentarDePeso(pablo)
    } else if(random < 0.5) {
        Adelgazar(pablo)

    }


}

console.log(`al final del año ${pablo.nombre} pesa ${pablo.peso.toFixed(1)}kg`)>

Medio enredado el asunto…

Mi intento del ejercicio sin mirar el vídeo completo

var persona = {
  nombre: 'David',
  edad: 22,
  peso: 75
}

const NUMERO_ALEATORIO = () => Math.random().toFixed(2)

const PRINT = value => console.log(value)

function variacionDePeso(persona) {
  for(let i = 1; i <= 365; i++) {
    if(NUMERO_ALEATORIO() <= 0.50) {
      persona.peso--
      PRINT(`Día ${i}: ${persona.peso}`)
    } else {
      persona.peso++
      PRINT(`Día ${i}: ${persona.peso}`)
    }
  }
  return PRINT(`Peso Total: ${persona.peso}`)
}

variacionDePeso(persona)

Genial!!

deasfio:
//arrow function
const MAY_EDAD = 18;
const esMayorEdad = ({edad})=> edad >= MAY_EDAD;

const esMenEdad = ({edad}) =>!esMayorEdad(edad);

for(var i = 1; i <= 100 ; i++) {
  console.log(i);
}

Buenos días, porque este código no me muestra el valor de las variables pantalla? Me muestra persona.nombre en vez de mostrar “Daniel”

var persona = {
nombre: “Daniel”,
apellido: “Perez”,
edad: 29,
sexo: “masc”,
peso: 75
};

console.log(“Al inicio Daniel pesa ${persona.peso}”);
console.log(’${persona.nombre}’);

Veo que las Arrow Functions sirve para funciones, pero para procedimientos(subrutinas) no sirve? Porque veo que el return viene incluido en una arrow function y al parecer no se puede sacar para que actue como procedimiento

Estructura For

Es un loop desde un número configurado a otro número configurado.

Se usa el keyword ‘for’ seguido de paréntesis con 3 comandos dentro separados por ‘;’.
El primero es la declaración del contador, desde dónde comienza a contar; ‘let i = 1’ en este caso.
El segundo es hasta dónde cuenta; ‘i <= 365’ en este caso.
El tercero es incrementar en 1 la variable contador; ‘i++’.

var sacha = {
	nombre: 'Sacha',
	apellido: 'Lifszyc',
	edad: 28,
	peso: 75
}

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

const VARIACION_DE_PESO = 0.2
const aumentoDePeso = persona => persona.peso += VARIACION_DE_PESO
const bajaDePeso = persona => persona.peso -= VARIACION_DE_PESO

for (let i = 1; i <= 365; i++) {
	var random = Math.random();
	if(random < 0.25) {
		aumentoDePeso(sacha)
	} else if (random < 0.50) {
		bajaDePeso(sacha)
	}
}

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

const DIAS_DEL_ANIO = 35
const INCREMENTO_DE_ESO = 0.2
const aumentarDePeso = persona => persona.peso += INCREMENTO_DE_ESO
const adelgazar = persona => persona.peso -= INCREMENTO_DE_ESO

for(var i = 0; i<=DIAS_DEL_ANIO;i++){
    var random = Math.random()
    if(random<0.25){
        aumentarDePeso(vic)
    }else if(0<0.5){
        adelgazar(vic)
    }
}

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

¿A que se refiere con Magic Number?

excelente explicación!!!

excelente Sacha

La clase

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.2
const DIAS_DEL_AÑO=365

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

for (var i=1; i<=DIAS_DEL_AÑO; i++) {
    var random = Math.random()

    if (random<0.25) aumentarDePeso(KarlxS)
    else if (random<0.5) adelgazar(KarlxS)
}

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