Arbeiten mit Arbeitsblättern mithilfe der Excel-JavaScript-API

In diesem Artikel wird anhand einiger Codebeispiele erklärt, wie Sie allgemeine Aufgaben mit Arbeitsblättern mithilfe der Excel-JavaScript-API ausführen. Eine vollständige Liste der Eigenschaften und Methoden, die von den Worksheet Objekten und WorksheetCollection unterstützt werden, finden Sie unter Worksheet Object (JavaScript-API für Excel) und WorksheetCollection-Objekt (JavaScript-API für Excel).

Abrufen von Arbeitsblättern

Im folgenden Codebeispiel werden die Auflistung der Arbeitsblätter und die name-Eigenschaft jedes Arbeitsblatts abgerufen. Anschließend wird eine Meldung in die Konsole geschrieben.

await Excel.run(async (context) => {
    let sheets = context.workbook.worksheets;
    sheets.load("items/name");

    await context.sync();
    
    if (sheets.items.length > 1) {
        console.log(`There are ${sheets.items.length} worksheets in the workbook:`);
    } else {
        console.log(`There is one worksheet in the workbook:`);
    }

    sheets.items.forEach(function (sheet) {
        console.log(sheet.name);
    });
});

Abrufen des aktives Arbeitsblatts

Im folgenden Codebeispiel wird das aktive Arbeitsblatt abgerufen, die name-Eigenschaft geladen und eine Meldung in die Konsole geschrieben.

await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getActiveWorksheet();
    sheet.load("name");

    await context.sync();
    console.log(`The active worksheet is "${sheet.name}"`);
});

Festlegen des aktiven Arbeitsblatts

Im folgenden Codebeispiel wird das aktive Arbeitsblatt auf das Arbeitsblatt Sample festgelegt, dessen name Eigenschaft geladen und eine Nachricht in die Konsole geschrieben. Wenn kein Arbeitsblatt mit diesem Namen vorhanden ist, löst die activate() Methode einen Fehler aus ItemNotFound .

await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getItem("Sample");
    sheet.activate();
    sheet.load("name");

    await context.sync();
    console.log(`The active worksheet is "${sheet.name}"`);
});

Festlegen eines Verweises mit der relativen Position

In diesem Beispiel wird erklärt, wie Sie mit der relativen Position einen Verweis auf ein Arbeitsblatt vornehmen.

Abrufen des ersten Arbeitsblatts

Im folgenden Codebeispiel wird das erste Arbeitsblatt der Arbeitsmappe abgerufen, die name-Eigenschaft geladen und eine Meldung in die Konsole geschrieben.

await Excel.run(async (context) => {
    let firstSheet = context.workbook.worksheets.getFirst();
    firstSheet.load("name");

    await context.sync();
    console.log(`The name of the first worksheet is "${firstSheet.name}"`);
});

Abrufen des letzten Arbeitsblatts

Im folgenden Codebeispiel wird das letzte Arbeitsblatt der Arbeitsmappe abgerufen, die name-Eigenschaft geladen und eine Meldung in die Konsole geschrieben.

await Excel.run(async (context) => {
    let lastSheet = context.workbook.worksheets.getLast();
    lastSheet.load("name");

    await context.sync();
    console.log(`The name of the last worksheet is "${lastSheet.name}"`);
});

Abrufen des nächsten Arbeitsblatts

Im folgenden Codebeispiel wird das Arbeitsblatt abgerufen, das auf das aktive Arbeitsblatt in der Arbeitsmappe folgt, dessen name -Eigenschaft geladen und eine Nachricht in die Konsole geschrieben. Wenn nach dem aktiven Arbeitsblatt kein Arbeitsblatt vorhanden ist, löst die getNext() Methode einen Fehler aus ItemNotFound .

await Excel.run(async (context) => {
    let currentSheet = context.workbook.worksheets.getActiveWorksheet();
    let nextSheet = currentSheet.getNext();
    nextSheet.load("name");

    await context.sync();
    console.log(`The name of the sheet that follows the active worksheet is "${nextSheet.name}"`);
});

Abrufen des vorherigen Arbeitsblatts

