No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Adquiere por un a帽o todos los cursos, escuelas y certificados por un precio especial.

Antes: $249

Currency
$219/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Comprar ahora

Termina en:

0D
3H
10M
9S

FlatMap

24/28
Recursos

El m茅todo flatMap es inmutable y consiste en la combinaci贸n de los m茅todos map y flat. Primero realiza la iteraci贸n de los elementos del array (como si fuera map), y despu茅s los aplana en una sola profundidad (como si fuera flat).

Este procedimiento recibe los mismos argumentos que el m茅todo map.

const strings = ["Nunca pares", "de Aprender"]

strings.map(string => string.split(" ")) 
// [ [ 'Nunca', 'pares' ], [ 'de', 'Aprender' ] ]

strings.flatMap(string => string.split(" ")) 
// [ 'Nunca', 'pares', 'de', 'Aprender' ]
const numbers = [1, 2, 3, 4]

numbers.map(number => [number * 2]) 
// [[2], [4], [6], [8]]

numbers.flatMap(number => [number *2]) 
// [2, 4, 6, 8]

Cuidado con el m茅todo flatMap, primero realiza el map y luego el flat.

const numbers2 = [1,[2,3], 4, 5]
numbers2.flatMap(number => [number *2]) 
// [ 2, NaN, 8, 10 ]
// * Recuerda: NaN = No a Number

Contribuci贸n creada por Andr茅s Guano.

Aportes 160

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

Te dejo a mano el objeto calendars para realizar el reto 馃槂

const calendars = {
  primaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 15),
      endDate: new Date(2021, 1, 1, 15, 30),
      title: "Cita 1",
    },
    {
      startDate: new Date(2021, 1, 1, 17),
      endDate: new Date(2021, 1, 1, 18),
      title: "Cita 2",
    },
  ],
  secondaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 12),
      endDate: new Date(2021, 1, 1, 12, 30),
      title: "Cita 2",
    },
    {
      startDate: new Date(2021, 1, 1, 9),
      endDate: new Date(2021, 1, 1, 10),
      title: "Cita 4",
    },
  ],
};

Les dejo el array de users:

const users = [
  { userId: 1, username: "Tom", attributes: ["Nice", "Cute"]},
  { userId: 2, username: "Mike", attributes: ["Lovely"]},
  { userId: 3, username: "Nico", attributes: ["Nice", "Cool"]},
]

Me parecia confuso al inicio la solucion, pero no tenia claro que primero flatMap() realiza un map y luego el flat. Propongo entonces que se llame mejor mapFlat(). lol

Mi soluci贸n al reto:

const rtaReto = Object.values(calendars).flat().map(item => item.startDate);
console.log(rtaReto);

lo intente

const challenge1 = calendars.primaryCalendar.flatMap(calendar =>calendar.startDate);
const challenge3 = calendars.secondaryCalendar.flatMap(calendar =>calendar.startDate);
console.log(challenge1.concat(challenge3));

Esta es mi respuesta

let calendarsApart = Object.values(calendars).flat().map(item => item.startDate);
  1. Con Object.values, obtenemos una lista con los valores de cada key en nuestro objeto calendars

  2. Con flat 鈥渁planamos鈥 la lista ya que con el paso anterior nos quedan dos arrays dentro de uno: [ [ ], [ ] ]

  3. Con map recorremos cada elemento de la lista ya unificada. Estos elementos son finalmente objetos asi que solo nos queda acceder al atributo de startDate y listo

Reto:

const rta3 = Object.values(calendars).flat().flatMap(cal => cal.startDate)

El calendario lo convierto de objeto a array. lo aplano un nivel para quitar la divisi贸n de primary y secondary y luego le mapeo el startDate 馃槂

Dicho en 鈥減alabras simples鈥濃
La raz贸n por la cual el flatMap en este 煤ltimo caso dio como resultado dos undefined es porque, por dentro, el flatMap siempre realiza primero el map y luego el flat. Y justo en este ejercicio para obtener correctamente las fechas necesit谩bamos realizar primero el flat y luego el map.

flatMap() es un m茅todo que primero mapea cada elemento, y despu茅s aplana el resultado en un nuevo array.
Es id茅ntico a hacer un map() seguido de un flat() de profundidad 1.
Si necesitas hacer un flat de mayor profundidad, es mejor usar los m茅todos por separado, en lugar de usar flatMap().
.

Usando flatMap como filtro

Con flatMap puedes filtrar elementos, por ejemplo:

.
Pero, 驴c贸mo funciona?
Funciona gracias al array vac铆o, ejemplo:


.
Cuando quieres aplanar un elemento que es un array vac铆o, flat() simplemente remueve el array, por lo tanto, podemos usar flatMap para que se comporte como una especie de filtro si es que lo necesitamos. 馃憤馃徎

Mi soluci贸n:

Mi soluci贸n:

const rta3 = Object.values(calendars).flat().flatMap(item => item.startDate)

console.log(rta3);

Mi soluci贸n al reto:

Object.values(calendars).flat().map(({startDate}) => startDate)

