Si queréis, lo miramos. Alguien decía que le estaba costando este, que es el layer.
En la fábrica de Papá Noel se acerca el día especial y todavía tenemos un montón de cosas por contar.
Por suerte, a Mark Zuck de Elf se le ha ocurrido... Anda, qué gracioso este chico.
Se le ha ocurrido crear una función que permite agrupar un array que puede ser de valores u objetos.
Muy bien, valores u objetos. Voy a poner esto pequeñito.
A través de una función o de una propiedad.
Nos trae un montón de ejemplos. Está bastante bien que tenga un montón de ejemplos para que no se equivoquéis.
Por ejemplo, lo que hay que hacer es agrupar.
Y lo que dice es que tú tienes un array de elementos, en este caso son números,
y hay que ejecutar con este método y dependiendo de lo que devuelva hay que agruparlo en un aquí.
Por ejemplo, este número 6, cuando se le pasa al mathflor, quedaría en 6.
Y el 4.2 quedaría en 4 y el 6.3 quedaría en 6.
Y entonces los que han quedado en 6 se agrupan aquí y los que han quedado con 4 se agruparían aquí.
Ahora, lo interesante de esta función en realidad es que aparte de pasarle una función,
como hemos dicho por aquí, a través de una función o de una propiedad.
Por ejemplo, esto sería la propiedad length.
Esto quiere decir que en el array este tendríamos el one de length tiene 3 letras,
el two tiene 3 letras y este tiene 5 letras.
Bueno, pues sería un objeto donde el 3, que es el length que tendría one y two,
pues están ahí agrupados y el 5 el three.
O sea, me parece un ejercicio muy, muy, no sé, no es muy difícil, pero es curioso.
Porque además es útil, que es una de las cosas que a mí normalmente los retos no me suelen gustar.
Pero esto es una cosa que te puedes encontrar realmente en la vida real.
Aquí lo tendríamos con una función también.
En cada una le pasas el timestamp y aquí lo que tienes que recuperar es el año.
Y aquí tendrías que este es del 2014 y este es del 2013.
No es que me lo sepa de memoria, sino que está aquí el resultado.
Y aquí lo mismo con un array de objetos que los tienes que agrupar por routing
y entonces quedan agrupados los que tienen 8, los que tienen 9 y los que tienen 10.
¿Vale? ¿Sí? ¿Está aquí? ¿Bien? ¿Sí? ¿Sí? ¿Sí?
Bueno, a ver, vamos a hacer yo cómo lo haría, luego lo podría optimizar y tal.
Pero yo pensando sobre esto, una cosa que empezaría...
Ah, bueno, voy a terminar de leer denunciado, importante.
Como ves, la función groupby recibe una colección array.
¿Vale? Todos reciben siempre un array.
Y luego una función o propiedad.
Y devuelvo un objeto con claves que son los valores de la función ejecutada
pasando como argumento cada elemento o de la propiedad por cada elemento.
O sea, puede ser la función, que es esto, o la propiedad, que es esto y que es esto.
¿Vale?
Luego los valores son un array de los valores que tengan la misma llave.
La dificultad del reto está más en comprender la función que la implementación.
Ya veremos que la implementación es bastante sencilla.
Pero lo que puede costar es entender cómo se agrupa, por qué se agrupa y todo esto.
Entonces, yo lo que empezaría es creando un objeto y devolviendo un objeto.
¿Vale?
Esto, seguro.
Entonces ya el test se me va quejando, ¿no?
Dice, este array con matflor debería ejecutar no sé qué, no sé cuánto.
¿Vale?
Me dice, debería ejecutar esto.
Esto es lo que me debería devolver.
Bueno, ya sé que he empezado mal.
Así que lo que podríamos empezar es hacer un for off.
¿Vale?
For.
Hay diferentes formas de hacerlo.
Yo voy a hacerlo con un for off.
Si lo preferís hacer con otra cosa, lo hacéis con otra cosa.
Y con esto, lo que tenemos que diferenciar sería la propiedad que tenemos que aplicar aquí.
Así que lo que vamos a hacer es tener la prop.
Bueno, la prop va a ser si es una función.
Vamos a hacer aquí.
Le vamos a llamar prop para ver si es una función o es la propiedad.
¿Cómo vamos a hacer esto?
¿Ves que aquí te aparece values y iteratí?
Se llama iteratí porque es lo que se ejecuta para cada elemento.
Entonces, lo que tenemos que mirar es que si el iteratí en realidad es una función o no es una función.
Lo voy a poner aquí, luego lo podemos optimizar.
Pero ahora mismo podemos mirar el type of del iteratí y miramos aquí.
Si es una function, ¿vale?
Pues si es una function, lo que tenemos que hacer con esto es iteratí, iteratí, value.
¿Vale?
Y si no, lo que tendríamos que hacer es de cada uno de los values, ¿vale?
Con esto que estamos haciendo, const value of values.
En este caso sería el primer valor, el siguiente valor y el siguiente valor del array.
Pues tendríamos que acceder a la propiedad.
Porque esas son las dos opciones.
O es un método o es una propiedad.
Así que yo haría esto por aquí.
Esto por un lado.
Ya tendríamos como la prop, ¿no?
Ahora, deberíamos mirar si la prop está ya en el objeto.
Que en el caso de este, pues obviamente al principio no estará.
Tenemos que mirar si prop está en el objeto.
Le podemos llamar prop o le podemos llamar key.
Creo que key puede quedar un poco mejor, ¿vale?
Si la key está en el objeto, por lo que deberíamos hacer sería simplemente object key.push value.
¿Vale?
Y si no, lo que deberíamos hacer, pues...
A ver, esto es un poco chungui.
No chungui, pero para simplificarlo y no poner un if, lo que vamos a hacer es simplemente asignarlo.
Le ponemos en el objeto, en la key, ¿vale?
Le hacemos la asignación de justamente un array que tenga el value.
Y con esto, mira, ya está, ya han pasado los test.
Ahora, esto se podría mejorar, ¿vale?
Porque, a ver, se podría mejorar al menos dándole mejores nombres.
¿Qué es lo que hemos hecho?
Volviendo otra vez.
Hemos creado un objeto vacío.
Luego, estamos iterando aquí cada uno de los valores del array, de los valores que se le pasa.
Por ejemplo, vamos a poner este ejemplo, 6.1, 4.2, 6.3, ¿vale?
Pues lo que estamos haciendo aquí, con el primero, el 6.1, lo tenemos aquí como value.
Miramos si el atirati, este es una función.
Si es una función, la ejecutamos con este valor.
O sea, estaríamos ejecutando mathflor con el 6.1.
Y esto lo que nos devuelve es justamente la key, que sería el 6.
Miramos si este key existe en el objeto.
Si existe en el objeto, lo que hacemos es simplemente un push.
¿Por qué?
Porque si existe, ya tenemos aquí un array.
Así que lo que hacemos es un push de este nuevo valor.
Y si no, lo que hacemos es crear esta key, ¿vale?
Porque imagínate que este objeto todavía no tiene esta key.
Creamosla aquí y le asignamos un array que ya tenga el primer valor, que en este caso sería el 6.1, ¿vale?
Y con esto ya lo tendríamos.
Lo difícil, o sea, lo complicado que tendríamos, a ver, asegurarnos que estamos haciendo este if,
porque si aquí, por lo que sea, hacemos esto y solo tenemos en cuenta las funciones.
A ver, iterative value.
Me dice que no es correcto directamente.
Pensaba que a lo mejor no.
Si es un...
Claro, es que al final iterative value.
Si hacemos esto, igual es con esto no peta.
Con esto no petará.
Vale.
¿Ves?
Si solo haces esto, ¿por qué no tiene en cuenta?
Claro, porque aquí no estoy teniendo en cuenta que el iterative puede ser una función.
Y si esto no lo tengo en cuenta, no va a pasar los test, obviamente.
Y también, si hacemos al revés y no miramos que sea una función y la ejecutamos sin más,
pues va a petar, ¿vale?
Va a petar porque es que pone el código no parece correcto.
Seguramente porque el iterative este está intentando ejecutar la función y no es una función,
porque ya hemos visto que a veces puede ser un string que es la propiedad que debes buscar.
Pues eso.
Esta podría ser una forma, a ver, si la queréis hacer un poco más entendible,
podéis utilizar un if aquí, en lugar de hacer esto.
O incluso este tipo de asignación, esta asignación que se hace aquí, la podéis hacer fuera.
Yo qué sé, podríais hacer algo así, como mirar si existe.
Y si existe se le ponga esto y entonces directamente esto lo podéis hacer así también.
Y le pusheáis este valor directamente.
Un poquito más fácil.
O sea, el hecho de que solo hace la asignación del array, en el caso de que no exista,
y luego le hace el push.
Así lo simplificáis, le quitáis el condicional y ya está.
Hay diferentes formas, lo que os guste más.
Además, este check también lo podéis hacer fuera.
En lugar de hacerlo en cada iteración, que a lo mejor no tiene sentido,
podéis mirar aquí si is function, lo podéis poner aquí fuera,
y luego aquí solo tenéis que hacer esto.
Entonces, bueno, os quitáis ese check, os lo quitáis de fuera.
O sea, lo quitáis de dentro, en lugar de hacerlo en cada iteración,
el type of, type of y type of.
Y tampoco que tenga un coste seguramente muy grande,
pero bueno, es una posible optimización.
Lo podéis quitar fuera y así tenéis ya aquí un boleano.
Solo miráis el boleano y lo utilizáis y ya tenéislo aquí, por aquí.
Y hombre, queda bastante limpio y fácil.
Lo que pasa es que es eso, es lo que hemos dicho,
que hay que entenderlo, ¿no?
Hay que entender hacer este condicional aquí.
Yo creo que este condicional es el más importante
para diferenciar entre la función o la propiedad.
Y ya está, ya está.
Con esto ya estaría.
Así de simple y sencillo, como lo habéis visto.
A mí no me costó mucho,
pero así veo que hay otra manera más eficiente o algo así.
Bueno, sí.