Documentation – Pivot Tabelle einfügen

Nodejscpp: Formatieren der Pivot Tabelle

Mon, 01 Jan 0001 00:00:00 +0000

Aussehen der Pivot-Tabelle

Wie man eine Pivot-Tabelle erstellt, erklärt, wie man eine einfache Pivot-Tabelle erstellt. Dieser Artikel beschreibt, wie man das Aussehen einer Pivot-Tabelle anpasst, indem man verschiedene Eigenschaften einstellt:

Optionen zum Formatieren von Pivot-Tabellen
Optionen zum Formatieren von Pivot-Feldern
Optionen zum Formatieren von Datenfeldern

Wie man die Formatierungsoptionen für Pivot-Tabellen festlegt

Die Klasse PivotTable steuert die gesamte Pivot-Tabelle und kann auf verschiedene Arten formatiert werden.

Wie man den AutoFormat-Typ festlegt

Microsoft Excel bietet eine Reihe vordefinierter Berichtformate. Aspose.Cells for Node.js via C++ unterstützt diese Formatierungsoptionen ebenfalls. Um darauf zuzugreifen:

Setzen Sie PivotTable.setIsAutoFormat(value) auf true.
Weisen Sie eine Formatierungsoption aus der PivotTableAutoFormatType-Aufzählung zu.

Wie man Formatierungsoptionen festlegt

Das unten stehende Codebeispiel zeigt, wie die Pivot-Tabelle formatiert wird, um Gesamtsummen für Zeilen und Spalten anzuzeigen, und wie die Feldreihenfolge des Berichts festgelegt wird. Es zeigt auch, wie eine benutzerdefinierte Zeichenfolge für Nullwerte festgelegt wird.

Manuelles Anpassen von Aussehen und Anmutung

Um das Erscheinungsbild des Pivot-Tabellenberichts manuell anzupassen, anstatt voreingestellte Berichtsformate zu verwenden, verwenden Sie die Methoden PivotTable.formatAll(style) und PivotTable.format(row, column, style). Erstellen Sie ein Style-Objekt für Ihre gewünschte Formatierung, zum Beispiel:

So setzen Sie Pivot-Feldformatoptionen

Die Klasse PivotField stellt ein Feld in einer Pivot-Tabelle dar und kann auf verschiedene Arten formatiert werden. Das unten stehende Codebeispiel zeigt, wie:

Auf Zeilenfelder zugreifen.
Untergesamtsummen einstellen.
Autosortierung einstellen.
Autoshow einstellen.

So setzen Sie Zeilen-/Spalten-/Seitenfeldformatoptionen

So setzen Sie Datenfeldformatoptionen

Das unten stehende Codebeispiel zeigt, wie man Anzeigeformate und Zahlenformat für Datenfelder einstellt.

So löschen Sie Pivot-Felder

Die Methode clear() der PivotFieldCollection-Klasse ermöglicht es Ihnen, Pivot-Felder zu löschen. Verwenden Sie sie, wenn Sie alle Pivot-Felder in den Bereichen wie Seite, Spalte, Zeile oder Daten löschen möchten. Das unten stehende Codebeispiel zeigt, wie man alle Pivot-Felder in einem Datenbereich löscht.

Nodejscpp: Erstellen von Pivot Tabellen und Pivot Diagrammen

Mon, 01 Jan 0001 00:00:00 +0000

Eine Pivot-Tabelle ist eine interaktive Zusammenfassung von Datensätzen. Sie können beispielsweise Hunderte von Rechnungseinträgen in einer Liste in einem Arbeitsblatt haben. Eine Pivot-Tabelle kann die Rechnungen nach Kunden, Produkt oder Datum zusammenfassen. Mit Microsoft Excel ist es möglich, die Informationen in der Pivot-Tabelle schnell neu anzuordnen, indem Sie Schaltflächen an eine neue Position ziehen.

Ein Pivot-Diagramm ist eine interaktive grafische Darstellung der Daten in einer Pivot-Tabelle. Pivot-Diagramme wurden in Excel 2000 eingeführt. Durch die Verwendung eines Pivot-Diagramms wird es noch einfacher, die Daten zu verstehen, da die Pivot-Tabelle automatisch Teil- und Gesamtsummen erstellt.

Aspose.Cells for Node.js via C++ unterstützt Pivot-Tabellen und Pivot-Diagramme.

Pivot-Tabellen und Diagramme mit Aspose.Cells for Node.js via C++ hinzufügen

Aspose.Cells for Node.js via C++ bietet eine spezielle Klasse zur Erstellung von Pivot-Tabellen. Diese Klassen werden verwendet, um PivotTable-Objekte zu erstellen und einzustellen, die als Grundbausteine eines PivotTable-Objekts dienen:

PivotField, ein Feld in einem Pivot-Tabellenbericht.
PivotFields, eine Sammlung aller PivotField-Objekte in einer Pivot-Tabelle.
PivotTable, ein Pivot-Tabellenbericht auf einem Arbeitsblatt.
PivotTables, eine Sammlung aller PivotTable-Objekte auf dem Arbeitsblatt.

Vorbereitung der Verwendung von Aspose.Cells for Node.js via C++

Installieren Sie Aspose.Cells for Node.js via C++ aus NPM, verwenden Sie den Befehl: $ npm install aspose.cells.node.
Sie können auch die Schritt-für-Schritt-Anleitung zur Installation von “Aspose.Cells for Node.js via C++” in Ihrer Entwicklerumgebung befolgen.

So fügen Sie eine Pivot-Tabelle mit Aspose.Cells for Node.js via C++ hinzu

Um eine Pivot-Tabelle mit Aspose.Cells for Node.js via C++ zu erstellen:

Fügen Sie einige Daten zu Zellen auf einem Arbeitsblatt hinzu, indem Sie die put_value-Methode eines Cell-Objekts verwenden. Sie verwenden auch eine Vorlagendatei, die bereits mit Daten gefüllt ist. Die Daten werden als Datenquelle der Pivot-Tabelle verwendet.
Fügen Sie dem Arbeitsblatt eine Pivot-Tabelle hinzu, indem Sie die Methode add der PivotTables-Sammlung aufrufen (die im Arbeitsblatt-Objekt gekapselt ist).
Greifen Sie auf das neue PivotTable-Objekt aus der PivotTables-Sammlung zu, indem Sie seinen Index übergeben. # Verwenden Sie eines der in dem PivotTable-Objekt gekapselten Pivot-Tabellenobjekte, um die Tabelle zu verwalten.

Codebeispiele finden Sie unten.

Wie man ein Pivot-Diagramm mit der Aspose.Cells for Node.js via C++ Bibliothek hinzufügt

Um ein PivotChart mit Aspose.Cells for Node.js via C++ zu erstellen:

Fügen Sie ein Diagramm hinzu.
Setzen Sie den PivotSource des Diagramms so, dass er auf eine vorhandene Pivot-Tabelle in der Tabelle verweist.
Setzen Sie andere Attribute.

Nodejscpp: Pivot Tabelle und Quelldaten

Mon, 01 Jan 0001 00:00:00 +0000

Quelldaten der Pivot-Tabelle

Es gibt Zeiten, in denen Sie Microsoft Excel-Berichte mit Pivot-Tabellen erstellen möchten, die Daten aus verschiedenen Datenquellen (wie einer Datenbank) enthalten, die zur Entwurfszeit nicht bekannt sind. Dieser Artikel stellt einen Ansatz zur Verfügung, um die Datenquelle einer Pivot-Tabelle dynamisch zu ändern.

Ändern der Datenquelle einer Pivot-Tabelle

Erstellen einer neuen Designer-Vorlage.
1. Erstellen Sie eine neue Designer-Vorlagendatei wie im folgenden Screenshot gezeigt.
2. Definieren Sie dann einen benannten Bereich, Datenquelle, der sich auf diesen Zellenbereich bezieht.
  
  Erstellen einer Designer-Vorlage & Definieren eines benannten Bereichs, Datenquelle

Erstellen einer Pivot-Tabelle auf Basis dieses benannten Bereichs.
1. Wählen Sie in Microsoft Excel Daten, dann PivotTable und PivotChart-Bericht aus.
2. Erstellen Sie eine Pivot-Tabelle basierend auf dem im ersten Schritt erstellten benannten Bereich.
  
  Erstellen einer Pivot-Tabelle basierend auf dem benannten Bereich, DataSource

Ziehen Sie das entsprechende Feld in Zeile und Spalte der Pivot-Tabelle und erstellen Sie dann die resultierende Pivot-Tabelle wie im Screenshot unten.

Erstellen einer Pivot-Tabelle basierend auf einem entsprechenden Feld

Klicken Sie mit der rechten Maustaste auf die Pivot-Tabelle und wählen Sie Tabellenoptionen.
1. Aktivieren Sie Beim Öffnen aktualisieren in den Dateneinstellungen.
  
  Festlegen der Pivot-Tabellenoptionen

Nun können Sie diese Datei als Ihre Designer-Vorlagendatei speichern.

Neue Daten einfügen und die Quelldaten einer Pivot-Tabelle ändern.
1. Sobald die Designer-Vorlage erstellt ist, verwenden Sie den folgenden Code, um die Quelldaten der Pivot-Tabelle zu ändern.

Die Ausführung des untenstehenden Beispielcodes ändert die Quelldaten der Pivot-Tabelle.

Nodejscpp: Erstellen Sie ein berechnetes Feld im Pivot Table

Mon, 01 Jan 0001 00:00:00 +0000

Mögliche Verwendungsszenarien

Wenn Sie eine Pivot-Tabelle basierend auf bekannten Daten erstellen, stellen Sie fest, dass die Daten darin nicht das sind, was Sie wollen. Die Daten, die Sie wollen, sind die Kombination dieser Originaldaten. Zum Beispiel müssen Sie die ursprünglichen Daten addieren, subtrahieren, multiplizieren und dividieren, bevor Sie die Daten wollen. Zu diesem Zeitpunkt müssen Sie ein berechnetes Feld erstellen und die entsprechende Formel für die Berechnung festlegen. Führen Sie dann einige Statistiken und andere Operationen auf dem berechneten Feld durch.

Wie man ein berechnetes Feld in einer Pivot-Tabelle in Excel hinzufügt

Fügen Sie ein berechnetes Feld in eine Pivot-Tabelle in Excel ein, befolgen Sie diese Schritte:

Wählen Sie die Pivot-Tabelle aus, zu der Sie ein berechnetes Feld hinzufügen möchten.
Gehen Sie zum Register PivotTable Analyse in der Menüleiste.
Klicken Sie auf “Felder, Elemente und Sets” und wählen Sie dann “Berechnetes Feld” im Dropdown-Menü aus.
Geben Sie im Feld “Name” einen Namen für das berechnete Feld ein.
Geben Sie im Feld “Formel” die Formel für die Berechnung ein, die Sie unter Verwendung der entsprechenden Feldnamen und mathematischen Operatoren in der Pivot-Tabelle durchführen möchten.
Klicken Sie auf “OK”, um das berechnete Feld zu erstellen.
Das neue berechnete Feld wird im Bereich Wertliste der Pivot-Tabelle unter den Werten angezeigt.
Ziehen Sie das berechnete Feld in den Wertebereich der Pivot-Tabelle, um die berechneten Werte anzuzeigen.

Wie man ein berechnetes Feld in Pivot-Tabellen mit der Aspose.Cells for Node.js via C++-Bibliothek hinzufügt

Fügen Sie ein berechnetes Feld in die Excel-Datei mit Aspose.Cells for Node.js via C++ ein. Bitte sehen Sie sich den folgenden Beispielcode an. Nach Ausführung des Beispielcodes wird eine Pivot-Tabelle mit berechnetem Feld zur Arbeitsblattdatei hinzugefügt.

Legen Sie die Originaldaten fest und erstellen Sie eine Pivot-Tabelle.
Erstellen Sie das berechnete Feld gemäß dem vorhandenen PivotField in der Pivot-Tabelle.
Fügen Sie das berechnete Feld in den Datenbereich ein.
Schließlich wird die Arbeitsmappe im XLSX-Ausgabeformat gespeichert.

Beispielcode

Nodejscpp: Aktualisieren von Pivot-Tabellen in Aspose.Cells for Node.js via C++

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells stellt eine abgestufte Aktualisierungs-API bereit, mit der Sie Pivot-Daten in vier verschiedenen Geltungsbereichen neu laden können – von der gesamten Arbeitsmappe bis hin zu einer einzelnen PivotTable. Ab Aspose.Cells for Node.js via C++ v26.7 ist die Legacy-Methode PivotTable.RefreshData() als veraltet markiert und sollte durch die effizienteren, cache-bewussten APIs ersetzt werden, die in diesem Artikel beschrieben werden.

