FlatMap

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

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

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 😃

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.

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

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

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

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

reto

const fechasDeInicio = Object.values(calendars)
const aplanar = fechasDeInicio.flat().map(fecha => fecha.startDate)

console.log(aplanar)```

Yo lo hice de esta manera:

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

console.log(rta2)

No me convence mucho mi solución xd

Object.values(calendars).flatMap(calendar=> calendar.flatMap(event => event.title))

Mi forma de resolver el reto:

const bigArray = calendars.primaryCalendar.concat(calendars.secondaryCalendar)
const rta = bigArray.flatMap(item => item.startDate)
console.log(rta)

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: “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 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: “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).flatMap((calendar) =>
calendar.map((item) => item.endDate)
);

console.log(“citas”, 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);