Documentation – Agregar campos de fila y columna a una tabla dinámica en Aspose.Cells para .NET

Cpp: Filtrar tablas dinámicas por etiqueta o valor

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

Aspose.Cells ofrece cinco estrategias prácticas para filtrar los datos mostrados en una tabla dinámica. Puede aplicar filtros de etiqueta a campos de fila o columna basados en texto, usar filtros de fecha cuando el campo solo contenga celdas de tipo fecha-hora o esté en blanco, aplicar filtros de valor frente a números agregados, usar filtros de los 10 mejores para clasificar por un campo de valor, u ocultar y mostrar manualmente elementos dinámicos individuales mediante la propiedad IsHidden. Cada estrategia se expone a través de API dedicadas en las clases PivotField y PivotItem.

Introducción

Las tablas dinámicas son herramientas analíticas potentes, pero los resúmenes sin procesar a menudo contienen mucha más información de la que necesita presentar. El filtrado es el mecanismo principal para reducir una tabla dinámica a las filas, columnas o valores que importan para un informe específico. Aspose.Cells for C++ replica las capacidades de filtrado disponibles en Microsoft Excel, exponiéndolas de forma programática para que la generación de informes pueda automatizarse por completo.

Las siguientes estrategias de filtrado se tratan en este artículo:

Filtro de etiqueta — filtra los elementos de un campo de fila o columna según sus etiquetas de texto.
Filtro de fecha — filtra campos de fila o columna que solo contienen valores de fecha-hora (o están en blanco).
Filtro de valor — filtra los elementos según los valores agregados de un campo de datos.
Filtro de los 10 mejores — muestra solo los N elementos superiores o inferiores clasificados por un campo de valor.
Ocultar/Mostrar elementos dinámicos — controla manualmente la visibilidad de cada elemento individual en un campo.

Cada enfoque utiliza un método diferente de la clase PivotField o una propiedad de la clase PivotItem. Después de aplicar cualquier filtro, debe llamar a RefreshData() y CalculateData() en la tabla dinámica para que los datos en caché y los valores calculados reflejen el nuevo estado del filtro.

Filtro de etiqueta

Un filtro de etiqueta le permite filtrar los elementos de un campo de fila o columna comparando sus etiquetas de texto con un patrón. Esto resulta útil cuando desea mostrar solo productos cuyos nombres comiencen con una letra específica, contengan una palabra concreta o coincidan con cualquier otro criterio basado en la etiqueta.

Aspose.Cells expone el filtrado por etiqueta a través del método PivotField.FilterByLabel(PivotFilterType, const char16_t*). La enumeración PivotFilterType incluye valores como CaptionBeginsWith, CaptionContains, CaptionEndsWith, CaptionDoesNotContain, CaptionIsNotBlank, CaptionIsBlank, entre otros. El segundo argumento proporciona la cadena de etiqueta utilizada para la comparación.

El siguiente ejemplo carga un libro de trabajo que contiene una tabla dinámica existente, aplica un filtro de etiqueta para que solo permanezcan visibles los elementos cuyas etiquetas comiencen con un prefijo especificado, actualiza la tabla dinámica y guarda el resultado.

#include "Aspose.Cells.h"

using namespace Aspose::Cells;

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

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

    // Cargar el libro existente que contiene una tabla dinámica
    Workbook wb(fileName);

    // Acceder a la hoja de cálculo por índice (primera hoja)
    Worksheet ws = wb.GetWorksheets().Get(0);

    // Acceder a la tabla dinámica por índice
    PivotTable pt = ws.GetPivotTables().Get(0);

    // Obtener el primer PivotField de fila
    PivotField rowField = pt.GetRowFields().Get(0);

    // Aplicar el filtro de etiqueta — mostrar solo los elementos de fila cuyas etiquetas comiencen con el prefijo proporcionado
    rowField.FilterByLabel(PivotFilterType::CaptionBeginsWith, prefix, U16String(u""));

    // Actualizar y recalcular los datos de la tabla dinámica para que el filtro surta efecto
    pt.RefreshData();

    // Guardar el libro de nuevo en el disco
    wb.Save(fileName);

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

