Comment calculer le temps de lecture estimé de votre texte à l’aide d’une macro ONLYOFFICE

L’estimation du temps de lecture est une fonctionnalité précieuse dans les éditeurs de texte, permettant aux utilisateurs de déterminer combien de temps, il pourrait falloir pour lire un document. Un de nos stagiaires, Vukasin a créé une macro originale, mais efficace qui calcule le temps de lecture estimé dans l’éditeur de documents texte ONLYOFFICE. Dans cet article, nous allons décomposer la macro, en expliquant comment chaque fonction opère et comment elles s’associent pour fournir une estimation précise du temps de lecture.

Construction de la macro

D’abord, nous récupérons l’objet document en utilisant la méthode Api.GetDocument() :

try {
        const document = Api.GetDocument();

Définition des 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

Ici, deux constantes sont définies :

• WORDS_PER_MINUTE : La vitesse de lecture moyenne d’un adulte (238 mots par minute).
• COMPLEX_WORD_LENGTH : Un seuil pour déterminer si un mot est complexe.

Comptage des mots

Ensuite, la fonction countWords divise le texte donné en mots en se basant sur les espaces blancs et compte le nombre de mots non vides :

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

Estimation de la complexité

Pour estimer la complexité, nous utilisons la fonction 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;
        }

Cette fonction détermine la complexité du texte en :

1. Le divisant en mots.
2. Filtrant les mots ayant 7 caractères ou plus (considérés comme complexes).
3. Calculant le ratio des mots complexes par rapport au nombre total de mots.

Récupération et traitement des paragraphes

Ensuite, nous continuons le traitement du texte :

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


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

Dans cette section, nous effectuons les opérations suivantes :

1. Récupérer tous les paragraphes du document.
2. Parcourir chaque paragraphe pour en extraire le texte.
3. Compter les mots dans chaque paragraphe et accumuler le nombre total de mots.
4. Stocker tout le texte pour l’estimation de la complexité.

Ajustement en fonction de la complexité

Ici, le facteur de complexité est utilisé pour ajuster la vitesse de lecture. Une complexité plus élevée entraîne une vitesse de lecture effective plus faible:

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

Calcul du temps de lecture

Ensuite, nous convertissons le nombre total de mots en minutes, puis en heures :

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

Formatage de la sortie

Après cela, nous formatons la sortie du temps de lecture en fonction du temps calculé.

    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" : ""
                    }`
                    : ""
                }`;
        }

Insertion de la sortie

Ensuite, nous insérons la sortie formatée :

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

Cette section :

1. Crée une chaîne de caractères formatée avec les détails du temps de lecture.
2. Crée un nouvel objet paragraphe et y ajoute du texte.
3. Applique un style (gras, italique et police Arial).
4. Insère le paragraphe au début du document.

Le code complet de la macro est le suivant :

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

Maintenant, exécutons notre macro et voyons comment elle fonctionne !

Cette macro offre un moyen intelligent d’estimer le temps de lecture dans ONLYOFFICE, et nous espérons qu’elle deviendra un ajout utile à votre boîte à outils de travail. Les macros ONLYOFFICE sont des outils polyvalents qui aident à améliorer considérablement les fonctionnalités par défaut et à créer des scripts spécifiquement adaptés à vos besoins. Nous vous encourageons à explorer notre bibliothèque de méthodes API et à développer vos propres macros. Si vous avez des questions ou des idées, n’hésitez pas à nous contacter ! Nous sommes toujours ouverts aux retours et à la collaboration. Bonne chance dans vos explorations !

À propos de l’auteur de la macro