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

Cpp: Filtern von Pivot-Tabellen nach Beschriftung oder Wert

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

Aspose.Cells stellt fünf praktische Strategien zum Filtern der in einer Pivot-Tabelle angezeigten Daten bereit. Sie können Beschriftungsfilter auf textbasierte Zeilen- oder Spaltenfelder anwenden, Datumsfilter verwenden, wenn das Feld ausschließlich Datums-/Uhrzeit-Zellen oder leere Zellen enthält, Wertfilter auf aggregierte Zahlen anwenden, Top-10-Filter zur Rangfolge nach einem Wertfeld einsetzen oder einzelne Pivot-Elemente manuell über die Eigenschaft IsHidden aus- und wieder einblenden. Jede Strategie wird über dedizierte APIs der Klassen PivotField und PivotItem bereitgestellt.

Einführung

Pivot-Tabellen sind leistungsstarke Analysewerkzeuge, doch Rohzusammenfassungen enthalten oft weitaus mehr Informationen, als Sie präsentieren möchten. Das Filtern ist der wichtigste Mechanismus, um eine Pivot-Tabelle auf die Zeilen, Spalten oder Werte einzugrenzen, die für einen bestimmten Bericht relevant sind. Aspose.Cells for C++ spiegelt die in Microsoft Excel verfügbaren Filterfunktionen wider und stellt diese programmatisch bereit, sodass die Berichterstellung vollständig automatisiert werden kann. Die folgenden Filterstrategien werden in diesem Artikel behandelt:

Beschriftungsfilter — filtert Elemente von Zeilen- oder Spaltenfeldern basierend auf deren Textbeschriftungen.
Datumsfilter — filtert Zeilen- oder Spaltenfelder, die ausschließlich Datums-/Uhrzeit-Werte (oder leere Werte) enthalten.
Wertfilter — filtert Elemente basierend auf den aggregierten Werten eines Datenfeldes.
Top-10-Filter — zeigt nur die obersten oder untersten N Elemente an, sortiert nach einem Wertfeld.
Pivot-Elemente ausblenden / einblenden — steuert manuell die Sichtbarkeit jedes einzelnen Elements in einem Feld. Jeder Ansatz verwendet eine andere Methode der Klasse PivotField oder eine Eigenschaft der Klasse PivotItem. Nach Anwendung eines beliebigen Filters müssen Sie RefreshData() und CalculateData() auf der Pivot-Tabelle aufrufen, damit die zwischengespeicherten Daten und berechneten Werte den neuen Filterzustand widerspiegeln.

Beschriftungsfilter

Ein Beschriftungsfilter ermöglicht es Ihnen, die Elemente eines Zeilen- oder Spaltenfeldes zu filtern, indem deren Textbeschriftungen mit einem Muster verglichen werden. Dies ist nützlich, wenn Sie nur Produkte anzeigen möchten, deren Namen mit einem bestimmten Buchstaben beginnen, ein bestimmtes Wort enthalten oder einem anderen beschriftungsbasierten Kriterium entsprechen. Aspose.Cells stellt die Beschriftungsfilterung über die Methode PivotField.FilterByLabel(PivotFilterType, const char16_t*) bereit. Die Enumeration PivotFilterType enthält Werte wie CaptionBeginsWith, CaptionContains, CaptionEndsWith, CaptionDoesNotContain, CaptionIsNotBlank, CaptionIsBlank und weitere. Das zweite Argument liefert die Beschriftungszeichenfolge für den Vergleich. Das folgende Beispiel lädt eine Arbeitsmappe mit einer vorhandenen Pivot-Tabelle, wendet einen Beschriftungsfilter an, sodass nur Elemente sichtbar bleiben, deren Beschriftungen mit einem bestimmten Präfix beginnen, aktualisiert die Pivot-Tabelle und speichert das Ergebnis.

#include "Aspose.Cells.h"

using namespace Aspose::Cells;

int main() {
    Aspose::Cells::Startup();

    U16String fileName(u"sample.xlsx");
    U16String prefix(u"B");

    // Lade die vorhandene Arbeitsmappe, die eine Pivot-Tabelle enthält
    Workbook wb(fileName);

    // Greife über den Index auf das Arbeitsblatt zu (erstes Arbeitsblatt)
    Worksheet ws = wb.GetWorksheets().Get(0);

    // Greife über den Index auf die Pivot-Tabelle zu
    PivotTable pt = ws.GetPivotTables().Get(0);

    // Hole das erste Zeilen-PivotField
    PivotField rowField = pt.GetRowFields().Get(0);

    // Wende den Label-Filter an — zeige nur Zeilenelemente, deren Beschriftungen mit dem angegebenen Präfix beginnen
    rowField.FilterByLabel(PivotFilterType::CaptionBeginsWith, prefix, U16String(u""));

    // Aktualisiere und berechne die Pivot-Tabellendaten neu, damit der Filter wirksam wird
    pt.RefreshData();

    // Speichere die Arbeitsmappe zurück auf die Festplatte
    wb.Save(fileName);

    Aspose::Cells::Cleanup();
    return 0;
}

Datumsfilter

Datumsfilter ermöglichen es Ihnen, eine Pivot-Tabelle nach datumsbasierten Kriterien wie heute, letzte Woche, diesem Monat, nächstes Quartal oder einem bestimmten Datumsbereich einzugrenzen. Es handelt sich um spezielle Filter, die nur für Felder funktionieren, die Datums-/Uhrzeit-Informationen speichern.