Einführung

Das Aktualisieren einer PivotTable ist selten ein einzelner Vorgang. Im Hintergrund verwaltet Aspose.Cells eine abgestufte Datenkette, die Ihre ursprünglichen Quelldaten mit den gerenderten Werten verbindet, die Sie im Arbeitsblatt sehen. Diese Kette zu verstehen, ist der Schlüssel zur Auswahl der richtigen Aktualisierungs-API für jede Situation. Die vierschichtige Datenkette ist:

Datenquelle — die ursprünglichen Arbeitsblattbereiche, die Datenbankabfrage oder der Konsolidierungsbereich, in dem die Rohwerte gespeichert sind.
PivotCache — der In-Memory-Snapshot der Quelldaten. Jede PivotTable wird auf einem PivotCache aufgebaut; hier werden alle Daten gesammelt und aggregiert.
PivotTable — das Anzeigeobjekt, das Zeilen-, Spalten-, Wert- und Filterfelder definiert. Eine PivotTable liest ausschließlich aus ihrem PivotCache, niemals direkt aus der Datenquelle.
Zellen — die Cells des Arbeitsblatts, in die die PivotTable ihre berechneten Werte und Stile rendert. Ein besonders wichtiges Konzept ist der freigegebene Cache. Wenn mehrere Pivot-Tabellen in einer Arbeitsmappe auf denselben Quellbereich verweisen, teilen sie sich eine PivotCache-Instanz. Ein einzelner PivotCache kann von vielen Pivot-Tabellen referenziert werden, und das Aktualisieren dieses Caches aktualisiert jede abhängige PivotTable auf einmal.
PivotCache.SourceType (Enum PivotTableSourceType) gibt an, woher die Cache-Daten stammen. Ab v26.7 unterstützt PivotCache.Refresh() nur die Quelltypen Sheet und Consolidation – also Daten, die in Arbeitsblattbereichen leben. Externe Quellen (Datenbanken, externe Verbindungen usw.) sind über die Cache-API noch nicht aktualisierbar.
Aufgrund dieser Kette gibt es in Aspose.Cells zwei grundlegende Aktualisierungspfade:

PivotCache.Refresh() — lädt Quelle → Cache neu UND berechnet alle abhängigen PivotTables in einem einzigen Vorgang neu.
PivotTable.CalculateData() — berechnet die Anzeige einer einzigen PivotTable aus bereits im Cache befindlichen Daten neu, ohne Round-Trip zur Datenquelle. Alle Szenarien in diesem Artikel verwenden Arbeitsblattzellen als Quelldaten, sodass der Quelltyp Sheet ist und die Aktualisierungsvorgänge wie beschrieben funktionieren.

Erforderliche Importe

Alle JavaScript-Beispiele in diesem Artikel gehen davon aus, dass das Modul Aspose.Cells for Node.js via C++ geladen wurde und sich die Pivot-Typen im Namespace Aspose.Cells.Pivot befinden. Eine typische Einrichtung ist:

const AsposeCells = require("aspose.cells.node");
const { PivotFieldType } = AsposeCells; (oder Zugriff über AsposeCells.Pivot.PivotFieldType)

Alle Pivot-Tabellen in der Arbeitsmappe aktualisieren

Wenn Sie sicherstellen müssen, dass jeder Pivot-Cache und jede Pivot-Tabelle in der Arbeitsmappe die neuesten Quelldaten widerspiegelt, ist die einfachste und umfassendste API Workbook.RefreshAll(). Ein einziger Aufruf durchläuft die gesamte Arbeitsmappe – er aktualisiert jeden PivotCache aus seiner Quelle und berechnet anschließend jede abhängige PivotTable neu. Dies ist der empfohlene Ansatz für allgemeine, vollständige Dokumentaktualisierungen, bei denen die Leistung keine Rolle spielt. Das folgende Beispiel erstellt eine Arbeitsmappe mit einem Fruit/Year/Amount-Quellbereich, erstellt eine PivotTable, ändert einige Quellwerte und verwendet anschließend RefreshAll(), um alles in einem einzigen Aufruf auf den neuesten Stand zu bringen.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);

// Schreibe die Kopfzeile in die Zellen A1:C1
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Schreibe Datenzeilen in die Zellen A2:C9 (8 Zeilen mit Obst-Daten für 2020 und 2021)
worksheet.getCells().get("A2").putValue("grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(50);

worksheet.getCells().get("A3").putValue("blueberry");
worksheet.getCells().get("B3").putValue(2020);
worksheet.getCells().get("C3").putValue(60);

worksheet.getCells().get("A4").putValue("kiwi");
worksheet.getCells().get("B4").putValue(2020);
worksheet.getCells().get("C4").putValue(70);

worksheet.getCells().get("A5").putValue("cherry");
worksheet.getCells().get("B5").putValue(2020);
worksheet.getCells().get("C5").putValue(80);

worksheet.getCells().get("A6").putValue("grape");
worksheet.getCells().get("B6").putValue(2021);
worksheet.getCells().get("C6").putValue(90);

worksheet.getCells().get("A7").putValue("blueberry");
worksheet.getCells().get("B7").putValue(2021);
worksheet.getCells().get("C7").putValue(100);

worksheet.getCells().get("A8").putValue("kiwi");
worksheet.getCells().get("B8").putValue(2021);
worksheet.getCells().get("C8").putValue(110);

worksheet.getCells().get("A9").putValue("cherry");
worksheet.getCells().get("B9").putValue(2021);
worksheet.getCells().get("C9").putValue(120);

// Füge eine Pivot-Tabelle hinzu: Quellbereich "A1:C9", Zielzelle "E3", Name "Pivot1"
let pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Weise die Pivot-Felder zu: Fruit zu Zeilen, Year zu Spalten, Amount zu Daten
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Ändere mehrere Amount-Werte in den Quelldaten, um Änderungen zu simulieren
worksheet.getCells().get("C2").putValue(55);
worksheet.getCells().get("C5").putValue(85);
worksheet.getCells().get("C9").putValue(125);

// Aktualisiere alle Pivot-Tabellen / Pivot-Caches in der Arbeitsmappe
workbook.refreshAll();

// Speichere die Arbeitsmappe
workbook.save("output.xlsx");

Alle Pivot-Tabellen auf einem einzelnen Arbeitsblatt aktualisieren

Manchmal müssen Sie nur die Pivot-Tabellen aktualisieren, die sich auf einem bestimmten Arbeitsblatt befinden – beispielsweise, wenn bekannt ist, dass Pivot-Tabellen auf anderen Arbeitsblättern nicht verwandt sind und nicht angefasst werden sollten. Für diesen Fall stellt Aspose.Cells Worksheet.RefreshPivotTables() bereit, das auf eine einzelne Worksheet-Instanz beschränkt ist. Dies ist selektiver als Workbook.RefreshAll(): nur die Pivot-Tabellen auf dem Zielarbeitsblatt werden aktualisiert, während Pivot-Tabellen auf anderen Arbeitsblättern unberührt bleiben. Das folgende Beispiel füllt dieselben Fruit/Year/Amount-Quelldaten, fügt eine PivotTable auf dem ersten Arbeitsblatt hinzu, ändert einige Quellwerte und aktualisiert anschließend nur die Pivot-Tabellen auf diesem Arbeitsblatt.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);

worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

worksheet.getCells().get("A2").putValue("grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(100);

worksheet.getCells().get("A3").putValue("blueberry");
worksheet.getCells().get("B3").putValue(2021);
worksheet.getCells().get("C3").putValue(150);

worksheet.getCells().get("A4").putValue("kiwi");
worksheet.getCells().get("B4").putValue(2020);
worksheet.getCells().get("C4").putValue(200);

worksheet.getCells().get("A5").putValue("cherry");
worksheet.getCells().get("B5").putValue(2021);
worksheet.getCells().get("C5").putValue(120);

worksheet.getCells().get("A6").putValue("grape");
worksheet.getCells().get("B6").putValue(2021);
worksheet.getCells().get("C6").putValue(180);

worksheet.getCells().get("A7").putValue("blueberry");
worksheet.getCells().get("B7").putValue(2020);
worksheet.getCells().get("C7").putValue(130);

worksheet.getCells().get("A8").putValue("kiwi");
worksheet.getCells().get("B8").putValue(2021);
worksheet.getCells().get("C8").putValue(220);

worksheet.getCells().get("A9").putValue("cherry");
worksheet.getCells().get("B9").putValue(2020);
worksheet.getCells().get("C9").putValue(140);

let pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

worksheet.getCells().get("C2").putValue(300);
worksheet.getCells().get("C5").putValue(250);
worksheet.getCells().get("C9").putValue(400);

worksheet.refreshPivotTables();

workbook.save("output.xlsx");

Eine einzelne PivotTable aktualisieren

Wenn Sie eine fein abgestimmte Kontrolle über eine einzelne PivotTable wünschen, bietet Ihnen die cache-basierte API zwei Möglichkeiten. Die Wahl zwischen ihnen hängt davon ab, was sich tatsächlich geändert hat: die zugrunde liegenden Quelldaten oder nur die Anzeige-/Layouteinstellungen der PivotTable selbst.

Quelldaten geändert — Verwenden Sie `PivotCache.Refresh()`

Wenn sich die zugrunde liegenden Quelldaten geändert haben, ist der richtige Einstiegspunkt pivotTable.PivotCache.Refresh(). Dieser Aufruf liest die Quelldaten erneut in den Cache und berechnet anschließend jede PivotTable neu, die von diesem Cache abhängt.

Da Pivot-Tabellen eine einzige PivotCache-Instanz gemeinsam nutzen, berechnet der Aufruf von PivotCache.Refresh() alle Pivot-Tabellen neu, die auf demselben Cache aufgebaut sind – nicht nur diejenige, die Sie referenzieren. Wenn zwei Pivot-Tabellen denselben Quellbereich gemeinsam nutzen, aktualisiert das Aktualisieren eines Caches beide.

Das folgende Beispiel erstellt zwei Pivot-Tabellen auf demselben Quellbereich, um dieses Verhalten mit freigegebenem Cache zu demonstrieren, ändert einige Quellwerte und aktualisiert anschließend über eine Cache-Referenz.

const AsposeCells = require("aspose.cells");

// Erstelle eine neue Arbeitsmappe und greife auf das erste Arbeitsblatt zu
const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);

