Cursos Empresas Blog Live Conf Eventos Precios

Reestructurando información sobre la marcha

Taller Práctico de JavaScript: Matemáticas y Estadística Básica

Contenido del curso

Introducción

1
¿Ya tomaste el Curso Práctico de JavaScript?
08:20 min

Matemáticas en JavaScript

Porcentajes

Estadística básica

Análisis de salarios

Próximos pasos

27
Toma el Taller Práctico de JavaScript: Videojuegos
04:27 min

Tomar examen

Reestructurando información sobre la marcha

Josue Cerron Tuesta

Estudiante

Hace 4 años

Utilicé el método forEach():

/**Análisis empresarial */
const company = () => {
    const empresas = {};

    salarios
        .forEach(item => item.trabajos.forEach(item => {
            if (!empresas[item.empresa]) empresas[item.empresa] = {};
            else {
                if (!empresas[item.empresa][item.year]) empresas[item.empresa][item.year] = [];
                else empresas[item.empresa][item.year].push(item.salario);
            }
        }));
    return empresas;
}

console.log(company());

Orlando Rodriguez

Estudiante

Hace 4 años

Espectacular tu lógica, me ayuda a entender como reestructurar, muchas gracias. Agrego como hacerlo tambien con la misma logica pero usando for...of

console.log(salarios);
let empresas = {};

const company = () => {
    for(element of salarios){
        for(item of element.trabajos){
            if(!empresas[item.empresa]){
                empresas[item.empresa] = {}
            } else {
                if (!empresas[item.empresa][item.year]) {
                    empresas[item.empresa][item.year] = [];
                } else {
                    empresas[item.empresa][item.year].push(item.salario)
                }
            }
        }
    }
}

company(salarios);
console.log(empresas);

Pablo Heredia

Estudiante

Hace 4 años

Me parecía una solución bastante estructurada hasta que me topé con una duda en cuanto al registro de valores. Por ejemplo, en la empresa "Freelance", en el año 2018, nos arroja la siguiente lista de valores: Freelance : 2018 : (6) [600, 750, 500, 400, 500, 600] Pero revisando los valores en salarios.js podemos ver que no se incluye el salario de 2018 de Juanita ni el de Alex. Creo que esto sucede ya que en la lógica del codigo, al primeramente no existir la empresa freelance, crea la empresa pero se salta ese valor, al igual que en la siguiente condición que creamos el año.

function restructuraPorCompanies(){
    const empresas = {};

    salarios.forEach(persona => persona.trabajos.forEach(item => {
        /*Cuando no existe la empresa en nuestro objeto la estamos creando, pero nunca volvemos a 
        iterar para ingresar ese valor a la lista, por lo que el salario del año 2018 de Juanita
        (que es la primera que se itera) se pierde 
        */
            if (!empresas[item.empresa]) {
                empresas[item.empresa] = {};
            }else {
                /*Lo mismo sucede aqui, ya que al iterar en Freelance y no encontrar el 2018, se crea el año
                pero se pierde el salario de alex, es por eso que el primer Salario que aparece en la lista de Freelance
                2018 es el de Nath
                */
                if (!empresas[item.empresa][item.year]){
                    empresas[item.empresa][item.year] = [];
                } else {
                empresas[item.empresa][item.year].push(item.salario);
                }
            }
        }));
    return empresas;
}

No se como se puede usar la logica del foreach pero incluyendo todos los valores

Juan Cortez

Ok, incluso a alguien que sabe de JS desde hace algún tiempo esto quema un poco el cerebro XD pero es bueno saber que uno aprende y mejora poco a poco.

Edwin Miguel Orellana Sotomayor

uff si que costo un poco entender jajaja

Himar Del rio plata

Entrar a la clase y ver estos comentarios es como...

Armando Alonso Hernández

llevo varias clases sin entender nada jaja :( esto es realmente complicado

Sebastian Collantes

Confirmo xd

Jhon Ramirez

confirmo, NO NOS RINDAMOS

Raúl Adolfo Sánchez Rodríguez

Explicación

David Mauricio Grajales Duran

Hace 3 años

Una pregunta, es que me gustaron mucho tus notas de la clase. Puedes por favor decirme donde tomas notas.

Gracias : )

Nestor Rios Garcia

Buena explicación por pasos.

Comparto mis apuntes, espero se puedan ayudar a la comprensión de la restructuración hecha

Ricardo Alfonso Chavez Vilcapoma