Der Datumsfilter funktioniert nur, wenn der Zeilen- oder Spaltenbereich ausschließlich Datums-/Uhrzeit-Zellen oder leere Werte enthält. Wenn das zugrundeliegende Feld andere Datentypen wie Zahlen oder Text enthält, liefert der Datumsfilter nicht das erwartete Ergebnis. Stellen Sie sicher, dass das Feld als Datum formatiert ist und alle Werte gültige DateTime-Instanzen oder leere Zellen sind, bevor Sie diesen Filter anwenden.

Aspose.Cells stellt die Datumsfilterung über die Methode PivotField.FilterByDate(PivotFilterType, const Vector<DateTime>& values) bereit. Die Enumeration PivotFilterType enthält dedizierte Datumswerte wie Today, Yesterday, LastWeek, ThisWeek, NextWeek, LastMonth, ThisMonth, NextMonth, LastQuarter, ThisQuarter, NextQuarter, LastYear, ThisYear, NextYear und Between. Je nach gewähltem Filtertyp übergeben Sie einen oder zwei DateTime-Werte (für Between übergeben Sie das Start- und Enddatum). Das folgende Beispiel lädt eine Arbeitsmappe mit einer Pivot-Tabelle, deren Zeilenbereich ein Datumsfeld enthält, wendet einen Datumsfilter an, der die sichtbaren Elemente auf einen bestimmten Datumsbereich beschränkt, aktualisiert die Pivot-Tabelle und speichert die Arbeitsmappe.

#include "Aspose.Cells.h"
#include <string>
#include <filesystem>

using namespace Aspose::Cells;
using namespace Aspose::Cells::Pivot;

int main() {
    Aspose::Cells::Startup();

    std::string inputPath = "sample.xlsx";
    std::string outputPath = "output_filtered.xlsx";

    if (!std::filesystem::exists(inputPath))
    {
        // Quellarbeitsmappe nicht gefunden.
        Aspose::Cells::Cleanup();
        return -1;
    }

    // Die vorhandene Arbeitsmappe laden, die die Pivot-Tabelle enthält
    Workbook workbook(U16String(inputPath.c_str()));

    // Auf das Arbeitsblatt zugreifen, das die Pivot-Tabelle enthält (über den Index)
    Worksheet worksheet = workbook.GetWorksheets().Get(0);

    // Auf die Pivot-Tabelle über den Index zugreifen
    PivotTable pivotTable = worksheet.GetPivotTables().Get(0);

    // Das Datums-PivotField aus dem Zeilenbereich abrufen
    PivotField dateField = pivotTable.GetRowFields().Get(0);

    // Das Datumskriterium für den Zwischen-Filter definieren
    Date startDate{2020, 1, 1, 0, 0, 0, 0};
    Date endDate{2020, 12, 31, 0, 0, 0, 0};

    // Den Datumsfilter auf das Pivot-Feld anwenden
    dateField.FilterByDate(PivotFilterType::DateBetween, startDate, endDate);

    // Die Pivot-Tabelle aktualisieren und neu berechnen, damit der Filter wirksam wird
    // Die Arbeitsmappe speichern
    workbook.Save(U16String(outputPath.c_str()));

    Aspose::Cells::Cleanup();
    return 0;
}

Wertfilter

Wertfilter arbeiten mit den aggregierten Werten, die eine Pivot-Tabelle in ihrem Datenbereich berechnet. Anstatt Textbeschriftungen abzugleichen, vergleichen sie numerische Gesamtsummen mit einem Schwellenwert. Typische Anwendungsfälle sind das Anzeigen nur der Produkte, deren Umsatzsumme einen Zielwert übersteigt, oder nur der Regionen, deren Transaktionsanzahl innerhalb eines Bereichs liegt. Aspose.Cells stellt die Wertfilterung über die Methode PivotField.FilterByValue(PivotField valueField, PivotFilterType filterType, const Vector<Variant>& values) bereit. Der Parameter filterType verwendet Werte wie ValueGreaterThan, ValueLessThan, ValueBetween, ValueEqual, ValueNotEqual, ValueGreaterThanOrEqual und ValueLessThanOrEqual. Der Parameter valueField gibt an, welches Datenfeld ausgewertet werden soll, und das letzte Argument (bzw. die letzten Argumente) liefert die Schwellenwerte. Das folgende Beispiel lädt eine Arbeitsmappe mit einer Pivot-Tabelle, wendet einen Wertfilter an, der nur Elemente beibehält, deren aggregierter Umsatz einen numerischen Schwellenwert überschreitet, aktualisiert die Pivot-Tabelle und speichert die Arbeitsmappe.

#include "Aspose.Cells.h"
#include <cfloat>

using namespace Aspose::Cells;

int main() {
    Aspose::Cells::Startup();

    Workbook wb(u"sample.xlsx");
    Worksheet worksheet = wb.GetWorksheets().Get(0);
    PivotTable pivotTable = worksheet.GetPivotTables().Get(0);

    PivotField rowField = pivotTable.GetRowFields().Get(0);
    PivotField dataField = pivotTable.GetDataFields().Get(0);

    int dataFieldIndex = -1;
    int dataFieldCount = pivotTable.GetDataFields().GetCount();
    for (int i = 0; i < dataFieldCount; i++)
    {
        PivotField current = pivotTable.GetDataFields().Get(i);
        if (current.GetName() == dataField.GetName())
        {
            dataFieldIndex = i;
            break;
        }
    }

    if (dataFieldIndex >= 0)
    {
        rowField.FilterByValue(dataFieldIndex, PivotFilterType::ValueGreaterThan, 5000, DBL_MAX);
    }

    wb.Save(u"output.xlsx");

    Aspose::Cells::Cleanup();
    return 0;
}

