¡Código inteligente! Sea un desarrollador de JavaScript más rápido, más productivo y más feliz al dominar estas funciones más importantes y recurrentes en el lenguaje.
Ya sea backend o frontend (o incluso naves espaciales), JavaScript está en todas partes. También es un lenguaje bastante flexible (lo que significa que tiene patrones de programación muy funcionales, así como buenas clases), y su similitud con otros lenguajes «similares a C» facilita la transición para los desarrolladores de otros lenguajes.
Si quieres sube de nivel tu juego JS, le sugiero que aprenda, practique y eventualmente domine las siguientes funciones básicas disponibles en el lenguaje. No todos estos son estrictamente «necesarios» para resolver problemas, pero pueden hacer mucho trabajo por usted en algunos casos, mientras que en otros, pueden reducir la cantidad de código que tiene que escribir.
Tabla de contenido
mapa()
¡Sería una herejía escribir un artículo sobre funciones importantes de JavaScript y no mencionar map()! 😆😆 Junto con filter() y reduce(), map() forma una especie de santísima trinidad. Estas son funciones que usará una y otra vez en su carrera, por lo que vale la pena echarles un vistazo. Abordemos uno por uno, comenzando con map().
map() es una de esas funciones que causan más problemas a las personas que aprenden JavaScript. ¿Por qué? No porque haya algo intrínsecamente complejo al respecto, sino porque la forma en que funciona esta función es una idea tomada de lo que se llama Programación Funcional. Y dado que no estamos expuestos a la programación funcional (nuestras escuelas y la industria están llenas de lenguajes orientados a objetos), el funcionamiento parece extraño o incluso incorrecto para nuestros cerebros sesgados.
JavaScript es mucho más funcional que el orientado a objetos, aunque sus versiones modernas están haciendo todo lo posible para ocultar este hecho. Pero eso es toda una lata de gusanos que quizás pueda abrir algún otro día. 🤣 Bien, map() . . .
map() es una función muy simple; se adjunta a una matriz y nos ayuda a convertir cada elemento en otra cosa, lo que da como resultado una nueva matriz. La forma exacta de convertir un elemento se proporciona como otra función que, por convención, es anónima.
¡Eso es todo al respecto! Puede llevar un tiempo acostumbrarse a la sintaxis, pero esencialmente eso es lo que estamos haciendo en una función map(). ¿Por qué querríamos usar map()? Depende de lo que estemos tratando de lograr. Por ejemplo, supongamos que registramos la temperatura de cada día de la última semana y la almacenamos como una matriz simple. Sin embargo, ahora se nos dice que los instrumentos no eran muy precisos y han informado 1,5 grados menos de temperatura de lo que deberían.
Podemos hacer esta corrección usando la función map() así:
const weeklyReadings = [20, 22, 20.5, 19, 21, 21.5, 23]; const correctedWeeklyReadings = weeklyReadings.map(reading => reading + 1.5); console.log(correctedWeeklyReadings); // gives [ 21.5, 23.5, 22, 20.5, 22.5, 23, 24.5 ]
Otro ejemplo muy práctico proviene del mundo de React, donde la creación de listas de elementos DOM a partir de matrices es un patrón común; Entonces, algo como esto es común:
export default ({ products }) => {
return products.map(product => {
return (
<div className="product" key={product.id}>
<div className="p-name">{product.name}</div>
<div className="p-desc">{product.description}</div>
</div>
);
});
};
Aquí, tenemos un componente React funcional que recibe una lista de productos como accesorios. A partir de esta lista (matriz), luego crea una lista de «divs» de HTML, esencialmente convirtiendo cada objeto de producto en HTML. El objeto de productos originales permanece intacto.
Puede argumentar que map() no es más que un bucle for glorificado y tendría toda la razón. Pero tenga en cuenta que tan pronto como haga ese argumento, es su mente entrenada orientada a objetos la que está hablando, mientras que estas funciones y su fundamento provienen de la programación funcional, donde la uniformidad, la compacidad y la elegancia son muy reverenciadas. 🙂
filtrar()
filter() es una función muy útil que se encontrará aplicando una y otra vez en muchas situaciones. Como sugiere el nombre, esta función filtra una matriz según las reglas o la lógica que proporcione y devuelve una nueva matriz que contiene elementos que cumplen esas reglas.
Reutilicemos nuestro ejemplo del clima. Supongamos que tenemos una matriz que contiene las temperaturas máximas para cada día de la semana pasada; ahora, queremos averiguar cuántos de esos días fueron más fríos. Sí, «más frío» es un término subjetivo, así que digamos que estamos buscando días en los que la temperatura estuvo por debajo de 20. Podemos hacer esto usando la función filter() de esta manera:
const weeklyReadings = [20, 22, 20.5, 19, 21, 21.5, 23];
const colderDays = weeklyReadings.filter(dayTemperature => {
return dayTemperature < 20;
});
console.log("Total colder days in week were: " + colderDays.length); // 1
Tenga en cuenta que la función anónima que pasamos a filter() debe devolver un valor booleano: verdadero o falso. Así es como filter() sabrá si incluir o no ese elemento en la matriz filtrada. Eres libre de escribir cualquier cantidad de lógica compleja dentro de esta función anónima; puede realizar llamadas a la API y leer las entradas de los usuarios, y así sucesivamente, siempre que se asegure de que, al final, está devolviendo un valor booleano.
Cuidado: esta es una nota al margen que me siento obligado a proporcionar en función de mi experiencia como desarrollador de JavaScript. Ya sea por descuido o fundamentos erróneos, muchos programadores crean errores sutiles en sus programas cuando usan filter(). Reescribamos el código anterior para contener el error:
const weeklyReadings = [20, 22, 20.5, 19, 21, 21.5, 23];
const colderDays = weeklyReadings.filter(dayTemperature => {
return dayTemperature < 20;
});
if(colderDays) {
console.log("Yes, there were colder days last week");
} else {
console.log("No, there were no colder days");
}
¿Notas algo? ¡Buen trabajo si lo hiciste! La condición if hacia el final verifica los días más fríos, ¡que en realidad es una matriz! Se sorprenderá de cuántas veces las personas cometen este error mientras corren para cumplir con los plazos o codifican desanimados (por el motivo que sea). El problema con esta condición es que JavaScript es un lenguaje extraño e inconsistente en muchos sentidos, y la «veracidad» de las cosas es uno de ellos. Tiempo [] == true devuelve false, haciéndote pensar que el código anterior no está roto, la realidad es que dentro de una condición if, [] se evalúa como verdadero! En otras palabras, el código que escribimos nunca dirá que no hubo días más fríos la semana pasada.
La solución es muy simple, como se indica en el código anterior al código anterior. Verificamos colderDays.length, que está garantizado para darnos un número entero (cero o superior) y, por lo tanto, funciona de manera consistente en comparaciones lógicas. Tenga en cuenta que filter() siempre, siempre, siempre devolverá una matriz, vacía o no vacía, por lo que podemos confiar en eso y escribir nuestras comparaciones lógicas con confianza.
Ha sido un desvío más largo de lo que estaba planeando, pero vale la pena destacar errores como este en diez mil palabras, todo en mayúsculas si es necesario. ¡Espero que no te moleste esto y te ahorres cientos de horas de esfuerzo de depuración! 🙂
reducir()
De todas las funciones de este artículo, así como de la biblioteca estándar de JavaScript, reduce() se encuentra entre las favoritas para coronarse como «confusa y rara». Si bien esta función es muy importante y da como resultado un código elegante en muchas situaciones, la mayoría de los desarrolladores de JavaScript la evitan y prefieren escribir un código más detallado.
La razón es esa, ¡y seré honesto aquí! — reduce() es difícil de entender, tanto en el sentido del concepto como en el de la ejecución. Cuando lees su descripción, lo has releído varias veces y aún así, dudas de ti mismo si lo leíste mal; y cuando lo ves en acción y tratas de visualizar cómo funciona, ¡tu cerebro se retuerce en mil nudos! 🤭
Ahora, no te asustes. La función reduce() no se parece en nada en complejidad e intimidación a, digamos, Árboles B+ y sus algoritmos. Es solo que este tipo de lógica rara vez se encuentra durante el trabajo diario del programador promedio.
Entonces, después de haberte asustado muchísimo y luego decirte de inmediato que no te preocupes, finalmente me gustaría mostrarte qué es esta función y por qué exactamente podríamos necesitarla.
Como sugiere el nombre, reduce() se usa para, bueno, reducir algo. Lo que reduce es una matriz y lo que reduce la matriz dada es un valor único (número, cadena, función, objeto, lo que sea). Aquí hay una forma más simple de decirlo: reduce() transforma una matriz en un solo valor. Tenga en cuenta que el valor de retorno de reduce() no es una matriz, como es el caso de map() y filter(). Haber entendido esto ya es la mitad de la batalla. 🙂
Ahora, es bastante obvio que si vamos a transformar (reducir) una matriz, debemos proporcionar la lógica necesaria; y según su experiencia como desarrollador de JS, ya habrá adivinado que lo hacemos usando una función. Esta función es lo que llamamos función reductora, que forma el primer argumento para reducir(). El segundo argumento es un valor inicial, como un número, una cadena, etc. (Explicaré en un momento qué diablos es este «valor inicial»).
Según lo que sabemos hasta ahora, podemos decir que una llamada a reduce() se ve así: array.reduce(reducerFunction, initialValue). Ahora abordemos el corazón de todo: la función reductora. Como ya se estableció, la función reducer es lo que le dice a reduce() cómo convertir la matriz en un solo valor. Se necesitan dos argumentos: una variable para actuar como un acumulador (no se preocupe, también explicaré este bit) y una variable para almacenar el valor actual.
Sé que sé . . . esa fue mucha terminología para una sola función que ni siquiera es obligatoria en JavaScript. 😝😝 Y es por eso que la gente huye de reduce(). Pero si lo aprende paso a paso, no solo lo entenderá sino que también lo apreciará a medida que se convierte en un mejor desarrollador.
Bien, volvamos al tema que nos ocupa. El «valor inicial» que se pasa a reduce() es . . . bueno, el valor inicial para el cálculo que desea utilizar. Por ejemplo, si vas a hacer una multiplicación en la función reductora, un valor inicial de 1 tiene sentido; para la suma, puede comenzar con 0, y así sucesivamente.
Ahora veamos la firma de la función reductora. Una función reductora que se pasa a reduce() tiene la siguiente forma: reducerFunction(accumulator, currentValue). «Acumulador» es solo un nombre elegante para la variable que recopila y contiene el resultado del cálculo; es exactamente como usar una variable llamada total para sumar todos los elementos en una matriz usando algo como total += arr[i]. Así es exactamente como se aplica la función reductora en reduce(): el acumulador se establece inicialmente en el valor inicial que proporciona, y luego, uno por uno, se visitan los elementos de la matriz, se realiza el cálculo y el resultado se almacena en el acumulador, y así sucesivamente. . .
Entonces, ¿qué es este «valor actual» en una función reductora? Es la misma idea que imaginaría mentalmente si le pido que recorra una matriz: tomaría una variable para comenzar en el índice cero y la movería hacia adelante un paso a la vez. Mientras haces esto, si te pido que te detengas repentinamente, te encontrarás en uno de los elementos de la matriz, ¿verdad? Esto es lo que queremos decir con valor actual: es el valor de la variable utilizada para representar el elemento de la matriz que se está considerando actualmente (piense en recorrer una matriz si eso ayuda).
Con todo lo dicho, es hora de ver un ejemplo simple y ver cómo toda esta jerga se combina en una llamada reduce() real. Digamos que tenemos una matriz que contiene los primeros n números naturales (1, 2, 3 . . . n) y estamos interesados en encontrar el factorial de n. Sabemos que para encontrar n! simplemente necesitamos multiplicar todo, lo que nos lleva a esta implementación:
const numbers = [1, 2, 3, 4, 5]; const factorial = numbers.reduce((acc, item) => acc * item, 1); console.log(factorial); // 120
Están sucediendo muchas cosas en estas meras tres líneas de código, así que analicemos una por una en el contexto de la discusión (muy larga) que hemos tenido hasta ahora. Como es obvio, números es la matriz que contiene todos los números que queremos multiplicar. A continuación, eche un vistazo a la llamada a numbers.reduce(), que dice que el valor inicial de acc debe ser 1 (porque no influye ni destruye ninguna multiplicación). A continuación, verifique el cuerpo de la función reductora, `(acc, item) => acc * item, que simplemente dice que el valor devuelto para cada iteración sobre la matriz debe ser ese elemento multiplicado por lo que ya esté en el acumulador. La iteración y, de hecho, almacenar la multiplicación explícitamente en el acumulador es lo que sucede detrás de escena, y es una de las principales razones por las que reduce() es un obstáculo tan grande para los desarrolladores de JavaScript.
¿Por qué usar reducir ()?
Es una gran pregunta y, para ser honesto, no tengo una respuesta segura. Lo que sea que haga reduce() se puede hacer a través de bucles, forEach(), etc. Sin embargo, esas técnicas dan como resultado mucho más código, lo que dificulta la lectura, especialmente si tiene prisa. Luego está la preocupación por la inmutabilidad: con reduce() y funciones similares, puede estar seguro de que sus datos originales no han sido mutados; esto en sí mismo elimina clases enteras de errores, especialmente en aplicaciones distribuidas.
Finalmente, reduce() es mucho más flexible, en el sentido de que el acumulador puede ser un objeto, una matriz o incluso una función si es necesario; lo mismo ocurre con el valor inicial y otras partes de la llamada de función: casi cualquier cosa puede entrar y casi cualquier cosa puede salir, por lo que existe una flexibilidad extrema en el diseño de código reutilizable.
Si aún no está convencido, también está perfectamente bien; la comunidad de JavaScript en sí misma está muy dividida sobre la «compacidad», «elegancia» y «poder» de reduce(), por lo que está bien si no lo usa. 🙂 Pero asegúrate de mirar algunos buenos ejemplos antes de decidir bin reduce().
alguno()
Digamos que tiene una matriz de objetos, cada uno de los cuales representa a una persona. Desea saber si hay personas en la matriz que tienen más de 35 años. Tenga en cuenta que no es necesario contar cuántas personas hay, y mucho menos recuperar una lista de ellas. Lo que estamos diciendo aquí es el equivalente de «uno o más» o «al menos uno».
¿Cómo haces esto?
Sí, puede crear una variable de bandera y recorrer la matriz para resolver este problema de esta manera:
const persons = [
{
name: 'Person 1',
age: 32
},
{
name: 'Person 2',
age: 40
},
];
let foundOver35 = false;
for (let i = 0; i < persons.length; i ++) {
if(persons[i].age > 35) {
foundOver35 = true;
break;
}
}
if(foundOver35) {
console.log("Yup, there are a few people here!")
}
¿El problema? El código es demasiado similar a C o Java, en mi opinión. «Verbose» es otra palabra que me viene a la mente. JS experimentado podría estar pensando en «feo», «horrible», etc. 😝 Y con razón, diría yo. Una forma de mejorar este fragmento de código es hacer uso de algo como map(), pero incluso entonces la solución es un poco torpe.
Resulta que tenemos una función bastante ordenada llamada some() que ya está disponible en el lenguaje central. Esta función trabaja con matrices y acepta una función de «filtrado» personalizada, devolviendo un valor booleano de verdadero o falso. Esencialmente, está haciendo lo que hemos estado tratando de hacer durante los últimos minutos, solo que de manera muy sucinta y elegante. Así es como podemos usarlo:
const persons = [
{
name: 'Person 1',
age: 32
},
{
name: 'Person 2',
age: 40
},
];
if(persons.some(person => {
return person.age > 35
})) {
console.log("Found some people!")
}
Misma entrada, mismo resultado que antes; ¡pero observe la reducción masiva en el código! ¡Observe también cuán drásticamente se reduce la carga cognitiva porque ya no necesitamos analizar el código línea por línea como si fuéramos el intérprete nosotros mismos! El código ahora casi se lee como lenguaje natural.
cada()
Al igual que some(), tenemos otra función útil llamada every(). Como puede adivinar ahora, esto también devuelve un valor booleano dependiendo de si todos los elementos de la matriz pasan la prueba dada. Por supuesto, la prueba para pasar se proporciona como una función anónima la mayor parte del tiempo. Te ahorraré el dolor de cómo se vería una versión ingenua del código, así que así es como se usa every():
const entries = [
{
id: 1
},
{
id: 2
},
{
id: 3
},
];
if(entries.every(entry => {
return Number.isInteger(entry.id) && entry.id > 0;
})) {
console.log("All the entries have a valid id")
}
Como es obvio, el código verifica todos los objetos en la matriz en busca de una propiedad de identificación válida. La definición de «válido» depende del contexto del problema, pero como puede ver, para este código, consideré números enteros no negativos. Una vez más, vemos lo simple y elegante que es leer el código, que es el único objetivo de esta(s) función(es) (y similares).
incluye()
¿Cómo verifica la existencia de subcadenas y elementos de matriz? Bueno, si eres como yo, buscas rápidamente indexOf() y luego buscas los documentos para que sepas sus posibles valores de retorno. Es un inconveniente considerable, y los valores devueltos son difíciles de recordar (rápido: ¿qué significa un proceso que devuelve 2 al sistema operativo?).
Pero hay una buena alternativa que podemos usar: include(). El uso es tan simple como el nombre, y el código resultante es extremadamente conmovedor. Tenga en cuenta que la coincidencia se realiza mediante include() y distingue entre mayúsculas y minúsculas, pero supongo que eso es lo que todos esperamos intuitivamente de todos modos. ¡Y ahora, es hora de algo de código!
const numbers = [1, 2, 3, 4, 5];
console.log(numbers.includes(4));
const name = "Ankush";
console.log(name.includes('ank')); // false, because first letter is in small caps
console.log(name.includes('Ank')); // true, as expected
Sin embargo, no esperes demasiado de este humilde método:
const user = {a: 10, b: 20};
console.log(user.includes('a')); // blows up, as objects don't have a "includes" method
No puede mirar dentro de los objetos ya que simplemente no está definido para los objetos. Pero bueno, sabemos que funciona en matrices, así que tal vez podamos hacer algunos trucos aquí. . . 🤔.
const persons = [{name: 'Phil'}, {name: 'Jane'}];
persons.includes({name: 'Phil'});
Entonces, ¿qué sucede cuando ejecutas este código? No explota, pero el resultado también es decepcionante: falso. 😫😫 En realidad, esto tiene que ver con objetos, punteros y cómo JavaScript ve y administra la memoria, que es un mundo en sí mismo. Si desea profundizar más, siéntase libre de dar el paso (quizás comience aquí), pero me detendré aquí.
Podemos hacer que el código anterior se comporte si lo reescribimos de la siguiente manera, pero en este punto, en mi opinión, se convierte más o menos en una broma:
const phil = {name: 'Phil'};
const persons = [phil, {name: 'Jane'}];
persons.includes(phil); // true
Aún así, muestra que podemos hacer que include() funcione en objetos, así que supongo que no es un desastre total. 😄
rodaja()
Supongamos que tenemos una cadena y le pido que devuelva una parte de ella que comienza con «r» y termina con «z» (los caracteres reales no son importantes). ¿Cómo lo abordarías? Tal vez crearía una nueva cadena y la usaría para almacenar todos los caracteres necesarios y devolverlos. O, si es como la mayoría de los programadores, me daría dos índices de matriz a cambio: uno que indica el comienzo de la subcadena y el otro que marca el final.
Ambos enfoques están bien, pero hay un concepto llamado rebanado que ofrece una buena solución en tales situaciones. Afortunadamente, no hay una teoría abstrusa a seguir; rebanar significa exactamente lo que parece: crear una cadena/matriz más pequeña a partir de la dada, al igual que creamos rebanadas de frutas. Veamos a qué me refiero, con la ayuda de un ejemplo sencillo:
const headline = "And in tonight's special, the guest we've all been waiting for!";
const startIndex = headline.indexOf('guest');
const endIndex = headline.indexOf('waiting');
const newHeadline = headline.slice(startIndex, endIndex);
console.log(newHeadline); // guest we've all been
Cuando rebanamos(), proporcionamos dos índices a JavaScript: uno en el que queremos iniciar el rebanado y el otro en el que queremos que se detenga. El problema con slice() es que el índice final no está incluido en el resultado final, por lo que vemos que falta la palabra «esperando» en el nuevo título del código anterior.
Conceptos como el corte son más prominentes en otros lenguajes, especialmente en Python. Si le pregunta a esos desarrolladores, le dirán que no pueden imaginar la vida sin esta funcionalidad, y con razón cuando el lenguaje proporciona una sintaxis muy ordenada para cortar.
Cortar es ordenado y extremadamente conveniente, y no hay razón para no usarlo. Tampoco es azúcar de sintaxis plagado de una penalización de rendimiento, ya que crea copias superficiales de la matriz/cadena original. Para los desarrolladores de JavaScript, recomiendo familiarizarse con slice() y agregarlo a su arsenal.
empalme()
El método splice() suena como un primo de slice() y, de alguna manera, podemos argumentar que lo es. Ambos crean nuevas matrices/cadenas a partir de las originales, con una pequeña pero importante diferencia: splice() elimina, cambia o agrega elementos, pero modifica la matriz original. Esta «destrucción» de la matriz original puede crear grandes problemas si no tiene cuidado o no comprende las copias y referencias profundas. Me pregunto qué impidió que los desarrolladores usaran el mismo enfoque que para slice() y dejaran intacta la matriz original, pero supongo que podemos ser más indulgentes con un idioma. creado en apenas diez días.
A pesar de mis quejas, echemos un vistazo a cómo funciona splice(). Mostraré un ejemplo en el que eliminamos algunos elementos de una matriz, ya que este es el uso más común que encontrará para este método. También me abstendré de proporcionar ejemplos de adición e inserción porque estos se pueden buscar fácilmente y también son simples.
const items = ['eggs', 'milk', 'cheese', 'bread', 'butter']; items.splice(2, 1); console.log(items); // [ 'eggs', 'milk', 'bread', 'butter' ]
La llamada a splice() anterior dice: comience en el índice 2 (el tercer lugar, es decir) de la matriz y elimine un elemento. En la matriz dada, ‘queso’ es el tercer elemento, por lo que se elimina de la matriz y la matriz de elementos se acorta, como se esperaba. Por cierto, los elementos eliminados son devueltos por splice() en el formulario o en una matriz, por lo que si quisiéramos, podríamos haber capturado ‘queso’ en una variable.
En mi experiencia, indexOf() y splice() tienen una gran sinergia: encontramos el índice de un elemento y luego lo eliminamos de la matriz dada. Sin embargo, tenga en cuenta que no siempre es el método más eficiente y, a menudo, usar claves de objeto (el equivalente de un mapa hash) es mucho más rápido.
cambio()
shift() es una especie de método de conveniencia y se usa para eliminar el primer elemento de una matriz. Tenga en cuenta que se puede hacer lo mismo con splice(), pero shift() es un poco más fácil de recordar e intuitivo cuando todo lo que necesita hacer es cortar el primer elemento.
const items = ['eggs', 'milk', 'cheese', 'bread', 'butter']; items.shift() console.log(items); // [ 'milk', 'cheese', 'bread', 'butter' ]
anular desplazamiento()
Así como shift() elimina el primer elemento de una matriz, unshift() agrega un nuevo elemento al comienzo de la matriz. Su uso es igual de sencillo y compacto:
const items = ['eggs', 'milk'];
items.unshift('bread')
console.log(items); // [ 'bread', 'eggs', 'milk' ]
Dicho esto, no puedo ayudarme y advertir a los nuevos en el juego: a diferencia de los populares métodos push() y pop(), shift() y unshift() son extremadamente ineficientes (debido a la forma en que funcionan los algoritmos subyacentes). Por lo tanto, si está operando en matrices grandes (digamos, más de 2000 elementos), demasiadas de estas llamadas a funciones pueden detener su aplicación.
llenar()
A veces es necesario cambiar varios elementos a un solo valor o incluso «restablecer» toda la matriz, por así decirlo. En esas situaciones, fill() lo salva de bucles y errores de uno en uno. Se puede usar para reemplazar parte o la totalidad de la matriz con el valor dado. Veamos un par de ejemplos:
const heights = [1, 2, 4, 5, 6, 7, 1, 1]; heights.fill(0); console.log(heights); // [0, 0, 0, 0, 0, 0, 0, 0] const heights2 = [1, 2, 4, 5, 6, 7, 1, 1]; heights2.fill(0, 4); console.log(heights2); // [1, 2, 4, 5, 0, 0, 0, 0]
Otras funciones que vale la pena mencionar
Si bien la lista anterior es lo que la mayoría de los desarrolladores de JavaScript terminan encontrando y usando en sus carreras, de ninguna manera está completa. Hay tantas funciones menores pero útiles (métodos) en JavaScript que no será posible cubrirlas todas en un solo artículo. Dicho esto, algunos que me vienen a la mente son los siguientes:
- reverso()
- clasificar()
- entradas()
- llenar()
- encontrar()
- plano()
Lo animo a que al menos busque estos para que tenga una idea de que existen comodidades como estas.
Conclusión
JavaScript es un lenguaje grande, a pesar de la pequeña cantidad de conceptos básicos para aprender. Las muchas funciones (métodos) disponibles para nosotros constituyen la mayor parte de este gran tamaño. Sin embargo, dado que JavaScript es un lenguaje secundario para la mayoría de los desarrolladores, no profundizamos lo suficiente y nos perdemos muchas funciones hermosas y útiles que ofrece. En realidad, lo mismo ocurre con los conceptos de programación funcional, ¡pero ese es un tema para otro día! 😅
Siempre que pueda, dedique algún tiempo a explorar el lenguaje principal (y, si es posible, bibliotecas de utilidades famosas como Lodash). Incluso unos pocos minutos dedicados a hacer este esfuerzo darán como resultado ganancias masivas de productividad y un código mucho más limpio y compacto.