Documentation – Pivot-Tabelle einfügen

Nodejsjava: Pivot-Tabellen und Pivot-Caches in Aspose.Cells for Node.js via Java aktualisieren

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

Aspose.Cells stellt eine mehrschichtige Aktualisierungs-API bereit, mit der Sie Pivot-Daten in vier unterschiedlichen Geltungsbereichen neu laden können – von der gesamten Arbeitsmappe bis hin zu einer einzelnen Pivot-Tabelle. Ab Aspose.Cells for Node.js via Java v26.7 ist die ältere 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 Pivot-Tabelle ist selten ein einzelner Vorgang. Im Hintergrund verwaltet Aspose.Cells eine mehrschichtige Datenkette, die Ihre ursprünglichen Quelldaten mit den angezeigten Werten verbindet, die Sie im Arbeitsblatt sehen. Das Verständnis dieser Kette ist der Schlüssel zur Auswahl der richtigen Aktualisierungs-API für jede Situation. Die vierschichtige Datenkette ist:

Datenquelle – die ursprünglichen Arbeitsblattbereiche, Datenbankabfragen oder Konsolidierungsbereiche, in denen die Rohwerte gespeichert sind.
PivotCache – der speicherinterne Schnappschuss der Quelldaten. Jede Pivot-Tabelle wird auf einem PivotCache aufgebaut; hier werden alle Daten gesammelt und aggregiert.
PivotTable – das Ansichtsobjekt, das Zeilen-, Spalten-, Wert- und Filterfelder definiert. Eine PivotTable liest nur aus ihrem PivotCache, niemals direkt aus der Datenquelle.
Cells – die Cells des Arbeitsblatts, in die die PivotTable ihre berechneten Werte und Stile rendert.

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:

PivotTable.CalculateData() – berechnet die Anzeige einer PivotTable aus bereits zwischengespeicherten Daten neu, ohne Roundtrip zur Datenquelle. Alle Szenarien in diesem Artikel verwenden Arbeitsblattzellen als Quelldaten, daher ist der Quelltyp Sheet und die Aktualisierungsvorgänge verhalten sich wie beschrieben.

Schnellstart

Wenn Sie nur den kürzestmöglichen Code benötigen, der jede Pivot-Tabelle in der Arbeitsmappe aktualisiert, reicht ein einziger Aufruf:

const aspose = require('aspose.cells');
const workbook = new aspose.cells.Workbook("input.xlsx");
workbook.refreshAll();
workbook.save("output.xlsx");

Der gesamte Rest dieses Artikels erklärt, wann Sie stattdessen eine enger gefasste API wählen sollten.

Erforderliche Importe

const aspose = require('aspose.cells');
Oder für bestimmte Importe: const { Workbook, Cells, PivotTableSourceType } = require('aspose.cells');

Alle Pivot-Tabellen in der Arbeitsmappe aktualisieren

Wenn Sie sicherstellen müssen, dass jeder Pivot-Cache und jede Pivot-Tabelle in der Arbeitsmappe die aktuellsten 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, dokumentweite Aktualisierungen, bei denen die Leistung keine Rolle spielt. Das folgende Beispiel erstellt eine Arbeitsmappe mit einem Quellbereich Obst/Jahr/Betrag, erstellt eine Pivot-Tabelle, ändert einige Quellwerte und verwendet anschließend RefreshAll(), um alles in einem einzigen Aufruf auf den neuesten Stand zu bringen.

const AsposeCells = require("aspose.cells");
// Eine neue Arbeitsmappe erstellen
const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);
// Kopfzeile in die Zellen A1:C1 schreiben
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");
// Datenzeilen in die Zellen A2:C9 schreiben (8 Zeilen mit Fruchtdaten 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);
// Eine Pivot-Tabelle hinzufügen: Quellbereich "A1:C9", Zielzelle "E3", Name "Pivot1"
const pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
const pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Pivot-Felder zuweisen: 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");
// Mehrere Amount-Werte in den Quelldaten ändern, um Änderungen zu simulieren
worksheet.getCells().get("C2").putValue(55);
worksheet.getCells().get("C5").putValue(85);
worksheet.getCells().get("C9").putValue(125);
// Alle Pivot-Tabellen / Pivot-Caches in der Arbeitsmappe aktualisieren
workbook.refreshAll();
// Die Arbeitsmappe speichern
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 zusammenhängen und nicht angefasst werden sollen. Für diesen Fall bietet Aspose.Cells Worksheet.RefreshPivotTables(), das auf eine einzelne Worksheet-Instanz beschränkt ist.

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 Pivot-Tabelle aktualisieren