Top-10-Filter

Der Top-10-Filter ist eine spezielle Form des Wertfilters, der nur die höchsten oder niedrigsten N Elemente basierend auf einem ausgewählten Wertfeld beibehält. Er wird häufig für Rangberichte wie „Top 10 Produkte nach Umsatz" oder „Untere 5 Regionen nach Verkaufsanzahl" verwendet.

Der Top-10-Filter ist nur wirksam, wenn die Pivot-Tabelle über ein oder mehrere Wertfelder im Datenbereich verfügt. Ohne mindestens ein Wertfeld gibt es keine aggregierte Messgröße, gegen die die Elemente eingestuft werden können, und der Filter kann nicht angewendet werden.

Aspose.Cells stellt die Top-10-Filterung über die Methode PivotField.FilterTop10(int32_t itemCount, bool isTop, PivotField valueField, PivotFilterType filterType) bereit. Der Parameter itemCount legt fest, wie viele Elemente beibehalten werden, isTop gibt an, ob die obersten Elemente (true) oder die untersten Elemente (false) beibehalten werden sollen, valueField verweist auf das für die Rangfolge verwendete Datenfeld, und filterType steuert, wie der Wert berechnet wird (in der Regel Sum, aber auch Count und Percent). Das folgende Beispiel lädt eine Arbeitsmappe mit einer Pivot-Tabelle, die ein Wertfeld enthält, wendet einen Top-10-Filter an, um nur die obersten 10 Elemente nach der Umsatzsumme beizubehalten, aktualisiert die Pivot-Tabelle und speichert die Arbeitsmappe.

#include "Aspose.Cells.h"
#include <stdexcept>

using namespace Aspose::Cells;
using namespace Aspose::Cells::Pivot;

int main() {
    Aspose::Cells::Startup();

    U16String inputPath(u"input.xlsx");
    U16String outputPath(u"output.xlsx");

    Workbook workbook(inputPath);

    Worksheet worksheet = workbook.GetWorksheets().Get(0);
    PivotTable pivotTable = worksheet.GetPivotTables().Get(0);

    if (pivotTable.GetDataFields().GetCount() == 0) {
        throw std::runtime_error("Pivot table has no value (data) PivotField.");
    }

    PivotField valueField = pivotTable.GetDataFields().Get(0);
    PivotField rowField = pivotTable.GetRowFields().Get(0);

    int valueFieldIndex = 0;

    rowField.FilterTop10(10, PivotFilterType::Sum, true, valueFieldIndex);

    workbook.Save(outputPath);

    Aspose::Cells::Cleanup();
    return 0;
}

Filtern durch Aus- oder Einblenden von Pivot-Elementen

Zusätzlich zu den strukturierten Filter-APIs ermöglicht Aspose.Cells die direkte Steuerung der Sichtbarkeit jedes einzelnen Pivot-Elements. Durch Iteration über die PivotItems-Sammlung eines PivotField und Umschalten der Eigenschaft IsHidden können Sie bestimmte Elemente selektiv unterdrücken, ohne einen formelbasierten Filter anzuwenden. Das Setzen von IsHidden = true blendet das Element aus der Pivot-Tabelle aus; das Setzen von IsHidden = false blendet es wieder ein und macht es erneut sichtbar. Dieser Ansatz ist nützlich, wenn die Filterregel unregelmäßig oder elementspezifisch ist, etwa um eine kleine Anzahl benannter Kategorien auszublenden, die in einem bestimmten Bericht nicht erscheinen sollen. Das folgende Beispiel lädt eine Pivot-Tabelle, blendet ein bestimmtes Element nach Namen aus, zeigt, wie es wieder eingeblendet wird, aktualisiert die Pivot-Tabelle und speichert die Arbeitsmappe.

#include "Aspose.Cells.h"
#include <string>

using namespace Aspose::Cells;

int main() {
    Aspose::Cells::Startup();

    // Lade eine vorhandene Arbeitsmappe, die eine Pivot-Tabelle enthält
    Workbook workbook(u"pivot_table_sample.xlsx");

    // Greife auf das erste Arbeitsblatt zu, das die Pivot-Tabelle enthält
    Worksheet sheet = workbook.GetWorksheets().Get(0);

    // Greife über den Index auf die Pivot-Tabelle zu (die erste Pivot-Tabelle auf dem Blatt)
    PivotTable pivotTable = sheet.GetPivotTables().Get(0);

    // Rufe das Ziel-PivotField ab (das erste Zeilenbeschriftungsfeld, in dem wir Elemente ausblenden/einblenden werden)
    PivotField pivotField = pivotTable.GetRowFields().Get(0);

    // Durchlaufe die PivotItems-Sammlung des ausgewählten PivotField
    int itemCount = pivotField.GetPivotItems().GetCount();
    for (int i = 0; i < itemCount; i++)
    {
        PivotItem item = pivotField.GetPivotItems().Get(i);

        U16String name = item.GetName();
        std::string nameStr = name.ToUtf8();

        // Blende Pivot-Elemente aus, die einem bestimmten Namen/Kriterium entsprechen
        if (nameStr == "Item1" || nameStr == "Item2")
        {
            item.SetIsHidden(true);
        }

        // Demonstriere das Einblenden: zeige ein zuvor ausgeblendetes Pivot-Element erneut an
        if (nameStr == "Item3")
        {
            item.SetIsHidden(false);
        }
    }

    // Aktualisiere und berechne die Pivot-Tabelle neu, damit die Änderungen wirksam werden
    pivotTable.CalculateData();

    // Speichere die Arbeitsmappe – ausgeblendete Elemente bleiben in den zugrunde liegenden Daten erhalten,
    // werden jedoch aus der angezeigten Pivot-Tabellen-Ausgabe ausgeschlossen
    workbook.Save(u"output_pivot_filtered.xlsx");

    Aspose::Cells::Cleanup();
    return 0;
}

