No tienes acceso a esta clase

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

FlatMap

24/28
Recursos

Aportes 90

Preguntas 2

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Regístrate o inicia sesión para participar.

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

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 😃

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. 👍🏻

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 “aplanamos” 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

Mi solución:

Mi solución:

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

console.log(rta3);

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

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

Dicho en “palabras 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.

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
]

Para las personas que buscan el código de la clase, por ejemplo un array de usuarios que el profesor usó le pueden tomar una captura de pantalla con Blackbox que es una extensión del navegador que copia el texto de la foto y lo deja listo para pegar.

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)
const finishArray = []
const rtaPrimaryCalendar = calendars.primaryCalendar.flatMap(item => item.startDate)
const rtaSecondaryCalendar = calendars.secondaryCalendar.flatMap(item => item.startDate)

finishArray.push(rtaPrimaryCalendar, rtaSecondaryCalendar);

console.log(finishArray.flat())

Mi solucion antes de ver la solucion jaja

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

console.log(rta);
const rta = Object.values(calendars).flat().flatMap((calendar) => calendar.startDate);

El reto de obtener “startDate”, muy entretenido 😁

Aquí esta la respuesta para el reto.

let rta = Object.values(calendars).flat().flatMap(date => date.startDate);

console.log(rta)

Para quienes quieran profundizar más en el uso de flat() y flatMap() les dejo este video de midudev donde explica a profundidad estas dos funciones:

https://www.youtube.com/watch?v=em_Vh7ZGrnw

#NuncaParenDeAprender 😄

Adjunto mi solución 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 startDates = [];
Object.keys(calendars).forEach(key => {
  const dates = calendars[key].flatMap(calendar => calendar.startDate);
  startDates.push(...dates);
});
console.log("🚀 ~ startDates", startDates);

Reto


let challenge = [...calendars.primaryCalendar,...calendars.secondaryCalendar];
console.log('Challenge:', challenge.map(element => element.startDate))

//Mi solucion
const ar = Object.values(calendars);
console.log(‘ar’,ar)
const res3 = ar.flatMap(cal => cal.map(item => item.startDate));
console.log(‘res3’,res3)

Object.values(calendars).flatMap((calendar) => calendar.flatMap((cal)=> cal.startDate));

Yo hice 2 flatMap seguidos y me dio el mismo output