Im folgenden Codebeispiel wird das Arbeitsblatt abgerufen, das dem aktiven Arbeitsblatt in der Arbeitsmappe vorangestellt ist, dessen -Eigenschaft geladen name und eine Nachricht in die Konsole geschrieben. Wenn vor dem aktiven Arbeitsblatt kein Arbeitsblatt vorhanden ist, löst die getPrevious() Methode einen Fehler aus ItemNotFound .

await Excel.run(async (context) => {
    let currentSheet = context.workbook.worksheets.getActiveWorksheet();
    let previousSheet = currentSheet.getPrevious();
    previousSheet.load("name");

    await context.sync();
    console.log(`The name of the sheet that precedes the active worksheet is "${previousSheet.name}"`);
});

Hinzufügen eines Arbeitsblatts

Im folgenden Codebeispiel wird der Arbeitsmappe ein neues Arbeitsblatt mit dem Namen Sample hinzugefügt, dessen Eigenschaften und position geladen name und eine Nachricht in die Konsole geschrieben. Das neue Arbeitsblatt wird nach allen vorhandenen Arbeitsblättern hinzugefügt.

await Excel.run(async (context) => {
    let sheets = context.workbook.worksheets;

    let sheet = sheets.add("Sample");
    sheet.load("name, position");

    await context.sync();
    console.log(`Added worksheet named "${sheet.name}" in position ${sheet.position}`);
});

Kopieren eines vorhandenen Arbeitsblatts

Worksheet.copy fügt ein neues Arbeitsblatt ein, bei dem es sich um eine Kopie eines vorhandenen Arbeitsblatts handelt. Am Ende des Namens des neuen Arbeitsblatts wird eine Zahl angehängt, und zwar auf eine Art und Weise, die dem Kopieren eines Arbeitsblatts über die Excel-Benutzeroberfläche entspricht (z. B. mein Blatt (2)). Worksheet.copy kann zwei Parameter verwenden, die beide optional sind:

• positionType – Eine WorksheetPositionType-Enumeration, die angibt, an welcher Stelle in der Arbeitsmappe das neue Arbeitsblatt hinzugefügt werden soll.
• relativeTo – Wenn positionTypeBefore oder After ist, müssen Sie ein Arbeitsblatt relativ zu dem Arbeitsblatt angeben, zu dem das neue Blatt hinzugefügt werden soll (dieser Parameter beantwortet die Frage "vor oder nach was?").

Im folgenden Codebeispiel wird das aktuelle Arbeitsblatt kopiert und das neue Blatt direkt hinter dem aktuellen Arbeitsblatt eingefügt.

await Excel.run(async (context) => {
    let myWorkbook = context.workbook;
    let sampleSheet = myWorkbook.worksheets.getActiveWorksheet();
    let copiedSheet = sampleSheet.copy(Excel.WorksheetPositionType.after, sampleSheet);
    await context.sync();
});

Arbeitsblatt löschen

Im folgenden Codebeispiel wird das letzte Arbeitsblatt der Arbeitsmappe (sofern es nicht das einzige Blatt der Arbeitsmappe ist) gelöscht und eine Meldung in die Konsole geschrieben.

await Excel.run(async (context) => {
    let sheets = context.workbook.worksheets;
    sheets.load("items/name");

    await context.sync();
    if (sheets.items.length === 1) {
        console.log("Unable to delete the only worksheet in the workbook");
    } else {
        let lastSheet = sheets.items[sheets.items.length - 1];

        console.log(`Deleting worksheet named "${lastSheet.name}"`);
        lastSheet.delete();

        await context.sync();
    }
});

Umbenennen eines Arbeitsblatts

Im folgenden Codebeispiel wird der Name im aktiven Arbeitsblatt zu Neuer Name geändert.

await Excel.run(async (context) => {
    let currentSheet = context.workbook.worksheets.getActiveWorksheet();
    currentSheet.name = "New Name";

    await context.sync();
});

Verschieben eines Arbeitsblatts

Im folgenden Codebeispiel wird ein Arbeitsblatt von der letzten an die erste Stelle der Arbeitsmappe verschoben.

await Excel.run(async (context) => {
    let sheets = context.workbook.worksheets;
    sheets.load("items");
    await context.sync();

    let lastSheet = sheets.items[sheets.items.length - 1];
    lastSheet.position = 0;
    await context.sync();
});