Zusammenfassung

Aspose.Cells for C++ stellt einen vollständigen Satz an Filterfunktionen für Pivot-Tabellen bereit, die denen in Microsoft Excel entsprechen. Beschriftungs-, Datums- und Wertfilter decken die häufigsten Analyseszenarien ab, während der Top-10-Filter Rangberichte abdeckt. Wenn die Filterregel unregelmäßig ist, bietet die Eigenschaft PivotItem.IsHidden eine flexible, elementbezogene Ausweichmöglichkeit. Die Kombination dieser Strategien — beispielsweise das Anwenden eines Beschriftungsfilters und anschließendes Ausblenden bestimmter Elemente — ermöglicht es Ihnen, vollständig aus dem Code heraus präzise zugeschnittene Pivot-Tabellenberichte zu erstellen.

Cpp: Absolute Position des Pivot Elements mit C++ angeben

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

Manchmal müssen Benutzer die absolute Position der Pivot-Elemente angeben. Die Aspose.Cells API hat einige neue Eigenschaften und eine Methode bereitgestellt, um diese Anforderung zu erfüllen.

Hinzugefügte PivotItem.GetPosition() Eigenschaft, die verwendet werden kann, um den Position-Index in allen Pivot-Elementen unabhängig vom übergeordneten Knoten anzugeben. Hinzugefügte PivotItem.GetPositionInSameParentNode() Eigenschaft, die verwendet werden kann, um den Position-Index in den Pivot-Elementen unter dem gleichen übergeordneten Knoten anzugeben.
Die Methode PivotItem.Move(int count, bool isSameParent) wurde hinzugefügt, um das Element basierend auf dem Zählwert nach oben oder unten zu verschieben, wobei der Zählwert die Anzahl der Positionen ist, um die das Pivot-Element nach oben oder unten verschoben werden soll. Wenn der Zählwert kleiner als null ist, wird das Element nach oben verschoben, während bei einem Zählwert größer als null das Pivot-Element nach unten verschoben wird. Der Boolesche Parameter isSameParent gibt an, ob die Verschiebung im selben Elternknoten erfolgen soll.
Der veraltete PivotItem.Move(int count)-Methode; es wird empfohlen, stattdessen die neu hinzugefügte Methode PivotItem.Move(int count, bool isSameParent) zu verwenden.

Der folgende Beispielcode erstellt eine Pivot-Tabelle und gibt dann die Positionen der Pivot-Elemente im selben Elternknoten an. Sie können die Quelldatei Excel und die Ausgabedatei Excel herunterladen. Wenn Sie die Ausgabedatei öffnen, sehen Sie, dass das Pivot-Element “4H12” an Position 0 im Elternknoten “K11” ist und “DIF400” an Position 3. Ebenso befindet sich CA32 an Position 1 und AAA3 an Position 2.

#include <iostream>
#include "Aspose.Cells.h"
using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    // Source directory path
    U16String srcDir(u"..\\Data\\01_SourceDirectory\\");

    // Output directory path
    U16String outDir(u"..\\Data\\02_OutputDirectory\\");

    // Create workbook
    Workbook wb(srcDir + u"source.xlsx");

    // Add new worksheet for pivot table
    WorksheetCollection worksheets = wb.GetWorksheets();
    Worksheet wsPivot = worksheets.Add(u"pvtNew Hardware");
    Worksheet wsData = worksheets.Get(u"New Hardware - Yearly");

    // Get the pivot tables collection for the pivot sheet
    PivotTableCollection pivotTables = wsPivot.GetPivotTables();

    // Add PivotTable to the worksheet
    int index = pivotTables.Add(u"='New Hardware - Yearly'!A1:D621", u"A3", u"HWCounts_PivotTable");

    // Get the PivotTable object
    PivotTable pvtTable = pivotTables.Get(index);

    // Add vendor row field
    pvtTable.AddFieldToArea(PivotFieldType::Row, u"Vendor");

    // Add item row field
    pvtTable.AddFieldToArea(PivotFieldType::Row, u"Item");

    // Add data field
    pvtTable.AddFieldToArea(PivotFieldType::Data, u"2014");

    // Turn off the subtotals for the vendor row field
    PivotField pivotField = pvtTable.GetRowFields().Get(u"Vendor");
    pivotField.SetSubtotals(PivotFieldSubtotalType::None, true);

    // Turn off grand total
    pvtTable.SetShowColumnGrandTotals(false);

    // Refresh and calculate data before modifying pivot items
    pvtTable.CalculateData();

    // Set positions for specific pivot items
    pvtTable.GetRowFields().Get(u"Item").GetPivotItems().Get(u"4H12").SetPositionInSameParentNode(0);
    pvtTable.GetRowFields().Get(u"Item").GetPivotItems().Get(u"DIF400").SetPositionInSameParentNode(3);

    // Recalculate data after modifying pivot items
    pvtTable.CalculateData();

    // Set positions for additional pivot items
    pvtTable.GetRowFields().Get(u"Item").GetPivotItems().Get(u"CA32").SetPositionInSameParentNode(1);
    pvtTable.GetRowFields().Get(u"Item").GetPivotItems().Get(u"AAA3").SetPositionInSameParentNode(2);

    // Save the workbook
    wb.Save(outDir + u"output_out.xlsx");

    Aspose::Cells::Cleanup();
}