const rta3 = Object.values(calendars).
flatMap(calendar=>calendar.flatMap(calendar=>calendar.startDate))
console.log('rta3',rta3)
console.log(Object.values(calendars).flat().flatMap(item => item.startDate))`
`` 

Aquí mi aporte.

<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);
const rta4 = rta3.flat().map(item => item.startDate);

console.log(rta4);> 

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

console.log(values);

Dejo mi solución


  const keys = Object.keys(calendars);
  const array = [];
  keys.forEach((element) => {
    array.push(calendars[element].map((item) => item.startDate));
  })

  console.log(array.flat());

Ésa fue la solución a mi reto, ¿Qué tal?

🦎Reto

const rpta = Object.values(calendars).flat().map(item => item.startDate);
console.log('flatMap', rpta);

Reto completado!

const keys = Object.keys(calendars);
const newArray = keys.flatMap(key => calendars[key]).flatMap(element => element.startDate);

Solución:


const startDates1 = calendars.primaryCalendar.map( element => element.startDate);
const startDates2 = calendars.secondaryCalendar.map( element => element.startDate);
const startDates = [...startDates1, ...startDates2];
console.log(startDates)

No se si soy yo, pero he visto soluciones algo rebuscadas a mi parecer. Aquí va la mía.
Codigo:

Consola:

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

A menudo utilizo flatMap para hacer filter y map a la vez

const people = [
  {
    name: 'Juan',
    lastname: 'Espinola',
    age: 19
  },
  {
    name: 'Julian',
    lastname: 'Gutierrez',
    age: 35
  },
  {
    name: 'Nicolas',
    lastname: 'Molina',
    age: 15
  }
]

const names = people.flatMap(person => {
  person.age >= 18
  ? return person
  : return []
})
// [ {...}, {...}, []] ---> [{...}, {....}]

Lo hago sólo con el fin de iterar una sóla vez, ya que a fines de legibilidad sería mejor primero aplicar un filter y luego un map.

Mi solución 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 arr = Object.values(calendars);

const rta3 = arr.map(e => e.flatMap(item => item.startDate)).flat();
console.log(rta3);

Mi solución al reto, un poco larga

 const newArrayDates = [];
 const transformToArray = Object.entries(calendars);
 const getPrimary = transformToArray.map(element => element[1]);
 for(let i=0;i<getPrimary.length;i++){
    for(let j=0;j<getPrimary.length;j++){
        newArrayDates.push(getPrimary[i][j].startDate);
    }
 }
 console.log(newArrayDates);

Este es mi intento de solucion por mi cuenta antes de la solucion del profe la cual me funcionó:

const element1 = calendars.primaryCalendar;
const element2 = calendars.secondaryCalendar;

const response1 = element1.flatMap(calendar => calendar.startDate);
const response2 = element2.flatMap(calendar => calendar.startDate);
const finalResponse = [...response1, ...response2];
console.log('Starts Dates: ', finalResponse);

Aquí mi solución.


//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 newArray = Object.values(calendars).flat()
const startDates = []
newArray.forEach(item =>{
    startDates.push(item.startDate)  
})

console.log(startDates)

Esta es mi solucion al reto de la clase

const appointments = Object.values(calendars).flat();
const startDate = appointments.map((date) => date.startDate);
/* object.values permite convertir un objeto en array */

const rta = Object.values(calendars);
const rta1 = rta.flat().map(item => item.startDate);

console.log('rtat', rta);
console.log('rta1', rta1);

Mi solución

Aunque he visto mejores soluciones, pero es así como lo pensé al inicio.

const cal1 = calendars.primaryCalendar.flatMap(item => item.startDate);
const cal2 = calendars.secondaryCalendar.flatMap(item => item.startDate);
const calComplete = cal1.concat(cal2);
console.log (calComplete);

Challenged completed

ok

Usando map

let primary, secondary

for(calendar in calendars) {

    primary = calendars['primaryCalendar'].map(item => item.startDate)
    secondary = calendars['secondaryCalendar'].map(item => item.startDate)
}

let dates = primary.concat(secondary)

En mi caso esta es la solución que planteo: 😁

Mi solución al reto:

const rta4 = Object.values(calendars).flat(Infinity).map(item => item.startDate)
console.log(rta4)

Creo que en el reto es mejor usar flat y luego map en vez de flatMap ya que estaríamos escribiendo un código más corto.

flatMap lo dejaría para los casos en los que primero necesito el map y luego el flat, como en el primer ejemplo de la clase.

mi solución 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 rta = Object.values(calendars).flatMap(calendar=>calendar.flatMap(date=>date.startDate));
console.log(rta);

Reto Calendars


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 pC = calendars.primaryCalendar.flatMap(item => item.startDate);
const sC = calendars.secondaryCalendar.flatMap(item => item.startDate);
const startDate = pC.concat(sC);

console.log(startDate);
// [
//     "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 users = [
{ userId: 1, username: “Tom”, attributes: [“Nice”, “Cute”] },
{ userId: 2, username: “Mike”, attributes: [“Lovely”] },
{ userId: 3, username: “Nico”, attributes: [“Nice”, “Cool”] },
];

const rta = users.map(({attributes})=> attributes);

Les dejo el reto, aunque no lo pude completar usando flatMap pues lo que me devuelve Object.values es un arrays de arrays y flatmap no lo aplana por completo así que al iterar te devuelve un array, no tenía mucho sentido usar un map dentro de flatmap, me parece mejor usar un flat y después un map.

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 arr = Object.values(calendars).flat()
const r = arr.map(el =>  el.startDate)
console.log("r: ", r)

const arr2 = Object.values(calendars)
const r2 = arr2.flatMap(el =>  el.startDate)
console.log("r2", r2)

MI solución al reto (no usé flatMap asi que no se si cuenta, seguro hay mejores formas de resolverlo):

const flatArray = Object.entries(calendars).flat(2)

const flatArrayFiltered = flatArray.filter(item => {
    if (typeof item === "object") return item
})

const rta = flatArrayFiltered.map(item => item.startDate)
const rta3 = calendars.primaryCalendar.flatMap(item => item.startDate);
const rta4 = calendars.secondaryCalendar.flatMap(item => item.startDate);
const rtaFinal = rta3.concat(rta4);
console.log(rtaFinal);

Medio cavernícola aunque funciona. Creo que debería recorrerlo con un método al array primero.

const primary = calendars.primaryCalendar.map(item => item)
const secondary = calendars.secondaryCalendar.map(item => item)
const concatArray = [...primary, ...secondary]
const resp = concatArray.flatMap(item => item.startDate)
console.log(resp)

No se si sea validod pero aquí dejo 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 plano = calendars.primaryCalendar.concat(calendars.secondaryCalendar)
  const rta3 = plano.flatMap(item => item.startDate)

  console.log(rta3);

Mi respuesta al reto fue la siguiente:

const rta2 = calendars.primaryCalendar.flatMap(value => value.startDate).concat(calendars.secondaryCalendar.flatMap(value => value.startDate));

console.log(rta2)

la respuesta al reto de calendars es esta, veo que se sacrifica mucho la legibilidad del codigo pero dado a como esta estructurado el objeto calendar esta fue la manera en la que consegui extraer la infomacion

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 3",
    },
    {
      startDate: new Date(2021, 1, 1, 9),
      endDate: new Date(2021, 1, 1, 10),
      title: "Cita 4",
    },
  ],
};


test = Object.entries(calendars)
.map(item =>item[1]).flat().map(item => item.startDate)

console.log(test)

fue super util haber visto el curso anterios de poo intermedio por esa funcion Object.entries()

FlatMap tiene restriccion de 1 nivel

Estos metodos son muy utilies 😃

FlatMap = Flat + Map metodos

Este curso sencillamente es muy útil.

Esta es mi solución al reto

recibo cualquier tipo de recomendació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 array = calendars.primaryCalendar.concat(calendars.secondaryCalendar)

const rta = array.flatMap(element => element.startDate)
console.log(rta)

Mi versión de solución

const startDates = Object.values(calendars).flatMap((calendar) =>
  calendar.flatMap((date) => date.startDate)
);

Hice algo diferente y creo con values se podría generar un mejor código, aún así, esta es mi solución:

const flatArray = Object.keys(calendars).flatMap(calendar => {
    return calendars[calendar].flatMap(event => event.startDate);
});

Comparto mi solución del reto. (^人^)

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

const startDates = []
for (iterator in calendars) {
    startDates.push(...calendars[iterator].flatMap(item => item.startDate));
}   
console.log(startDates);

El output:

asi me quedo a mi 😅😅😅

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 keys = Object.keys(calendars);
const result = keys.map(key => calendars[key])
  .flat()
  .map(calendar => `start date: ${calendar.startDate}`)

console.log(result);

Ojala no quede :clown emoji: despues de ver la solución JAJAJA

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 startDates = Object.keys(calendars).reduce((arr, c) => {

    return arr.concat(calendars[c].flatMap(calendar => calendar.startDate));
}, []);

console.log(startDates);

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

Solución al reto con concat y flatmap

const union = calendars.primaryCalendar.concat( calendars.secondaryCalendar ).flatMap( date => date.startDate );
console.log( 'Respuesta al reto: ', union );

Dejo mi solucion al reto:

let result = [];
Object.keys(calendars).forEach((element) => {
  result = result.concat(calendars[element].flatMap((date) => date.startDate));
});

console.log(result);

Poco practica la solución mía pero funciona.

const pC = calendars.primaryCalendar.flatMap((item) => item.startDate);
const sC = calendars.secondaryCalendar.flatMap((item) => item.startDate);
const rta3 = pC.concat(sC)
console.log(final);

Esta fue la solución que se me ocurrio

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 = Object.values(calendars).flatMap(item => {
  return item
}).map(meet => meet.startDate);

console.log(dates);