Cómo calcular el tiempo estimado de lectura de tu texto usando una macro de ONLYOFFICE

Estimar el tiempo de lectura es una característica valiosa en los editores de texto, ya que permite a los usuarios saber cuánto tiempo podría llevar leer un documento. Uno de nuestros aprendices, Vukasin, creó una macro peculiar, pero eficaz que calcula el tiempo estimado de lectura dentro del Editor de documentos ONLYOFFICE. En este artículo, desglosaremos la macro, explicando cómo funciona cada función y cómo se combinan para proporcionar una estimación precisa del tiempo de lectura.

Creación de la macro

Primero, recuperamos el objeto del documento utilizando el método Api.GetDocument():

try {
        const document = Api.GetDocument();

Definición de las constantes

      // Constants for reading speed calculations
        const WORDS_PER_MINUTE = 238; // Average adult reading speed
        const COMPLEX_WORD_LENGTH = 7; // Words with this many chars or more are considered complex

Aquí se definen dos constantes:

• WORDS_PER_MINUTE: La velocidad media de lectura de un adulto (238 palabras por minuto).
• COMPLEX_WORD_LENGTH: Un umbral para determinar si una palabra es compleja.

Contando palabras 

Luego, la función countWords divide el texto dado en palabras basadas en los espacios en blanco y cuenta el número de palabras no vacías:

 function countWords(text) {
            if (!text) return 0;
            return text.split(/\s+/).filter((word) => word.length > 0).length;
        }

Estimando la complejidad

Para estimar la complejidad, utilizamos la función estimatedComplexity:

   function estimateComplexity(text) {
            if (!text) return 0;
            const words = text.split(/\s+/).filter((word) => word.length > 0);
            if (words.length === 0) return 0;


            const complexWords = words.filter(
                (word) => word.length >= COMPLEX_WORD_LENGTH
            ).length;
            return complexWords / words.length;
        }

Esta función determina la complejidad del texto al:

1. Dividirlo en palabras.
2. Filtrar las palabras que tienen menos de 7 caracteres.
3. Calcular la proporción de palabras complejas respecto al total de palabras.

Recuperando y procesando párrafos.

Luego continuamos procesando el texto:

        const paragraphs = document.GetAllParagraphs();
        let totalWords = 0;
        let totalText = "";


        paragraphs.forEach((paragraph) => {
            const text = paragraph.GetText();
            totalWords += countWords(text);
            totalText += text + " ";
        });

En esta sección, realizamos lo siguiente:

1. Recuperamos todos los párrafos del documento.
2. Iteramos a través de cada párrafo para extraer el texto.
3. Contamos las palabras en cada párrafo y acumulamos el total de palabras.
4. Almacenamos todo el texto para la estimación de complejidad.

Ajustando por complejidad 

Aquí se usa el factor de complejidad para ajustar la velocidad de lectura. Una mayor complejidad resulta en una velocidad de lectura efectiva más baja:

        const complexityFactor = estimateComplexity(totalText);
        const complexityAdjustment = 1 - complexityFactor * 0.3;
        const effectiveWPM = WORDS_PER_MINUTE * complexityAdjustment;

Calculando el tiempo de lectura

Luego, convertimos el total de palabras en minutos y, posteriormente, en horas:

        const readingTimeMinutes = totalWords / effectiveWPM;
        const readingTimeHours = readingTimeMinutes / 60;

Formateando la salida

Después de eso, formateamos la salida del tiempo de lectura según el tiempo calculado.

    let readingTimeText;
        if (readingTimeMinutes < 1) {
            readingTimeText = `less than 1 minute`;
        } else if (readingTimeMinutes < 60) {
            readingTimeText = `${Math.ceil(readingTimeMinutes)} minute${Math.ceil(readingTimeMinutes) !== 1 ? "s" : ""
                }`;
        } else {
            const hours = Math.floor(readingTimeHours);
            const remainingMinutes = Math.ceil((readingTimeHours - hours) * 60);
            readingTimeText = `${hours} hour${hours !== 1 ? "s" : ""}${remainingMinutes > 0
                    ? ` and ${remainingMinutes} minute${remainingMinutes !== 1 ? "s" : ""
                    }`
                    : ""
                }`;
        }

Instertando la salida 

Luego, insertamos la salida formateada:

      const infoText = `Reading Time: ${readingTimeText} (${totalWords} words at ${Math.round(
            effectiveWPM
        )} words per minute)`;


        const oParagraph = Api.CreateParagraph();
        oParagraph.AddText(infoText);
        oParagraph.SetBold(true);
        oParagraph.SetItalic(true);
        oParagraph.SetFontFamily("Arial");
        document.InsertContent([oParagraph], 0);
    } catch (error) {
        console.log("Error: " + error.message);
    }
})();