Bitte beachten Sie, dass es erforderlich ist, die Methoden PivotTable.RefreshData und PivotTable.CalculateData aufzurufen, bevor Sie die Eigenschaften PivotItem.GetPosition(), PivotItem.GetPositionInSameParentNode() und die Methode PivotItem.Move(int count, bool isSameParent) verwenden.

Cpp: Erhalten des Cell Objekts anhand des DisplayName des PivotField im PivotTable mit C++

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

Aspose.Cells bietet die PivotTable::GetCellByDisplayName()-Methode, mit der Sie auf das Cell-Objekt anhand des Anzeigenamens eines Pivot-Felds zugreifen können. Diese Methode ist nützlich, wenn Sie die Überschrift Ihres Pivot-Felds hervorheben oder formatieren möchten. Dieser Artikel erklärt, wie man das Cell-Objekt anhand des Anzeigenamens eines Datenfelds abruft und anschließend formatiert.

Erhalten des Cell-Objekts anhand des DisplayName des PivotField im PivotTable

Der folgende Code greift auf die erste Pivot-Tabelle des Arbeitsblatts zu und ruft dann die Zelle anhand des DisplayName des zweiten Datenfelds der Pivot-Tabelle ab. Anschließend ändert er die Füllfarbe und die Schriftfarbe der Zelle auf Hellblau bzw. Schwarz. Nachstehend sind Screenshots, die zeigen, wie die Pivot-Tabelle vor und nach der Ausführung des Codes aussieht.

Pivot-Tabelle - Vorher

#include <iostream>
#include "Aspose.Cells.h"
using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    U16String srcDir(u"..\\Data\\01_SourceDirectory\\");
    U16String outDir(u"..\\Data\\02_OutputDirectory\\");

    Workbook workbook(srcDir + u"source.xlsx");
    Worksheet worksheet = workbook.GetWorksheets().Get(0);
    PivotTable pivotTable = worksheet.GetPivotTables().Get(0);

    Cell cell = pivotTable.GetCellByDisplayName(pivotTable.GetDataFields().Get(0).GetDisplayName());

    Style style = cell.GetStyle();
    style.SetForegroundColor(Color::LightBlue());
    style.GetFont().SetColor(Color::Black());

    pivotTable.Format(cell.GetRow(), cell.GetColumn(), style);
    workbook.Save(outDir + u"output_out.xlsx");

    std::cout << "Pivot table formatted successfully!" << std::endl;

    Aspose::Cells::Cleanup();
}

Pivot-Tabelle - Nachher

Cpp: Gruppierung von Pivot Feldern in der PivotTable mit C++

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

Mögliche Verwendungsszenarien

Microsoft Excel ermöglicht es Ihnen, Pivot-Felder der Pivot-Tabelle zu gruppieren. Wenn eine große Menge von Daten mit einem Pivot-Feld verbunden ist, ist es oft nützlich, sie in Abschnitte zu gruppieren. Aspose.Cells bietet diese Funktion auch mit der Methode PivotTable.GroupBy().

Gruppieren von Pivot-Feldern in der Pivot-Tabelle

Der folgende Beispielcode lädt die Beispieldatei Excel und führt eine Gruppierung des ersten Pivot-Felds mit der Methode PivotTable.GroupBy() durch. Anschließend aktualisiert und berechnet er die Daten der Pivot-Tabelle und speichert die Arbeitsmappe als Ausgabedatei Excel. Der Screenshot zeigt die Auswirkung des Beispielcodes auf die Beispieldatei Excel. Wie im Screenshot zu sehen ist, ist das erste Pivot-Feld nun nach Monaten und Quartalen gruppiert.

Beispielcode

#include <iostream>
#include "Aspose.Cells.h"
using namespace Aspose::Cells;

int main()
{
	Aspose::Cells::Startup();

	U16String srcDir(u"../Data/01_SourceDirectory/");
	U16String outDir(u"../Data/02_OutputDirectory/");

	Workbook wb(srcDir + u"sampleGroupPivotFieldsInPivotTable.xlsx");

	Worksheet ws = wb.GetWorksheets().Get(1);

	PivotTable pt = ws.GetPivotTables().Get(0);

	Date dtStart{ 2023, 12, 31, 0, 0, 0, 0 };
	Date dtEnd{ 2025, 9, 5 , 0, 0, 0, 0 };

	Vector<PivotGroupByType> groupTypeList{
		 PivotGroupByType::Months,
		 PivotGroupByType::Quarters
	};

	PivotField field = pt.GetRowFields().Get(0);
	field.GroupBy(dtStart, dtEnd, groupTypeList, 1, true);

	pt.RefreshData();
	pt.CalculateData();

	wb.Save(outDir + u"outputGroupPivotFieldsInPivotTable2.xlsx");

	std::cout << "Pivot field grouped successfully." << std::endl;

	Aspose::Cells::Cleanup();
	return 0;
}