Tres formas de solucionarlo

const calendars = {
  primaryCalendar: [{
      startDate: new Date(2021, 1, 1, 15),
      endDate: new Date(2021, 1, 1, 15, 30),
      title: "Cita 1",
    },
    {
      startDate: new Date(2021, 1, 1, 17),
      endDate: new Date(2021, 1, 1, 18),
      title: "Cita 2",
    },
  ],
  secondaryCalendar: [{
      startDate: new Date(2021, 1, 1, 12),
      endDate: new Date(2021, 1, 1, 12, 30),
      title: "Cita 2",
    },
    {
      startDate: new Date(2021, 1, 1, 9),
      endDate: new Date(2021, 1, 1, 10),
      title: "Cita 4",
    },
  ],
};
 
 
let res = []
 
// Utilizando for..in
for (cal in calendars) {
  res.push(...calendars[cal].map((el) => el.startDate));
}
console.log('for..in', res);
 
// con flatMap()
res = Object.values(calendars).flatMap(el => el.map(el => el.startDate))
console.log('flatMap()', res)
 
// con flat() y map(), me parece m谩s apropiado
res = Object.values(calendars).flat().map(el => el.startDate)
console.log('flat() y map()', res)

Este fue mi soluci贸n al reto:

console.log(Object.values(calendars).flatMap(calendar => calendar.map(date => date.startDate)));

// output
[
  'Mon Feb 01 2021 15:00:00 GMT-0600 (hora est谩ndar central)',
  'Mon Feb 01 2021 17:00:00 GMT-0600 (hora est谩ndar central)',
  'Mon Feb 01 2021 12:00:00 GMT-0600 (hora est谩ndar central)',
  'Mon Feb 01 2021 09:00:00 GMT-0600 (hora est谩ndar central)'
]

Para obtener ese output lo 煤nico que hice fue agregar .toString() al final de startDate: new Date(x, x, x, x).

Esto me viene a la mente con flat || map 贸 flatmap:

Esta es mi soluci贸n

let calendarsArray = Object.values(calendars)

let startDates = calendarsArray.flat(3).map(obj => obj.startDate)

vamos a ver como lo hizo el profe

  const res = Object.values(calendars).flatMap(item => item.map(ele => ele.startDate))

Se me hizo un poco complejo, creo que la soluci贸n es recorrer el objeto e ir aplicando el flatmap鈥 asi

const onlyStartDates = (dates) => dates.flatMap(({ startDate }) => startDate);

const startDates = [];

// recorremos las llaves del obj.
for (const key in calendars) {
  startDates.push(onlyStartDates(calendars[key]));
}

const rta = startDates.flat();
console.log('rtaReto :>> ', rta);
output: rtaReto :>>  [
  2021-02-01T20:00:00.000Z,
  2021-02-01T22:00:00.000Z,
  2021-02-01T17:00:00.000Z,
  2021-02-01T14:00:00.000Z
]

Comparto mi desarrollo del reto:

const calendars = {
  primaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 15),
      endDate: new Date(2021, 1, 1, 15, 30),
      title: "Cita 1",
    },
    {
      startDate: new Date(2021, 1, 1, 17),
      endDate: new Date(2021, 1, 1, 18),
      title: "Cita 2",
    },
  ],
  secondaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 12),
      endDate: new Date(2021, 1, 1, 12, 30),
      title: "Cita 2",
    },
    {
      startDate: new Date(2021, 1, 1, 9),
      endDate: new Date(2021, 1, 1, 10),
      title: "Cita 4",
    },
  ],
};

const rta2 = Object.values(calendars).flatMap(item => item.map(item => item.startDate));
console.log(rta2);
const array = Object.values(calendars).flat(2).map( date => date.startDate);

Esta es mi solucion al reto:

const res3 = Object.values(calendars).flat().map(item => item.startDate)

Mi soluci贸n con el reto fue a trav茅s de la siguiente soluci贸n:

console.log('calendars',Object.values(calendars).flat().map(value => value.startDate));

Mi soluci贸n:

const fechainicio = Object.values(calendars).flat().map(item => item.startDate)

Vi que muchos luego de hacer (calendars).flat hacian .flatmap pero eso se supone que hace primero un map y luego un flat, lo que me hizo pensar que es mejor hacer un map directo.

mi solucion al reto 馃槂

const fechasInicio = []
for (const calendar in calendars) {
  fechasInicio.push(calendars[calendar].map( appointment => appointment.startDate))
}

console.log(fechasInicio.flat())
/*
[
  2021-02-01T20:00:00.000Z,
  2021-02-01T22:00:00.000Z,
  2021-02-01T17:00:00.000Z,
  2021-02-01T14:00:00.000Z
]
*/ 

mi aporte del reto

// extraigo los valores de los atributos del objeto
const array = Object.values(calendars)
console.log('values', array);
//me queda un array con dos array's aplico flat para aplanar el array que necesito
const rta3 = array.flat(2)
console.log('flat', rta3);
//extraigo los valores requridos
const rta4 = rta3.flatMap(item => item.startDate)
console.log('flatMap', rta4);

