Como calcular o tempo estimado de leitura do seu texto usando uma macro do ONLYOFFICE

Estimar o tempo de leitura é um recurso valioso em editores de texto, permitindo que os usuários determinem quanto tempo pode levar para ler um documento. Um de nossos estagiários, Vukasin criou uma macro peculiar, mas eficaz, que calcula o tempo estimado de leitura dentro do ONLYOFFICE Document Editor. Neste artigo, detalharemos a macro, explicando como cada função funciona e como elas se unem para fornecer uma estimativa precisa do tempo de leitura.

Construindo a macro

Primeiro recuperamos o objeto do documento usando o método Api.GetDocument():

try {
        const document = Api.GetDocument();

Definindo 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

Aqui, duas constantes são definidas:

• WORDS_PER_MINUTE: A velocidade média de leitura de um adulto (238 palavras por minuto).
• COMPLEX_WORD_LENGTH: Um limite para determinar se uma palavra é complexa.

Contando palavras

Em seguida, a função countWords divide o texto fornecido em palavras com base nos espaços em branco e conta o número de palavras não vazias:

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

Estimando a complexidade

Para estimar a complexidade, usamos a função estimatedComplexety:

   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 função determina a complexidade do texto por:

1. Dividindo em palavras.
2. Filtrando palavras com menos de 7 caracteres.
3. Calculando a proporção de palavras complexas em relação à contagem total de palavras.

Recuperando e processando parágrafos

Em seguida, continuamos processando o texto:

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


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

Nesta seção fazemos o seguinte:

1. Recupere todos os parágrafos do documento.
2. Percorra cada parágrafo para extrair o texto.
3. Conte as palavras em cada parágrafo e acumule a contagem total de palavras.
4. Armazene todo o texto para estimativa de complexidade.

Ajustando para complexidade

Aqui, o fator de complexidade é usado para ajustar a velocidade de leitura. Uma complexidade maior resulta em uma velocidade de leitura efetiva menor:

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

Calculando o tempo de leitura

Em seguida, convertemos o total de palavras em minutos e depois em horas:

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

Formatando a saída

Depois disso, formatamos a saída do tempo de leitura com base no tempo 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" : ""
                    }`
                    : ""
                }`;
        }

Inserindo saída

Em seguida, inserimos a saída formatada:

      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 seção:

1. Cria uma string formatada com detalhes de tempo de leitura.
2. Cria um novo objeto de parágrafo e adiciona texto a ele.
3. Aplica estilo (negrito, itálico e fonte Arial).
4. Insere o parágrafo no início do documento.

O código completo da macro é o seguinte:

(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);
    }
})();

Agora vamos executar nossa macro e ver como ela funciona!

Esta macro fornece uma maneira inteligente de estimar o tempo de leitura no ONLYOFFICE e esperamos que se torne uma adição útil ao seu kit de trabalho. As macros do ONLYOFFICE são ferramentas versáteis que ajudam a melhorar significativamente a funcionalidade padrão e a criar scripts que são adaptados especificamente às suas necessidades. Nós o encorajamos a explorar nosso Biblioteca de métodos de API e desenvolva suas próprias macros. Se você tiver alguma dúvida ou ideia, sinta-se à vontade para conversar conosco! Estamos sempre abertos a feedback e colaboração. Boa sorte em seus esforços exploratórios!

Sobre o autor da macro