Festlegen der Sichtbarkeit des Arbeitsblatts

In diesen Beispielen wird erklärt, wie Sie die Sichtbarkeit eines Arbeitsblatts festlegen.

Ausblenden eines Arbeitsblatts

Im folgenden Codebeispiel wird die Sichtbarkeit eines Arbeitsblatts mit dem Namen Beispiel auf „Ausgeblendet“ festgelegt, die name-Eigenschaft geladen und eine Meldung in die Konsole geschrieben.

await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getItem("Sample");
    sheet.visibility = Excel.SheetVisibility.hidden;
    sheet.load("name");

    await context.sync();
    console.log(`Worksheet with name "${sheet.name}" is hidden`);
});

Einblenden eines Arbeitsblatts

Im folgenden Codebeispiel wird die Sichtbarkeit eines Arbeitsblatts mit dem Namen Beispiel auf „Sichtbar“ festgelegt, die name-Eigenschaft geladen und eine Meldung in die Konsole geschrieben.

await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getItem("Sample");
    sheet.visibility = Excel.SheetVisibility.visible;
    sheet.load("name");

    await context.sync();
    console.log(`Worksheet with name "${sheet.name}" is visible`);
});

Abrufen einer einzelnen Zelle des Arbeitsblatts

Im folgenden Codebeispiel wird die Zelle der Zeile 2 in Spalte 5 des Arbeitsblatts mit dem Namen Beispiel abgerufen, die Eigenschaften address und values werden geladen und es wird eine Meldung in die Konsole geschrieben. Die Werte, die an die Methode getCell(row: number, column:number) übergeben werden, bestehen aus der nullindizierten Zeilennummer und Spaltennummer der abgerufenen Zelle.

await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getItem("Sample");
    let cell = sheet.getCell(1, 4);
    cell.load("address, values");

    await context.sync();
    console.log(`The value of the cell in row 2, column 5 is "${cell.values[0][0]}" and the address of that cell is "${cell.address}"`);
});

Erkennen von Datenänderungen

Das Add-In muss möglicherweise auf Datenänderungen von Benutzern in einem Arbeitsblatt reagieren. Um diese Änderungen zu erkennen, können Sie für das onChanged-Ereignis eines Arbeitsblatts einen Ereignishandler registrieren. Ereignishandler für das onChanged-Ereignis empfangen ein WorksheetChangedEventArgs-Objekt, wenn das Ereignis ausgelöst wird.

Das WorksheetChangedEventArgs-Objekt liefert Informationen zu den Änderungen und zur Quelle. Da onChanged ausgelöst wird, wenn sich entweder das Format oder der Wert der Daten ändert, kann es hilfreich sein, dass das Add-In prüft, ob die Werte tatsächlich geändert wurden. Die details-Eigenschaft kapselt diese Informationen als ChangedEventDetail. Das folgende Codebeispiel zeigt, wie die Vorher- und Nachher-Werte sowie die Typen einer Zelle angezeigt werden, die geändert wurde.

// This function would be used as an event handler for the Worksheet.onChanged event.
function onWorksheetChanged(eventArgs) {
    Excel.run(function (context) {
        let details = eventArgs.details;
        let address = eventArgs.address;

        // Print the before and after types and values to the console.
        console.log(`Change at ${address}: was ${details.valueBefore}(${details.valueTypeBefore}),`
            + ` now is ${details.valueAfter}(${details.valueTypeAfter})`);
        return context.sync();
    });
}

Erkennen von Formeländerungen

Ihr Add-In kann Änderungen an Formeln in einem Arbeitsblatt nachverfolgen. Dies ist nützlich, wenn ein Arbeitsblatt mit einer externen Datenbank verbunden ist. Wenn sich die Formel im Arbeitsblatt ändert, löst das Ereignis in diesem Szenario entsprechende Updates in der externen Datenbank aus.

Um Änderungen an Formeln zu erkennen, registrieren Sie einen Ereignishandler für das onFormulaChanged-Ereignis eines Arbeitsblatts. Ereignishandler für das onFormulaChanged Ereignis empfangen ein WorksheetFormulaChangedEventArgs-Objekt , wenn das Ereignis ausgelöst wird.