Esta fue mi solucion:

Hola que tal? Esto aplique yo:
const calendars = {
primaryCalendar: [
{
startDate: new Date(2021, 1, 1, 15),
endDate: new Date(2021, 1, 1, 15, 30),
title: 鈥淐ita 1鈥,
},
{
startDate: new Date(2021, 1, 1, 17),
endDate: new Date(2021, 1, 1, 18),
title: 鈥淐ita 2鈥,
},
],
secondaryCalendar: [
{
startDate: new Date(2021, 1, 1, 12),
endDate: new Date(2021, 1, 1, 12, 30),
title: 鈥淐ita 2鈥,
},
{
startDate: new Date(2021, 1, 1, 9),
endDate: new Date(2021, 1, 1, 10),
title: 鈥淐ita 4鈥,
},
],
};
const esto = calendars.primaryCalendar
const esto2 = calendars.secondaryCalendar
const esto1 = esto.concat(esto2)
const estof= esto1.map(item => item.startDate)

console.log(estof)

Mi soluci贸n 馃懆鈥嶐煉:

const calendars = {
  primaryCalendar: [
    { startDate: new Date(2021, 1, 1, 15), endDate: new Date(2021, 1, 1, 15, 30), title: "Cita 1", },
    { startDate: new Date(2021, 1, 1, 17), endDate: new Date(2021, 1, 1, 18), title: "Cita 2", },
  ],
  secondaryCalendar: [
    { startDate: new Date(2021, 1, 1, 12), endDate: new Date(2021, 1, 1, 12, 30), title: "Cita 2", },
    { startDate: new Date(2021, 1, 1, 9), endDate: new Date(2021, 1, 1, 10), title: "Cita 4", },
  ],
};

const dates = [...calendars.primaryCalendar, ...calendars.secondaryCalendar]
	.flatMap( (calendar) => calendar.startDate );

console.log('startDates', dates);
/*
startDates [
  2021-02-01T20:00:00.000Z,
  2021-02-01T22:00:00.000Z,
  2021-02-01T17:00:00.000Z,
  2021-02-01T14:00:00.000Z
]
*/
const startDates = Object.values(calendars).flatMap(calendar => calendar.flatMap(cal=>cal.startDate));
console.log(startDates);

const calendars = {
primaryCalendar: [
{
startDate: new Date(2021, 1, 1, 15),
endDate: new Date(2021, 1, 1, 15, 30),
title: 鈥淐ita 1鈥,
},
{
startDate: new Date(2021, 1, 1, 17),
endDate: new Date(2021, 1, 1, 18),
title: 鈥淐ita 2鈥,
},
],
secondaryCalendar: [
{
startDate: new Date(2021, 1, 1, 12),
endDate: new Date(2021, 1, 1, 12, 30),
title: 鈥淐ita 2鈥,
},
{
startDate: new Date(2021, 1, 1, 9),
endDate: new Date(2021, 1, 1, 10),
title: 鈥淐ita 4鈥,
},
],
};

const rta3 = Object.values(calendars).flatMap((calendar) =>
calendar.map((item) => item.endDate)
);

console.log(鈥渃itas鈥, rta3);

La soluci贸n al utlimo ejercicio se resuelve de manera mas sencilla de la siguiente manera:

const rta2 = Object.values(calendars).flat().map(date => date.startDate);

console.log(rta2);

Reto 1

function getStartDates(calendars) {
  const startDates = Object.values(calendars)
    .flatMap(calendar => calendar.map(event => event.startDate));
  
  return startDates;
}

const startDates = getStartDates(calendars);
console.log(startDates);

Resolvi el reto de la siguiente forma:
1- Pase el objeto a array

const calendarsArr = Object.entries(calendars) 

2-Aplique flat(2) para aplanar el array de forma que los 2 arrays de Calendar queden a la misma profundidad

calendarsArr.flat(2)

3-Aplique el .filter de modo que me devuelva un nuevo array con los objetos que registran las fechas

calendarsArr.flat(2).filter(e => e.startDate)

4-Por 煤ltimo aplique un .map para tener un nuevo array solo con las fechas de comienzo

calendarsArr.flat(2).filter(e => e.startDate).map(e => e.startDate)

mi soluci贸n:

const dates = calendars.primaryCalendar.flatMap(item => item.startDate)
const dates2 = calendars.secondaryCalendar.flatMap(item => item.startDate)
const final = dates.concat(dates2)

Les comparto mi soluci贸n alternativa a Object.values y en lugar de usar un map interno, utilice un flat antes del flatMap.

let array = []
for(const element in calendars){
  array.push(calendars[element])
}

let rta = array.flat().flatMap(element => {
  return element.startDate
})

Mi soluci贸n al reto:

console.log(Object.values(calendars).flat().map(obj => obj.startDate));

Tal vez la soluci贸n no sea la mas escalable, pero almeno cumple el reto 馃槄:

function citas(obj){
    let answer =[];
    answer.push(obj.primaryCalendar);
    answer.push(obj.secondaryCalendar);
    
    const rta = answer.flat();
    return rta.map(item=>item.startDate)
}

console.log(citas(calendars));/*[
    2021-02-01T20:00:00.000Z,
    2021-02-01T22:00:00.000Z,
    2021-02-01T17:00:00.000Z,
    2021-02-01T14:00:00.000Z
]*/ 

Soluci贸n鈥 馃槃
.

const props = Object.keys(calendars);
const rta3 = props.flatMap((key) =>
  calendars[key].map((item) => item.startDate)
);
console.log(rta3);

Dejo mi soluci贸n 馃槃.

const arrayStart= (Object.values(calendars).flat(1).flatmap(item=> item.startDate));

As铆 lo resolv铆 yo

const rta3 = Object.values(calendars).flat(2).map(date => date.startDate)
console.log(rta3);

Mi soluci贸n sin utilizar los metodo de flat y flatmap

<
  const array = Object.values(calendars)
  const salidaIndividualDeStarDate = []
  const array2 = array.map(item => item.map( listaDeStarDate => listaDeStarDate.startDate))
  const newArrayDate = array2.forEach( subArrayDate => subArrayDate.forEach( valorIndividual => salidaIndividualDeStarDate.push(valorIndividual)))
  console.log(salidaIndividualDeStarDate);
> 

Mi solucion al reto sin usar Flat ni FlatMap:

const entries = Object.entries(calendars);
const flatObjet = (array, key) => {
  let startDates = [];

  for (let i = 0; i < array.length; i++) {
    if (!Array.isArray(array[i])) {
      let element = array[i];
      if (typeof element == 'object') {
        startDates.push(element[key]);
      }
      continue;
    } else {
      let element = array[i];
      startDates = startDates.concat(flatObjet(element, key));
    }
  }
  return startDates;
};

Mi soluci贸n al reto:

const dates = Object.values(calendars).flat().map(e => e.startDate);
console.log(dates);

mi respuesta:

console.log('flat', (Object.values(calendars).flat()).map(x=>x.startDate))

Mi soluci贸n al reto

const keys = Object.keys(calendars);
const startDates = keys.flatMap((calendar) => {
    return calendars[calendar].map((date) => date.startDate)
})
console.log('startDates', startDates);
const objArray = Object.values(calendars); //convertimos a array el object
//console.log(objArray);

const rta3 = objArray.map( date =>{
    return date.map( item =>{
        return item.startDate
    })
}).flat(2);
console.log('Calendars',rta3);

Mi soluci贸n:

const rta3 = Object.values(calendars).flat().map(item => item.startDate);;
console.log(rta3);

Mi solucion al reto:

const rta3 = calendars.primaryCalendar.concat(calendars.secondaryCalendar);
const rtaFinal = rta3.flatMap(date => date.startDate);
console.log('rtaFinal', rtaFinal);

As铆 o mas claro?

let flatten1 = calendars.primaryCalendar.flatMap(item => item.startDate)
let flatten2 = calendars.secondaryCalendar.flatMap(item => item.startDate)
  console.log(flatten1.concat(flatten2))

Otra soluci贸n utilizando fat y map por separado:

const calendarsValues = Object.values(calendars);

const startDates = calendarsValues
.flat()
.map((obj) => obj['startDate']);

console.log(startDates);

Output:

[
  2021-02-01T19:00:00.000Z,
  2021-02-01T21:00:00.000Z,
  2021-02-01T16:00:00.000Z,
  2021-02-01T13:00:00.000Z
]

Pd: Us茅 el mismo array de fechas que usa el profesor en la clase.

Mi soluci贸n al reto:

const arrayStartDate = Object.entries(calendars)
    .flatMap(array => array[1])
    .map(date => date.startDate);

mi solucion:

console.log(Object.values(calendars).flat().flatMap(item => item.startDate))

Comparto la soluci贸n que se me ocurri贸

const calendars = {
  primaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 15),
      endDate: new Date(2021, 1, 1, 15, 30),
      title: "Cita 1",
    },
    {
      startDate: new Date(2021, 1, 1, 17),
      endDate: new Date(2021, 1, 1, 18),
      title: "Cita 2",
    },
  ],
  secondaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 12),
      endDate: new Date(2021, 1, 1, 12, 30),
      title: "Cita 2",
    },
    {
      startDate: new Date(2021, 1, 1, 9),
      endDate: new Date(2021, 1, 1, 10),
      title: "Cita 4",
    },
  ],
};
calendars.primaryCalendar.flatMap(date => date.startDate).concat(calendars.secondaryCalendar.flatMap(date => date.startDate));