Filtro de fecha

Los filtros de fecha le permiten reducir una tabla dinámica mediante criterios basados en fechas, como hoy, la semana pasada, este mes, el próximo trimestre o un rango de fechas específico. Son filtros especializados que solo funcionan con campos que almacenan información de fecha-hora.

El filtro de fecha solo funciona cuando el área de fila o columna contiene únicamente celdas de tipo fecha-hora o valores en blanco. Si el campo subyacente contiene otros tipos de datos como números o texto, el filtro de fecha no producirá el resultado esperado. Asegúrese de que el campo esté formateado como una fecha y de que todos los valores sean instancias válidas de DateTime o celdas vacías antes de aplicar este filtro.

Aspose.Cells expone el filtrado por fecha a través del método PivotField.FilterByDate(PivotFilterType, const Vector<DateTime>& values). La enumeración PivotFilterType contiene valores de fecha dedicados como Today, Yesterday, LastWeek, ThisWeek, NextWeek, LastMonth, ThisMonth, NextMonth, LastQuarter, ThisQuarter, NextQuarter, LastYear, ThisYear, NextYear y Between. Dependiendo del tipo de filtro elegido, debe pasar uno o dos valores DateTime (para Between, debe pasar las fechas de inicio y fin).

El siguiente ejemplo carga un libro de trabajo con una tabla dinámica cuyo área de filas contiene un campo de fecha, aplica un filtro de fecha que restringe los elementos visibles a un rango de fechas particular, actualiza la tabla dinámica y guarda el libro de trabajo.

#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))
    {
        // Libro de trabajo fuente no encontrado.
        Aspose::Cells::Cleanup();
        return -1;
    }

    // Cargar el libro de trabajo existente que contiene la tabla dinámica
    Workbook workbook(U16String(inputPath.c_str()));

    // Acceder a la hoja de trabajo que contiene la tabla dinámica (por índice)
    Worksheet worksheet = workbook.GetWorksheets().Get(0);

    // Acceder a la tabla dinámica por índice
    PivotTable pivotTable = worksheet.GetPivotTables().Get(0);

    // Obtener el PivotField de fecha del área de filas
    PivotField dateField = pivotTable.GetRowFields().Get(0);

    // Definir el criterio de fecha para el filtro Entre
    Date startDate{2020, 1, 1, 0, 0, 0, 0};
    Date endDate{2020, 12, 31, 0, 0, 0, 0};

    // Aplicar el filtro de fecha en el campo dinámico
    dateField.FilterByDate(PivotFilterType::DateBetween, startDate, endDate);

    // Actualizar y recalcular la tabla dinámica para que el filtro surta efecto
    // Guardar el libro de trabajo
    workbook.Save(U16String(outputPath.c_str()));

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

Filtro de valor

Los filtros de valor operan sobre los valores agregados que una tabla dinámica calcula en su área de datos. En lugar de hacer coincidir etiquetas de texto, comparan totales numéricos con un umbral. Los casos de uso típicos incluyen mostrar solo productos cuya suma de ventas supere una cantidad objetivo o solo regiones cuyo número de transacciones se encuentre dentro de un rango.

Aspose.Cells expone el filtrado por valor a través del método PivotField.FilterByValue(PivotField valueField, PivotFilterType filterType, const Vector<Variant>& values). El parámetro filterType utiliza valores como ValueGreaterThan, ValueLessThan, ValueBetween, ValueEqual, ValueNotEqual, ValueGreaterThanOrEqual y ValueLessThanOrEqual. El parámetro valueField especifica qué campo de datos se debe evaluar, y el/los último(s) argumento(s) proporciona(n) el/los valor(es) umbral.

El siguiente ejemplo carga un libro de trabajo con una tabla dinámica, aplica un filtro de valor que conserva solo los elementos cuyas ventas agregadas superan un umbral numérico, actualiza la tabla dinámica y guarda el libro de trabajo.