Im folgenden Codebeispiel wird gezeigt, wie Sie den onFormulaChanged Ereignishandler registrieren, das WorksheetFormulaChangedEventArgsFormulaDetails-Array der geänderten Formel mithilfe des -Objekts abrufen und dann Details zur geänderten Formel mit den FormulaChangedEventDetail-Eigenschaften ausgeben.

async function run() {
    await Excel.run(async (context) => {
        // Retrieve the worksheet named "Sample".
        let sheet = context.workbook.worksheets.getItem("Sample");
    
        // Register the formula changed event handler for this worksheet.
        sheet.onFormulaChanged.add(formulaChangeHandler);
    
        await context.sync();
    });
}

async function formulaChangeHandler(event) {
    await Excel.run(async (context) => {
        // Retrieve details about the formula change event.
        // Note: This method assumes only a single formula is changed at a time. 
        let cellAddress = event.formulaDetails[0].cellAddress;
        let previousFormula = event.formulaDetails[0].previousFormula;
        let source = event.source;
    
        // Print out the change event details.
        console.log(
          `The formula in cell ${cellAddress} changed. 
          The previous formula was: ${previousFormula}. 
          The source of the change was: ${source}.`
        );         
    });
}

Behandeln von Sortierereignissen

Die Ereignisse onColumnSorted und onRowSorted geben an, wann Arbeitsblattdaten sortiert sind. Diese Ereignisse sind mit einzelnen Worksheet-Objekten und mit den WorkbookCollection-Arbeitsmappen verbunden. Sie lösen aus, ob die Sortierung programmgesteuert oder manuell über die Excel-Benutzeroberfläche erfolgt.

Die Ereignisse onColumnSorted und onRowSorted stellen ihre Rückrufe mit WorksheetColumnSortedEventArgs bzw. WorksheetRowSortedEventArgs zur Verfügung. Diese geben weitere Details zum Ereignis. Insbesondere verfügen beide EventArgs über eine address-Eigenschaft, welche die Zeilen oder Spalten darstellt, die als Ergebnis des Sortiervorgangs verschoben wurden. Jede Zelle mit sortiertem Inhalt wird einbezogen, auch wenn der Wert dieser Zelle nicht Teil der Sortierkriterien war.

In den folgenden Bildern sind die von der address-Eigenschaft zurückgegebenen Bereiche für Sortierereignisse dargestellt. Erstens, hier sind die Beispieldaten vor dem Sortieren:

Wenn eine Top-to-Bottom-Sortierung für "Q1" (die Werte in "B") ausgeführt wird, werden die folgenden hervorgehobenen Zeilen von WorksheetRowSortedEventArgs.addresszurückgegeben.

Wenn eine Links-nach-Rechts-Sortierung für "Quinces" (die Werte in "4") für die ursprünglichen Daten ausgeführt wird, werden die folgenden hervorgehobenen Spalten von WorksheetColumnsSortedEventArgs.addresszurückgegeben.

Das folgende Codebeispiel zeigt, wie Sie einen Ereignishandler für das Worksheet.onRowSorted-Ereignis registrieren. Beim Rückruf des Handlers wird die Füllfarbe für den Bereich gelöscht und dann die Zellen der verschobenen Zeilen ausgefüllt.

await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getActiveWorksheet();

    // This will fire whenever a row has been moved as the result of a sort action.
    sheet.onRowSorted.add(async (event) => {
        await Excel.run(async (context) => {
            console.log("Row sorted: " + event.address);
            let sheet = context.workbook.worksheets.getActiveWorksheet();

            // Clear formatting for section, then highlight the sorted area.
            sheet.getRange("A1:E5").format.fill.clear();
            if (event.address !== "") {
                sheet.getRanges(event.address).format.fill.color = "yellow";
            }

            await context.sync();
        });
    });

    await context.sync();
});

Suchen Sie alle Zellen mit übereinstimmendem Text

Das Worksheet-Objekt verfügt über eine findAll-Methode für die Suche nach einer angegebenen Zeichenfolge innerhalb des Arbeitsblatts. Es gibt ein RangeAreas-Objekt zurück, das eine Sammlung von Range-Objekten darstellt, die alle gleichzeitig bearbeitet werden können.