/*Solucion*/

    const calendars = {
      primaryCalendar: [
        {
          startDate: new Date(2021, 1, 1, 15),
          endDate: new Date(2021, 1, 1, 15, 30),
          title: "Cita 1",
        },
        {
          startDate: new Date(2021, 1, 1, 17),
          endDate: new Date(2021, 1, 1, 18),
          title: "Cita 2",
        },
      ],
      secondaryCalendar: [
        {
          startDate: new Date(2021, 1, 1, 12),
          endDate: new Date(2021, 1, 1, 12, 30),
          title: "Cita 2",
        },
        {
          startDate: new Date(2021, 1, 1, 9),
          endDate: new Date(2021, 1, 1, 10),
          title: "Cita 4",
        },
      ],
    };

 const intento = Object.values(calendars).flat().flatMap(item => item.startDate);

 console.log(intento);


Mi soluci贸n

 const OneCalendar = calendars.primaryCalendar.map((date) => date.startDate )
 const twoCalendar = calendars.secondaryCalendar.map(date =>date.startDate)
 const newCalendar = twoCalendar.concat(OneCalendar) 
 
 console.log('Calendar', newCalendar);
//mi solucion:

// Creamos un objeto que representa dos calendarios con citas programadas
const calendars = {
    primaryCalendar: [
      // Cita 1 en el calendario principal
        {
        startDate: new Date(2021, 1, 1, 15), // 15:00
        endDate: new Date(2021, 1, 1, 15, 30), // 15:30
        title: "Cita 1",
        },
      // Cita 2 en el calendario principal
        {
        startDate: new Date(2021, 1, 1, 17), // 17:00
        endDate: new Date(2021, 1, 1, 18), // 18:00
        title: "Cita 2",
        },
    ],
    secondaryCalendar: [
      // Cita 1 en el calendario secundario
        {
        startDate: new Date(2021, 1, 1, 12), // 12:00
        endDate: new Date(2021, 1, 1, 12, 30), // 12:30
        title: "Cita 2",
        },
      // Cita 2 en el calendario secundario
        {
        startDate: new Date(2021, 1, 1, 9), // 9:00
        endDate: new Date(2021, 1, 1, 10), // 10:00
        title: "Cita 4",
        },
    ],
};

  // Creamos un nuevo array que contiene los valores del objeto calendars
let newArray = Object.values(calendars).flat();

  // Aplicamos una funci贸n que extrae la fecha de inicio de cada objeto de cita y aplanamos el resultado en un nuevo array.
  //aqui no es necesario el flat map porque ya aplicamos el flat arriba pero bueh jajajaja. como aplica primero el map y luego el flat es que se complica
let final = newArray.flatMap((element) => element["startDate"]);

  // Mostramos el resultado final en la consola
console.log(final);

Aqu铆 mi soluci贸n al reto de los calendarios.

Reto 1

const rta = Object.values(calendars).flatMap(item => item.map(date => date.startDate));
const calendars = {
  primaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 15),
      endDate: new Date(2021, 1, 1, 15, 30),
      title: "Cita 1",
    },
    {
      startDate: new Date(2021, 1, 1, 17),
      endDate: new Date(2021, 1, 1, 18),
      title: "Cita 2",
    },
  ],
  secondaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 12),
      endDate: new Date(2021, 1, 1, 12, 30),
      title: "Cita 2",
    },
    {
      startDate: new Date(2021, 1, 1, 9),
      endDate: new Date(2021, 1, 1, 10),
      title: "Cita 4",
    },
  ],
};

const challenge = Object.values(calendars).flat().map(item => item.startDate)

Solution:
.
.
.

const calendars = {
    primaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 15),
        endDate: new Date(2021, 1, 1, 15, 30),
        title: "Cita 1",
      },
      {
        startDate: new Date(2021, 1, 1, 17),
        endDate: new Date(2021, 1, 1, 18),
        title: "Cita 2",
      },
    ],
    secondaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 12),
        endDate: new Date(2021, 1, 1, 12, 30),
        title: "Cita 2",
      },
      {
        startDate: new Date(2021, 1, 1, 9),
        endDate: new Date(2021, 1, 1, 10),
        title: "Cita 4",
      },
    ],
  };

const raw = Object.values(calendars)
const subArray = raw.flat()
const sD = subArray.map(item => item.startDate)

console.log(sD)
// [
//     2021-02-01T19:00:00.000Z,
//     2021-02-01T21:00:00.000Z,
//     2021-02-01T16:00:00.000Z,
//     2021-02-01T13:00:00.000Z
//   ]

Mi solucion al reto usando for in.

let newArray = [];
   for (elements in calendars) {
    let items = calendars[elements];
    for(dates in items) {    
     let array = calendars[elements][dates];
        newArray.push(array.startDate)
    }
    console.log(newArray);
    }
   

Mi soluci贸n usando Object.keys del objeto calendars

const myDates = Object.keys(calendars).flatMap(key => {
    return calendars[key].map(date => date.startDate);
});

Impresionante como dos lineas de c贸digo pueden hacer tanto.

  	let count = Object.values(calendars);
  	console.log(count.flatMap(item => item.map(calendar => calendar.startDate)));

Este habia sido mi solucion al reto y la verdad me habia rendido porque me arrojaba un objeto y no un array pero al profesor tambien le dio como resultado un objeto asi que supongo que mi solucion tambien es valida