Estoy así :(

Daniel Triana

8:20 JAJAJA, de con razón todo en español excepto el ‘year’.

Sebastian Pacheco Lopez

function meadianaSalarioYear(nombreEmpresa, year) {
  const arrayYear = empresas[nombreEmpresa][year];
  const medianaSalario = PlatziMath.calcularMediana(arrayYear);
  return medianaSalario
}

Usando la funcion de calcularMediana y obteniendo el array de salarios en x año del objeto empresas

Javier Marin

Me gustó en cierto modo la solución del profesor pero la verdad es que es verbosa in extremis, acá un snippet mas funcional y compacta:

const empresas = salarios
  .map(persona => persona.trabajos)
  .reduce((prev, trabajos) => {
    trabajos.forEach(({ year, empresa, salario }) => {
      if (!prev[empresa]) prev[empresa] = {}
      if (!prev[empresa][year]) prev[empresa][year] = []
      prev[empresa][year].push(salario)
    })
    return prev;
  }, {});

Alexis Daniel Sanchez Arias

Se me hace bastante buena tu idea de inicializar un array dentro del objeto usando el metodo forEach con los condicionales. Aunque creo que podrias haber logrado una logica mas sencilla usando Object.entries

O tambien simplemente usando for in lo que creo que sería mucho más sencillo de mantener

Silvia Corrales

Notas de la clase:

Analisis empresarial

Reordenaremos la informacion que tenemos de modo que tengamos un objeto con las distintas empresas, y en donde a su vez, cada una tendra un array por cada año registrado con los salarios que han tenido las personas en dichos años.

// Crear una variable de tipo objeto en donde tendremos la informacion ordenada por empresa:
const empresas = {};
// Recorrer el array de salarios:
for (persona of salarios) {
  // Recorrer cada uno de los trabajos que han tenido las personas:
  for (trabajo of persona.trabajos) {
    // Crear una propiedad dentro del objeto 'empresas' por cada una de las empresas. Si la empresa no existe dentro del objeto se crea la empresa como propiedad y su valor sera un objeto:
    if (!empresas[trabajo.empresa]) {
      empresas[trabajo.empresa] = {};
    }
    // Dentro de cada empresa se creará una propiedad por cada año que tengan registradas las personas que hayan trabajado en dicha empresa, y el valor de esta propiedad sera un array:
    if (!empresas[trabajo.empresa][trabajo.year]) {
      empresas[trabajo.empresa][trabajo.year] = [];
    }
    // Dentro del array de la propiedad de año se insertaran los salarios que se tengan registrados para dichos años:
    empresas[trabajo.empresa][trabajo.year].push(trabajo.salario);
  }
}

console.log(empresas);

Celso ariel Santa cruz

yo utilice la misma logica pero con otra sintaxis, para practicar:

const empresas = {};
reestrurarArray();

function reestrurarArray (){
    salarios.forEach (persona=>persona.trabajos.forEach(trabajo=>{
        if (!empresas[trabajo.empresa]) empresas[trabajo.empresa]={};
        if (!empresas[trabajo.empresa][trabajo.year]) empresas[trabajo.empresa][trabajo.year]=[];
        empresas[trabajo.empresa][trabajo.year].push(trabajo.salario);
    }))
}

Joaquin Federico Demarchi

Pueden acercar documentacion con ejemplos que explique como se referencian los objetos array dentro de objetos

Juan Castro

Profesor

Estas lecturas te van a gustar:

Alan Muñoz Badillo

Hola a todos, con el fin de poder comprender mejor los pasos para la reestructuración de los datos en la función enseñada, me fui creando un manual paso a paso. Me sirvió bastante para entender que pasa en cada ciclo y condicional, y las referencia los elementos. Se los dejo por si es útil para alguien, está en pdf, saludos.

https://drive.google.com/file/d/1mLyysRClgbedLwlF-ZwhE3iwkKG2wmG9/view?usp=sharing

marco antonio

Ok yo lo hice así

Eliezer Hernandez

Desarrolle una fución para registrar las empresas(así ya no tenía que hacerlo yo mismo 😅) a partir de la información del array de “salarios” y además esta función registra los salarios por año en la empresa.

. Resultado mostrado en consola:

. Código:

function registrarPersona(empresas) {
  salarios.forEach(({ trabajos, name }) => {
    trabajos.forEach(({ year, empresa, salario }) => {
      if (!empresas[empresa]) {
        empresas[empresa] = {};
      }
      if (!empresas[empresa][year]) {
        empresas[empresa][year] = [];
      }
      empresas[empresa][year].push(salario);
    });
  });
}
registrarPersona(empresas);
console.log(empresas);

Gustavo Muñiz Barrios

Me tomo tiempo entender todo, pero pude entenderlo mas fácil con este método: Haz todo por partes. Es decir cuando escribas el primer for "for(trabajo of salarios){}" solo pon dentro un console.log para que veas que es lo que devuelve la consola:

const empresas = {}; // Aqui guardamos toda la información de todas las empresas que tengamos
for (persona of salarios) { 
	console.log(persona);
}

Cuando entiendas bien que es lo que hace ese for escribe el siguiente y haz un console.log:

const empresas = {}; // Aqui guardamos toda la información de todas las empresas que tengamos
for (persona of salarios) { //
     for (trabajo of persona.trabajos) {
       console.log(trabajo);
    } 
}

De esta forma tendrás una mejor idea de lo que hace cada ciclo for con el array salarios.

Jeison Gomez

Yo me salte estas clases de la ruta de aprendizaje, me vi primero los métodos de los array y luego me vine a los cursos prácticos, y todo se entiende mas fácil.

const companies = salarios.flatMap(person => person.trabajos)
    .reduce((object, job) => {
        if(!object[job.empresa]) {
            object[job.empresa] = {};
        }

        if(!object[job.empresa][job.year]) {
            object[job.empresa][job.year] = [];
        }

        object[job.empresa][job.year].push(job.salario)

        return object
    }, {})

console.log(companies);

Felipe Moreno

Me quemó las neuronas pero acá esta mi solución 🫠

function estructurarEmpresas(arraySalarios){
    const trabajos_globales = [];
    arraySalarios.forEach(salario => {
        trabajos_globales.push(...salario.trabajos);
    });
    const empresas = {};
    for (let i = 0; i < trabajos_globales.length; i++) {
        empresas[trabajos_globales[i].empresa] = {};
    }

    for (const empresa in empresas) {
        for (let i = 0; i < trabajos_globales.length; i++) {
            if(trabajos_globales[i].empresa == empresa){
                empresas[empresa][trabajos_globales[i].year] = [];
            }
        }
        for (let i = 0; i < trabajos_globales.length; i++) {
            if(trabajos_globales[i].empresa == empresa){
                empresas[empresa][trabajos_globales[i].year].push(trabajos_globales[i].salario);
            }
        }
    }
    return empresas;
}

Joserph Camacho

Aqui mi solución al reto, aunque creo que fue un código muy largo pero al menos cuando vea la solución del profesor veré como cambio mi lógica para optimizar mi código, pero por ahora da el resultado esperado: Código:

Output:

Uriel Solis Salinas

A ver si les ayuda un poco más esta explicación en la función que hizo el profe, a mi me ayudó un poco más.

/* Recorriendo el arreglo de salarios.*/
for (persona of salarios) {
   /* Por cada persona en el arreglo de salarios, se esta recorriendo cada uno de los trabajos que tuvo la persona. */
    for (trabajo of persona.trabajos) {
        /* Se está haciendo un nuevo objeto de "empresas" que tenga una propiedad por cada distinta empresa. */
        if (!empresas[trabajo.empresa]) {
            empresas[trabajo.empresa] = {};
        }
        /*Por cada distinta empresa, se esta creando una propiedad con el año en la que esa empresa tuvo empleados recibiendo un salario.*/
        if (!empresas[trabajo.empresa][trabajo.year]) {
            empresas[trabajo.empresa][trabajo.year] = [];
        }
        /* Por cada año, se esta agregando un array con los distintos salarios.*/
        empresas[trabajo.empresa][trabajo.year].push(trabajo.salario);
    }
}

Puedo sacar la mediana con esta función (todo debajo del código que escribimos en la restructuracion).

// Sacar la mediana por empresa y año seleccionados en la funcion

function medianaEmpresa (empresa, year){
    array = empresas[empresa][year];
    let mediana = MathCalculos.calcularMediana(array);
    console.log(mediana);

}
medianaEmpresa("MarketerosCOL",2022);
// 900

Reestructurando información sobre la marcha

Introducción

¿Ya tomaste el Curso Práctico de JavaScript?

Matemáticas en JavaScript

Fórmulas matemáticas en JavaScript

Math en JavaScript

Reto: altura de un triángulo

Porcentajes

Cómo calcular porcentajes

Calculando descuentos con JavaScript

Ejercicio de crear cupones de descuento

Método find vs. método filter

Estadística básica

Qué es promedio, moda y mediana

Calculando el promedio

Método reduce

Calculando la mediana en una lista impar

Calculando la mediana en una lista par

Método sort

Calculando la moda: objetos a partir de arrays

Calculando la moda: arrays a partir de objetos

Promedio Ponderado en JavaScript: Fórmulas y Casos de Uso

PlatziMath: clases y métodos estáticos

Análisis de salarios

Cómo estructurar información en proyectos de software

Análisis salarial con JavaScript

Proyección salarial personal

Reestructurando información sobre la marcha

Salarios empresariales

Proyección de salarios por empresas

Top 10% de salarios

Análisis de la Mediana Salarial con HTML, CSS y JavaScript

Próximos pasos

Toma el Taller Práctico de JavaScript: Videojuegos