• ¡Obtenga la seguridad de la aplicación de la manera correcta! Detectar, proteger, monitorear, acelerar y más ...
  • 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 funcionales incondicionales, así como buenas clases), y su similitud con otros lenguajes "tipo C" facilita la transición para los desarrolladores de otros lenguajes.

    Si deseas sube de nivel tu juego JS, Le sugiero que aprenda, practique y eventualmente domine las siguientes funciones básicas disponibles en el idioma. No todos estos son estrictamente "necesarios" para resolver problemas, pero pueden hacer mucho trabajo pesado para usted en algunos casos, mientras que en otros, pueden reducir la cantidad de código que tiene que escribir.

    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 santa trinidad. Estas son funciones que usará una y otra vez en su carrera, por lo que vale la pena verlas. Abordémoslos uno por uno, comenzando con map().

    map() es una de las funciones que dan 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 sesgados cerebros.

    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 esa es una lata llena de gusanos que quizás pueda abrir algún otro día. 🤣 Está bien, entonces, map() . . .

    map() es una función muy simple; se adhiere a una matriz y nos ayuda a convertir cada uno elemento en otra cosa, lo que resulta en una nueva matriz. Cómo exactamente convertir un elemento se proporciona como otra función, que por convención, es anónima.

    ¡Eso es todo al respecto! La sintaxis puede tomar algún tiempo para acostumbrarse, pero esencialmente eso es lo que estamos haciendo en un map() función. ¿Por qué podríamos querer usar map()? Depende de lo que estemos tratando de lograr. Por ejemplo, digamos 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 reportado 1.5 grados menos de temperatura de la que deberían.

    Podemos hacer esta corrección usando el map() funciona 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 funcional Reaccionar componente que recibe una lista de productos como accesorios. A partir de esta lista (matriz), luego crea una lista de "divs" HTML, esencialmente convirtiendo cada objeto de producto en HTML. El original products El objeto permanece intacto.

    Puedes argumentar que map() no es más que un glorificado for bucle y estarías totalmente en lo cierto. Pero observe 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 veneradas. 🙂

    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 / lógica que proporciona y devuelve una nueva matriz que contiene elementos que satisfacen esas reglas.

    Reutilicemos nuestro ejemplo del tiempo. Suponga que tenemos una matriz que contiene las temperaturas máximas para cada día de la semana pasada; ahora, queremos saber cuántos de esos días fueron más fríos. Sí, "más frío" es un término subjetivo, por lo que supongamos que buscamos días en los que la temperatura fue inferior a 20. Podemos hacer esto usando el filter() funciona así:

    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 a la que pasamos filter() debe devolver un valor booleano: true or false. 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 del usuario, etc., siempre que se asegure de que, al final, está devolviendo un valor booleano.

    Ten 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 por fundamentos incorrectos, 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");
    }

    ¿Notaste algo? ¡Buen trabajo si lo hicieras! los if condición hacia las comprobaciones finales colderDays, 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 codificar con desánimo (por cualquier motivo). 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 una de ellas. Mientras [] == true devuelve falso, haciéndote pensar que el código anterior no está roto, la realidad es que dentro de un if condición, [] 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. Buscamos colderDays.length, que está garantizado para darnos un número entero (cero o superior) y, por lo tanto, funcionará consistentemente en comparaciones lógicas. Tenga en cuenta que filter() siempre, siempre, Siempre hay devolver una matriz, vacía o no vacía, para que podamos 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 resaltar errores como este en diez mil palabras, todo en mayúsculas si es necesario. ¡Espero que esto no te muerda 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 los pioneros para las coronas de "confuso y extraño". 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 de concepto como de ejecución. Cuando lee su descripción, lo ha releído varias veces y aún así, duda de si lo leyó mal; y cuando lo ves en acción y tratas de visualizar cómo funciona, ¡tu cerebro se tuerce en mil nudos! 🤭

    Ahora, no te asustes. los reduce() La función no se acerca 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 haberlo asustado y de decirle inmediatamente que no se preocupe, finalmente me gustaría mostrarle qué es esta función y por qué exactamente podríamos necesitarla.

    Como su nombre indica, 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 sencilla de decirlo: reduce() transforma una matriz en un solo valor. Tenga en cuenta que el valor de retorno de reduce() no es una matriz, que es el caso de map() y filter(). Habiendo entendido todo esto ya es la mitad de la batalla. 🙂

    Ahora, es un poco obvio que si vamos a transformar (reducir) una matriz, necesitamos proporcionar la lógica necesaria; y en base a su experiencia como desarrollador de JS, lo más probable es que ya haya adivinado que lo hacemos usando una función. Esta función es lo que llamamos la función reductora, que forma el primer argumento para reduce(). 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 nuestro entendimiento hasta ahora, podemos decir que una llamada a reduce() Se ve como esto: array.reduce(reducerFunction, startingValue). Ahora abordemos el meollo de todo: la función reductora. Como ya se estableció, la función reductora es lo que dice 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 era 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 comprenderá, sino que también lo apreciará a medida que se convierta 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 agregar, puede comenzar con 0, Y así sucesivamente.

    Ahora veamos la firma de la función reductora. Se pasa una función reductora 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 de una matriz usando algo como total += arr[i]. Así es exactamente como funciona el reductor en reduce() se aplica: el acumulador se establece inicialmente en el valor inicial que usted 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, ¿cuál es este "valor actual" en una función reductora? Es la misma idea que se imagina mentalmente si le pido que recorra una matriz: tomaría una variable para comenzar en el índice cero y avanzarla paso a paso. Mientras haces esto, si te pido que te detengas de repente, 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).

    Dicho todo esto, es hora de ver un ejemplo sencillo y ver cómo toda esta jerga se combina en una reduce() llamada. Digamos que tenemos una matriz que contiene la primera 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 vamos a descomprimirlas una por una en el contexto de la (muy larga) discusión que hemos tenido hasta ahora. Como es obvio, numbers es la matriz que contiene todos los números que queremos multiplicar. A continuación, eche un vistazo a numbers.reduce() call, que dice que el valor inicial para acc debiera ser 1 (porque no influye ni destruye ninguna multiplicación). A continuación, compruebe el cuerpo de la función reductora, `(acc, item) => acc * item, que simplemente dice que el valor de retorno para cada iteración sobre la matriz debe ser ese elemento multiplicado por lo que ya esté en el acumulador. La iteración y el almacenamiento de la multiplicación explícitamente en el acumulador es lo que está sucediendo detrás de escena, y es una de las principales razones reduce() es un obstáculo para los desarrolladores de JavaScript.

    ¿Por qué utilizar reduce()?

    Es una gran pregunta y, para ser honesto, no tengo una respuesta segura. Lo que sea 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 se han modificado; 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 a la función: casi cualquier cosa puede entrar y casi cualquier cosa puede salir, por lo que hay una flexibilidad extrema en el diseño de código reutilizable.

    Si aún no está convencido, también está bien; La comunidad de JavaScript en sí está muy dividida sobre la "compacidad", la "elegancia" y el "poder" de reduce(), por lo que está bien si no lo usa. 🙂 Pero asegúrate de mirar algunos buenos ejemplos antes de que decidas tirar la basura reduce().

    algunos()

    Digamos que tiene una matriz de objetos, y cada objeto 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 son, y mucho menos recuperar una lista de ellas. Lo que estamos diciendo aquí es el equivalente a "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 parecido 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 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() ya disponible en el idioma principal. Esta función trabaja con matrices y acepta una función de "filtrado" personalizada, devolviendo un valor booleano de true or false. Esencialmente, está haciendo lo que hemos estado tratando de hacer durante los últimos minutos, solo 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, el mismo resultado que antes; ¡pero observe la reducción masiva de 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 los intérpretes. 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 todas los elementos de la matriz pasan la prueba dada. Por supuesto, la prueba para aprobar 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 every() se usa:

    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 comprueba todos los objetos de la matriz para una id propiedad. La definición de "válido" depende del contexto del problema, pero como puede ver, para este código, consideré los 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 función (y otras similares).

    incluye ()

    ¿Cómo verifica la existencia de subcadenas y elementos de matriz? Bueno, si eres como yo, rápidamente buscas indexOf() y luego busque los documentos para hacerle saber sus posibles valores de retorno. Es un inconveniente considerable y los valores devueltos son difíciles de recordar (rápido, ¿qué devuelve un proceso 2 al sistema operativo significa?).

    Pero hay una buena alternativa que podemos utilizar: includes(). El uso es tan simple como el nombre y el código resultante es extremadamente reconfortante. Tenga en cuenta que la coincidencia se realiza mediante includes() distingue entre mayúsculas y minúsculas, pero supongo que eso es lo que todos los intuitivos esperamos de todos modos. ¡Y ahora, tiempo para un poco 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 espere 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 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 ejecuta este código? No explota, pero el resultado también es decepcionante: false. 😫😫 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 sumergirse más profundamente, siéntase libre de dar el paso (tal vez comience Aquí), pero me detendré aquí.

    We enlatado hacer que el código anterior se comporte si lo reescribimos de la siguiente manera, pero en este punto, más o menos se convierte en una broma, en mi opinión:

    const phil = {name: 'Phil'};
    const persons = [phil, {name: 'Jane'}];
    persons.includes(phil); // true

    Aún así, demuestra que podemos hacer includes() funciona con objetos, así que supongo que no es un desastre total. 😄

    rebanada()

    Supongamos que tenemos una cadena y le pido que devuelva una parte de ella que comience con "r" y termine con "z" (los caracteres reales no son importantes). ¿Cómo lo abordarías? Quizás crearía una nueva cadena y la usaría para almacenar todos los caracteres necesarios y devolverlos. O si eres como la mayoría de los programadores, me darías dos índices de matriz a cambio: uno indica el inicio de la subcadena y el otro marca el final.

    Ambos enfoques están bien, pero hay un concepto llamado corte que ofrece una solución ordenada 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 rodajas 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 nos slice(), proporcionamos dos índices a JavaScript: uno en el que queremos iniciar el corte y el otro en el que queremos que se detenga. La trampa con slice() es que el índice final es no 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 rebanar son más prominentes en otros idiomas, notablemente Python. Si les pregunta a esos desarrolladores, 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 limpio y extremadamente conveniente, y no hay razón para no usarlo. Tampoco es un 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, les recomiendo que se familiaricen con slice() y agregarlo a tu 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 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é impedía a los desarrolladores usar el mismo enfoque que para slice() y dejar intacta la matriz original, pero supongo que podemos ser más indulgentes con un idioma creado en solo diez días.

    A pesar de mis quejas, veamos cómo splice() trabajos. 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 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 la splice() arriba dice: empezar 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 artículos 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, el uso de claves de un objeto (el equivalente a un mapa hash) es mucho más rápido.

    cambio()

    shift() es una especie de método conveniente y se utiliza para eliminar el primer elemento de una matriz. Observe 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' ]

    unshift ()

    Así como shift() elimina el primer elemento de una matriz, unshift() agrega un nuevo elemento al inicio 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 evitarlo y advertir a los nuevos en el juego: a diferencia del popular push() y pop() métodos, shift() y unshift() son extremadamente ineficientes (debido a la forma en que funcionan los algoritmos subyacentes). Entonces, si está operando en arreglos grandes (digamos, más de 2000 elementos), muchas 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() le ahorra bucles y errores uno a uno. Se puede usar para reemplazar parte o toda 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 dignas de mención

    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 (métodos) menores pero útiles 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:

    • reverse()
    • sort()
    • entries()
    • fill()
    • find()
    • flat()

    Te animo a que al menos los busques para que tengas una idea de que existen comodidades como estas.

    Conclusión

    JavaScript es un idioma extenso, 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 idioma secundario para la mayoría 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 este esfuerzo darán como resultado ganancias de productividad masivas y un código mucho más limpio y compacto.