#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;
}

Filtro de los 10 mejores

El filtro de los 10 mejores es una forma especializada de filtro de valor que conserva solo los N elementos más altos o más bajos según un campo de valor elegido. Se usa comúnmente para informes de clasificación como “los 10 productos principales por ingresos” o “las 5 regiones inferiores por número de ventas”.

El filtro de los 10 mejores solo es efectivo cuando la tabla dinámica tiene uno o más campos de valor en el área de datos. Sin al menos un campo de valor, no hay ninguna medida agregada con la que clasificar los elementos, y el filtro no se puede aplicar.

Aspose.Cells expone el filtrado de los 10 mejores a través del método PivotField.FilterTop10(int32_t itemCount, bool isTop, PivotField valueField, PivotFilterType filterType). El parámetro itemCount define cuántos elementos se deben conservar, isTop indica si se conservan los elementos superiores (true) o los inferiores (false), valueField hace referencia al campo de datos utilizado para la clasificación, y filterType controla cómo se calcula el valor (normalmente Sum, pero también Count y Percent).

El siguiente ejemplo carga un libro de trabajo con una tabla dinámica que contiene un campo de valor, aplica un filtro de los 10 mejores para conservar solo los 10 elementos más altos según la suma de ventas, actualiza la tabla dinámica y guarda el libro de trabajo.

#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;
}

Filtrar ocultando o mostrando elementos dinámicos

Además de las API de filtrado estructurado, Aspose.Cells le permite controlar directamente la visibilidad de cada elemento dinámico individual. Iterando a través de la colección PivotItems de un PivotField y alternando la propiedad IsHidden, puede suprimir selectivamente elementos específicos sin aplicar un filtro basado en fórmulas. Establecer IsHidden = true oculta el elemento de la tabla dinámica; establecer IsHidden = false lo muestra y vuelve a hacerlo visible.

Este enfoque resulta útil cuando la regla de filtrado es irregular o específica del elemento, como ocultar un pequeño número de categorías con nombre que no deben aparecer en un informe concreto. El siguiente ejemplo carga una tabla dinámica, oculta un elemento específico por nombre, muestra cómo volver a mostrarlo, actualiza la tabla dinámica y guarda el libro de trabajo.

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

using namespace Aspose::Cells;

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

    // Cargar un libro existente que contiene una tabla dinámica
    Workbook workbook(u"pivot_table_sample.xlsx");

    // Acceder a la primera hoja de cálculo que contiene la tabla dinámica
    Worksheet sheet = workbook.GetWorksheets().Get(0);

    // Acceder a la tabla dinámica por índice (la primera tabla dinámica de la hoja)
    PivotTable pivotTable = sheet.GetPivotTables().Get(0);

    // Obtener el PivotField objetivo (el primer campo de etiqueta de fila en el que ocultaremos/mostraremos elementos)
    PivotField pivotField = pivotTable.GetRowFields().Get(0);

    // Iterar a través de la colección PivotItems del PivotField seleccionado
    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();

        // Ocultar elementos de la tabla dinámica que coincidan con un nombre/criterio específico
        if (nameStr == "Item1" || nameStr == "Item2")
        {
            item.SetIsHidden(true);
        }

        // Demostrar cómo mostrar: volver a mostrar un elemento de tabla dinámica previamente oculto
        if (nameStr == "Item3")
        {
            item.SetIsHidden(false);
        }
    }

    // Refrescar y recalcular la tabla dinámica para que los cambios surtan efecto
    pivotTable.CalculateData();

    // Guardar el libro: los elementos ocultos permanecen en los datos subyacentes
    // pero se excluyen de la salida mostrada de la tabla dinámica
    workbook.Save(u"output_pivot_filtered.xlsx");

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

Resumen