Wenn Sie eine fein abgestimmte Kontrolle über eine einzelne Pivot-Tabelle wünschen, bietet Ihnen die cache-basierte API zwei Optionen. Die Wahl zwischen ihnen hängt davon ab, was sich tatsächlich geändert hat: die zugrunde liegenden Quelldaten oder nur die Ansichts- bzw. Layouteinstellungen der Pivot-Tabelle 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 ein und berechnet anschließend jede PivotTable neu, die von diesem Cache abhängt.

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

Wenn sich die Quelldaten nicht geändert haben, sondern nur die Ansichts- oder Layouteinstellungen der Pivot-Tabelle geändert wurden (z. B. ein Feld in einen anderen Bereich verschoben oder eine Beim-Öffnen-aktualisieren-Einstellung umgeschaltet wurde), ist kein Roundtrip zur Datenquelle erforderlich. 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. Das folgende Beispiel ändert eine Nicht-Quell-Eigenschaft der Pivot-Tabelle 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);
// Schreibe die Kopfzeile Fruit / Year / Amount
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");
// Schreibe 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üge eine Pivot-Tabelle mit dem Namen "Pivot1" hinzu, platziert in der Zielzelle E3, mit Quelle A1:C9
var pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Felder zuweisen: Fruit zu Zeile, Year zu Spalte, Amount zu Daten
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Eine Ansichts-/Layout-Eigenschaft ändern – dies ist eine reine Präsentationsä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
// Daten, die bereits im PivotCache gehalten werden. Da sich die Quelldaten nicht geändert haben,
// erfolgt kein Roundtrip zur Quelle – nur die zwischengespeicherten Werte werden neu berechnet
// in die Arbeitsblatt-Zellen.
pivotTable.calculateData();
// Speichere die Arbeitsmappe auf der Festplatte
workbook.save("output.xlsx");

Eine Arbeitsmappe enthält oft viele Pivot-Tabellen, die alle auf einem gemeinsam genutzten Cache basieren. Um sie aufzulisten – beispielsweise vor einer Stapelaktualisierung oder um die Auswirkungen des gemeinsamen Caches zu diagnostizieren – verwenden Sie PivotCache.GetPivotTables(). Diese Methode gibt die Sammlung jeder PivotTable zurück, die vom angegebenen Cache abhängt.

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

Vor Aspose.Cells for Node.js via Java v26.7 war die Standardmethode zum Aktualisieren einer Pivot-Tabelle der Aufruf von PivotTable.RefreshData() für jede Pivot-Tabelle einzeln. 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:

Es ruft die Daten bei jedem Aufruf aus der Quelle erneut ab, selbst wenn sich die Quelle nicht geändert hat. Die empfohlenen Ersatzlösungen sind: Das folgende Beispiel zeigt das neue effiziente Muster für Arbeitsmappen mit mehreren Pivot-Tabellen, die einen einzigen Cache gemeinsam nutzen.

Welche Aktualisierungs-API sollte ich verwenden?

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

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

Häufige Fallstricke

Vergessen, vor dem Speichern zu aktualisieren. Eine Pivot-Tabelle schreibt ihre gerenderten Werte nur dann in das Arbeitsblatt, wenn ihre Datenkette aktualisiert wird. Wenn Sie Quellzellen ändern, rufen Sie PivotCache.Refresh() (oder Workbook.RefreshAll()) vor Workbook.save() auf, sonst enthält die gespeicherte Datei weiterhin die alten aggregierten Werte.
Aufruf der veralteten RefreshData() pro Tabelle. In v26.7 ist PivotTable.RefreshData() als veraltet markiert und ruft bei jedem Aufruf die Quelle erneut ab. Bei mehreren Pivot-Tabellen, die einen Cache gemeinsam nutzen, bedeutet dies N redundante Quellabrufe. Ersetzen Sie dies durch einen einzigen PivotCache.Refresh(), gefolgt von CalculateData() pro Tabelle.
Aktualisierung, wenn nur das Layout geändert wurde. Wenn Sie nur die Ansicht einer Pivot-Tabelle geändert haben (Spaltenreihenfolge, ConsolidationFunction usw.), ohne die Quelldaten zu berühren, ist PivotCache.Refresh() unnötig und langsam. Rufen Sie pivotTable.CalculateData() auf, um aus dem vorhandenen Cache neu zu rendern.
Externe Quelle wird von PivotCache.Refresh() nicht unterstützt. Wenn die Quelle der Pivot-Tabelle aus einer externen Verbindung stammt (Datenbank, OLAP-Cube usw.), kann PivotCache.Refresh() sie in v26.7 nicht aktualisieren – es unterstützt derzeit nur die Quelltypen Sheet und Consolidation. Für externe Quellen öffnen Sie die Arbeitsmappe erneut oder erstellen Sie den Cache aus der Quelle neu.