const startingDate = ([...calendars.primaryCalendar, ...calendars.secondaryCalendar].flatMap(item => item.startDate).flat())

Bueno yo guardar铆a en una variable las startDate de la primera propiedad de calendars y en otra variable las startDate de la segunda propiedad de calendars, usando el m茅todo .flatMap() en cada una:

  const respuesta1 = calendars.primaryCalendar.flatMap(calendar => calendar.startDate);

const respuesta2 = calendars.secondaryCalendar.flatMap(calendar => calendar.startDate);

Luego concateno ambas respuestas con el m茅todo .concat();

const respuestaFinal = respuesta1.concat(respuesta2);

Hola 馃憢

Les comparto mi soluci贸n el reto de la clase

/* Nombre de los Calendarios */
const nameCalendars = Object.keys(calendars);
/* Lista de las Fechas de Inicio*/
const startDates = nameCalendars.flatMap(nameCalendar => {
    return calendars[nameCalendar].map(element => element.startDate);
});
console.log(startDates);
[
  2021-02-01T21:00:00.000Z,
  2021-02-01T23:00:00.000Z,
  2021-02-01T18:00:00.000Z,
  2021-02-01T15:00:00.000Z
]

Mi solucion:

const dates = calendars.primaryCalendar
     .concat(calendars.secondaryCalendar)
     .flatMap((item) => item.startDate);
console.log(dates);
const startDate = Object
    .values(calendars)
    .flatMap(calendar => calendar)
    .map(calendar => calendar.startDate);
    console.log("馃殌 ~ startDate", startDate)

Mi solucion al reto

 const respuesta = Object.values(calendars).flatMap(array => {
    const data = [];
    array.forEach(i => data.push(i.startDate))
    return data
  });

Asi lo resolv铆

const calendars = {
    primaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 15),
        endDate: new Date(2021, 1, 1, 15, 30),
        title: "Cita 1",
      },
      {
        startDate: new Date(2021, 1, 1, 17),
        endDate: new Date(2021, 1, 1, 18),
        title: "Cita 2",
      },
    ],
    secondaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 12),
        endDate: new Date(2021, 1, 1, 12, 30),
        title: "Cita 2",
      },
      {
        startDate: new Date(2021, 1, 1, 9),
        endDate: new Date(2021, 1, 1, 10),
        title: "Cita 4",
      },
    ],
  };

  const starts = calendars.primaryCalendar.map(item => item.startDate);
  const starts2 = calendars.secondaryCalendar.map(item => item.startDate);

  const array = starts.concat(starts2)

  console.log(array);

A mi se me ocurrio concatenar dos flatmap, uno por cada propiedad del objeto madre.

<const newCalendar = calendars.primaryCalendar
  .flatMap((date) => date.startDate)
  .concat(calendars.secondaryCalendar.flatMap((date) => date.startDate));
console.log(newCalendar);> 

Mi solucion al ejercicio es esta.

let rta = [];
for(let cl in calendars){
    const calendar = calendars[cl];
    rta.push(...calendar.map(date=>date.startDate));
}
console.log(rta);

Esta es mi soluci贸n:

Object.values(calendars).flat().map(e => e.startDate)

Hay una peque帽a cosa a tener en cuanta con flatMap y es que este m茅todo, al contrario de como su nombre indica 馃槀, primero hace el map y despu茅s el flat, por eso al profesor no le funciono como esperaba, y para este caso es mejor no utilizarlo

const calendars = {
    primaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 15),
        endDate: new Date(2021, 1, 1, 15, 30),
        title: "Cita 1",
      },
      {
        startDate: new Date(2021, 1, 1, 17),
        endDate: new Date(2021, 1, 1, 18),
        title: "Cita 2",
      },
    ],
    secondaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 12),
        endDate: new Date(2021, 1, 1, 12, 30),
        title: "Cita 2",
      },
      {
        startDate: new Date(2021, 1, 1, 9),
        endDate: new Date(2021, 1, 1, 10),
        title: "Cita 4",
      },
    ],
  };
  const rta= calendars.primaryCalendar.flatMap(date=>date.startDate).concat(calendars.secondaryCalendar.flatMap(date=>date.startDate))
  console.log(rta)

Esta fue mi soluci贸n al reto. Nada que ver con la del profe, pero el resultado es el mismo jajajaja

const calendars = {
    primaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 15),
        endDate: new Date(2021, 1, 1, 15, 30),
        title: "Cita 1",
      },
      {
        startDate: new Date(2021, 1, 1, 17),
        endDate: new Date(2021, 1, 1, 18),
        title: "Cita 2",
      },
    ],
    secondaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 12),
        endDate: new Date(2021, 1, 1, 12, 30),
        title: "Cita 2",
      },
      {
        startDate: new Date(2021, 1, 1, 9),
        endDate: new Date(2021, 1, 1, 10),
        title: "Cita 4",
      },
    ],
  };


const rta3 = Object.values(calendars).flat().flatMap(cal => cal.startDate);
console.log('Start Calendar:', rta3);

