CÓMO ENCONTRAR LA PALABRA MÁS LARGA EN JAVASCRIPT

October 16, 2025

Introducción a la Búsqueda de la Palabra Más Larga

Encontrar la longitud de la palabra más larga en una cadena es un problema común en programación, especialmente en JavaScript. Este desafío requiere dividir una cadena en palabras, contar los caracteres de cada una y determinar cuál tiene la mayor longitud. En este tutorial, exploraremos tres enfoques para resolver este problema: utilizando un bucle for, el método sort() y el método reduce(). Cada método se explicará paso a paso, con ejemplos de código y análisis detallados, para que los desarrolladores, desde principiantes hasta avanzados, puedan entender y aplicar estas soluciones en sus proyectos. Este artículo está diseñado para sitios web de programación y noticias tecnológicas, ofreciendo un enfoque práctico y actualizado al 13 de octubre de 2025.

El objetivo es devolver la longitud de la palabra más larga en una cadena como un número. Por ejemplo, para la cadena “The quick brown fox jumped over the lazy dog”, la palabra más larga es “jumped” con 6 caracteres, por lo que la función debe devolver 6. A continuación, se presentan casos de prueba para validar las soluciones:

“The quick brown fox jumped over the lazy dog” debe devolver 6.
“May the force be with you” debe devolver 5.
“Google do a barrel roll” debe devolver 6.
“What is the average airspeed velocity of an unladen swallow” debe devolver 8.
“What if we try a super-long word such as otorhinolaryngology” debe devolver 19.

Cada solución utilizará el método split() de JavaScript para dividir la cadena en un arreglo de palabras, separadas por espacios. A partir de ahí, cada enfoque procesará el arreglo de manera diferente para encontrar la longitud de la palabra más larga.

Solución con un Bucle For

El primer enfoque utiliza un bucle for para iterar sobre un arreglo de palabras y comparar la longitud de cada una. Este método es intuitivo y fácil de entender, especialmente para quienes están comenzando en programación. La idea es dividir la cadena en palabras, inicializar una variable para almacenar la longitud máxima y actualizarla si se encuentra una palabra más larga.

Primero, usamos el método split(’ ‘) para convertir la cadena en un arreglo de palabras. Por ejemplo:

let str = "The quick brown fox jumped over the lazy dog";
let strSplit = str.split(" ");
// Resultado: ["The", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"]

Luego, inicializamos una variable longestWord en 0 para almacenar la longitud de la palabra más larga. Iteramos sobre el arreglo con un bucle for, comparando la longitud de cada palabra con longestWord. Si la longitud de la palabra actual es mayor, actualizamos longestWord.

Aquí está el código completo:

function findLongestWord(str) {
    let strSplit = str.split(" ");
    let longestWord = 0;
    for (let i = 0; i < strSplit.length; i++) {
        if (strSplit[i].length > longestWord) {
            longestWord = strSplit[i].length;
        }
    }
    return longestWord;
}
console.log(findLongestWord("The quick brown fox jumped over the lazy dog")); // 6

Cómo Funciona el Bucle For

Analicemos el proceso paso a paso con la cadena “The quick brown fox jumped over the lazy dog”:

División de la cadena: str.split(' ') crea el arreglo ["The", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"].
Inicialización: longestWord se establece en 0.
Iteración:
- Para “The” (3 caracteres), 3 > 0, por lo que longestWord = 3.
- Para “quick” (5 caracteres), 5 > 3, por lo que longestWord = 5.
- Para “brown” (5 caracteres), 5 > 5, no se actualiza.
- Para “fox” (3 caracteres), 3 > 5, no se actualiza.
- Para “jumped” (6 caracteres), 6 > 5, por lo que longestWord = 6.
- Para “over” (4 caracteres), 4 > 6, no se actualiza.
- Para “the” (3 caracteres), 3 > 6, no se actualiza.
- Para “lazy” (4 caracteres), 4 > 6, no se actualiza.
- Para “dog” (3 caracteres), 3 > 6, no se actualiza.
Resultado: Se devuelve longestWord, que es 6.

Este enfoque es eficiente porque solo recorre el arreglo una vez, con una complejidad temporal de O(n), donde n es el número de palabras. Es ideal para principiantes debido a su simplicidad y claridad.

Solución con el Método sort()

El segundo enfoque utiliza el método sort() para ordenar el arreglo de palabras según su longitud, de mayor a menor, y luego devuelve la longitud del primer elemento. Este método es más conciso pero puede ser menos intuitivo para principiantes debido a la función de comparación en sort().

Primero, dividimos la cadena en un arreglo con split(’ ‘), como en el método anterior. Luego, usamos sort() con una función de comparación que ordena las palabras por longitud descendente. Finalmente, tomamos la longitud del primer elemento del arreglo ordenado.

Aquí está el código:

function findLongestWord(str) {
    let longestWord = str.split(" ").sort((a, b) => b.length - a.length);
    return longestWord[0].length;
}
console.log(findLongestWord("The quick brown fox jumped over the lazy dog")); // 6

Cómo Funciona el Método sort()

Veamos el proceso con la misma cadena:

División de la cadena: str.split(' ') genera ["The", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"].
Ordenamiento: La función sort((a, b) => b.length - a.length) compara las longitudes de las palabras:
- Si b.length - a.length es positivo, b se coloca antes de a.
- Por ejemplo, “quick” (5) y “The” (3): 5 - 3 = 2, por lo que “quick” va primero.
- El arreglo ordenado es ["jumped", "quick", "brown", "over", "lazy", "The", "fox", "the", "dog"].
Resultado: La longitud del primer elemento, jumped, es 6.

La complejidad temporal de este método es O(n log n) debido al algoritmo de ordenamiento subyacente. Aunque es más lento que el bucle for para arreglos grandes, el código es más conciso y elegante, lo que lo hace atractivo para desarrolladores que prefieren un estilo funcional.

Solución con el Método reduce()

El tercer enfoque utiliza el método reduce() para recorrer el arreglo y mantener un acumulador con la palabra más larga encontrada. Este método es funcional y compacto, ideal para desarrolladores familiarizados con la programación funcional en JavaScript.

Dividimos la cadena en un arreglo con split(’ ‘). Luego, usamos reduce() con un valor inicial de una cadena vacía ("") para comparar la longitud de cada palabra con la del acumulador. Si la palabra actual es más larga, se convierte en el nuevo acumulador; de lo contrario, se mantiene el acumulador anterior. Finalmente, devolvemos la longitud del acumulador.

Aquí está el código:

function findLongestWord(str) {
    let longestWord = str.split(" ").reduce((longest, currentWord) => {
        return currentWord.length > longest.length ? currentWord : longest;
    }, "");
    return longestWord.length;
}
console.log(findLongestWord("The quick brown fox jumped over the lazy dog")); // 6

Cómo Funciona el Método reduce()

Analicemos el proceso:

División de la cadena: str.split(' ') produce ["The", "quick", "brown", "fox", "jumped", "over", "the", "lazy", "dog"].
Reducción:
- Inicialmente, longest es "" (cadena vacía, longitud 0).
- Para “The” (3 caracteres), 3 > 0, longest se convierte en “The”.
- Para “quick” (5 caracteres), 5 > 3, longest se convierte en “quick”.
- Para “brown” (5 caracteres), 5 > 5, se mantiene “quick”.
- Para “fox” (3 caracteres), 3 > 5, se mantiene “quick”.
- Para “jumped” (6 caracteres), 6 > 5, longest se convierte en “jumped”.
- Para “over” (4 caracteres), 4 > 6, se mantiene “jumped”.
- Para “the” (3 caracteres), 3 > 6, se mantiene “jumped”.
- Para “lazy” (4 caracteres), 4 > 6, se mantiene “jumped”.
- Para “dog” (3 caracteres), 3 > 6, se mantiene “jumped”.
Resultado: La longitud de jumped es 6.

La complejidad temporal es O(n), similar al bucle for, ya que recorre el arreglo una vez. Sin embargo, reduce() ofrece un enfoque más funcional, lo que puede ser preferido en proyectos que siguen este paradigma.

Comparación de los Métodos

Cada método tiene sus ventajas y desventajas, dependiendo del contexto y las necesidades del proyecto:

Bucle for: Es el más simple y eficiente en términos de tiempo (O(n)). Ideal para principiantes o cuando la legibilidad es prioritaria. Sin embargo, el código es más largo y menos elegante.
Método sort(): Es conciso y fácil de leer, pero su complejidad O(n log n) lo hace menos eficiente para arreglos grandes. Es útil cuando la brevedad del código es importante.
Método reduce(): Ofrece un enfoque funcional y una complejidad de O(n). Es ideal para desarrolladores avanzados que prefieren un estilo declarativo, pero puede ser menos intuitivo para principiantes.

Para la mayoría de los casos, el bucle for es la mejor opción debido a su simplicidad y eficiencia. Sin embargo, en proyectos donde el estilo funcional es preferido, reduce() es una excelente alternativa. El método sort() es útil cuando la prioridad es un código compacto y el tamaño del arreglo no es un problema.

Ejemplos Adicionales

Probemos los tres métodos con los casos de prueba proporcionados:

// Bucle for
function findLongestWordFor(str) {
    let strSplit = str.split(" ");
    let longestWord = 0;
    for (let i = 0; i < strSplit.length; i++) {
        if (strSplit[i].length > longestWord) {
            longestWord = strSplit[i].length;
        }
    }
    return longestWord;
}

// Método sort()
function findLongestWordSort(str) {
    let longestWord = str.split(" ").sort((a, b) => b.length - a.length);
    return longestWord[0].length;
}

// Método reduce()
function findLongestWordReduce(str) {
    let longestWord = str.split(" ").reduce((longest, currentWord) => {
        return currentWord.length > longest.length ? currentWord : longest;
    }, "");
    return longestWord.length;
}

console.log(findLongestWordFor("May the force be with you")); // 5
console.log(findLongestWordSort("Google do a barrel roll")); // 6
console.log(
    findLongestWordReduce(
        "What is the average airspeed velocity of an unladen swallow"
    )
); // 8
console.log(
    findLongestWordFor(
        "What if we try a super-long word such as otorhinolaryngology"
    )
); // 19

Todos los métodos producen los resultados esperados, demostrando su validez. La elección entre ellos dependerá de las necesidades específicas del proyecto, como el tamaño del arreglo, los requisitos de legibilidad y el estilo de codificación preferido.

Consideraciones de Rendimiento

En términos de rendimiento, el bucle for y reduce() son más rápidos para arreglos grandes debido a su complejidad lineal (O(n)). El método sort(), con una complejidad de O(n log n), puede ser menos eficiente en escenarios con muchas palabras. Además, reduce() puede consumir más memoria si el acumulador almacena cadenas largas, aunque en este caso, el impacto es mínimo ya que solo guardamos una palabra.

Para aplicaciones del mundo real, como procesar texto en un editor o analizar datos de entrada de usuario, el bucle for es generalmente la opción más robusta. Sin embargo, en entornos donde el código funcional es la norma, reduce() puede integrarse mejor con otras operaciones de arrays.

Conclusiones

Encontrar la longitud de la palabra más larga en una cadena es un ejercicio fundamental que ilustra diferentes enfoques de programación en JavaScript. El bucle for ofrece simplicidad y eficiencia, ideal para principiantes o aplicaciones donde el rendimiento es crítico. El método sort() proporciona un código conciso, adecuado para proyectos pequeños donde la legibilidad es clave. Por su parte, el método reduce() es perfecto para un enfoque funcional, alineado con paradigmas modernos de desarrollo. Al dominar estas técnicas, los desarrolladores pueden elegir la mejor herramienta según el contexto, mejorando tanto la eficiencia como la calidad del código. Prueba estos métodos en tus proyectos y evalúa cuál se adapta mejor a tus necesidades.