Nodejsjava: Stile auf Pivot-Tabellen in Aspose.Cells for Node.js via Java anwenden

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

Aspose.Cells unterstützt sowohl das Anwenden von Legacy-Pivot-Autoformaten (für .xls-Dateien vorgesehen) als auch modernen benannten oder benutzerdefinierten Pivot-Tabellenstilen (für .xlsx-, .xlsm- und .xlsb-Dateien vorgesehen). Welche API Sie aufrufen sollten, hängt vom Dateiformat ab, in dem die Arbeitsmappe gespeichert wird, 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, 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 gilt die moderne Stil-API statt der Legacy-API.

PivotTable.pivotTableStyleType wählt einen der integrierten benannten Stile aus (helle und dunkle Designs, einschließlich der in Excel 2017 hinzugefügten Stile). Diese Voreinstellungen sind schreibgeschützt.
PivotTable.pivotTableStyleName wählt einen benutzerdefinierten Stil aus, den Sie selbst über Worksheets.getTableStyles().addPivotTableStyle(...) definieren. Benutzerdefinierte Stile sind erforderlich, wenn Sie Farben, Rahmen oder Schriftarten ändern möchten, die über die Voreinstellungen hinausgehen. 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 Stilnamen-APIs vorgenommenen Einstellungen überschreibt. Dies ist nützlich, wenn ein einheitliches Erscheinungsbild unabhängig vom zugrunde liegenden Design erforderlich ist.

Ein Legacy-XLS-Voreinstellungs-Autoformat anwenden

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

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

let workbook = new AsposeCells.Workbook();
// Das erste Arbeitsblatt abrufen
let sheet = workbook.getWorksheets().get(0);
// Quelldaten mit Kopfzeile (Frucht, Jahr, Betrag) befüllen
// und 9 Datenzeilen mit Traube, Heidelbeere, 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);
// Pivot-Tabelle an Zielzelle E3 hinzufügen, benannt als "Pivot1", unter Verwendung des Quellbereichs A1:C10
let pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = sheet.getPivotTables().get(pivotIndex);
// Felder zuweisen: Frucht -> Zeilen, 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 sinnvoll.
// Beim Speichern als .xlsx/.xlsm/.xlsb ignoriert Excel AutoFormatType
// und verwendet das, was PivotTableStyleType / PivotTableStyleName angibt.
pivotTable.setAutoFormatType(AsposeCells.PivotTableAutoFormatType.REPORT_5);
// Die Arbeitsmappe im Legacy-.xls-Format speichern
workbook.save("output.xls");

Einen modernen benannten Pivot-Tabellenstil als Voreinstellung anwenden

Einen benutzerdefinierten Pivot-Tabellenstil definieren und anwenden

Die integrierten Voreinstellungen können nicht geändert werden. Wann immer Sie Farben, Rahmen oder Schriftarten überschreiben müssen, müssen Sie einen benutzerdefinierten Pivot-Stil definieren. Der Arbeitsablauf besteht aus drei Schritten:

Fügen Sie der TableStyles-Sammlung der Arbeitsmappe über Worksheets.getTableStyles().addPivotTableStyle(String name) einen benutzerdefinierten Stil hinzu. Dies gibt den Index des neu erstellten Stils zurück.
Konfigurieren Sie den Stil, indem Sie Elemente (wie WholeTable oder GrandTotalRow) über TableStyle.tableStyleElements.add(TableStyleElementType) hinzufügen und dann jedem Element über TableStyleElement.setElementStyle(Style) ein Style zuweisen.
Wenden Sie den benutzerdefinierten Stil auf die Pivot-Tabelle an, indem Sie PivotTable.pivotTableStyleName auf den Namen des Stils festlegen. 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 Stile, die Sie über addPivotTableStyle definiert haben. Beides festzulegen ist harmlos, aber nur das für die beabsichtigte Quelle passende wird gerendert.