como me rei de la forma en la que lo hice y los largos paso que di y cuando veo sus repuestas que son muchisimo mas cortas y cuando vi la del profesor realmente me sorprende lo claro que la tienen seguire practicando.

como lo hizo el profe y algunos de ustedes

let cds = Object.values(calendars).flatMap((item) => {
  return item.map((date) => date.startDate);
});

como lo hice yo 馃う鈥嶁檪锔


let rts = calendars.primaryCalendar.map((item) => item.startDate);
let rts2 = calendars.secondaryCalendar.map((item) => item.startDate);

let result = rts.concat(rts2);
console.log(result);

Reto resuelto!

  • Tenemos como conjunto universal calendars, dentro de este 2 sub-conjuntos primaryCalendear y secondaryCalendear.
  • Estos 2 a su vez tienes 2 objetos (Cita1 y CIta2) son estos 2 objetos los que nos importan aqui hallamos el valor de starDate.
    Procedimiento:
  1. Con Values obtenemos los 2 primeros sub-conjuntos.
  2. En la prueba se obtuvo 鈥渦ndefine鈥 por que el subcojunto no tiene propiedades como tal , en cambio los 2 objetos dentro si.
  3. Se realiza un map final para acceder a estos objetos y finalmente organizar las starDate.

Mi ejercisio lo resolvi para tener satisfaccion propia ya que hice una modificacion al final nada mas por hacer que se vea mas estetico el codigo por asi decirlo 鉂わ笍

const calendars = {
    primaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 15),
        endDate: new Date(2021, 1, 1, 15, 30),
        title: "Cita 1",
      },
      {
        startDate: new Date(2021, 1, 1, 17),
        endDate: new Date(2021, 1, 1, 18),
        title: "Cita 2",
      },
    ],
    secondaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 12),
        endDate: new Date(2021, 1, 1, 12, 30),
        title: "Cita 2",
      },
      {
        startDate: new Date(2021, 1, 1, 9),
        endDate: new Date(2021, 1, 1, 10),
        title: "Cita 4",
      },
    ],
  };

// Solo valores del StartDate
const value = Object.values(calendars);
const valueFinal = value.flat().map(item => item.startDate);


const keys = Object.keys(calendars);
const final = [
    [keys[0], valueFinal[0], valueFinal[1]],
    [keys[0], valueFinal[2], valueFinal[3]]];

console.log(valueFinal);
console.log(final);

No me funciona flat por alguna raz贸n.

Soluci贸n al reto:

const rtaPrimaryCalendar = calendars.primaryCalendar.flatMap(
  (item) => item.startDate
);
const rtaSecondaryCalendar = calendars.secondaryCalendar.flatMap(
  (item) => item.startDate
);
const rta3 = rtaPrimaryCalendar.concat(rtaSecondaryCalendar);
console.log("star-date", rta3);

My soluci贸n 馃槃

const startDate = Object.values(calendars)
.flat()
.map((calendar) => calendar.startDate);

隆Hola! Dejo mi aporte de la forma en la que cumpl铆 el reto, no es tan simple como la del profesor pero quiz谩s pueda serte de 煤tilidad:

let keysCalendar = Object.keys(calendars);
let rtaExercice = []
for (const [key,value] of Object.entries(calendars)) {
    rtaExercice.push(value.flatMap(element => element.startDate))
}
const finalRta = rtaExercice.flat();
console.log(finalRta);

Mi soluci贸n al reto:

const rta = Object.values(calendars).flatMap(calendario => calendario.flatMap(fecha => fecha.startDate))

console.log(rta);

Esta es mi soluci贸n, veremos que ejemplo da el profe

const elemento = Object.values(calendars).flat().map(user => user.startDate);
console.log(elemento);

Lo hice de otra manera y al comparar con el del profesor aparentemente esta bien.

// reto:
const calendars = {
   primaryCalendar: [
      {
         startDate: new Date(2021, 1, 1, 15),
         endDate: new Date(2021, 1, 1, 15, 30),
         title: "Cita 1",
      },
      {
         startDate: new Date(2021, 1, 1, 17),
         endDate: new Date(2021, 1, 1, 18),
         title: "Cita 2",
      },
   ],
   secondaryCalendar: [
      {
         startDate: new Date(2021, 1, 1, 12),
         endDate: new Date(2021, 1, 1, 12, 30),
         title: "Cita 2",
      },
      {
         startDate: new Date(2021, 1, 1, 9),
         endDate: new Date(2021, 1, 1, 10),
         title: "Cita 4",
      },
   ],
};

const reto = Object.values(calendars).flatMap(item => {
   return item.map(date => date.startDate);
});
console.log(reto);


const retov2 = Object.values(calendars).flat(2).flatMap(date => date.startDate);
console.log(retov2);

output:

[
  2021-02-01T21:00:00.000Z,
  2021-02-01T23:00:00.000Z,
  2021-02-01T18:00:00.000Z,
  2021-02-01T15:00:00.000Z
]
[
  2021-02-01T21:00:00.000Z,
  2021-02-01T23:00:00.000Z,
  2021-02-01T18:00:00.000Z,
  2021-02-01T15:00:00.000Z
]