// Schreibe die Kopfzeile: Frucht / Jahr / Betrag
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Schreibe ungefähr 9 Datenzeilen (Traube / Blaubeere / Kiwi / Kirsche über 2020-2021)
worksheet.getCells().get("A2").putValue("Grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(100);

worksheet.getCells().get("A3").putValue("Blueberry");
worksheet.getCells().get("B3").putValue(2020);
worksheet.getCells().get("C3").putValue(200);

worksheet.getCells().get("A4").putValue("Kiwi");
worksheet.getCells().get("B4").putValue(2020);
worksheet.getCells().get("C4").putValue(300);

worksheet.getCells().get("A5").putValue("Cherry");
worksheet.getCells().get("B5").putValue(2020);
worksheet.getCells().get("C5").putValue(400);

worksheet.getCells().get("A6").putValue("Grape");
worksheet.getCells().get("B6").putValue(2021);
worksheet.getCells().get("C6").putValue(500);

worksheet.getCells().get("A7").putValue("Blueberry");
worksheet.getCells().get("B7").putValue(2021);
worksheet.getCells().get("C7").putValue(600);

worksheet.getCells().get("A8").putValue("Kiwi");
worksheet.getCells().get("B8").putValue(2021);
worksheet.getCells().get("C8").putValue(700);

worksheet.getCells().get("A9").putValue("Cherry");
worksheet.getCells().get("B9").putValue(2021);
worksheet.getCells().get("C9").putValue(800);

// Füge die erste Pivot-Tabelle "Pivot1" hinzu, verankert an Zelle E3, Quellbereich A1:C9
const pivotIndex1 = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
const pivotTable1 = worksheet.getPivotTables().get(pivotIndex1);

// Weise Felder für Pivot1 zu
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Füge eine ZWEITE Pivot-Tabelle "Pivot2" hinzu, verankert an E15, unter Verwendung desselben Quellbereichs A1:C9
// Sowohl Pivot1 als auch Pivot2 teilen sich einen einzelnen PivotCache, da der Quellbereich identisch ist.
const pivotIndex2 = worksheet.getPivotTables().add("A1:C9", "E15", "Pivot2");
const pivotTable2 = worksheet.getPivotTables().get(pivotIndex2);

// Weise dieselben Felder für Pivot2 zu
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Ändere mehrere Betragszellenwerte in den Quelldaten, um eine Datenänderung zu simulieren
worksheet.getCells().get("C2").putValue(150);
worksheet.getCells().get("C4").putValue(350);
worksheet.getCells().get("C7").putValue(650);

// Aktualisiere den geteilten PivotCache.
// Da Pivot1 und Pivot2 denselben PivotCache teilen, aktualisiert dieser einzelne Aufruf
// BEIDE Pivot-Tabellen (Daten + Stil) aus der aktualisierten Quelle.
pivotTable1.getPivotCache().refresh();

// Speichere die Arbeitsmappe
workbook.save("output.xlsx");

Nur Ansicht/Layout geändert — Verwenden Sie `CalculateData()`

Wenn sich die Quelldaten nicht geändert haben, sondern nur die Anzeige- oder Layouteinstellungen der PivotTable geändert wurden (zum Beispiel wurde ein Feld in einen anderen Bereich verschoben oder eine Einstellung „Beim Öffnen aktualisieren" umgeschaltet), ist es nicht erforderlich, einen Round-Trip zur Datenquelle durchzuführen. Der Cache enthält bereits die richtigen Daten; nur die gerenderte PivotTable muss neu berechnet werden. In diesem Fall ist pivotTable.CalculateData() die richtige Wahl. Dies vermeidet den unnötigen Quellabruf und ist deutlich schneller, wenn viele Pivot-Tabellen denselben Cache gemeinsam nutzen. Das folgende Beispiel ändert eine Nicht-Quelleigenschaft der PivotTable und ruft anschließend CalculateData() auf, um sie aus dem vorhandenen Cache neu zu rendern.

var workbook = new AsposeCells.Workbook();
var worksheet = workbook.getWorksheets().get(0);

// Schreibt die Kopfzeile Fruit / Year / Amount
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Schreibt 8 Datenzeilen (Zeilen 2-9, passend zum Quellbereich A1:C9)
worksheet.getCells().get("A2").putValue("Grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(100);

worksheet.getCells().get("A3").putValue("Blueberry");
worksheet.getCells().get("B3").putValue(2020);
worksheet.getCells().get("C3").putValue(200);

worksheet.getCells().get("A4").putValue("Kiwi");
worksheet.getCells().get("B4").putValue(2020);
worksheet.getCells().get("C4").putValue(300);

worksheet.getCells().get("A5").putValue("Cherry");
worksheet.getCells().get("B5").putValue(2020);
worksheet.getCells().get("C5").putValue(400);

worksheet.getCells().get("A6").putValue("Grape");
worksheet.getCells().get("B6").putValue(2021);
worksheet.getCells().get("C6").putValue(150);

worksheet.getCells().get("A7").putValue("Blueberry");
worksheet.getCells().get("B7").putValue(2021);
worksheet.getCells().get("C7").putValue(250);

worksheet.getCells().get("A8").putValue("Kiwi");
worksheet.getCells().get("B8").putValue(2021);
worksheet.getCells().get("C8").putValue(350);

worksheet.getCells().get("A9").putValue("Cherry");
worksheet.getCells().get("B9").putValue(2021);
worksheet.getCells().get("C9").putValue(450);

// Fügt eine Pivot-Tabelle namens "Pivot1" an der Zielzelle E3 hinzu, mit Quelle A1:C9
var pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Weist die Felder zu: Fruit als Zeile, Year als Spalte, Amount als Daten
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Data, "Amount");

// Ändert eine Anzeige-/Layout-Eigenschaft — dies ist eine reine Darstellungsänderung,
// daher ist KEIN erneutes Einlesen der Quelldaten über PivotCache.Refresh() erforderlich.
pivotTable.setRefreshDataOnOpeningFile(false);

// calculateData() rendert die Anzeige DIESER Pivot-Tabelle (Daten + Stil) neu aus den
// bereits im PivotCache enthaltenen Daten. Da sich die Quelldaten nicht geändert haben,
// erfolgt kein Roundtrip zur Quelle — nur die zwischengespeicherten Werte werden in die
// Arbeitsblattzellen neu berechnet.
pivotTable.calculateData();

// Speichert die Arbeitsmappe auf der Festplatte
workbook.save("output.xlsx");

Alle Pivot-Tabellen abrufen, die denselben PivotCache gemeinsam nutzen

Eine Arbeitsmappe enthält häufig viele Pivot-Tabellen, die alle auf einem gemeinsam genutzten Cache aufbauen. Um sie aufzulisten – beispielsweise vor der Durchführung einer Batch-Aktualisierung oder um die Auswirkungen des freigegebenen Caches zu diagnostizieren – verwenden Sie PivotCache.GetPivotTables(). Diese Methode gibt die Sammlung jeder PivotTable zurück, die von dem angegebenen Cache abhängt. Dies ist auch der direkteste Weg, um zu bestätigen, dass zwei Pivot-Tabellen tatsächlich dieselbe PivotCache-Instanz gemeinsam nutzen: Sie können Cache-Referenzen vergleichen oder einfach die von GetPivotTables() zurückgegebene Sammlung durchlaufen und beobachten, welche Pivot-Tabellen darin erscheinen. Das folgende Beispiel erstellt zwei Pivot-Tabellen auf demselben Quellbereich, überprüft, dass sie dieselbe Cache-Instanz gemeinsam nutzen, und listet anschließend die Pivot-Tabellen des Caches auf.

Migration von der veralteten Methode `PivotTable.RefreshData()`

Vor Aspose.Cells for Node.js via C++ v26.7 bestand die Standardmethode zum Aktualisieren einer Pivot-Tabelle darin, PivotTable.RefreshData() für jede PivotTable einzeln aufzurufen. Ab v26.7 ist diese Methode als veraltet markiert und sollte durch die oben beschriebenen cache-bewussten APIs ersetzt werden. Es gibt zwei Gründe, warum der RefreshData()-Ansatz pro Tabelle in realen Arbeitsmappen problematisch ist:

Er ruft bei jedem Aufruf Daten erneut aus der Quelle ab, selbst wenn sich die Quelle nicht geändert hat.
Jeder Aufruf aktualisiert den gesamten gemeinsam genutzten Cache. Wenn viele Pivot-Tabellen einen Cache gemeinsam nutzen, führt der wiederholte Aufruf von RefreshData() pro PivotTable dazu, dass derselbe Cache immer wieder erneut abgerufen wird, was sehr langsam ist. Die empfohlenen Ersetzungen sind:
ALLE Pivot-Tabellen in der Arbeitsmappe aktualisieren → verwenden Sie workbook.refreshAll();
Einige davon aktualisieren → verwenden Sie pivotTable.PivotCache.Refresh(); für einen Cache. Da der Cache freigegeben ist, aktualisiert dieser einzige Aufruf jede PivotTable, die auf diesem Cache aufbaut. Andere Pivot-Tabellen, die auf einem bereits aktualisierten Cache sitzen, können sicher übersprungen werden.
Nur die Ansicht/das Layout der PivotTable hat sich geändert → verwenden Sie pivotTable.CalculateData(); um aus dem vorhandenen Cache ohne Round-Trip zur Quelle neu zu rendern. Das folgende Beispiel demonstriert das neue effiziente Muster für Arbeitsmappen mit mehreren Pivot-Tabellen, die sich einen einzigen Cache teilen.

let workbook = new AsposeCells.Workbook();

let sheet = workbook.getWorksheets().get(0);



// --- Quelldaten aufbauen: Frucht / Jahr / Betrag (Kopfzeile + 9 Zeilen) ---

sheet.getCells().get("A1").putValue("Fruit");

sheet.getCells().get("B1").putValue("Year");

sheet.getCells().get("C1").putValue("Amount");



sheet.getCells().get("A2").putValue("Grape");      sheet.getCells().get("B2").putValue(2020); sheet.getCells().get("C2").putValue(1000);
sheet.getCells().get("A3").putValue("Blueberry");  sheet.getCells().get("B3").putValue(2020); sheet.getCells().get("C3").putValue(2000);
sheet.getCells().get("A4").putValue("Kiwi");       sheet.getCells().get("B4").putValue(2020); sheet.getCells().get("C4").putValue(1500);
sheet.getCells().get("A5").putValue("Cherry");     sheet.getCells().get("B5").putValue(2020); sheet.getCells().get("C5").putValue(2500);
sheet.getCells().get("A6").putValue("Grape");      sheet.getCells().get("B6").putValue(2021); sheet.getCells().get("C6").putValue(3000);
sheet.getCells().get("A7").putValue("Blueberry");  sheet.getCells().get("B7").putValue(2021); sheet.getCells().get("C7").putValue(1800);
sheet.getCells().get("A8").putValue("Kiwi");       sheet.getCells().get("B8").putValue(2021); sheet.getCells().get("C8").putValue(2200);
sheet.getCells().get("A9").putValue("Cherry");     sheet.getCells().get("B9").putValue(2021); sheet.getCells().get("C9").putValue(2700);



// --- Die erste Pivot-Tabelle (Pivot1) an der Zielzelle E3 hinzufügen ---

let idx1 = sheet.getPivotTables().add("A1:C9", "E3", "Pivot1");

let pivotTable1 = sheet.getPivotTables().get(idx1);
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// --- Die ZWEITE Pivot-Tabelle (Pivot2) auf demselben Quellbereich hinzufügen ---
// Sowohl Pivot1 als auch Pivot2 teilen sich EINEN zugrundeliegenden PivotCache.
// Genau dies ist das Szenario, in dem der alte RefreshData()-Ansatz pro
// Tabelle ineffizient wird: Das Aktualisieren einer Tabelle ruft den gesamten
// gemeinsamen Cache erneut ab, sodass N Aktualisierungen N teure Abrufe
// verursachen.
let idx2 = sheet.getPivotTables().add("A1:C9", "E15", "Pivot2");

let pivotTable2 = sheet.getPivotTables().get(idx2);
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// --- Mehrere Betragswerte in den Quelldaten ändern ---

sheet.getCells().get("C2").putValue(5000);   // Grape  2020

sheet.getCells().get("C5").putValue(7500);   // Cherry 2020

sheet.getCells().get("C9").putValue(9500);   // Cherry 2021



// --- VERALTETES Muster (vor 26.7) — PivotTable.RefreshData() ---

// pivotTable1.RefreshData();  // ruft erneut aus der Quelle ab, aktualisiert den gesamten Cache
// pivotTable2.RefreshData();  // ruft ERNEUT ab — der Cache ist bereits aktuell!
// Jeder Aufruf baut den gemeinsamen Cache neu auf, also N Tabellen = N redundante Abrufe.



// --- NEUES Muster ab v26.7: Den Cache EINMAL aktualisieren, dann nach Bedarf neu rendern ---

// Ein einziger Aufruf von PivotCache.Refresh() holt die geänderten Werte in den

// gemeinsamen Cache UND berechnet die Anzeige JEDER Pivot-Tabelle neu, die darauf

// verweist. Da Pivot1 und Pivot2 einen PivotCache gemeinsam nutzen, aktualisiert

// dieser eine Aufruf beide Tabellen — kein zweiter Quell-Roundtrip ist erforderlich.

pivotTable1.getPivotCache().refresh();



// CalculateData() rendert nur die Anzeige einer Pivot-Tabelle (Daten + Stil) aus den

// bereits im Cache vorhandenen Daten neu — es greift NICHT auf die Quelle zu.

// Wir rufen es hier auf Pivot2 nur auf, um die API zu demonstrieren: Nachdem der Cache

// einmal aktualisiert wurde, kann jede abhängige Tabelle neu gerendert werden, ohne

// zur Quelle zurückzugehen. Verwenden Sie CalculateData() eigenständig, wenn nur die

// Ansichts-/Layout-Einstellungen der Pivot-Tabelle geändert wurden und der Cache aktuell ist.

pivotTable2.calculateData();



workbook.save("output.xlsx");

Welche Aktualisierungs-API sollte ich verwenden?

Die folgende Tabelle fasst die verfügbaren Aktualisierungs-APIs zusammen und gibt an, wann welche zu wählen ist.

Ziel	Empfohlene API	Hinweise
Alles in der Arbeitsmappe aktualisieren	`Workbook.RefreshAll()`	Ein Aufruf; deckt alle Caches und Tabellen ab.
Nur Pivot-Tabellen auf einem einzelnen Blatt aktualisieren	`Worksheet.RefreshPivotTables()`	Auf ein Arbeitsblatt beschränkt.
Quelldaten für einen Cache geändert	`pivotTable.PivotCache.Refresh()`	Aktualisiert ALLE Pivot-Tabellen auf diesem freigegebenen Cache.
Nur Ansichts-/Layouteinstellungen geändert	`pivotTable.CalculateData()`	Überspringt unnötigen Round-Trip zur Quelle.
Alle Pivot-Tabellen auf einem freigegebenen Cache auflisten	`pivotCache.GetPivotTables()`	Vor der Massenaktualisierung zur Aufzählung verwenden.
In der Praxis sind die cache-basierten APIs der veralteten Methode `RefreshData()` pro Tabelle vorzuziehen. Sie kennen freigegebene Caches, vermeiden redundante Quellabrufe und ermöglichen es Ihnen, den kleinsten Geltungsbereich zu wählen, der Ihre Aktualisierungsanforderung erfüllt.

Nodejscpp: Stile auf PivotTables in Aspose.Cells für .NET anwenden

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells unterstützt die Anwendung sowohl älterer Pivot-Autoformate (für .xls-Dateien vorgesehen) als auch moderner benannter oder benutzerdefinierter PivotTable-Formatvorlagen (für .xlsx-, .xlsm- und .xlsb-Dateien vorgesehen). Welche API Sie aufrufen sollten, hängt vom Dateiformat ab, in dem die Arbeitsmappe gespeichert wird, und nicht vom Format, aus dem sie geladen wurde.

Einführung

Aspose.Cells stellt zwei parallele Stil-APIs für Pivot-Tabellen bereit. Die Entscheidung zwischen ihnen wird durch das Dateiformat bestimmt, in dem Sie die Arbeitsmappe speichern, und nicht durch das Format, aus dem Sie sie lesen. Eine aus einer .xls-Datei geladene Arbeitsmappe kann als .xlsx neu gespeichert werden, und in diesem Fall kommt die moderne Stil-API zum Einsatz und nicht die ältere.

Für die Legacy-.xls-Ausgabe verwenden Sie die Eigenschaft PivotTable.AutoFormatType zusammen mit der Enumeration Aspose.Cells.Pivot.PivotTableAutoFormatType. Diese API entspricht der Autoformat-Auswahl, die klassisches Excel für Pivot-Tabellen angeboten hat.

Für die moderne .xlsx-, .xlsm- und .xlsb-Ausgabe stehen zwei Varianten der Stil-API zur Verfügung:

PivotTable.PivotTableStyleType wählt eine der integrierten benannten Formatvorlagen aus (helle und dunkle Designs, einschließlich der in Excel 2017 hinzugefügten Formatvorlagen). Diese Voreinstellungen sind schreibgeschützt.
PivotTable.PivotTableStyleName wählt eine benutzerdefinierte Formatvorlage aus, die Sie selbst über Workbook.Worksheets.TableStyles.AddPivotTableStyle(...) definieren. Benutzerdefinierte Formatvorlagen sind erforderlich, wenn Sie Farben, Rahmen oder Schriftarten über das hinaus ändern möchten, was die Voreinstellungen bieten.

Darüber hinaus ist PivotTable.FormatAll(Style) eine Verknüpfung, die ein einzelnes Style-Objekt auf jede Zelle der Pivot-Tabelle anwendet und alle über die beiden oben genannten Stilnamens-APIs vorgenommenen Einstellungen überschreibt. Dies ist nützlich, wenn ein einheitliches Erscheinungsbild unabhängig vom zugrunde liegenden Design erforderlich ist.

Anwenden eines Legacy-XLS-Voreinstellungs-Autoformats

PivotTable.AutoFormatType akzeptiert einen Wert aus der Enumeration Aspose.Cells.Pivot.PivotTableAutoFormatType. Die verfügbaren Werte sind Report1 bis Report10, Classic und Table1 bis Table10.

AutoFormatType wird nur berücksichtigt, wenn die Arbeitsmappe als .xls gespeichert wird. Wenn dieselbe Arbeitsmappe als .xlsx, .xlsm oder .xlsb gespeichert wird, ignoriert Excel diese Eigenschaft und greift auf die Einstellungen PivotTableStyleType und PivotTableStyleName zurück.

Das folgende Beispiel lädt eine neue Arbeitsmappe, befüllt die Beispieldaten Fruit/Year/Amount, fügt eine Pivot-Tabelle hinzu, wendet PivotTableAutoFormatType.Report5 an und speichert das Ergebnis als .xls.

Warum keine Spaltenfelder? Die Autoformate der Report-Serie (Report1 bis Report10, Table1 bis Table10) wurden im klassischen Excel für eindimensionale Pivot-Tabellen mit nur Zeilenfeldern und Werten entworfen — sie haben keine integrierte Formatierung für Spaltenfeld-Überschriften. Wenn Ihre Pivot-Tabelle Spaltenfelder benötigt, verwenden Sie stattdessen die modernen PivotTableStyleType-Voreinstellungen aus Szenario 2 unten, die für das zweidimensionale Layout moderner Excel-Versionen entwickelt wurden.

const AsposeCells = require("aspose.cells");

// Szenario 1: Ein Legacy-XLS-Voreinstellungs-Autoformat anwenden
// Verwendete API: PivotTable.AutoFormatType
// Zieldateiformat: .xls (Legacy)
// Für vollständige Beispiele und Datendateien besuchen Sie bitte https://github.com/aspose-cells/Aspose.Cells-for-.NET

// Eine neue Arbeitsmappe erstellen
const workbook = new AsposeCells.Workbook();

// Das erste Arbeitsblatt abrufen
const sheet = workbook.getWorksheets().get(0);

// Quelldaten mit Kopfzeile befüllen (Obst, Jahr, Betrag)
// und 9 Datenzeilen mit Trauben, Heidelbeeren, Kiwi, Kirsche über 2020 und 2021
sheet.getCells().get(0, 0).putValue("Fruit");
sheet.getCells().get(0, 1).putValue("Year");
sheet.getCells().get(0, 2).putValue("Amount");

sheet.getCells().get(1, 0).putValue("grape");
sheet.getCells().get(1, 1).putValue(2020);
sheet.getCells().get(1, 2).putValue(50);

sheet.getCells().get(2, 0).putValue("blueberry");
sheet.getCells().get(2, 1).putValue(2020);
sheet.getCells().get(2, 2).putValue(30);

sheet.getCells().get(3, 0).putValue("kiwi");
sheet.getCells().get(3, 1).putValue(2020);
sheet.getCells().get(3, 2).putValue(25);

sheet.getCells().get(4, 0).putValue("cherry");
sheet.getCells().get(4, 1).putValue(2020);
sheet.getCells().get(4, 2).putValue(40);

sheet.getCells().get(5, 0).putValue("grape");
sheet.getCells().get(5, 1).putValue(2021);
sheet.getCells().get(5, 2).putValue(60);

sheet.getCells().get(6, 0).putValue("blueberry");
sheet.getCells().get(6, 1).putValue(2021);
sheet.getCells().get(6, 2).putValue(35);

sheet.getCells().get(7, 0).putValue("kiwi");
sheet.getCells().get(7, 1).putValue(2021);
sheet.getCells().get(7, 2).putValue(28);

sheet.getCells().get(8, 0).putValue("cherry");
sheet.getCells().get(8, 1).putValue(2021);
sheet.getCells().get(8, 2).putValue(45);

sheet.getCells().get(9, 0).putValue("grape");
sheet.getCells().get(9, 1).putValue(2020);
sheet.getCells().get(9, 2).putValue(45);

// Eine Pivot-Tabelle in der Zielzelle E3 mit dem Namen "Pivot1" unter Verwendung des Quellbereichs A1:C10 hinzufügen
const pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
const pivotTable = sheet.getPivotTables().get(pivotIndex);

// Felder zuweisen: Obst -> Zeilen, Jahr -> Spalten, Betrag -> Daten
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Das Legacy-XLS-Voreinstellungs-Autoformat "Report5" anwenden
// Hinweis: Diese Eigenschaft ist nur beim Speichern als .xls relevant.
// Beim Speichern als .xlsx/.xlsm/.xlsb ignoriert Excel AutoFormatType
// und verwendet, was auch immer PivotTableStyleType / PivotTableStyleName angibt.
pivotTable.setAutoFormatType(AsposeCells.PivotTableAutoFormatType.Report5);

// Die Arbeitsmappe im Legacy-.xls-Format speichern
workbook.save("output.xls");

Anwenden einer modernen benannten PivotTable-Voreinstellungs-Formatvorlage

PivotTable.PivotTableStyleType akzeptiert einen Wert aus der Enumeration Aspose.Cells.PivotTableStyleType. Die Enumeration umfasst die hellen Designs PivotTableStyleLight1 bis PivotTableStyleLight28 und die dunklen Designs PivotTableStyleDark1 bis PivotTableStyleDark28. Die in Excel 2017 hinzugefügten Formatvorlagen (die zweite Welle der hellen und dunklen Designs) sind über dieselbe Enumeration erreichbar.

Dies ist die empfohlene API für jedes moderne Dateiformat. Anders als beim Legacy-Autoformat wird die hier ausgewählte Formatvorlage von Excel originalgetreu wiedergegeben und übersteht Roundtrips durch andere Office-Tools.

Das folgende Beispiel verwendet dieselben Fruit/Year/Amount-Daten, erstellt eine identische Pivot-Tabelle, wendet PivotTableStyleDark1 an und speichert die Arbeitsmappe als .xlsx.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);

// Kopfzeile: Frucht / Jahr / Betrag
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// 9 Datenzeilen mit Frucht / Jahr / Betrag
worksheet.getCells().get("A2").putValue("Grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(100);

worksheet.getCells().get("A3").putValue("Blueberry");
worksheet.getCells().get("B3").putValue(2020);
worksheet.getCells().get("C3").putValue(150);

worksheet.getCells().get("A4").putValue("Kiwi");
worksheet.getCells().get("B4").putValue(2020);
worksheet.getCells().get("C4").putValue(200);

worksheet.getCells().get("A5").putValue("Cherry");
worksheet.getCells().get("B5").putValue(2020);
worksheet.getCells().get("C5").putValue(180);

worksheet.getCells().get("A6").putValue("Grape");
worksheet.getCells().get("B6").putValue(2021);
worksheet.getCells().get("C6").putValue(120);

worksheet.getCells().get("A7").putValue("Blueberry");
worksheet.getCells().get("B7").putValue(2021);
worksheet.getCells().get("C7").putValue(170);

worksheet.getCells().get("A8").putValue("Kiwi");
worksheet.getCells().get("B8").putValue(2021);
worksheet.getCells().get("C8").putValue(210);

worksheet.getCells().get("A9").putValue("Cherry");
worksheet.getCells().get("B9").putValue(2021);
worksheet.getCells().get("C9").putValue(190);

worksheet.getCells().get("A10").putValue("Grape");
worksheet.getCells().get("B10").putValue(2021);
worksheet.getCells().get("C10").putValue(130);

// Fügt eine Pivot-Tabelle an E3 mit dem Namen "Pivot1" hinzu, basierend auf A1:C10
let pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Pivot-Felder zuweisen: Frucht -> Zeilenbereich, Jahr -> Spaltenbereich, Betrag -> Datenbereich
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Wendet einen modernen benannten Pivot-Stil für Excel 2007+ an.
// PivotTableStyleType ist die korrekte API für .xlsx- / .xlsm- / .xlsb-Dateien; AutoFormatType
// wird von Excel für diese Formate ignoriert. PivotTableStyleDark1 gehört zur dunklen Theme-Familie
// (PivotTableStyleDark1..PivotTableStyleDark28), und dieselbe Enumeration enthält auch die neueren
// Excel-2017-Themes hell/dunkel (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivotTable.setPivotTableStyleType(AsposeCells.PivotTableStyleType.PivotTableStyleDark1);

// Als modernes .xlsx speichern — dies ist das Format, für das PivotTableStyleType relevant ist.
workbook.save("output.xlsx");

Definieren und Anwenden einer benutzerdefinierten PivotTable-Formatvorlage

Die integrierten Voreinstellungen können nicht geändert werden. Wann immer Sie Farben, Rahmen oder Schriftarten überschreiben müssen, müssen Sie eine benutzerdefinierte Pivot-Formatvorlage definieren. Der Arbeitsablauf umfasst drei Schritte:

Fügen Sie der TableStyles-Sammlung der Arbeitsmappe über Workbook.Worksheets.TableStyles.AddPivotTableStyle(string name) eine benutzerdefinierte Formatvorlage hinzu. Dies gibt den Index der neu erstellten Formatvorlage zurück.
Konfigurieren Sie die Formatvorlage, indem Sie Elemente (wie WholeTable oder GrandTotalRow) über TableStyle.TableStyleElements.Add(TableStyleElementType) hinzufügen, und weisen Sie dann jedem Element über TableStyleElement.SetElementStyle(Style) eine Style zu.
Wenden Sie die benutzerdefinierte Formatvorlage auf die Pivot-Tabelle an, indem Sie PivotTable.PivotTableStyleName auf den Namen der Formatvorlage setzen. Verwenden Sie hier nicht PivotTableStyleType, da diese Eigenschaft integrierte Voreinstellungen auswählt.

PivotTableStyleName und PivotTableStyleType sind nicht austauschbar. Verwenden Sie PivotTableStyleType für integrierte Voreinstellungen und PivotTableStyleName für benutzerdefinierte Formatvorlagen, die Sie über AddPivotTableStyle definiert haben. Beides zu setzen ist harmlos, aber nur die Einstellung, die zur beabsichtigten Quelle passt, wird wiedergegeben.

Die verfügbaren TableStyleElementType-Werte umfassen WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels und PageFieldValues.

Das folgende Beispiel definiert eine benutzerdefinierte Pivot-Formatvorlage mit einem dünnen schwarzen Rahmen auf WholeTable und einer fett formatierten roten Schriftart auf GrandTotalRow, wendet sie dann über PivotTableStyleName an und speichert als .xlsx.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);

// Quelldaten befüllen: Kopfzeile + 9 Datenzeilen (A1:C10)
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

worksheet.getCells().get("A2").putValue("Grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(100);

worksheet.getCells().get("A3").putValue("Blueberry");
worksheet.getCells().get("B3").putValue(2020);
worksheet.getCells().get("C3").putValue(200);

worksheet.getCells().get("A4").putValue("Kiwi");
worksheet.getCells().get("B4").putValue(2020);
worksheet.getCells().get("C4").putValue(300);

worksheet.getCells().get("A5").putValue("Cherry");
worksheet.getCells().get("B5").putValue(2020);
worksheet.getCells().get("C5").putValue(400);

worksheet.getCells().get("A6").putValue("Grape");
worksheet.getCells().get("B6").putValue(2021);
worksheet.getCells().get("C6").putValue(500);

worksheet.getCells().get("A7").putValue("Blueberry");
worksheet.getCells().get("B7").putValue(2021);
worksheet.getCells().get("C7").putValue(600);

worksheet.getCells().get("A8").putValue("Kiwi");
worksheet.getCells().get("B8").putValue(2021);
worksheet.getCells().get("C8").putValue(700);

worksheet.getCells().get("A9").putValue("Cherry");
worksheet.getCells().get("B9").putValue(2021);
worksheet.getCells().get("C9").putValue(800);

worksheet.getCells().get("A10").putValue("Grape");
worksheet.getCells().get("B10").putValue(2021);
worksheet.getCells().get("C10").putValue(900);

// Pivot-Tabelle aus A1:C10 hinzufügen, verankert bei E3, mit dem Namen "Pivot1"
let pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Schritt 1: Neuen benutzerdefinierten Pivot-Tabellenstil registrieren und dessen Index erfassen
let styleIndex = workbook.getWorksheets().getTableStyles().addPivotTableStyle("CustomPivotStyle");
let tableStyle = workbook.getWorksheets().getTableStyles().get(styleIndex);

// Schritt 2: WholeTable-Element hinzufügen und dünne schwarze Rahmen auf allen vier Seiten anwenden
let wholeTableElementIndex = tableStyle.getTableStyleElements().add(AsposeCells.TableStyleElementType.WholeTable);
let wholeTableElement = tableStyle.getTableStyleElements().get(wholeTableElementIndex);
let wholeTableStyle = workbook.createStyle();
wholeTableStyle.getBorders().get(AsposeCells.BorderType.TopBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.TopBorder).setColor(AsposeCells.Color.Black);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.BottomBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.BottomBorder).setColor(AsposeCells.Color.Black);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.LeftBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.LeftBorder).setColor(AsposeCells.Color.Black);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.RightBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.RightBorder).setColor(AsposeCells.Color.Black);
wholeTableElement.setElementStyle(wholeTableStyle);