Cpp: Pivot Tabelle verbergen und Daten sortieren mit C++

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

Pivot-Tabelle verbergen und Daten sortieren

Aspose.Cells unterstützt das Ausblenden und Sortieren von Daten in der Pivot-Tabelle. Der folgende Codeausschnitt demonstriert diese Funktion, indem die Spalte Score absteigend sortiert und dann die Zeilen mit einem Wert von weniger als 60 ausgeblendet werden.

#include <iostream>
#include "Aspose.Cells.h"

using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    // Source and output directories
    U16String srcDir(u"..\\Data\\01_SourceDirectory\\");
    U16String outDir(u"..\\Data\\02_OutputDirectory\\");

    // Load the workbook
    Workbook workbook(srcDir + u"PivotTableHideAndSortSample.xlsx");

    // Get the first worksheet
    Worksheet worksheet = workbook.GetWorksheets().Get(0);

    // Get the first pivot table
    PivotTable pivotTable = worksheet.GetPivotTables().Get(0);
    CellArea dataBodyRange = pivotTable.GetDataBodyRange();
    int currentRow = 3;
    int rowsUsed = dataBodyRange.EndRow;

    // Sorting score in descending order
    PivotField field = pivotTable.GetRowFields().Get(0);
    field.SetIsAutoSort(true);
    field.SetIsAscendSort(false);
    field.SetAutoSortField(0);

    pivotTable.CalculateData();

    // Hiding rows with score less than 60
    while (currentRow < rowsUsed)
    {
        Cell cell = worksheet.GetCells().Get(currentRow, 1);
        double score = cell.GetDoubleValue();
        if (score < 60)
        {
            worksheet.GetCells().HideRow(currentRow);
        }
        currentRow++;
    }

    pivotTable.CalculateData();

    // Save the Excel file
    workbook.Save(outDir + u"PivotTableHideAndSort_out.xlsx");

    std::cout << "Pivot table hide and sort completed successfully." << std::endl;

    Aspose::Cells::Cleanup();
}

Die in dem Codeausschnitt verwendeten Quell- und Ausgabedateien im Excel-Format sind zur Referenz beigefügt.

Quelldatei

Ausgabedatei

Cpp: Benutzerdefinierte Sortierung in Pivot Tabelle mit C++

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

Benutzerdefiniertes Sortieren in der Pivot-Tabelle

Mit der Aspose.Cells-API können Sie Pivot-Tabellen nach Feldwerten sortieren. Das folgende Codebeispiel lädt die Beispiel-Excel-Datei und fügt drei Pivot-Tabellen hinzu. Die erste Pivot-Tabelle ist ohne benutzerdefinierte Sortierung, die zweite sortiert nach den Zeilenfeldern “SeaFood”, und die dritte nach den Spaltenfeldern “28/07/2000”.

Die Beispieldatei und die Ausgabedateien können von hier heruntergeladen werden, um den Beispielcode zu testen:

Quelldatei Excel

Ausgabedatei Excel

Ausgabedatei PDF