Bueno en mi respuesta anterior no puse Object.values pero funciono igual JAJAJ

const dates2 = Object.values(calendars.primaryCalendar.concat(calendars.secondaryCalendar).flatMap(a=>a.startDate))
console.log(dates2)

Me siento totalmente orgulloso conmigo mismo en decir que el reto fue de lo mas simple. Eso por supuesto por el excelente aprendizaje que esta brindando el profesor!
Mi codigo:

const dates = calendars.primaryCalendar.concat(calendars.secondaryCalendar).flatMap(a=>a.startDate)
console.log(dates)

Para el que quiera comprender mejor el reto, pongo la respuesta con su salida paso a paso:

const reto1 = Object.values(calendars);
const reto2 = reto1.flat();
const reto3 = reto2.map(item => item.startDate);
console.log("reto1:", reto1); // pasamos un objeto a un array
console.log("reto2:", reto2); // aplanamos con flat() el array
console.log("reto3:", reto3); // nos quedamos con los startDate

Saludos! 馃槃

Alternativa de soluci贸n

function startDates(calendars) {
  const dates = [];
  Object.entries(calendars).map(
    calendar => {
      calendar[1].map(
        appoinment => {
          dates.push(appoinment.startDate);
        });
    }
  );
  return dates;
}

reto:

  const array = Object.entries(calendars);
  const res3 = array.flatMap(calendar=>calendar[1]).map(objCalendar=>objCalendar.startDate);
  console.log(res3);

Mi solucion al reto

const calendars = {
  primaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 15),
      endDate: new Date(2021, 1, 1, 15, 30),
      title: "Cita 1",
    },
    {
      startDate: new Date(2021, 1, 1, 17),
      endDate: new Date(2021, 1, 1, 18),
      title: "Cita 2",
    },
  ],
  secondaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 12),
      endDate: new Date(2021, 1, 1, 12, 30),
      title: "Cita 2",
    },
    {
      startDate: new Date(2021, 1, 1, 9),
      endDate: new Date(2021, 1, 1, 10),
      title: "Cita 4",
    },
  ],
};

const res2 = calendars.primaryCalendar.flatMap(date => date.startDate)
const res3 = calendars.secondaryCalendar.flatMap(date => date.startDate)
const finalRest = res2.concat(res3)

console.log(res2);
console.log(res3);
console.log(finalRest);

Mi soluci贸n:

const arrayOne = calendars.primaryCalendar.flatMap(item => item.startDate);
const arrayTwo = calendars.secondaryCalendar.flatMap(item => item.startDate);
const reto = arrayOne.concat(arrayTwo)
console.log(reto);

Esta fue mi soluci贸n, ser铆a genial si se parece a la de alguien m谩s

const calendars = {
  primaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 15),
      endDate: new Date(2021, 1, 1, 15, 30),
      title: "Cita 1",
    },
    {
      startDate: new Date(2021, 1, 1, 17),
      endDate: new Date(2021, 1, 1, 18),
      title: "Cita 2",
    },
  ],
  secondaryCalendar: [
    {
      startDate: new Date(2021, 1, 1, 12),
      endDate: new Date(2021, 1, 1, 12, 30),
      title: "Cita 2",
    },
    {
      startDate: new Date(2021, 1, 1, 9),
      endDate: new Date(2021, 1, 1, 10),
      title: "Cita 4",
    },
  ],
};

const calendarsAsArray = Object.values(calendars)
const startDates = calendarsAsArray.flatMap(calendar => {
    return calendar.map(date => date.startDate)
})
function findStartDate(object){
  return Object.values(object).flat().map((date)=>{
    return Object.entries(date)[0]
  })
}

findStartDate(calendars)
  const rta3 = calendars.primaryCalendar.flatMap(calendar => calendar.startDate);
  const rta4 = calendars.secondaryCalendar.flatMap(calendar => calendar.startDate);
  console.log([...rta3,...rta4]);

Aqu铆 el reto de la clase

<code> 
const calendars = {
    primaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 15),
        endDate: new Date(2021, 1, 1, 15, 30),
        title: "Cita 1",
      },
      {
        startDate: new Date(2021, 1, 1, 17),
        endDate: new Date(2021, 1, 1, 18),
        title: "Cita 2",
      },
    ],
    secondaryCalendar: [
      {
        startDate: new Date(2021, 1, 1, 12),
        endDate: new Date(2021, 1, 1, 12, 30),
        title: "Cita 2",
      },
      {
        startDate: new Date(2021, 1, 1, 9),
        endDate: new Date(2021, 1, 1, 10),
        title: "Cita 4",
      },
    ],
  };

  const primaryCalendar = calendars.primaryCalendar.map(item => item.startDate)
  const secondaryCalendar = calendars.secondaryCalendar.map(item => item.startDate)
  const rta4 = primaryCalendar.concat(secondaryCalendar);
  console.log(rta4)