// Schritt 3: GrandTotalRow-Element hinzufügen und fettgedruckte rote Schrift anwenden
let grandTotalElementIndex = tableStyle.getTableStyleElements().add(AsposeCells.TableStyleElementType.GrandTotalRow);
let grandTotalElement = tableStyle.getTableStyleElements().get(grandTotalElementIndex);
let grandTotalStyle = workbook.createStyle();
grandTotalStyle.getFont().setIsBold(true);
grandTotalStyle.getFont().setColor(AsposeCells.Color.Red);
grandTotalElement.setElementStyle(grandTotalStyle);

// Schritt 4: Benutzerdefinierten Stil über den Namen anwenden (NICHT über PivotTableStyleType, dies ist für eingebaute Voreinstellungen)
pivotTable.setPivotTableStyleName("CustomPivotStyle");

workbook.save("output.xlsx");

Anwenden einer Formatvorlage auf jede Pivot-Zelle mit FormatAll

PivotTable.FormatAll(Style) ist eine Verknüpfung, die ein einzelnes Style-Objekt auf jede Zelle der Pivot-Tabelle anwendet, einschließlich des Datenbereichs, der Zeilen- und Spaltenüberschriften sowie der Summen. Alles, was zuvor über PivotTableStyleType oder PivotTableStyleName festgelegt wurde, wird überschrieben.