Esta sección:

1. Crea una cadena formateada con los detalles del tiempo de lectura.
2. Crea un nuevo objeto de párrafo y agrega texto a él.
3. Aplica estilo (negrita, cursiva y la fuente Arial).
4. Inserta el párrafo al inicio del documento.

El código completo de la macro es el siguiente:

(function () {
    try {
        const document = Api.GetDocument();
        // Constants for reading speed calculations
        const WORDS_PER_MINUTE = 238; // Average adult reading speed
        const COMPLEX_WORD_LENGTH = 7; // Words with this many chars or more are considered complex


        function countWords(text) {
            if (!text) return 0;
            return text.split(/\s+/).filter((word) => word.length > 0).length;
        }


        function estimateComplexity(text) {
            if (!text) return 0;
            const words = text.split(/\s+/).filter((word) => word.length > 0);
            if (words.length === 0) return 0;


            const complexWords = words.filter(
                (word) => word.length >= COMPLEX_WORD_LENGTH
            ).length;
            return complexWords / words.length;
        }


        const paragraphs = document.GetAllParagraphs();
        let totalWords = 0;
        let totalText = "";


        paragraphs.forEach((paragraph) => {
            const text = paragraph.GetText();
            totalWords += countWords(text);
            totalText += text + " ";
        });


        const complexityFactor = estimateComplexity(totalText);


        const complexityAdjustment = 1 - complexityFactor * 0.3;
        const effectiveWPM = WORDS_PER_MINUTE * complexityAdjustment;


        const readingTimeMinutes = totalWords / effectiveWPM;
        const readingTimeHours = readingTimeMinutes / 60;


        let readingTimeText;
        if (readingTimeMinutes < 1) {
            readingTimeText = `less than 1 minute`;
        } else if (readingTimeMinutes < 60) {
            readingTimeText = `${Math.ceil(readingTimeMinutes)} minute${Math.ceil(readingTimeMinutes) !== 1 ? "s" : ""
                }`;
        } else {
            const hours = Math.floor(readingTimeHours);
            const remainingMinutes = Math.ceil((readingTimeHours - hours) * 60);
            readingTimeText = `${hours} hour${hours !== 1 ? "s" : ""}${remainingMinutes > 0
                    ? ` and ${remainingMinutes} minute${remainingMinutes !== 1 ? "s" : ""
                    }`
                    : ""
                }`;
        }


        const infoText = `Reading Time: ${readingTimeText} (${totalWords} words at ${Math.round(
            effectiveWPM
        )} words per minute)`;


        const oParagraph = Api.CreateParagraph();
        oParagraph.AddText(infoText);
        oParagraph.SetBold(true);
        oParagraph.SetItalic(true);
        oParagraph.SetFontFamily("Arial");
        document.InsertContent([oParagraph], 0);
    } catch (error) {
        console.log("Error: " + error.message);
    }
})();

Ahora, ¡ejecutemos nuestra macro y veamos cómo funciona!

Esta macro ofrece una forma inteligente de estimar el tiempo de lectura en ONLYOFFICE y esperamos que se convierta en una adición útil a tu kit de trabajo. Las macros de ONLYOFFICE son herramientas versátiles que ayudan a mejorar significativamente la funcionalidad predeterminada y crear scripts adaptados específicamente a tus necesidades. Te invitamos a explorar nuestra biblioteca de métodos de la API y desarrollas tus propias macros. Si tienes alguna pregunta o idea, no dudes en contactarnos. ¡Siempre estamos abiertos a comentarios y colaboración! ¡Te deseamos muchas suertes en tus esfuerzos exploratorios!

Sobre el autor de la macro