#include <iostream>
#include "Aspose.Cells.h"
using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    // Source directory
    U16String srcDir(u"..\\Data\\01_SourceDirectory\\");
    U16String outDir(u"..\\Data\\02_OutputDirectory\\");

    // Load the workbook
    Workbook wb(srcDir + u"SamplePivotSort.xlsx");

    // Get the first worksheet
    Worksheet sheet = wb.GetWorksheets().Get(0);

    // Get the pivot tables collection
    PivotTableCollection pivotTables = sheet.GetPivotTables();

    // Source PivotTable
    // Add a PivotTable to the worksheet
    int index = pivotTables.Add(u"=Sheet1!A1:C10", u"E3", u"PivotTable2");

    // Access the instance of the newly added PivotTable
    PivotTable pivotTable = pivotTables.Get(index);

    // Unshow grand totals for rows and columns
    pivotTable.SetShowRowGrandTotals(false);
    pivotTable.SetShowColumnGrandTotals(false);

    // Drag the first field to the row area
    pivotTable.AddFieldToArea(PivotFieldType::Row, 1);
    PivotField rowField = pivotTable.GetRowFields().Get(0);
    rowField.SetIsAutoSort(true);
    rowField.SetIsAscendSort(true);

    // Drag the second field to the column area
    pivotTable.AddFieldToArea(PivotFieldType::Column, 0);
    PivotField colField = pivotTable.GetColumnFields().Get(0);
    colField.SetNumberFormat(u"dd/mm/yyyy");
    colField.SetIsAutoSort(true);
    colField.SetIsAscendSort(true);

    // Drag the third field to the data area
    pivotTable.AddFieldToArea(PivotFieldType::Data, 2);

    pivotTable.CalculateData();
    // End of source PivotTable

    // Sort the PivotTable on "SeaFood" row field values
    // Add a PivotTable to the worksheet
    index = pivotTables.Add(u"=Sheet1!A1:C10", u"E10", u"PivotTable2");

    // Access the instance of the newly added PivotTable
    pivotTable = pivotTables.Get(index);

    // Unshow grand totals for rows and columns
    pivotTable.SetShowRowGrandTotals(false);
    pivotTable.SetShowColumnGrandTotals(false);

    // Drag the first field to the row area
    pivotTable.AddFieldToArea(PivotFieldType::Row, 1);
    rowField = pivotTable.GetRowFields().Get(0);
    rowField.SetIsAutoSort(true);
    rowField.SetIsAscendSort(true);

    // Drag the second field to the column area
    pivotTable.AddFieldToArea(PivotFieldType::Column, 0);
    colField = pivotTable.GetColumnFields().Get(0);
    colField.SetNumberFormat(u"dd/mm/yyyy");
    colField.SetIsAutoSort(true);
    colField.SetIsAscendSort(true);
    colField.SetAutoSortField(0);

    // Drag the third field to the data area
    pivotTable.AddFieldToArea(PivotFieldType::Data, 2);

    pivotTable.CalculateData();
    // End of sort the PivotTable on "SeaFood" row field values

    // Sort the PivotTable on "28/07/2000" column field values
    // Add a PivotTable to the worksheet
    index = pivotTables.Add(u"=Sheet1!A1:C10", u"E18", u"PivotTable2");

    // Access the instance of the newly added PivotTable
    pivotTable = pivotTables.Get(index);

    // Unshow grand totals for rows and columns
    pivotTable.SetShowRowGrandTotals(false);
    pivotTable.SetShowColumnGrandTotals(false);

    // Drag the first field to the row area
    pivotTable.AddFieldToArea(PivotFieldType::Row, 1);
    rowField = pivotTable.GetRowFields().Get(0);
    rowField.SetIsAutoSort(true);
    rowField.SetIsAscendSort(true);
    rowField.SetAutoSortField(0);

    // Drag the second field to the column area
    pivotTable.AddFieldToArea(PivotFieldType::Column, 0);
    colField = pivotTable.GetColumnFields().Get(0);
    colField.SetNumberFormat(u"dd/mm/yyyy");
    colField.SetIsAutoSort(true);
    colField.SetIsAscendSort(true);

    // Drag the third field to the data area
    pivotTable.AddFieldToArea(PivotFieldType::Data, 2);

    pivotTable.CalculateData();
    // End of sort the PivotTable on "28/07/2000" column field values

    // Save the Excel file
    wb.Save(outDir + u"out_java.xlsx");

    // Save as PDF
    PdfSaveOptions options;
    options.SetOnePagePerSheet(true);
    wb.Save(outDir + u"out_java.pdf", options);

    Aspose::Cells::Cleanup();
}

Cpp: Pivot Filter mit C++

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

Mögliche Verwendungsszenarien

Wenn Sie eine Pivot-Tabelle mit bekannten Daten erstellen und filtern möchten, lernen und verwenden Sie den Filter. Er kann Ihnen helfen, die gewünschten Daten effizient herauszufiltern. Mit der API von Aspose.Cells können Sie Filter auf Felder in Pivot-Tabellen hinzufügen und löschen.

Filter in Pivot-Tabelle in Excel hinzufügen

Filter in Pivot-Tabelle in Excel hinzufügen, folgen Sie diesen Schritten:

Wählen Sie die Pivot-Tabelle aus, aus der Sie den Filter löschen möchten.
Klicken Sie auf den Dropdown-Pfeil für den Filter, den Sie in der Pivot-Tabelle hinzufügen möchten.
Wählen Sie “Top 10” aus dem Dropdown-Menü.
Legen Sie den Anzeigemodus und die Filteranzahl fest.

Filter in Pivot-Tabelle hinzufügen

Bitte sehen Sie sich den folgenden Beispielcode an. Es legt die Daten fest und erstellt darauf basierend eine Pivot-Tabelle. Fügen Sie dann einen Filter im Zeilenfeld der Pivot-Tabelle hinzu. Schließlich speichert es die Arbeitsmappe im Format output XLSX. Nach Ausführung des Beispielcodes wird eine Pivot-Tabelle mit einem Top-10-Filter zum Arbeitsblatt hinzugefügt.

Beispielcode

#include <iostream>
#include "Aspose.Cells.h"
using namespace Aspose::Cells;

int main()
{
    Aspose::Cells::Startup();

    // Create a new workbook
    Workbook workbook;

    // Get the first worksheet
    Worksheet ws = workbook.GetWorksheets().Get(0);
    Cells cells = ws.GetCells();

    // Set values to cells
    Cell cell = cells.Get(u"A1");
    cell.PutValue(u"Fruit");
    cell = cells.Get(u"B1");
    cell.PutValue(u"Count");

    cell = cells.Get(u"A2");
    cell.PutValue(u"Apple");
    cell = cells.Get(u"A3");
    cell.PutValue(u"Mango");
    cell = cells.Get(u"A4");
    cell.PutValue(u"Blackberry");
    cell = cells.Get(u"A5");
    cell.PutValue(u"Cherry");
    cell = cells.Get(u"A6");
    cell.PutValue(u"Guava");
    cell = cells.Get(u"A7");
    cell.PutValue(u"Carambola");
    cell = cells.Get(u"A8");
    cell.PutValue(u"Banana");
    cell = cells.Get(u"B2");
    cell.PutValue(5);
    cell = cells.Get(u"B3");
    cell.PutValue(3);
    cell = cells.Get(u"B4");
    cell.PutValue(6);
    cell = cells.Get(u"B5");
    cell.PutValue(4);
    cell = cells.Get(u"B6");
    cell.PutValue(5);
    cell = cells.Get(u"B7");
    cell.PutValue(2);
    cell = cells.Get(u"B8");
    cell.PutValue(20);

    // Add a PivotTable to the worksheet
    int32_t i = ws.GetPivotTables().Add(u"=A1:B8", u"D10", u"PivotTable1");

    // Access the instance of the newly added PivotTable
    PivotTable pivotTable = ws.GetPivotTables().Get(i);
    pivotTable.AddFieldToArea(PivotFieldType::Row, 0);

    pivotTable.AddFieldToArea(PivotFieldType::Data, u"Count");
    pivotTable.GetDataFields().Get(0).SetFunction(ConsolidationFunction::Sum);

    PivotField field = pivotTable.GetRowFields().Get(0);
    field.SetIsAutoSort(true);
    field.SetIsAscendSort(false);
    field.SetAutoSortField(0);

    // Add top10 filter
    PivotField filterField = pivotTable.GetRowFields().Get(0);
    filterField.FilterTop10(0, PivotFilterType::Count, false, 5);

    pivotTable.CalculateData();

    // Save the workbook
    workbook.Save(u"filterout.xlsx");

    Aspose::Cells::Cleanup();
    return 0;
}