FormatAll überschreibt sowohl PivotTableStyleType als auch PivotTableStyleName. Verwenden Sie es nur, wenn ein einheitliches, designunabhängiges Erscheinungsbild über die gesamte Pivot-Tabelle erforderlich ist.

Das folgende Beispiel erstellt eine Style mit gelber Vollfüllung, fett formatierter dunkelblauer Schriftart und dünnen schwarzen Rahmen auf allen Seiten, wendet sie dann mit FormatAll an und speichert als .xlsx.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);

// Quelldaten befüllen: Kopfzeile (Zeile 1) + 9 Datenzeilen (Zeilen 2-10)
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

worksheet.getCells().get("A2").putValue("Grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(5000);

worksheet.getCells().get("A3").putValue("Blueberry");
worksheet.getCells().get("B3").putValue(2020);
worksheet.getCells().get("C3").putValue(3000);

worksheet.getCells().get("A4").putValue("Kiwi");
worksheet.getCells().get("B4").putValue(2020);
worksheet.getCells().get("C4").putValue(4000);

worksheet.getCells().get("A5").putValue("Cherry");
worksheet.getCells().get("B5").putValue(2020);
worksheet.getCells().get("C5").putValue(2000);

worksheet.getCells().get("A6").putValue("Grape");
worksheet.getCells().get("B6").putValue(2021);
worksheet.getCells().get("C6").putValue(6000);

worksheet.getCells().get("A7").putValue("Blueberry");
worksheet.getCells().get("B7").putValue(2021);
worksheet.getCells().get("C7").putValue(3500);

worksheet.getCells().get("A8").putValue("Kiwi");
worksheet.getCells().get("B8").putValue(2021);
worksheet.getCells().get("C8").putValue(4500);

worksheet.getCells().get("A9").putValue("Cherry");
worksheet.getCells().get("B9").putValue(2021);
worksheet.getCells().get("C9").putValue(2500);

worksheet.getCells().get("A10").putValue("Grape");
worksheet.getCells().get("B10").putValue(2021);
worksheet.getCells().get("C10").putValue(5500);

// Pivot-Tabelle hinzufügen: Quellbereich A1:C10, Zielzelle E3, Name "Pivot1"
let pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Pivot-Felder zuweisen: Fruit -> Zeilenbereich, Year -> Spaltenbereich, Amount -> Datenbereich
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Eine Stilvorlage erstellen, die auf jede Zelle der Pivot-Tabelle angewendet wird
let style = workbook.createStyle();
style.setForegroundColor(AsposeCells.Color.Yellow);
style.setPattern(AsposeCells.BackgroundType.Solid);
style.getFont().setIsBold(true);
style.getFont().setColor(AsposeCells.Color.DarkBlue);
style.getBorders().get(AsposeCells.BorderType.TopBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
style.getBorders().get(AsposeCells.BorderType.TopBorder).setColor(AsposeCells.Color.Black);
style.getBorders().get(AsposeCells.BorderType.BottomBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
style.getBorders().get(AsposeCells.BorderType.BottomBorder).setColor(AsposeCells.Color.Black);
style.getBorders().get(AsposeCells.BorderType.LeftBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
style.getBorders().get(AsposeCells.BorderType.LeftBorder).setColor(AsposeCells.Color.Black);
style.getBorders().get(AsposeCells.BorderType.RightBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
style.getBorders().get(AsposeCells.BorderType.RightBorder).setColor(AsposeCells.Color.Black);

// formatAll anwenden: erzwingt diesen einzelnen Stil auf jede Zelle der Pivot-Tabelle,
// und überschreibt alle zuvor gesetzten PivotTableStyleType / PivotTableStyleName
pivotTable.formatAll(style);

// Arbeitsmappe im modernen .xlsx-Format speichern
workbook.save("output.xlsx");

Welche Stil-API sollte ich verwenden?

Die Wahl der Stil-API hängt vom Dateiformat ab, in dem Sie speichern. Verwenden Sie die folgende Tabelle als Kurzreferenz.

Zieldateiformat	Zu verwendende API	Hinweise
`.xls` (Legacy)	`PivotTable.AutoFormatType`	Werte aus `Aspose.Cells.Pivot.PivotTableAutoFormatType` (z. B. `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Wird beim Speichern in modernen Formaten ignoriert.
`.xlsx` / `.xlsm` / `.xlsb` (modern, integrierte Formatvorlage)	`PivotTable.PivotTableStyleType`	Werte aus `Aspose.Cells.PivotTableStyleType` (helle/dunkle Designs, einschließlich der Ergänzungen aus Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (modern, benutzerdefinierte Formatvorlage)	`PivotTable.PivotTableStyleName` + `Worksheets.TableStyles.AddPivotTableStyle(...)`	Verwenden Sie dies, wenn die integrierten Voreinstellungen nicht ausreichen. Konfiguration über `TableStyleElement.SetElementStyle(...)`.
Beliebiges Format (einheitliche Überschreibung)	`PivotTable.FormatAll(Style)`	Verknüpfung, die jede andere Stileinstellung in der gesamten Pivot-Tabelle überschreibt.

Im Zweifelsfall speichern Sie als .xlsx und verwenden PivotTableStyleType für integrierte Designs oder PivotTableStyleName für benutzerdefinierte Designs.

Nodejscpp: Zeilen- und Spaltenfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

Mon, 01 Jan 0001 00:00:00 +0000

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");

worksheet.getCells().get(0, 0).putValue("Category");
worksheet.getCells().get(0, 1).putValue("Item");
worksheet.getCells().get(0, 2).putValue("Year");
worksheet.getCells().get(0, 3).putValue("Amount");

worksheet.getCells().get(1, 0).putValue("Fruit");
worksheet.getCells().get(1, 1).putValue("Apple");
worksheet.getCells().get(1, 2).putValue(2020);
worksheet.getCells().get(1, 3).putValue(100);

worksheet.getCells().get(2, 0).putValue("Fruit");
worksheet.getCells().get(2, 1).putValue("Apple");
worksheet.getCells().get(2, 2).putValue(2021);
worksheet.getCells().get(2, 3).putValue(150);

worksheet.getCells().get(3, 0).putValue("Fruit");
worksheet.getCells().get(3, 1).putValue("Banana");
worksheet.getCells().get(3, 2).putValue(2020);
worksheet.getCells().get(3, 3).putValue(80);

worksheet.getCells().get(4, 0).putValue("Fruit");
worksheet.getCells().get(4, 1).putValue("Banana");
worksheet.getCells().get(4, 2).putValue(2021);
worksheet.getCells().get(4, 3).putValue(90);

worksheet.getCells().get(5, 0).putValue("Vegetable");
worksheet.getCells().get(5, 1).putValue("Carrot");
worksheet.getCells().get(5, 2).putValue(2020);
worksheet.getCells().get(5, 3).putValue(50);

worksheet.getCells().get(6, 0).putValue("Vegetable");
worksheet.getCells().get(6, 1).putValue("Carrot");
worksheet.getCells().get(6, 2).putValue(2021);
worksheet.getCells().get(6, 3).putValue(60);

worksheet.getCells().get(7, 0).putValue("Vegetable");
worksheet.getCells().get(7, 1).putValue("Daikon");
worksheet.getCells().get(7, 2).putValue(2020);
worksheet.getCells().get(7, 3).putValue(40);

worksheet.getCells().get(8, 0).putValue("Vegetable");
worksheet.getCells().get(8, 1).putValue("Daikon");
worksheet.getCells().get(8, 2).putValue(2021);
worksheet.getCells().get(8, 3).putValue(45);

let pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

let categoryField = pivotTable.getRowFields().get(0);
categoryField.setSubtotals(AsposeCells.PivotFieldSubtotalType.Automatic, true);

pivotTable.calculateData();

workbook.save("output_automatic.xlsx");

Szenario 2 — Unterdrücken aller Zwischensummen (None)

Der Aufruf von SetSubtotals(PivotFieldSubtotalType.None, true) entfernt jede Zwischensummenzeile aus der PivotTable und lässt nur die Feldzeilen sowie die Gesamtsumme am Ende übrig. Dies ist nützlich, wenn Sie die rohen gruppierten Daten ohne Zusammenfassungszeilen anzeigen möchten.

const AsposeCells = require("aspose.cells");

const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");

const headers = ["Category", "Item", "Year", "Amount"];
for (let j = 0; j < headers.length; j++) {
    worksheet.getCells().get(0, j).putValue(headers[j]);
}

const data = [
    ["Fruit",     "Apple",  2020, 100],
    ["Fruit",     "Apple",  2021, 150],
    ["Fruit",     "Banana", 2020, 80],
    ["Fruit",     "Banana", 2021, 90],
    ["Vegetable", "Carrot", 2020, 50],
    ["Vegetable", "Carrot", 2021, 60],
    ["Vegetable", "Daikon", 2020, 40],
    ["Vegetable", "Daikon", 2021, 45]
];

for (let i = 0; i < data.length; i++) {
    for (let j = 0; j < data[i].length; j++) {
        worksheet.getCells().get(i + 1, j).putValue(data[i][j]);
    }
}

const pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1");
const pivotTable = worksheet.getPivotTables().get(pivotIndex);

pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

const categoryField = pivotTable.getRowFields().get(0);
categoryField.setSubtotals(AsposeCells.PivotFieldSubtotalType.None, true);
pivotTable.calculateData();

workbook.save("output_none.xlsx");

Szenario 3 — Benutzerdefinierte Zwischensummen-Teilmenge (Sum + Average)

Sie sind nicht auf einen einzelnen Zwischensummentyp beschränkt. Jeder Aufruf von SetSubtotals wirkt unabhängig auf einen Typ. Wenn Sie die Methode zweimal aufrufen — einmal mit Sum und einmal mit Average — erhalten Sie eine benutzerdefinierte Teilmenge von zwei Zwischensummenzeilen für jede Category-Gruppe.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");

worksheet.getCells().get("A1").putValue("Category");
worksheet.getCells().get("B1").putValue("Item");
worksheet.getCells().get("C1").putValue("Year");
worksheet.getCells().get("D1").putValue("Amount");

worksheet.getCells().get(1, 0).putValue("Fruit");
worksheet.getCells().get(1, 1).putValue("Apple");
worksheet.getCells().get(1, 2).putValue(2020);
worksheet.getCells().get(1, 3).putValue(100);

worksheet.getCells().get(2, 0).putValue("Fruit");
worksheet.getCells().get(2, 1).putValue("Apple");
worksheet.getCells().get(2, 2).putValue(2021);
worksheet.getCells().get(2, 3).putValue(150);

worksheet.getCells().get(3, 0).putValue("Fruit");
worksheet.getCells().get(3, 1).putValue("Banana");
worksheet.getCells().get(3, 2).putValue(2020);
worksheet.getCells().get(3, 3).putValue(80);

worksheet.getCells().get(4, 0).putValue("Fruit");
worksheet.getCells().get(4, 1).putValue("Banana");
worksheet.getCells().get(4, 2).putValue(2021);
worksheet.getCells().get(4, 3).putValue(90);

worksheet.getCells().get(5, 0).putValue("Vegetable");
worksheet.getCells().get(5, 1).putValue("Carrot");
worksheet.getCells().get(5, 2).putValue(2020);
worksheet.getCells().get(5, 3).putValue(50);

worksheet.getCells().get(6, 0).putValue("Vegetable");
worksheet.getCells().get(6, 1).putValue("Carrot");
worksheet.getCells().get(6, 2).putValue(2021);
worksheet.getCells().get(6, 3).putValue(60);

worksheet.getCells().get(7, 0).putValue("Vegetable");
worksheet.getCells().get(7, 1).putValue("Daikon");
worksheet.getCells().get(7, 2).putValue(2020);
worksheet.getCells().get(7, 3).putValue(40);

worksheet.getCells().get(8, 0).putValue("Vegetable");
worksheet.getCells().get(8, 1).putValue("Daikon");
worksheet.getCells().get(8, 2).putValue(2021);
worksheet.getCells().get(8, 3).putValue(45);

let pivotTables = worksheet.getPivotTables();
let pivotIndex = pivotTables.add("A1:D9", "F3", "PivotTable1");
let pivotTable = pivotTables.get(pivotIndex);

pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

let categoryField = pivotTable.getRowFields().get(0);
categoryField.setSubtotals(AsposeCells.PivotFieldSubtotalType.Sum, true);
categoryField.setSubtotals(AsposeCells.PivotFieldSubtotalType.Average, true);

pivotTable.calculateData();

workbook.save("output_custom.xlsx");

Zusammenfassung

Die drei oben genannten Szenarien verwenden denselben Datensatz und dieselbe PivotTable-Struktur. Der einzige Unterschied zwischen ihnen ist der Aufruf von SetSubtotals, der auf das äußere Zeilenfeld Category angewendet wird. Denken Sie an die Regel mit den zwei Feldern: Ein einzelnes Feld in einem Bereich hat keine Grundlage für eine Zwischensumme. Platzieren Sie daher immer mindestens zwei Felder im Zeilen- oder Spaltenbereich, wenn Sie möchten, dass SetSubtotals eine sichtbare Wirkung hat.

Nodejscpp: Wertfelder einer PivotTable in Aspose.Cells für .NET verwalten

Mon, 01 Jan 0001 00:00:00 +0000

Hinzufügen eines Felds zum Datenbereich

Das Hinzufügen eines Basisfelds zum Daten-(Wert-)Bereich ist der erste Schritt, um zu gestalten, wie eine PivotTable Ihre Quelldaten aggregiert. Aspose.Cells stellt PivotTable.addFieldToArea(PivotFieldType, string) bereit, eine Überladung, die die Konstante PivotFieldType.Data und den Namen der Quellspalte akzeptiert. Sobald ein Feld zum Datenbereich hinzugefügt wurde, macht die API es über die Sammlung PivotTable.getDataFields() in der Reihenfolge verfügbar, in der die Felder hinzugefügt wurden. Standardmäßig wird eine numerische Quellspalte mit ConsolidationFunction.Sum zusammengefasst, während eine nicht numerische Spalte standardmäßig Count verwendet.

const AsposeCells = require("aspose.cells");

const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");

// Kopfzeilen in A1:D1
worksheet.getCells().get(0, 0).putValue("Category");
worksheet.getCells().get(0, 1).putValue("Item");
worksheet.getCells().get(0, 2).putValue("Year");
worksheet.getCells().get(0, 3).putValue("Amount");

// Datenzeilen A2:D9 mit verschachtelten Schleifen, die nach j verzweigen
for (let i = 1; i <= 8; i++) {
 for (let j = 0; j < 4; j++) {
 switch (j) {
 case 0:
 worksheet.getCells().get(i, j).putValue(i <= 4 ? "Fruit" : "Vegetable");
 break;
 case 1:
 if (i === 1 || i === 2) worksheet.getCells().get(i, j).putValue("Apple");
 else if (i === 3 || i === 4) worksheet.getCells().get(i, j).putValue("Banana");
 else if (i === 5 || i === 6) worksheet.getCells().get(i, j).putValue("Carrot");
 else worksheet.getCells().get(i, j).putValue("Daikon");
 break;
 case 2:
 worksheet.getCells().get(i, j).putValue(2020 + ((i - 1) % 2));
 break;
 case 3:
 if (i === 1) worksheet.getCells().get(i, j).putValue(100);
 else if (i === 2) worksheet.getCells().get(i, j).putValue(150);
 else if (i === 3) worksheet.getCells().get(i, j).putValue(80);
 else if (i === 4) worksheet.getCells().get(i, j).putValue(90);
 else if (i === 5) worksheet.getCells().get(i, j).putValue(50);
 else if (i === 6) worksheet.getCells().get(i, j).putValue(60);
 else if (i === 7) worksheet.getCells().get(i, j).putValue(40);
 else worksheet.getCells().get(i, j).putValue(45);
 break;
 }
 }
}

// Pivot-Tabelle bei F3 mit dem Namen PivotTable1 hinzufügen
const pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1", true, false);
const pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Pivot-Layout: Kategorie und Element in Zeile, Jahr in Spalte, Betrag als Datenfeld
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Data, "Amount");

pivotTable.calculateData();
workbook.save("output_drag.xlsx");

Ändern der Zusammenfassungsfunktion

Jedes im Datenbereich platzierte Feld wird intern als PivotField-Instanz umschlossen, und seine Eigenschaft getFunction() gibt einen Wert aus der Enumeration ConsolidationFunction zurück. Mit demselben Setter setFunction() können Sie zwischen den verfügbaren Aggregaten wechseln, einschließlich Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var und Varp.

Das Ändern der Zusammenfassungsfunktion wirkt sich nur auf das Aggregat aus, die Quellspalte ändert sich nicht.

Sie können daher ein Datenfeld als Sum belassen, während Sie ein zweites Datenfeld hinzufügen, das auf dieselbe Quellspalte abzielt, aber Count oder Average verwendet, alles in einer einzigen PivotTable.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");

worksheet.getCells().get(0, 0).putValue("Category");
worksheet.getCells().get(0, 1).putValue("Item");
worksheet.getCells().get(0, 2).putValue("Year");
worksheet.getCells().get(0, 3).putValue("Amount");

for (let i = 1; i <= 8; i++)
{
 for (let j = 0; j <= 3; j++)
 {
 if (j == 0)
 {
 worksheet.getCells().get(i, j).putValue(i <= 5 ? "Fruit" : "Vegetable");
 }
 else if (j == 1)
 {
 let items = ["Apple", "Apple", "Banana", "Banana", "Carrot", "Carrot", "Daikon", "Daikon"];
 worksheet.getCells().get(i, j).putValue(items[i - 1]);
 }
 else if (j == 2)
 {
 let years = [2020, 2021, 2020, 2021, 2020, 2021, 2020, 2021];
 worksheet.getCells().get(i, j).putValue(years[i - 1]);
 }
 else
 {
 let amounts = [100, 150, 80, 90, 50, 60, 40, 45];
 worksheet.getCells().get(i, j).putValue(amounts[i - 1]);
 }
 }
}

let pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1", true, false);
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");

pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

let countField = pivotTable.getDataFields().get(1);
countField.setFunction(AsposeCells.ConsolidationFunction.Count);

pivotTable.calculateData();

workbook.save("output_function.xlsx");

Wertfelder auf die Zeilen- oder Spaltenachse setzen

Wenn eine PivotTable zwei oder mehr Datenfelder enthält, stellt Aspose.Cells ein zusätzliches virtuelles Feld namens PivotTable.getValuesField bereit. Dieses virtuelle Feld stellt das Aggregat jedes Datenfelds dar, das sich im Datenbereich befindet. Sie können es als Basis-Pivot-Feld in den Zeilen- oder Spaltenbereich ziehen, was nützlich ist, um mehrere Kennzahlen nebeneinander anzuordnen.

PivotTable.getValuesField() funktioniert nicht, wenn kein oder nur ein Wertfeld vorhanden ist.

Die folgenden Szenarien führen durch drei durchgängige Beispiele, die jede der oben beschriebenen Funktionen anhand derselben Pivot-Struktur demonstrieren.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");

worksheet.getCells().get(0, 0).putValue("Category");
worksheet.getCells().get(0, 1).putValue("Item");
worksheet.getCells().get(0, 2).putValue("Year");
worksheet.getCells().get(0, 3).putValue("Amount");

let categories = ["Fruit", "Fruit", "Fruit", "Fruit", "Vegetable", "Vegetable", "Vegetable", "Vegetable"];
let items = ["Apple", "Apple", "Banana", "Banana", "Carrot", "Carrot", "Daikon", "Daikon"];
let years = [2020, 2021, 2020, 2021, 2020, 2021, 2020, 2021];
let amounts = [100, 150, 80, 90, 50, 60, 40, 45];

for (let i = 1; i <= 8; i++)
{
 for (let j = 0; j <= 3; j++)
 {
 if (j == 0) worksheet.getCells().get(i, j).putValue(categories[i - 1]);
 else if (j == 1) worksheet.getCells().get(i, j).putValue(items[i - 1]);
 else if (j == 2) worksheet.getCells().get(i, j).putValue(years[i - 1]);
 else worksheet.getCells().get(i, j).putValue(amounts[i - 1]);
 }
}

let pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1", true, false);
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

pivotTable.getDataFields().get(1).setFunction(AsposeCells.ConsolidationFunction.Count);

pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, pivotTable.getValuesField());

pivotTable.calculateData();
workbook.save("output_plot.xlsx");

Nodejscpp: Filterfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells unterstützt den gesamten Lebenszyklus von Filterfeldern in Pivot-Tabellen. Sie können ein Filterfeld über eine High-Level-Komfort-API oder über die Low-Level-Sammlung PageFields hinzufügen, und sie können den Filter im Einzelauswahlmodus steuern, ihn löschen, um alle Seitenelemente anzuzeigen, oder das Feld auf Mehrfachauswahl umschalten, damit Benutzer mehrere Seitenelemente gleichzeitig über die Kontrollkästchen-Benutzeroberfläche in Excel auswählen können.

Einführung

Ein Filterfeld ist ein Pivot-Feld, das steuert, welche Teilmenge der Quelldaten der Pivot-Körper anzeigt. Endbenutzer sehen es als Dropdown oben in einer gerenderten Pivot-Tabelle in Excel, und die Auswahl eines der verfügbaren Seitenelemente baut den Pivot-Körper neu auf, sodass nur die Datensätze zusammengefasst werden, die zu diesem Seitenelement gehören. Ein Pivot-Feld wird zu einem Filterfeld, wenn es als PivotFieldType.Page registriert wird, anstatt als PivotFieldType.Row, PivotFieldType.Column oder PivotFieldType.Data.

Ein Filterfeld kann in zwei Verhaltensweisen arbeiten. Im Standardverhalten der Einzelauswahl ist immer nur ein Seitenelement sichtbar, sodass der Pivot-Körper genau eine Teilmenge zusammenfasst. Im Verhalten der Mehrfachauswahl zeigt das Feld eine Kontrollkästchenliste, und der Pivot-Körper fasst die Vereinigung aller markierten Seitenelemente zusammen. Dasselbe Quellfeld kann durch Umschalten einer einzigen Eigenschaft zwischen diesen Verhaltensweisen hin und her bewegt werden.

Aspose.Cells for Node.js via C++ bietet zwei gleichwertige Möglichkeiten, ein Filterfeld zu registrieren. Die High-Level-API ist PivotTable.addFieldToArea(PivotFieldType.Page, "fieldName"), die den Namen der Quellspalte übernimmt und das Feld in einem einzigen Aufruf hinzufügt. Die Low-Level-API ist PivotTable.pageFields.add(PivotField), die verwendet wird, wenn Sie bereits eine PivotField-Referenz besitzen und dieselbe Feldinstanz zum Filterbereich hinzufügen möchten. Beide APIs füllen am Ende dieselbe PageFields-Sammlung, und der Rest dieses Artikels zeigt, wie Sie zwischen ihnen wählen und wie Sie jeden Filtermodus steuern.

Hinzufügen eines Filterfelds

Es gibt zwei Möglichkeiten, ein Pivot-Feld im Filterbereich zu registrieren. Der High-Level-Aufruf übernimmt den Namen der Quellspalte als Zeichenfolge und ist der häufigste Weg. Der Low-Level-Aufruf akzeptiert eine vorhandene PivotField-Instanz und ist praktisch, wenn dasselbe Feldobjekt in mehreren Pivot-Bereichen wiederverwendet werden muss. Beide Aufrufe platzieren das Feld in PivotTable.pageFields, wonach es als Seiten-Dropdown oben in der gerenderten Pivot-Tabelle erscheint.

Hinzufügen eines Filterfelds mit addFieldToArea

Das folgende Beispiel erstellt einen kleinen Fruit / Year / Amount-Datensatz, platziert eine Pivot-Tabelle in Zelle E3 mit Fruit im Zeilenbereich, Amount im Datenbereich und Year im Filterbereich, aktualisiert die Pivot-Tabelle und speichert die Arbeitsmappe.

var workbook = new AsposeCells.Workbook();
var worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");

// Kopfzeile einrichten
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// 9 Zeilen Beispieldaten befüllen: Frucht, Jahr, Betrag
var data = [
    [ "apple", 2020, 100 ],
    [ "banana", 2021, 200 ],
    [ "apple", 2021, 150 ],
    [ "grape", 2020, 120 ],
    [ "orange", 2022, 180 ],
    [ "banana", 2020, 90 ],
    [ "grape", 2021, 130 ],
    [ "apple", 2022, 170 ],
    [ "orange", 2021, 110 ]
];

for (var i = 0; i < data.length; i++)
{
    worksheet.getCells().get(i + 1, 0).putValue(data[i][0]);
    worksheet.getCells().get(i + 1, 1).putValue(data[i][1]);
    worksheet.getCells().get(i + 1, 2).putValue(data[i][2]);
}

// Pivot-Tabelle verankert an Zelle E3 hinzufügen
var pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "PivotTable1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Felder ihren Bereichen hinzufügen: Frucht als Zeile, Betrag als Daten, Jahr als Seitenfeld
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");

// Pivot-Tabellen-Daten aktualisieren und berechnen
pivotTable.calculateData();

// Arbeitsmappe speichern
workbook.save("pageFieldSample.xlsx");

Hinzufügen eines Filterfelds mit pageFields.add

Wenn Sie bereits mit einer PivotField-Instanz arbeiten, können Sie diese direkt an PivotTable.pageFields.add übergeben. Die Pivot-Tabelle und das Filterfeld werden genau wie im vorherigen Szenario konstruiert; nur die endgültige Registrierung im Filterbereich wird durch den Low-Level-API-Aufruf ersetzt.

let workbook = new AsposeCells.Workbook();
let sheet = workbook.getWorksheets().get(0);

// Überschriften
sheet.getCells().get("A1").putValue("Fruit");
sheet.getCells().get("B1").putValue("Year");
sheet.getCells().get("C1").putValue("Amount");

// Beispieldaten (9 Zeilen)
sheet.getCells().get("A2").putValue("apple");     sheet.getCells().get("B2").putValue("2020"); sheet.getCells().get("C2").putValue(100);
sheet.getCells().get("A3").putValue("apple");     sheet.getCells().get("B3").putValue("2021"); sheet.getCells().get("C3").putValue(150);
sheet.getCells().get("A4").putValue("apple");     sheet.getCells().get("B4").putValue("2022"); sheet.getCells().get("C4").putValue(200);
sheet.getCells().get("A5").putValue("grape");     sheet.getCells().get("B5").putValue("2020"); sheet.getCells().get("C5").putValue(300);
sheet.getCells().get("A6").putValue("grape");     sheet.getCells().get("B6").putValue("2021"); sheet.getCells().get("C6").putValue(400);
sheet.getCells().get("A7").putValue("grape");     sheet.getCells().get("B7").putValue("2022"); sheet.getCells().get("C7").putValue(500);
sheet.getCells().get("A8").putValue("blueberry"); sheet.getCells().get("B8").putValue("2020"); sheet.getCells().get("C8").putValue(250);
sheet.getCells().get("A9").putValue("blueberry"); sheet.getCells().get("B9").putValue("2021"); sheet.getCells().get("C9").putValue(350);
sheet.getCells().get("A10").putValue("blueberry");sheet.getCells().get("B10").putValue("2022"); sheet.getCells().get("C10").putValue(450);

// Pivot-Tabelle bei E3 hinzufügen, die A1:C10 abdeckt
let pivotIndex = sheet.getPivotTables().add("E3", "A1:C10", "PivotTable1");
let pivotTable = sheet.getPivotTables().get(pivotIndex);

// Frucht -> Zeile, Betrag -> Daten (Jahr wird unten zur Seite hinzugefügt)
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Low-Level-Ansatz: Das vorhandene Jahr-PivotField aus BaseFields holen
// und es über PageFields.Add(PivotField) im Seitenbereich registrieren.
let yearField = pivotTable.getBaseFields().get("Year");
pivotTable.getPageFields().add(yearField);

// Aktualisieren, damit das neue Seitenfeld in der gespeicherten Arbeitsmappe widergespiegelt wird
pivotTable.calculateData();

workbook.save("output.xlsx");

Einzelauswahl-Filterung (Anzeigen eines Seitenelements)

Im Standardverhalten der Einzelauswahl rendert das Filterfeld als einzelnes Dropdown, und die PivotField.currentPageItem-Ganzzahl wählt aus, welches Seitenelement den Pivot-Körper steuert. Durch Zuweisen eines bestimmten Index wird genau dieses Element ausgewählt; durch Zuweisen des speziellen Sentinelwerts 0x7FFD (dezimal 32765) wird der Filter gelöscht, sodass alle Seitenelemente gleichzeitig zusammengefasst werden. Einzelauswahl ist die Standardeinstellung; Sie müssen sie nicht explizit aktivieren.

Anzeigen aller Elemente

Das Setzen von currentPageItem auf den magischen Wert 0x7FFD entspricht dem Löschen des Filters: der Pivot-Körper fasst jedes Seitenelement zusammen, als ob kein Filter angewendet wäre.

let workbook = new AsposeCells.Workbook();
let sheet = workbook.getWorksheets().get(0);

// Fruit/Jahr/Betrag Daten einfügen
sheet.getCells().get("A1").putValue("Fruit");
sheet.getCells().get("B1").putValue("Year");
sheet.getCells().get("C1").putValue("Amount");

let data = [
    ["Apple", 2022, 100],
    ["Apple", 2023, 150],
    ["Banana", 2022, 80],
    ["Banana", 2023, 120],
    ["Cherry", 2022, 200],
    ["Cherry", 2023, 250]
];

for (let r = 0; r < data.length; r++) {
    for (let c = 0; c < data[r].length; c++) {
        sheet.getCells().get(r + 1, c).putValue(data[r][c]);
    }
}

// Pivot-Tabelle bei E3 erstellen
let pivotTables = sheet.getPivotTables();
let index = pivotTables.add("=A1:C7", "E3", "PivotTable1");
let pivotTable = pivotTables.get(index);

// Pivot-Felder konfigurieren: Fruit→Zeile, Amount→Daten, Year→Seite
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");

pivotTable.calculateData();

// Den Seitenfilter zurücksetzen, damit jedes Element im Seitenfeld sichtbar ist.
// 0x7FFD (Dezimal 32765) ist der spezielle Sentinel-Wert, der "alle Elemente" bedeutet —
// entspricht der Auswahl von "(Alle)" im Dropdown-Menü des Seitenfelds in Excel.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD);

workbook.save("output.xlsx");

Anzeigen eines bestimmten Elements

Das Setzen von currentPageItem auf einen tatsächlichen Index wählt genau dieses eine Seitenelement aus. Der Index ist die Position des Elements in der sortierten Elementliste des Filterfelds, sodass beispielsweise 1 das zweite Element nach dem Sortieren auswählt.

var workbook = new AsposeCells.Workbook();
var sheet = workbook.getWorksheets().get(0);
var cells = sheet.getCells();

// Beispieldaten hinzufügen (Frucht/Jahr/Betrag)
cells.get("A1").putValue("Fruit");
cells.get("B1").putValue("Year");
cells.get("C1").putValue("Amount");

cells.get("A2").putValue("Apple");
cells.get("B2").putValue("2020");
cells.get("C2").putValue("100");

cells.get("A3").putValue("Apple");
cells.get("B3").putValue("2021");
cells.get("C3").putValue("150");

cells.get("A4").putValue("Banana");
cells.get("B4").putValue("2020");
cells.get("C4").putValue("200");

cells.get("A5").putValue("Banana");
cells.get("B5").putValue("2021");
cells.get("C5").putValue("250");

// Pivot-Tabelle bei E3 hinzufügen
var pivotTables = sheet.getPivotTables();
var pivotIndex = pivotTables.add("A1:C5", "E3", "PivotTable1");
var pivotTable = pivotTables.get(pivotIndex);

// Felder hinzufügen: Frucht→Zeile, Betrag→Daten, Jahr→Seite
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");

// Seitenfeld-spezifische Operationen
pivotTable.getPageFields().get(0).setCurrentPageItem(1); // 1 = zweites Element in sortierter Reihenfolge (z. B. "2021")

// Pivot-Tabelle aktualisieren und berechnen
pivotTable.calculateData();

workbook.save("output.xlsx");

Mehrfachauswahl-Filterung

Die Mehrfachauswahl-Filterung verwandelt das Seiten-Dropdown in eine Kontrollkästchenliste und ermöglicht es dem Endbenutzer, mehrere Seitenelemente gleichzeitig auszuwählen. Aspose.Cells stellt zwei Eigenschaften bereit, die zusammenarbeiten. PivotField.isMultipleItemSelectionAllowed muss auf true gesetzt werden, bevor die Mehrfachauswahl-Benutzeroberfläche überhaupt wirksam wird. Nach der Aktivierung steuert PivotItem.isHidden, welche Elemente in der Kontrollkästchenliste erscheinen, sodass Sie entweder jedes Element anzeigen oder nur bestimmte Elemente auf eine Whitelist setzen können.

Der folgende Code aktiviert die Mehrfachauswahl für dasselbe Year-Filterfeld, das in Szenario 1a erstellt wurde, und zeigt dann zwei Muster: Teil A deckt jedes Seitenelement auf, indem isHidden für jeden Eintrag auf false belassen wird, während Teil B nur die von Ihnen gewählten Quellwerte auf die Whitelist setzt und alles andere über einen switch (pivotItems[i].getStringValue())-Block ausblendet.

let workbook = new AsposeCells.Workbook();
let sheet = workbook.getWorksheets().get(0);
let cells = sheet.getCells();

// Beispieldaten: Frucht | Jahr | Betrag
cells.get(0, 0).putValue("Fruit");
cells.get(0, 1).putValue("Year");
cells.get(0, 2).putValue("Amount");

let data = [
    ["apple", "2019", "100"],
    ["apple", "2020", "150"],
    ["apple", "2021", "200"],
    ["banana", "2019", "110"],
    ["banana", "2020", "160"],
    ["banana", "2021", "210"],
    ["grape", "2019", "120"],
    ["grape", "2020", "170"],
    ["grape", "2021", "220"]
];

for (let i = 0; i < data.length; i++) {
    cells.get(i + 1, 0).putValue(data[i][0]);
    cells.get(i + 1, 1).putValue(parseInt(data[i][1]));
    cells.get(i + 1, 2).putValue(parseInt(data[i][2]));
}

let pivotSheet = workbook.getWorksheets().add("Pivot");
let pivots = pivotSheet.getPivotTables();
let pivotIndex = pivots.add("E3", "A1:C10", "PivotTable1");
let pivotTable = pivots.get(pivotIndex);

pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");

// — Mehrfachauswahl für das Seitenfeld aktivieren
pivotTable.getPageFields().get(0).setIsMultipleItemSelectionAllowed(true);

// Teil A — ALLE Elemente auswählen (alle Elemente sichtbar machen)
let pivotItems = pivotTable.getPageFields().get(0).getPivotItems();
for (let i = 0; i < pivotItems.getCount(); i++) {
    pivotItems.get(i).setIsHidden(false);
}

// Teil B — nur bestimmte Elemente nach Quellwert auswählen
for (let i = 0; i < pivotItems.getCount(); i++) {
    switch (pivotItems.get(i).getStringValue()) {
        case "2020":
        case "grape":
        case "blueberry":
            pivotItems.get(i).setIsHidden(false);
            break;
        default:
            pivotItems.get(i).setIsHidden(true);
            break;
    }
}

pivotTable.calculateData();

workbook.save("output.xlsx");

Hinweis: Bei Verwendung der Mehrfachauswahl-Filterung über PivotItem.isHidden muss mindestens ein PivotItem sichtbar bleiben (isHidden == false). Wenn jedes Element ausgeblendet ist, stürzt Excel entweder beim Öffnen der Datei ab oder rendert eine leere Pivot-Tabelle. Überprüfen Sie immer, dass Ihre Mehrfachauswahl-Whitelist mindestens ein Element aus Ihren Quelldaten enthält.

Welche API und welchen Modus sollte ich verwenden?

Die folgende Tabelle fasst zusammen, wann Sie jede API und jeden Modus verwenden sollten, damit Sie die richtige Kombination auswählen können, ohne jedes Szenario im Detail lesen zu müssen.

Szenario / Anwendungsfall	Empfohlene API	Verwendete Eigenschaft	Hinweise
Hinzufügen eines Filterfelds nach Quellspaltenname (am häufigsten)	`PivotTable.addFieldToArea(PivotFieldType.Page, "fieldName")`	n/v	High-Level, einzeilig. Verwenden Sie dies, sofern Sie keine `PivotField`-Referenz benötigen.
Hinzufügen eines Filterfelds, wenn Sie bereits ein `PivotField`-Objekt haben	`PivotTable.pageFields.add(PivotField)`	n/v	Verwenden Sie dies, wenn das Feldobjekt anderweitig bezogen wurde oder wiederverwendet werden muss.
Filter auf ein einzelnes Seitenelement (Standardmodus)	`PivotField.currentPageItem`	auf einen bestimmten Index setzen	Beispielsweise zeigt `1` das zweite Element in der sortierten Liste an.
Alle Elemente anzeigen / Filter löschen	`PivotField.currentPageItem`	auf `0x7FFD` setzen	Der magische Wert `0x7FFD` (dezimal 32765) ist der Sentinelwert für „alle Elemente".
Mehrfachauswahl-Benutzeroberfläche in Excel aktivieren	`PivotField.isMultipleItemSelectionAllowed`	auf `true` setzen	Erforderlich, bevor `isHidden`-Aufrufe wirksam werden.
Einzelne Elemente in einer Mehrfachauswahlliste ausblenden / anzeigen	`PivotItem.isHidden`	pro Element setzen	Mindestens ein Element muss sichtbar bleiben (`isHidden == false`).

Denken Sie immer an die Sichtbarkeitseinschränkung, wenn Sie die Mehrfachauswahl-Filterung konfigurieren. Wenn jedes PivotItem in einem Mehrfachauswahl-Filterfeld ausgeblendet ist, stürzt Excel beim Öffnen ab oder rendert eine leere Pivot-Tabelle. Erstellen Sie Ihre Whitelist anhand Ihrer Quelldaten, sodass mindestens ein Element sichtbar bleibt, und Ihre gespeicherten Arbeitsmappen werden auf jedem Computer zuverlässig geöffnet.

Nodejscpp: Pivot Tabelle aus einem Arbeitsblatt löschen

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells for Node.js via C++ bietet eine Funktion zum Löschen oder Entfernen einer Pivot-Tabelle aus einem Arbeitsblatt. Sie können die Pivot-Tabelle entweder mit dem Pivot-Table-Objekt oder anhand ihrer Position löschen. Bitte verwenden Sie die Worksheet.getPivotTables().remove(pivotTable)-Methode, um die Pivot-Tabelle mit dem Pivot-Table-Objekt zu löschen, und die Worksheet.getPivotTables().removeAt(index, keepData)-Methode, um das Pivot-Table-Objekt anhand seiner Position innerhalb der Pivot-Tabellen-Sammlung zu löschen.

Wie man eine Pivot-Tabelle mit Aspose.Cells for Node.js via C++ aus einem Arbeitsblatt löscht

Der folgende Beispielcode löscht zwei Pivot-Tabellen aus dem Arbeitsblatt. Zuerst entfernt er die Pivot-Tabelle unter Verwendung der Worksheet.getPivotTables().remove(pivotTable)-Methode und dann entfernt er die Pivot-Tabelle unter Verwendung der Worksheet.getPivotTables().removeAt(index, keepData)-Methode

Nodejscpp: Pivot Tabelle in ODS Datei speichern

Mon, 01 Jan 0001 00:00:00 +0000

Aspose.Cells for Node.js via C++ bietet die Möglichkeit, Pivot-Tabellen in ODS-Dateien zu speichern. Hierzu konvertieren Sie einfach eine Arbeitsmappe mit vorhandener Pivot-Tabelle oder erstellen eine neue Pivot-Tabelle und speichern die Datei im ODS-Format. Stellen Sie sicher, dass Sie PivotTable.calculateData vor dem Speichern aufrufen, um sicherzustellen, dass die Pivot-Tabelle im Ausgabedokument gerendert wird. Der folgende Codeausschnitt zeigt, wie man eine Pivot-Tabelle in einer ODS-Datei speichert.

Beispielcode

Die Ausgabedatei, die durch den obigen Code generiert wurde, ist als Referenz angehängt.

Ausgabedatei ODS

Documentation – Pivot Tabelle einfügen

Nodejscpp: Formatieren der Pivot Tabelle

Aussehen der Pivot-Tabelle

Wie man die Formatierungsoptionen für Pivot-Tabellen festlegt

Wie man den AutoFormat-Typ festlegt

Wie man Formatierungsoptionen festlegt

Manuelles Anpassen von Aussehen und Anmutung

So setzen Sie Pivot-Feldformatoptionen

So setzen Sie Zeilen-/Spalten-/Seitenfeldformatoptionen

So setzen Sie Datenfeldformatoptionen

So löschen Sie Pivot-Felder

Nodejscpp: Erstellen von Pivot Tabellen und Pivot Diagrammen

Pivot-Tabellen und Diagramme mit Aspose.Cells for Node.js via C++ hinzufügen

Vorbereitung der Verwendung von Aspose.Cells for Node.js via C++

So fügen Sie eine Pivot-Tabelle mit Aspose.Cells for Node.js via C++ hinzu

Wie man ein Pivot-Diagramm mit der Aspose.Cells for Node.js via C++ Bibliothek hinzufügt

Nodejscpp: Pivot Tabelle und Quelldaten

Quelldaten der Pivot-Tabelle

Ändern der Datenquelle einer Pivot-Tabelle

Nodejscpp: Erstellen Sie ein berechnetes Feld im Pivot Table

Mögliche Verwendungsszenarien

Wie man ein berechnetes Feld in einer Pivot-Tabelle in Excel hinzufügt

Wie man ein berechnetes Feld in Pivot-Tabellen mit der Aspose.Cells for Node.js via C++-Bibliothek hinzufügt

Beispielcode

Nodejscpp: Aktualisieren von Pivot-Tabellen in Aspose.Cells for Node.js via C++

Einführung

Erforderliche Importe

Alle Pivot-Tabellen in der Arbeitsmappe aktualisieren

Alle Pivot-Tabellen auf einem einzelnen Arbeitsblatt aktualisieren

Eine einzelne PivotTable aktualisieren

Quelldaten geändert — Verwenden Sie PivotCache.Refresh()

Nur Ansicht/Layout geändert — Verwenden Sie CalculateData()

Alle Pivot-Tabellen abrufen, die denselben PivotCache gemeinsam nutzen

Migration von der veralteten Methode PivotTable.RefreshData()

Welche Aktualisierungs-API sollte ich verwenden?

Nodejscpp: Stile auf PivotTables in Aspose.Cells für .NET anwenden

Einführung

Anwenden eines Legacy-XLS-Voreinstellungs-Autoformats

Anwenden einer modernen benannten PivotTable-Voreinstellungs-Formatvorlage

Definieren und Anwenden einer benutzerdefinierten PivotTable-Formatvorlage

Anwenden einer Formatvorlage auf jede Pivot-Zelle mit FormatAll

Welche Stil-API sollte ich verwenden?

Nodejscpp: Zeilen- und Spaltenfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

Szenario 2 — Unterdrücken aller Zwischensummen (None)

Szenario 3 — Benutzerdefinierte Zwischensummen-Teilmenge (Sum + Average)

Zusammenfassung

Nodejscpp: Wertfelder einer PivotTable in Aspose.Cells für .NET verwalten

Hinzufügen eines Felds zum Datenbereich

Ändern der Zusammenfassungsfunktion

Wertfelder auf die Zeilen- oder Spaltenachse setzen

Nodejscpp: Filterfelder zu einer PivotTable in Aspose.Cells für .NET hinzufügen

Einführung

Hinzufügen eines Filterfelds

Hinzufügen eines Filterfelds mit addFieldToArea

Hinzufügen eines Filterfelds mit pageFields.add

Einzelauswahl-Filterung (Anzeigen eines Seitenelements)

Anzeigen aller Elemente

Anzeigen eines bestimmten Elements

Mehrfachauswahl-Filterung

Welche API und welchen Modus sollte ich verwenden?

Nodejscpp: Pivot Tabelle aus einem Arbeitsblatt löschen

Wie man eine Pivot-Tabelle mit Aspose.Cells for Node.js via C++ aus einem Arbeitsblatt löscht

Nodejscpp: Pivot Tabelle in ODS Datei speichern

Beispielcode

Quelldaten geändert — Verwenden Sie `PivotCache.Refresh()`

Nur Ansicht/Layout geändert — Verwenden Sie `CalculateData()`

Migration von der veralteten Methode `PivotTable.RefreshData()`