Berechnen der geschätzten Lesezeit Ihres Textes mithilfe eines ONLYOFFICE-Makros

Die Schätzung der Lesezeit ist eine wertvolle Funktion in Texteditoren, mit der Benutzer bestimmen können, wie lange sie voraussichtlich zum Lesen eines Dokuments benötigen. Einer unserer Praktikanten, Vukasin, hat ein originelles, aber effektives Makro entwickelt, das die geschätzte Lesezeit im ONLYOFFICE-Dokumenteditor berechnet. In diesem Artikel analysieren wir das Makro und erklären, wie die einzelnen Funktionen funktionieren und wie sie zusammenwirken, um eine genaue Schätzung der Lesezeit zu ermöglichen.

Erstellen des Makros

Zuerst rufen wir das Dokumentobjekt mit der Methode Api.GetDocument() ab:

try {
        const document = Api.GetDocument();

Definieren von Konstanten

      // 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

Hier werden zwei Konstanten definiert:

• WORDS_PER_MINUTE: Die durchschnittliche Lesegeschwindigkeit eines Erwachsenen (238 Wörter pro Minute).
• COMPLEX_WORD_LENGTH: Ein Schwellenwert zur Bestimmung, ob ein Wort komplex ist.

Wörter zählen

Anschließend zerlegt die Funktion countWords den gegebenen Text anhand der Leerzeichen in Wörter und zählt die Anzahl der nicht leeren Wörter:

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

Komplexität schätzen

Um die Komplexität abzuschätzen, verwenden wir die Funktion 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;
        }

Diese Funktion bestimmt die Komplexität des Textes durch:

1. Aufteilen in Wörter.
2. Herausfiltern von Wörtern mit weniger als 7 Zeichen.
3. Berechnen des Verhältnisses komplexer Wörter zur Gesamtwortzahl.

Abrufen und Verarbeiten von Absätzen

Anschließend verarbeiten wir den Text weiter:

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


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

In diesem Abschnitt führen wir Folgendes aus:

1. Alle Absätze aus dem Dokument abrufen.
2. Jeden Absatz durchlaufen, um Text zu extrahieren.
3. Die Wörter in jedem Absatz zählen und die Gesamtwortzahl addieren.
4. Der gesamte Text wird zur Komplexitätsschätzung gespeichert.

Anpassung an die Komplexität

Hier wird der Komplexitätsfaktor zur Anpassung der Lesegeschwindigkeit verwendet. Eine höhere Komplexität führt zu einer geringeren effektiven Lesegeschwindigkeit:

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

Berechnung der Lesezeit

Anschließend rechnen wir die Gesamtzahl der Wörter in Minuten und weiter in Stunden um:

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

Formatieren der Ausgabe

Anschließend formatieren wir die Lesezeitausgabe basierend auf der berechneten Zeit.

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

Ausgabe einfügen

Dann fügen wir die formatierte Ausgabe ein:

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

Dieser Abschnitt:

1. Erstellt eine formatierte Zeichenfolge mit Angaben zur Lesezeit.
2. Erstellt ein neues Absatzobjekt und fügt Text hinzu.
3. Wendet Formatierungen an (Fett, Kursiv und Arial).
4. Fügt den Absatz am Anfang des Dokuments ein.

Der gesamte Makrocode lautet wie folgt:

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

Dieses Makro bietet eine intelligente Möglichkeit, die Lesezeit in ONLYOFFICE abzuschätzen, und wir hoffen, dass es eine nützliche Ergänzung für Ihr Arbeitsmaterial darstellt. ONLYOFFICE-Makros sind vielseitige Tools, die die Standardfunktionalität deutlich verbessern und Skripte erstellen, die speziell auf Ihre Bedürfnisse zugeschnitten sind. Wir empfehlen Ihnen, unsere API-Methodenbibliothek zu erkunden und Ihre eigenen Makros zu entwickeln. Bei Fragen oder Ideen können Sie sich gerne an uns wenden! Wir freuen uns immer über Feedback und Zusammenarbeit. Viel Erfolg bei Ihren Erkundungsbemühungen!

Über den Autor des Makros