Aspose.Cells for C++ proporciona un conjunto completo de capacidades de filtrado de tablas dinámicas que coinciden con las que se encuentran en Microsoft Excel. Los filtros de etiqueta, fecha y valor cubren los escenarios analíticos más comunes, mientras que el filtro de los 10 mejores gestiona los informes de clasificación. Cuando la regla de filtrado es irregular, la propiedad PivotItem.IsHidden ofrece una alternativa flexible a nivel de elemento. Combinar estas estrategias —por ejemplo, aplicar un filtro de etiqueta y luego ocultar elementos específicos— le permite generar informes de tablas dinámicas dirigidos con precisión enteramente desde código.

Cpp: Especificando la posición absoluta del ítem de pivote con C++

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

A veces, los usuarios necesitan especificar la posición absoluta de los ítems de pivote. La API de Aspose.Cells ha expuesto algunas propiedades nuevas y un método para lograr este requisito.

Se agregó la propiedad PivotItem.GetPosition() que se puede usar para especificar el índice de posición en todos los PivotItems independientemente del nodo padre. Se agregó la propiedad PivotItem.GetPositionInSameParentNode() que se puede utilizar para especificar el índice de posición en los PivotItems bajo el mismo nodo padre.
Se añadió el método PivotItem.Move(int count, bool isSameParent) para mover el ítem hacia arriba o abajo basado en un valor de conteo, donde el contador es la cantidad de posiciones para mover el PivotItem hacia arriba o abajo. Si el valor del conteo es menor que cero, el ítem se moverá hacia arriba; si el valor es mayor que cero, el PivotItem se moverá hacia abajo. El parámetro booleano isSameParent especifica si la operación de movimiento debe realizarse en el mismo nodo padre o no.
El método PivotItem.Move(int count) ha quedado obsoleto; por lo tanto, se recomienda usar el método PivotItem.Move(int count, bool isSameParent) recién añadido.

El siguiente código de ejemplo crea una tabla dinámica y luego especifica las posiciones de los ítems de pivote en el mismo nodo padre. Puedes descargar los archivos de Excel original y de salida para referencia. Si abres el archivo Excel de salida, verás que el ítem de pivote “4H12” está en la posición 0 en el padre “K11” y “DIF400” está en la posición 3. De manera similar, CA32 está en la posición 1 y AAA3 en la posición 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();
}

Ten en cuenta que es necesario llamar a los métodos PivotTable.RefreshData y PivotTable.CalculateData antes de usar PivotItem.GetPosition(), PivotItem.GetPositionInSameParentNode() y PivotItem.Move(int count, bool isSameParent).

Cpp: Obtener el objeto de celda por el nombre visible del campo de pivote en una tabla dinámica con C++

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

Aspose.Cells proporciona el método PivotTable::GetCellByDisplayName(), que puede usar para acceder al objeto de celda por el nombre visible de un campo de pivote. Este método es útil cuando desea resaltar o dar formato a la cabecera de su campo dinámico. Este artículo explica cómo recuperar el objeto de celda por el nombre visible de un campo de datos y luego aplicar formato a este.

Obtener el objeto de celda por el nombre visible del campo de pivote en una tabla dinámica

El siguiente código accede a la primera tabla dinámica de la hoja de trabajo y luego recupera la celda por el nombre visible del segundo campo de datos de la tabla dinámica. Luego, cambia el color de relleno y el color de fuente de la celda a azul claro y negro, respectivamente. A continuación, se muestran capturas de pantalla de cómo se ve la tabla dinámica antes y después de la ejecución del código.

Tabla Dinámica - Antes

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

Tabla Dinámica - Después

Cpp: Agrupar campos dinámicos en la tabla dinámica con C++

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

Escenarios de uso posibles

Microsoft Excel te permite agrupar campos de tabla dinámica de la tabla dinámica. Cuando hay una gran cantidad de datos relacionados con un campo de tabla dinámica, a menudo es útil agruparlos en secciones. Aspose.Cells también proporciona esta función utilizando el método PivotTable.GroupBy().

Agrupar campos de la tabla dinámica