Die verfügbaren TableStyleElementType-Werte umfassen WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels und PageFieldValues. Das folgende Beispiel definiert einen benutzerdefinierten Pivot-Stil mit einem dünnen schwarzen Rahmen auf WholeTable und einer fetten roten Schriftart auf GrandTotalRow, wendet ihn 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 hinzufügen, bezogen auf A1:C10, verankert bei E3, benannt "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: Einen 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: Ein WholeTable-Element hinzufügen und dünne schwarze Rahmen auf allen vier Seiten anwenden
let wholeTableElementIndex = tableStyle.getTableStyleElements().add(AsposeCells.TableStyleElementType.WHOLE_TABLE);
let wholeTableElement = tableStyle.getTableStyleElements().get(wholeTableElementIndex);
let wholeTableStyle = workbook.createStyle();
let topBorder = wholeTableStyle.getBorders().get(AsposeCells.BorderType.TOP_BORDER);
topBorder.setLineStyle(AsposeCells.CellBorderType.THIN);
topBorder.setColor(AsposeCells.Color.BLACK);
let bottomBorder = wholeTableStyle.getBorders().get(AsposeCells.BorderType.BOTTOM_BORDER);
bottomBorder.setLineStyle(AsposeCells.CellBorderType.THIN);
bottomBorder.setColor(AsposeCells.Color.BLACK);
let leftBorder = wholeTableStyle.getBorders().get(AsposeCells.BorderType.LEFT_BORDER);
leftBorder.setLineStyle(AsposeCells.CellBorderType.THIN);
leftBorder.setColor(AsposeCells.Color.BLACK);
let rightBorder = wholeTableStyle.getBorders().get(AsposeCells.BorderType.RIGHT_BORDER);
rightBorder.setLineStyle(AsposeCells.CellBorderType.THIN);
rightBorder.setColor(AsposeCells.Color.BLACK);
wholeTableElement.setElementStyle(wholeTableStyle);
// Schritt 3: Ein GrandTotalRow-Element hinzufügen und eine fette rote Schriftart anwenden
let grandTotalElementIndex = tableStyle.getTableStyleElements().add(AsposeCells.TableStyleElementType.GRAND_TOTAL_ROW);
let grandTotalElement = tableStyle.getTableStyleElements().get(grandTotalElementIndex);
let grandTotalStyle = workbook.createStyle();
grandTotalStyle.getFont().setBold(true);
grandTotalStyle.getFont().setColor(AsposeCells.Color.RED);
grandTotalElement.setElementStyle(grandTotalStyle);
// Schritt 4: Den benutzerdefinierten Stil namentlich anwenden (NICHT über PivotTableStyleType, der für integrierte Voreinstellungen gedacht ist)
pivotTable.setPivotTableStyleName("CustomPivotStyle");
workbook.save("output.xlsx");

Einen Stil mit FormatAll auf jede Pivot-Zelle anwenden

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 hinweg erforderlich ist.

Das folgende Beispiel erstellt ein Style-Objekt mit gelber Vollfüllung, fetter dunkelblauer Schriftart und dünnen schwarzen Rahmen auf allen Seiten, wendet es 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");
// Einen Stil erstellen, der 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,
// überschreibt jeden zuvor festgelegten 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, integrierter Stil)	`PivotTable.pivotTableStyleType`	Werte aus `Aspose.Cells.PivotTableStyleType` (helle/dunkle Designs, einschließlich der Ergänzungen aus Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (modern, benutzerdefinierter Stil)	`PivotTable.pivotTableStyleName` + `Worksheets.getTableStyles().addPivotTableStyle(...)`	Verwenden, 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 Sie `pivotTableStyleType` für integrierte Designs oder `pivotTableStyleName` für benutzerdefinierte Designs.

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

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

Hinzufügen eines Felds zum Zeilen- oder Spaltenbereich

Die Methode PivotTable.addFieldToArea(PivotFieldType fieldType, String fieldName) verschiebt ein Basisfeld aus den Quelldaten in einen der vier Pivot-Bereiche. Das Argument fieldType akzeptiert einen der folgenden PivotFieldType-Werte.

ROW — Felder, die vertikal auf der linken Seite platziert sind
COLUMN — Felder, die horizontal oben platziert sind
DATA — Felder, deren Werte aggregiert werden
PAGE — Felder, die als Berichtsfilter verwendet werden Nachdem Felder hinzugefügt wurden, können Sie über die Eigenschaften PivotTable.getRowFields() und PivotTable.getColumnFields() darauf zugreifen. Jede Eigenschaft gibt eine PivotFieldCollection zurück. Das Feld am Index 0 von RowFields ist das äußerste Zeilenfeld, und nachfolgende Indizes stehen für darin verschachtelte Felder. Dieselbe Indexierungskonvention gilt für ColumnFields. Die Verschachtelungsreihenfolge der Felder ist wichtig. Wenn zuerst Category zum Zeilenbereich und dann Item hinzugefügt wird, entsteht eine Pivot-Tabelle, deren äußere Gruppierung Category und deren innere Gruppierung Item ist. Durch Umkehren der Reihenfolge wird die Hierarchie umgekehrt.