Filter in Pivot-Tabelle in Excel löschen

Filter in Pivot-Tabelle in Excel löschen, befolgen Sie diese Schritte:

Wählen Sie die Pivot-Tabelle aus, aus der Sie den Filter löschen möchten.
Klicken Sie auf den Dropdown-Pfeil für den Filter, den Sie in der Pivot-Tabelle löschen möchten.
Wählen Sie “Filter löschen” aus dem Dropdown-Menü aus.
Wenn Sie alle Filter aus der Pivot-Tabelle löschen möchten, können Sie auch auf die Schaltfläche “Filter löschen” im PivotTable-Analyse-Tab im Menüband in Excel klicken.

Filter in Pivot-Tabelle löschen

Filter in Pivot-Tabelle löschen mit Aspose.Cells. Bitte beachten Sie den folgenden Beispielcode.

Daten setzen und eine Pivot-Tabelle basierend darauf erstellen.
Einen Filter auf das Zeilenfeld der Pivot-Tabelle hinzufügen.
Die Arbeitsmappe im Format output XLSX speichern. Nach Ausführung des Beispielcodes wird eine Pivot-Tabelle mit einem Top10-Filter zum Arbeitsblatt hinzugefügt.
Den Filter auf einem bestimmten Pivot-Feld löschen. Nach Ausführung des Codes zum Löschen des Filters wird der Filter auf dem spezifischen Pivot-Feld gelöscht. Bitte prüfen Sie das output XLSX.

Beispielcode

#include <iostream>
#include "Aspose.Cells.h"
using namespace Aspose::Cells;

int main() {
    Aspose::Cells::Startup();

    // Create a new workbook
    Workbook workbook;

    // Get the first worksheet
    Worksheet ws = workbook.GetWorksheets().Get(0);
    Cells cells = ws.GetCells();

    // Set values to cells
    Cell cell = cells.Get(u"A1");
    cell.PutValue(u"Fruit");
    cell = cells.Get(u"B1");
    cell.PutValue(u"Count");

    cell = cells.Get(u"A2");
    cell.PutValue(u"Apple");
    cell = cells.Get(u"A3");
    cell.PutValue(u"Mango");
    cell = cells.Get(u"A4");
    cell.PutValue(u"Blackberry");
    cell = cells.Get(u"A5");
    cell.PutValue(u"Cherry");
    cell = cells.Get(u"A6");
    cell.PutValue(u"Guava");
    cell = cells.Get(u"A7");
    cell.PutValue(u"Carambola");
    cell = cells.Get(u"A8");
    cell.PutValue(u"Banana");
    cell = cells.Get(u"B2");
    cell.PutValue(5);
    cell = cells.Get(u"B3");
    cell.PutValue(3);
    cell = cells.Get(u"B4");
    cell.PutValue(6);
    cell = cells.Get(u"B5");
    cell.PutValue(4);
    cell = cells.Get(u"B6");
    cell.PutValue(5);
    cell = cells.Get(u"B7");
    cell.PutValue(2);
    cell = cells.Get(u"B8");
    cell.PutValue(20);

    // Add a PivotTable to the worksheet
    int i = ws.GetPivotTables().Add(u"=A1:B8", u"D10", u"PivotTable1");

    // Access the instance of the newly added PivotTable
    PivotTable pivotTable = ws.GetPivotTables().Get(i);
    pivotTable.AddFieldToArea(PivotFieldType::Row, 0);

    pivotTable.AddFieldToArea(PivotFieldType::Data, u"Count");
    pivotTable.GetDataFields().Get(0).SetFunction(ConsolidationFunction::Sum);

    PivotField field = pivotTable.GetRowFields().Get(0);
    field.SetIsAutoSort(true);
    field.SetIsAscendSort(false);
    field.SetAutoSortField(0);

    // Add top10 filter
    PivotField filterField = pivotTable.GetRowFields().Get(0);
    filterField.FilterTop10(0, PivotFilterType::Count, false, 5);

    pivotTable.CalculateData();

    workbook.Save(u"out_add.xlsx");

    // Clear PivotFilter from the specific PivotField
    pivotTable.GetPivotFilters().ClearFilter(field.GetBaseIndex());
    pivotTable.CalculateData();

    workbook.Save(u"out_delete.xlsx");

    Aspose::Cells::Cleanup();
    return 0;
}