El siguiente código de muestra carga el archivo Excel de muestra y realiza agrupaciones en el primer campo de tabla dinámica utilizando el método PivotTable.GroupBy(). Luego actualiza y calcula los datos de la tabla dinámica y guarda la hoja de cálculo como archivo Excel de salida. La captura de pantalla muestra el efecto del código de muestra en el archivo Excel de muestra. Como se puede ver en la captura de pantalla, el primer campo de tabla dinámica está ahora agrupado por meses y trimestres.

Código de muestra

#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: Ocultar y ordenar datos en tablas dinámicas con C++

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

Ocultar y ordenar datos en tablas dinámicas

Aspose.Cells admite ocultar y ordenar datos en la tabla dinámica. El siguiente fragmento de código demuestra esta característica ordenando la columna de Puntuación en orden descendente y luego ocultando las filas con una puntuación inferior a 60.

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

Los archivos de Excel de origen y salida utilizados en el fragmento de código están adjuntos como referencia.

Archivo de origen

Archivo de salida

Cpp: Filtro de tabla dinámica con C++

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

Escenarios de uso posibles

Cuando creas una tabla dinámica con datos conocidos y deseas filtrarla, necesitas aprender y usar filtro. Puede ayudarte a filtrar los datos que deseas de manera efectiva. Usando la API de Aspose.Cells, puedes agregar y borrar filtros en los valores de los campos en Tablas dinámicas.

Agregar filtro en tabla dinámica en Excel

Agregar filtro en tabla dinámica en Excel, sigue estos pasos:

Selecciona la Tabla Dinámica de la que deseas eliminar el filtro.
Haz clic en la flecha desplegable del filtro que deseas agregar en la tabla dinámica.
Selecciona “Los 10 principales” en el menú desplegable.
Establece el modo de exhibición y el número de filtros.

Agregar filtro en tabla dinámica

Por favor, consulta el siguiente código de ejemplo. Establece los datos y crea una Tabla Dinámica basada en ellos. Luego añade un filtro en el campo de fila de la tabla dinámica. Finalmente, guarda el libro de trabajo en formato XLSX de salida. Después de ejecutar el código de ejemplo, se añade una tabla dinámica con filtro top10 a la hoja de cálculo.

Código de muestra

#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;
}

Borrar filtro en tabla dinámica en Excel

Limpiar filtro en Tabla Dinámica en Excel, sigue estos pasos:

Selecciona la Tabla Dinámica de la que deseas eliminar el filtro.
Haz clic en la flecha desplegable para el filtro que deseas borrar en la tabla dinámica.
Selecciona “Limpiar filtro” en el menú desplegable.
Si deseas borrar todos los filtros de la tabla dinámica, también puedes hacer clic en el botón “Limpiar filtros” en la pestaña Analizar tabla dinámica en la cinta de Excel.

Borrar filtro en tabla dinámica

Eliminar filtro en tabla dinámica usando Aspose.Cells. Por favor, consulta el siguiente código de ejemplo.

Establece los datos y crea una tabla dinámica basada en ellos.
Agrega un filtro en el campo de fila de la tabla dinámica.
Guarda el libro en formato XLSX de salida. Después de ejecutar el código de ejemplo, se añade un filtro top10 a la hoja de cálculo.
Elimina el filtro en un campo de la tabla dinámica específico. Después de ejecutar el código para eliminar el filtro, se eliminará el filtro en el campo de la tabla dinámica específico. Por favor, revisa el XLSX de salida.

Código de muestra

#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;
}

Cpp: Ordenamiento personalizado en tabla dinámica con C++

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

Orden personalizado en la tabla dinámica

Al usar la API de Aspose.Cells, puedes ordenar tablas dinámicas por valores de campo. El siguiente fragmento de código carga el archivo de Excel de ejemplo y agrega tres tablas dinámicas. La primera tabla dinámica es sin ordenamiento personalizado, la segunda está ordenada en los valores del campo de fila “SeaFood” y la tercera en los valores del campo de columna “28/07/2000”.

El archivo fuente de ejemplo y los archivos de salida se pueden descargar desde aquí para probar el código de ejemplo:

Archivo de Excel Fuente

Archivo de Excel de Salida

Archivo de PDF de Salida

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