Zwischensummen von Pivot-Feldern

Die Methode PivotField.setSubtotals(PivotFieldSubtotalType subtotalType, boolean shown) steuert, welche Zwischensummenzeilen für ein Pivot-Feld angezeigt werden. Jeder Aufruf schaltet einen einzelnen Zwischensummentyp unabhängig um. Wenn shown = true übergeben wird, wird die Zwischensumme angezeigt, während shown = false sie ausblendet. Da jeder Aufruf nur einen Typ betrifft, wird durch mehrmaliges Aufrufen der Methode mit unterschiedlichen subtotalType-Werten eine benutzerdefinierte Teilmenge von Zwischensummen erstellt. Die Enum PivotFieldSubtotalType definiert die verfügbaren Zwischensummenarten.

AUTOMATIC — Aspose.Cells wählt die Standardauswahl (typischerweise SUM für numerische Felder)
NONE — unterdrückt jede Zwischensummenzeile
SUM
COUNT
AVERAGE
MAX
MIN
PRODUCT
STD_DEV
STD_DEVP
VAR
VARP

Zwischensummen werden nur gerendert, wenn sich zwei oder mehr Pivot-Felder im Zeilenbereich (oder im Spaltenbereich) befinden. Für ein einzelnes Feld gibt es nichts Sinnvolles, wofür eine Zwischensumme gebildet werden kann. Daher haben setSubtotals-Aufrufe in diesem Fall keine sichtbare Wirkung. Dieser Artikel platziert daher in jedem Beispiel zwei Zeilenfelder (Category außen, Item innen), damit die Zwischensummengrenze zwischen jeder Category-Gruppe sichtbar ist.

Szenario 1 — Automatische (Standard-) Zwischensummen

Wenn Sie setSubtotals überhaupt nicht aufrufen, wendet Aspose.Cells die Auswahl AUTOMATIC auf numerische Felder an. Das folgende Beispiel bestätigt dieses Verhalten explizit, indem setSubtotals(PivotFieldSubtotalType.AUTOMATIC, true) auf dem äußeren Zeilenfeld Category aufgerufen wird.

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 — Alle Zwischensummen unterdrücken (Keine)

Der Aufruf von setSubtotals(PivotFieldSubtotalType.NONE, true) entfernt jede Zwischensummenzeile aus der Pivot-Tabelle und lässt nur die Feldzeilen und das Gesamtergebnis unten übrig. Dies ist nützlich, wenn Sie die rohen gruppierten Daten ohne zusammenfassende Zeilen wünschen.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");
let headers = ["Category", "Item", "Year", "Amount"];
for (let j = 0; j < headers.length; j++)
{
    worksheet.getCells().get(0, j).putValue(headers[j]);
}
let 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]);
    }
}
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.None, true);
pivotTable.calculateData();
workbook.save("output_none.xlsx");

Szenario 3 — Benutzerdefinierte Zwischensummen-Teilmenge (Summe + Durchschnitt)