Das folgende Codebeispiel findet alle Zellen mit Werten, die der Zeichenfolge Complete entsprechen und färbt diese grün ein. Beachten Sie, dass findAll einen ItemNotFound Fehler auslöst, wenn die angegebene Zeichenfolge nicht im Arbeitsblatt vorhanden ist. Wenn Sie nicht sicher sind, ob die angegebene Zeichenfolge im Arbeitsblatt vorhanden ist, verwenden Sie die findAllOrNullObject-Methode , um dieses Szenario ordnungsgemäß zu behandeln.

await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getItem("Sample");
    let foundRanges = sheet.findAll("Complete", {
        completeMatch: true, /* Match the whole cell value, not any part of the text. */
        matchCase: false /* Make the search case-insensitive. */
    });

    await context.sync();
    foundRanges.format.fill.color = "green";
});

Filtern von Daten

Ein AutoFilter wendet Datenfilter auf einen Bereich im Arbeitsblatt an. Diese wird mit Worksheet.autoFilter.applyerstellt, die über die folgenden Parameter verfügt.

• range: Der Bereich, auf den der Filter angewendet wird, entweder als Range-Objekt oder Zeichenfolge angegeben.
• columnIndex: Der nullbasierte Spaltenindex, mit denen die Filterkriterien ausgewertet werden.
• criteria: Ein FilterCriteria-Objekt, das bestimmt, welche Zeilen basierend auf der Zelle der Spalte gefiltert werden sollen.

Das erste Codebeispiel zeigt, wie ein Filter zum verwendeten Bereich des Arbeitsblatts hinzugefügt wird. Dieser Filter blendet Einträge, die nicht zu den oberen 25 % gehören, basierend auf den Werten in Spalte 3 aus.

// This method adds a custom AutoFilter to the active worksheet
// and applies the filter to a column of the used range.
await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getActiveWorksheet();
    let farmData = sheet.getUsedRange();

    // This filter will only show the rows with the top 25% of values in column 3.
    sheet.autoFilter.apply(farmData, 3, { criterion1: "25", filterOn: Excel.FilterOn.topPercent });
    await context.sync();
});

Das nächste Codebeispiel veranschaulicht das Aktualisieren des automatischen Filters mithilfe der reapply-Methode. Dies sollte durchgeführt werden, wenn sich die Daten im Bereich ändern.

// This method refreshes the AutoFilter to ensure that changes are captured.
await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getActiveWorksheet();
    sheet.autoFilter.reapply();
    await context.sync();
});

Im folgenden Codebeispiel wird gezeigt, wie Sie die clearColumnCriteria -Methode verwenden, um den automatischen Filter nur aus einer Spalte zu löschen, während der Filter für andere Spalten aktiv bleibt.

// This method clears the AutoFilter setting from one column.
await Excel.run(async (context) => {
    // Retrieve the active worksheet.
    let sheet = context.workbook.worksheets.getActiveWorksheet();

    // Clear the filter from only column 3.
    sheet.autoFilter.clearColumnCriteria(3);
    await context.sync();
});

Das endgültige AutoFilter-Codebeispiel zeigt, wie der Auto-Filter mithilfe der remove-Methode aus dem Arbeitsblatt entfernt wird.

// This method removes all AutoFilters from the active worksheet.
await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getActiveWorksheet();
    sheet.autoFilter.remove();
    await context.sync();
});

AutoFilter kann auch auf einzelne Tabellen angewendet werden. Weitere Informationen finden Sie unter Arbeiten mit Tabellen mithilfe der Excel-JavaScript-API.

Datenschutz

Ihr Add-In kann die Möglichkeit eines Benutzers steuern, die Daten in einem Arbeitsblatt zu bearbeiten. Die protection-Eigenschaft des Arbeitsblatts ist ein WorksheetProtection-Objekt mit einer protect()-Methode. Das folgende Beispiel zeigt ein einfaches Szenario, in dem der komplette Schutz des aktiven Arbeitsblatts umgeschaltet wird.

await Excel.run(async (context) => {
    let activeSheet = context.workbook.worksheets.getActiveWorksheet();
    activeSheet.load("protection/protected");
    await context.sync();

    if (!activeSheet.protection.protected) {
        activeSheet.protection.protect();
    }
});

Die protect-Methode verfügt über zwei optionale Parameter:

• options: Ein WorksheetProtectionOptions-Objekt, das bestimmte Bearbeitungseinschränkungen definiert.
• password: Eine Zeichenfolge, die für das Kennwort steht, das zur Umgehung des Schutzes und zur Bearbeitung des Arbeitsblatts erforderlich ist.

Der Artikel Schützen eines Arbeitsblatts enthält weitere Informationen zum Schutz von Arbeitsblättern und zur Änderung des Schutzes über die Excel-Benutzeroberfläche.

Erkennen von Änderungen am Schutzstatus des Arbeitsblatts

Der Schutzstatus eines Arbeitsblatts kann durch ein Add-In oder über die Excel-Benutzeroberfläche geändert werden. Um Änderungen am Schutzstatus zu erkennen, registrieren Sie einen Ereignishandler für das onProtectionChanged Ereignis eines Arbeitsblatts. Ereignishandler für das onProtectionChanged Ereignis empfangen ein WorksheetProtectionChangedEventArgs -Objekt, wenn das Ereignis ausgelöst wird.

Im folgenden Codebeispiel wird gezeigt, wie Sie den onProtectionChanged Ereignishandler registrieren und das WorksheetProtectionChangedEventArgs -Objekt verwenden, um die isProtectedEigenschaften , worksheetIdund source des Ereignisses abzurufen.

// This function registers an event handler for the onProtectionChanged event of a worksheet.
async function run() {
    await Excel.run(async (context) => {
        // Retrieve the worksheet named "Sample".
        let sheet = context.workbook.worksheets.getItem("Sample");
    
        // Register the onProtectionChanged event handler.
        sheet.onProtectionChanged.add(checkProtection);
        await context.sync();
    });
}

// This function is an event handler that returns the protection state of a worksheet 
// and information about the changed worksheet.
async function checkProtection(event) {
    await Excel.run(async (context) => {
        // Retrieve the protection, worksheet ID, and source properties of the event.
        let protectionStatus = event.isProtected;
        let worksheetId = event.worksheetId;
        let source = event.source;

        // Print the event properties to the console.
        console.log("Protection status changed. Protection status is now: " + protectionStatus);
        console.log("    ID of changed worksheet: " + worksheetId);
        console.log("    Source of change event: " + source);    
    });
}

Seitenlayout und Druckeinstellungen

Add-Ins haben Zugriff auf die Seitenlayout-Einstellungen auf Arbeitsblattebene. Diese steuern, wie das Blatt gedruckt wird. A Worksheet Objekt verfügt über drei Layout-bezogene Eigenschaften: horizontalPageBreaks, verticalPageBreaks, pageLayout.

Worksheet.horizontalPageBreaks und Worksheet.verticalPageBreaks sind PageBreakCollections. Dies sind Sammlungen von Seitenumbrüche, die Bereiche angeben, in denen manuelle Seitenumbrüche eingefügt werden. Das folgende Codebeispiel fügt einen horizontalen Seitenumbruch über Zeile21 hinzu.

await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getActiveWorksheet();
    sheet.horizontalPageBreaks.add("A21:E21"); // The page break is added above this range.
    await context.sync();
});

Worksheet.pageLayout ist ein PageLayoutObjekt. Dieses Objekt enthält Layout- und Druckeinstellungen, die unabhängig von einer druckerspezifischen Implementierung sind. Diese Einstellungen umfassen Ränder, Ausrichtung, Seitennummerierung, Titelzeilen und Druckbereich.

Das folgende Codebeispiel zentriert die Seite (vertikal und horizontal), setzt eine Titelzeile, die oben auf jeder Seite gedruckt wird, und setzt den gedruckten Bereich auf einen Unterabschnitt des Arbeitsblattes.

await Excel.run(async (context) => {
    let sheet = context.workbook.worksheets.getActiveWorksheet();

    // Center the page in both directions.
    sheet.pageLayout.centerHorizontally = true;
    sheet.pageLayout.centerVertically = true;

    // Set the first row as the title row for every page.
    sheet.pageLayout.setPrintTitleRows("$1:$1");

    // Limit the area to be printed to the range "A1:D100".
    sheet.pageLayout.setPrintArea("A1:D100");

    await context.sync();
});

Siehe auch

• JavaScript-Objektmodell für Excel in Office-Add-Ins