Sie sind nicht auf einen einzelnen Zwischensummentyp beschränkt. Jeder setSubtotals-Aufruf wirkt unabhängig auf einen Typ. Wenn die Methode daher zweimal aufgerufen wird — einmal mit SUM und einmal mit AVERAGE — wird eine benutzerdefinierte Teilmenge von zwei Zwischensummenzeilen für jede Category-Gruppe erzeugt.

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 Pivot-Tabellenstruktur. Der einzige Unterschied zwischen ihnen ist der setSubtotals-Aufruf, der auf das äußere Zeilenfeld Category angewendet wird. Denken Sie an die Zwei-Felder-Regel: Ein einzelnes Feld in einem Bereich hat keine Möglichkeit zur Zwischensummenbildung dazwischen. Platzieren Sie daher immer mindestens zwei Felder im Zeilen- oder Spaltenbereich, wenn Sie möchten, dass setSubtotals eine sichtbare Wirkung hat. `javascript

Nodejsjava: Wertfelder in Aspose.Cells for Node.js via Java

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

Wertfelder sind das Herzstück jeder Pivot-Tabelle, die numerischen Aggregate, die die Quelldaten zusammenfassen. In Aspose.Cells for Node.js via Java wird der Datenbereich einer Pivot-Tabelle gefüllt, indem Basisfelder über PivotTable.addFieldToArea hinzugefügt werden, und jedes in diesem Bereich platzierte Feld kann eine eigene Zusammenfassungsfunktion haben. Wenn zwei oder mehr Datenfelder vorhanden sind, stellt Aspose.Cells ein spezielles Aggregatfeld, PivotTable.getValuesField(), bereit, das als Basisfeld auf die Zeilen- oder Spaltenachse abgebildet werden kann, wodurch Sie eine feinere Kontrolle darüber erhalten, wie Wertfelder im Layout angezeigt werden.

Hinzufügen eines Felds zum Datenbereich

Das Hinzufügen eines Basisfelds zum Datenbereich (Wertebereich) ist der erste Schritt, um zu gestalten, wie eine Pivot-Tabelle 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, ist es über die Sammlung PivotTable.getDataFields() in der Reihenfolge zugänglich, 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 auf COUNT gesetzt ist.

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", true, false);
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");
pivotTable.calculateData();
workbook.save("output_drag.xlsx");

Ändern der Zusammenfassungsfunktion

Jedes im Datenbereich platzierte Feld wird intern als PivotField-Instanz umschlossen, und die getFunction()-Eigenschaft gibt einen Wert aus der ConsolidationFunction-Enumeration zurück. Derselbe setFunction()-Setter ermöglicht es Ihnen, zwischen den verfügbaren Aggregaten zu wechseln, einschließlich SUM, COUNT, AVERAGE, MAX, MIN, PRODUCT, STD_DEV, STD_DEVP, VAR und VARP.

Das Ändern von Function 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 Pivot-Tabelle.

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", true, false);
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");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.getDataFields().get(1).setFunction(AsposeCells.ConsolidationFunction.Count);
pivotTable.calculateData();
workbook.save("output_function.xlsx");

Wertfelder auf die Zeilen- oder Spaltenachse abbilden

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

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

Die folgenden Szenarien durchlaufen drei durchgängige Beispiele, die jede oben beschriebene Funktion anhand derselben Pivot-Struktur demonstrieren.

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", true, false);
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");
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");

Nodejsjava: 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. Sie können den Filter im Einzel-Auswahl-Modus steuern, ihn löschen, um alle Seitenelemente anzuzeigen, oder das Feld auf Mehrfachauswahl umschalten, sodass Benutzer über die Kontrollkästchen-Benutzeroberfläche in Excel mehrere Seitenelemente gleichzeitig auswählen können.

Einführung

Ein Filterfeld ist ein Pivot-Feld, das steuert, welche Teilmenge der Quelldaten der Pivot-Bereich anzeigt. Endbenutzer sehen es als Dropdown am oberen Rand einer gerenderten Pivot-Tabelle in Excel. Durch die Auswahl eines der verfügbaren Seitenelemente wird der Pivot-Bereich neu aufgebaut, 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 Einzel-Auswahl ist jeweils nur ein Seitenelement sichtbar, sodass der Pivot-Bereich genau eine Teilmenge zusammenfasst. Im Verhalten Mehrfachauswahl zeigt das Feld eine Kontrollkästchenliste, und der Pivot-Bereich fasst die Vereinigung aller markierten Seitenelemente zusammen. Dasselbe Quellfeld kann zwischen diesen Verhaltensweisen hin- und hergeschaltet werden, indem eine einzelne Eigenschaft umgeschaltet wird. Aspose.Cells for Node.js via Java bietet zwei gleichwertige Möglichkeiten, ein Filterfeld zu registrieren. Die High-Level-API ist pivotTable.addFieldToArea(PivotFieldType.Page, "fieldName"), die den Namen der Quellspalte annimmt und das Feld in einem einzigen Aufruf hinzufügt. Die Low-Level-API ist pivotTable.getPageFields().add(PivotField), die verwendet wird, wenn Sie bereits eine PivotField-Referenz haben und dieselbe Feldinstanz dem Filterbereich hinzufügen möchten. Beide APIs füllen am Ende dieselbe PageFields-Sammlung, und der Rest dieses Artikels zeigt, wie Sie zwischen diesen 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 nimmt 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.getPageFields(), woraufhin es als Seiten-Dropdown am oberen Rand der gerenderten Pivot-Tabelle angezeigt wird.

Hinzufügen eines Filterfelds mit addFieldToArea

Das folgende Beispiel erstellt einen kleinen Datensatz mit Fruit, Year und Amount, platziert eine Pivot-Tabelle an 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 mit Beispieldaten befüllen: Frucht, Jahr, Menge
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 hinzufügen, verankert an Zelle E3
var pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "PivotTable1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Felder ihren Bereichen hinzufügen: Frucht als Zeile, Menge 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 getPageFields().add

Wenn Sie bereits mit einer PivotField-Instanz arbeiten, können Sie diese direkt an pivotTable.getPageFields().add übergeben. Die Pivot-Tabelle und das Filterfeld werden genau wie im vorherigen Szenario erstellt; 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);
// Kopfzeilen
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);
// Fruit -> Zeile, Amount -> Daten (Year wird unten zur Seite hinzugefügt)
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Low-Level-Ansatz: das vorhandene Year-PivotField aus BaseFields holen
// und ü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");

Einzel-Auswahl-Filterung (Anzeigen eines Seitenelements)

Im Standardverhalten der Einzel-Auswahl wird das Filterfeld als einzelnes Dropdown gerendert, und der Integer PivotField.CurrentPageItem wählt aus, welches Seitenelement den Pivot-Bereich steuert. Durch Zuweisen eines bestimmten Index wird dieses eine Element ausgewählt; durch Zuweisen des speziellen Sentinel-Werts 0x7FFD (dezimal 32765) wird der Filter gelöscht, sodass alle Seitenelemente gleichzeitig zusammengefasst werden. Einzel-Auswahl 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-Bereich fasst alle Seitenelemente zusammen, als ob kein Filter angewendet wäre.

var workbook = new AsposeCells.Workbook();
var sheet = workbook.getWorksheets().get(0);
// Fülle Obst/Jahr/Betrag Daten
sheet.getCells().get("A1").putValue("Fruit");
sheet.getCells().get("B1").putValue("Year");
sheet.getCells().get("C1").putValue("Amount");
var data = [
    ["Apple", 2022, 100],
    ["Apple", 2023, 150],
    ["Banana", 2022, 80],
    ["Banana", 2023, 120],
    ["Cherry", 2022, 200],
    ["Cherry", 2023, 250]
];
for (var r = 0; r < data.length; r++) {
    for (var c = 0; c < data[r].length; c++) {
        sheet.getCells().get(r + 1, c).putValue(data[r][c]);
    }
}
// Erstelle Pivot-Tabelle bei E3
var pivotTables = sheet.getPivotTables();
var index = pivotTables.add("=A1:C7", "E3", "PivotTable1");
var pivotTable = pivotTables.get(index);
// Konfiguriere Pivot-Felder: Obst→Zeile, Betrag→Daten, Jahr→Seite
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");
pivotTable.calculateData();
// Lösche den Seitenfilter, 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 Excel-Seitenfeld-Dropdown.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD);
workbook.save("output.xlsx");

Anzeigen eines bestimmten Elements

Das Setzen von CurrentPageItem auf einen realen 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 (Obst/Jahr/Betrag)
cells.get("A1").setValue("Fruit");
cells.get("B1").setValue("Year");
cells.get("C1").setValue("Amount");
cells.get("A2").setValue("Apple");
cells.get("B2").setValue("2020");
cells.get("C2").setValue("100");
cells.get("A3").setValue("Apple");
cells.get("B3").setValue("2021");
cells.get("C3").setValue("150");
cells.get("A4").setValue("Banana");
cells.get("B4").setValue("2020");
cells.get("C4").setValue("200");
cells.get("A5").setValue("Banana");
cells.get("B5").setValue("2021");
cells.get("C5").setValue("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: Obst→Zeile, Betrag→Daten, Jahr→Seite
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");
// Seitenfeldspezifische 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 wandelt das Seiten-Dropdown in eine Kontrollkästchenliste um 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 angezeigt werden, sodass Sie entweder jedes Element anzeigen oder nur bestimmte Elemente auf die 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 ausgewählten Quellwerte auf die Whitelist setzt und alles andere über einen switch (pivotItems[i].getStringValue())-Block ausblendet.

const AsposeCells = require("aspose.cells");
// — Die Pivot-Tabelle und das Seitenfeld werden genau wie in
//   Szenario 1a erstellt (Fruit/Year/Amount-Daten, Pivot bei E3, Fruit→Zeile,
//   Amount→Daten, Year→Seite über AddFieldToArea).
//   Unten wenden wir Mehrfachauswahl-Filterung auf das Seitenfeld an.
const workbook = new AsposeCells.Workbook();
const sheet = workbook.getWorksheets().get(0);
const 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");
const 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]));
}
const pivotSheet = workbook.getWorksheets().add("Pivot");
const pivots = pivotSheet.getPivotTables();
const pivotIndex = pivots.add("E3", "A1:C10", "PivotTable1");
const pivotTable = pivots.get(pivotIndex);
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.ROW, "Fruit");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.DATA, "Amount");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.PAGE, "Year");
// — Mehrfachauswahl auf dem Seitenfeld aktivieren
pivotTable.getPageFields().get(0).setMultipleItemSelectionAllowed(true);
// Teil A — ALLE Elemente auswählen (jedes Element sichtbar machen)
const pivotItems = pivotTable.getPageFields().get(0).getPivotItems();
for (let i = 0; i < pivotItems.getCount(); i++) {
    pivotItems.get(i).setHidden(false);
}
// Teil B — nur bestimmte Elemente anhand des Quellwerts auswählen
for (let i = 0; i < pivotItems.getCount(); i++) {
    switch (pivotItems.get(i).getStringValue()) {
        case "2020":
        case "grape":
        case "blueberry":
            pivotItems.get(i).setHidden(false);
            break;
        default:
            pivotItems.get(i).setHidden(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 beim Öffnen der Datei entweder ab oder rendert eine leere Pivot-Tabelle. Stellen Sie immer sicher, dass Ihre Mehrfachauswahl-Whitelist mindestens ein Element aus Ihren Quelldaten enthält.

Welche API und welcher Modus sollten verwendet werden?

Die folgende Tabelle fasst zusammen, wann Sie welche API und welchen 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
Filterfeld anhand des Quellspaltennamens hinzufügen (am häufigsten)	`pivotTable.addFieldToArea(PivotFieldType.Page, "fieldName")`	n/a	High-Level, einzeilig. Verwenden Sie dies, sofern Sie keine `PivotField`-Referenz benötigen.
Filterfeld hinzufügen, wenn Sie bereits ein `PivotField`-Objekt haben	`pivotTable.getPageFields().add(PivotField)`	n/a	Verwenden Sie dies, wenn das Feldobjekt anderswo erhalten wurde oder wiederverwendet werden muss.
Auf ein einzelnes Seitenelement filtern (Standardmodus)	`PivotField.CurrentPageItem`	auf einen bestimmten Index setzen	Beispielsweise zeigt `1` das zweite Element in der sortierten Liste.
Alle Elemente anzeigen / Filter löschen	`PivotField.CurrentPageItem`	auf `0x7FFD` setzen	Der magische Wert `0x7FFD` (dezimal 32765) ist der Sentinel 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 aus- / einblenden	`PivotItem.IsHidden`	pro Element setzen	Mindestens ein Element muss sichtbar bleiben (`IsHidden == false`).

Denken Sie immer an die Sichtbarkeitsbeschrä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.

Documentation – Pivot-Tabelle einfügen

Nodejsjava: Pivot-Tabellen und Pivot-Caches in Aspose.Cells for Node.js via Java aktualisieren

Einführung

Schnellstart

Erforderliche Importe

Alle Pivot-Tabellen in der Arbeitsmappe aktualisieren

Alle Pivot-Tabellen auf einem einzelnen Arbeitsblatt aktualisieren

Eine einzelne Pivot-Tabelle aktualisieren

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

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

Migration von der veralteten Methode PivotTable.RefreshData()

Welche Aktualisierungs-API sollte ich verwenden?

Häufige Fallstricke

Nodejsjava: Stile auf Pivot-Tabellen in Aspose.Cells for Node.js via Java anwenden

Einführung

Ein Legacy-XLS-Voreinstellungs-Autoformat anwenden

Einen modernen benannten Pivot-Tabellenstil als Voreinstellung anwenden

Einen benutzerdefinierten Pivot-Tabellenstil definieren und anwenden

Einen Stil mit FormatAll auf jede Pivot-Zelle anwenden

Welche Stil-API sollte ich verwenden?

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

Hinzufügen eines Felds zum Zeilen- oder Spaltenbereich

Zwischensummen von Pivot-Feldern

Szenario 1 — Automatische (Standard-) Zwischensummen

Szenario 2 — Alle Zwischensummen unterdrücken (Keine)

Szenario 3 — Benutzerdefinierte Zwischensummen-Teilmenge (Summe + Durchschnitt)

Zusammenfassung

Nodejsjava: Wertfelder in Aspose.Cells for Node.js via Java

Hinzufügen eines Felds zum Datenbereich

Ändern der Zusammenfassungsfunktion

Wertfelder auf die Zeilen- oder Spaltenachse abbilden

Nodejsjava: 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 getPageFields().add

Einzel-Auswahl-Filterung (Anzeigen eines Seitenelements)

Anzeigen aller Elemente

Anzeigen eines bestimmten Elements

Mehrfachauswahl-Filterung

Welche API und welcher Modus sollten verwendet werden?

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

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

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