Documentation – Insertar tabla dinámica

Nodejsjava: Actualizar Tablas Dinámicas y Cachés de Tablas Dinámicas en Aspose.Cells for Node.js via Java

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

Aspose.Cells ofrece una API de actualización en capas que permite recargar datos de tablas dinámicas en cuatro niveles diferentes, desde todo el libro hasta una sola tabla dinámica. A partir de Aspose.Cells for Node.js via Java v26.7, el método heredado PivotTable.RefreshData() está marcado como obsoleto y debe reemplazarse por las API más eficientes y conscientes de la caché descritas en este artículo.

Introducción

Actualizar una tabla dinámica rara vez es una operación única. En segundo plano, Aspose.Cells mantiene una cadena de datos en capas que conecta sus datos de origen originales con los valores renderizados que ve en la hoja de cálculo. Comprender esta cadena es la clave para elegir la API de actualización adecuada para cualquier situación. La cadena de datos de cuatro capas es:

Origen de Datos — los rangos originales de la hoja de cálculo, la consulta a la base de datos o el rango de consolidación donde residen los valores brutos.
PivotCache — la instantánea en memoria de los datos de origen. Cada tabla dinámica se construye sobre un PivotCache; aquí es donde se recopilan y agregan todos los datos.
PivotTable — el objeto de vista que define los campos de fila, columna, valor y filtro. Una PivotTable lee solo de su PivotCache, nunca directamente del origen de datos.
Celdas — el Cells de la hoja de cálculo en el que la PivotTable renderiza sus valores calculados y estilos.

PivotCache.SourceType (enumeración PivotTableSourceType) indica de dónde provienen los datos de la caché. A partir de la v26.7, PivotCache.Refresh() solo admite los tipos de origen Sheet y Consolidation, es decir, datos que residen en rangos de hojas de cálculo. Los orígenes externos (bases de datos, conexiones externas, etc.) aún no se pueden actualizar a través de la API de caché.

Debido a esta cadena, existen dos rutas fundamentales de actualización en Aspose.Cells:

PivotTable.CalculateData() — recalcula la visualización de una PivotTable a partir de los datos ya almacenados en caché, sin volver al origen de datos. Todos los escenarios de este artículo usan datos de origen de celdas de la hoja de cálculo, por lo que el tipo de origen es Sheet y las operaciones de actualización se comportan como se describe.

Inicio Rápido

Si solo necesita el código más corto posible que actualice cada tabla dinámica del libro, basta con una sola llamada:

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

Todo lo demás de este artículo explica cuándo elegir una API más específica en su lugar.

Importaciones Requeridas

const aspose = require('aspose.cells');
O para importaciones específicas: const { Workbook, Cells, PivotTableSourceType } = require('aspose.cells');

Actualizar Todas las Tablas Dinámicas del Libro

Cuando necesita asegurarse de que cada caché de tabla dinámica y cada tabla dinámica del libro refleje los datos de origen más recientes, la API más sencilla y completa es Workbook.RefreshAll(). Una sola llamada recorre todo el libro: actualiza cada PivotCache desde su origen y luego recalcula cada PivotTable dependiente. Este es el enfoque recomendado para actualizaciones generales de documentos completos donde el rendimiento no es una preocupación. El siguiente ejemplo crea un libro con un rango de origen Fruto/Año/Importe, crea una tabla dinámica, modifica algunos valores de origen y luego usa RefreshAll() para poner todo al día con una sola llamada.

const AsposeCells = require("aspose.cells");
// Crear un nuevo libro de trabajo
const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);
// Escribir la fila de encabezado en las celdas A1:C1
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");
// Escribir filas de datos en las celdas A2:C9 (8 filas de datos de frutas entre 2020 y 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);
// Agregar una tabla dinámica: rango de origen "A1:C9", celda de destino "E3", nombre "Pivot1"
const pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
const pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Asignar campos dinámicos: Fruta a Filas, Año a Columnas, Cantidad a Datos
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Modificar varios valores de Cantidad en los datos de origen para simular cambios
worksheet.getCells().get("C2").putValue(55);
worksheet.getCells().get("C5").putValue(85);
worksheet.getCells().get("C9").putValue(125);
// Actualizar todas las tablas dinámicas / caché dinámica en el libro de trabajo
workbook.refreshAll();
// Guardar el libro de trabajo
workbook.save("output.xlsx");

Actualizar Todas las Tablas Dinámicas en una Sola Hoja de Cálculo

A veces solo necesita actualizar las tablas dinámicas que se encuentran en una hoja de cálculo específica; por ejemplo, cuando se sabe que las tablas dinámicas de otras hojas no están relacionadas y no deben modificarse. Para este caso, Aspose.Cells ofrece Worksheet.RefreshPivotTables(), que está limitada a una sola instancia de Worksheet.

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");

Actualizar una Sola Tabla Dinámica

Cuando desea un control detallado sobre una sola tabla dinámica, la API basada en caché le ofrece dos opciones. La elección entre ellas depende de lo que realmente haya cambiado: los datos de origen subyacentes, o solo la configuración de vista/diseño de la propia tabla dinámica.

Cambiaron los Datos de Origen — Use `PivotCache.Refresh()`

Si los datos de origen subyacentes han cambiado, el punto de entrada correcto es pivotTable.PivotCache.Refresh(). Esta llamada vuelve a leer los datos de origen en la caché y luego recalcula cada PivotTable que depende de esa caché.

Solo Cambió la Vista/Diseño — Use `CalculateData()`

Si los datos de origen no han cambiado pero solo se ha modificado la configuración de vista o diseño de la tabla dinámica (por ejemplo, se ha movido un campo a un área diferente o se ha activado/desactivado una opción de actualización al abrir), no es necesario volver al origen de datos. La caché ya contiene los datos correctos; solo la PivotTable renderizada necesita recálculo. En este caso, pivotTable.CalculateData() es la opción correcta. El siguiente ejemplo modifica una propiedad que no es de origen de la tabla dinámica y luego llama a CalculateData() para volver a renderizarla desde la caché existente.

var workbook = new AsposeCells.Workbook();
var worksheet = workbook.getWorksheets().get(0);
// Escribir la fila de encabezado Fruta / Año / Cantidad
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");
// Escribir 8 filas de datos (filas 2-9, ajustándose al rango de origen 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);
// Agregar una tabla dinámica llamada "Pivot1" ubicada en la celda de destino E3, con origen en A1:C9
var pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Asignar campos: Fruta a Fila, Año a Columna, Cantidad a Datos
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Modificar una propiedad de vista/diseño — este es un cambio únicamente de presentación,
// por lo que NO requiere releer los datos de origen mediante PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(false);
// CalculateData() vuelve a renderizar la visualización de ESTA tabla dinámica (datos + estilo) a partir de los
// datos ya almacenados en el PivotCache. Dado que los datos de origen no cambiaron,
// no se realiza un recorrido de ida y vuelta al origen — solo los valores en caché se recalculan
// en las celdas de la hoja de cálculo.
pivotTable.calculateData();
// Guardar el libro en disco
workbook.save("output.xlsx");

Un libro a menudo contiene muchas tablas dinámicas que se asientan sobre una caché compartida. Para enumerarlas — por ejemplo, antes de realizar una actualización por lotes o para diagnosticar el impacto de la caché compartida — use PivotCache.GetPivotTables(). Este método devuelve la colección de cada PivotTable que depende de la caché indicada.

Migración desde el Obsoleto `PivotTable.RefreshData()`

Antes de Aspose.Cells for Node.js via Java v26.7, la forma estándar de actualizar una tabla dinámica era llamar a PivotTable.RefreshData() en cada tabla dinámica individualmente. A partir de la v26.7, ese método está marcado como obsoleto y debe reemplazarse por las API conscientes de la caché descritas anteriormente. Hay dos razones por las que el enfoque de RefreshData() por tabla resulta problemático en libros reales:

Vuelve a obtener datos del origen cada vez que se llama, incluso cuando el origen no ha cambiado. Los reemplazos recomendados son: El siguiente ejemplo demuestra el nuevo patrón eficiente para libros con múltiples tablas dinámicas que comparten una sola caché.

¿Qué API de Actualización Debo Usar?

La tabla siguiente resume las API de actualización disponibles y cuándo elegir cada una.

Objetivo	API Recomendada	Notas
Actualizar todo el libro	`Workbook.RefreshAll()`	Una sola llamada; cubre todas las cachés y tablas.
Actualizar solo las tablas dinámicas de una hoja	`Worksheet.RefreshPivotTables()`	Limitada a una hoja de cálculo.
Cambiaron los datos de origen de una caché	`pivotTable.PivotCache.Refresh()`	Actualiza TODAS las tablas dinámicas de esa caché compartida.
Solo cambió la configuración de vista/diseño	`pivotTable.CalculateData()`	Evita una lectura innecesaria del origen.
Listar todas las tablas dinámicas de una caché compartida	`pivotCache.GetPivotTables()`	Úsela para enumerar antes de una actualización masiva.
En la práctica, prefiera las API basadas en caché sobre la obsoleta `RefreshData()` por tabla. Son conscientes de las cachés compartidas, evitan lecturas redundantes del origen y le permiten elegir el alcance más pequeño que satisfaga su requisito de actualización.

Errores Comunes

Olvidar actualizar antes de guardar. Una tabla dinámica solo escribe sus valores renderizados en la hoja de cálculo cuando se actualiza su cadena de datos. Si modifica celdas de origen, llame a PivotCache.Refresh() (o Workbook.RefreshAll()) antes de Workbook.save(); de lo contrario, el archivo guardado aún contendrá los valores agregados antiguos.
Llamar al obsoleto RefreshData() por tabla. En la v26.7, PivotTable.RefreshData() está marcado como obsoleto y vuelve a obtener el origen en cada llamada. Con varias tablas dinámicas que comparten una caché, esto significa N lecturas redundantes del origen. Reemplácelo por una sola llamada a PivotCache.Refresh() seguida de CalculateData() por tabla.
Actualizar cuando solo ha cambiado el diseño. Si solo cambió la vista de la tabla dinámica (orden de columnas, ConsolidationFunction, etc.) sin modificar los datos de origen, PivotCache.Refresh() es innecesario y lento. Llame a pivotTable.CalculateData() para volver a renderizar desde la caché existente.
Origen externo no admitido por PivotCache.Refresh(). Si el origen de la tabla dinámica proviene de una conexión externa (base de datos, cubo OLAP, etc.), PivotCache.Refresh() no puede actualizarla en la v26.7; actualmente solo admite los tipos de origen Sheet y Consolidation. Para orígenes externos, vuelva a abrir el libro o reconstruya la caché desde el origen.

Nodejsjava: Aplicar estilos a tablas dinámicas en Aspose.Cells for Node.js via Java

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

Aspose.Cells admite tanto autoformatos de tablas dinámicas heredados (diseñados para archivos .xls) como estilos de tabla dinámica personalizados o con nombre modernos (diseñados para archivos .xlsx, .xlsm y .xlsb). La API que debe usar depende del formato de archivo en el que se guarda el libro, no del formato desde el que se cargó.

Introducción

Aspose.Cells expone dos API de estilos paralelas para tablas dinámicas. La decisión entre ellas depende del formato de archivo en el que guarda el libro, no del formato desde el que lo lee. Un libro cargado desde un archivo .xls se puede volver a guardar como .xlsx, y en ese caso se aplica la API de estilos moderna en lugar de la heredada.

PivotTable.pivotTableStyleType selecciona uno de los estilos con nombre integrados (temas claros y oscuros, incluidos los estilos añadidos en Excel 2017). Estos preajustes son de solo lectura.
PivotTable.pivotTableStyleName selecciona un estilo personalizado que usted mismo define mediante Worksheets.getTableStyles().addPivotTableStyle(...). Los estilos personalizados son necesarios siempre que desee modificar colores, bordes o fuentes más allá de lo que ofrecen los preajustes. Además, PivotTable.formatAll(Style) es un acceso directo que aplica un único objeto Style a cada celda de la tabla dinámica, sobrescribiendo lo establecido mediante cualquiera de las API de nombre de estilo anteriores. Esto resulta útil cuando se requiere una apariencia uniforme independientemente del tema subyacente.

Aplicar un autoformato preestablecido XLS heredado

PivotTable.autoFormatType acepta un valor de la enumeración Aspose.Cells.Pivot.PivotTableAutoFormatType. Los valores disponibles son Report1 a Report10, Classic y Table1 a Table10. El siguiente ejemplo carga un libro nuevo, rellena los datos de muestra Fruit/Year/Amount, añade una tabla dinámica, aplica PivotTableAutoFormatType.Report5 y guarda el resultado como .xls.

¿Por qué no hay campos de columna? Los autoformatos de la serie Report (Report1 a Report10, Table1 a Table10) fueron diseñados en Excel clásico para tablas dinámicas de una sola dimensión, con únicamente campos de fila y valores, ya que no incluyen estilo integrado para los encabezados de campos de columna. Si su tabla dinámica necesita campos de columna, utilice en su lugar los preajustes modernos de PivotTableStyleType del Escenario 2, que están diseñados para el diseño bidimensional que emplea el Excel moderno.

let workbook = new AsposeCells.Workbook();
// Obtener la primera hoja de cálculo
let sheet = workbook.getWorksheets().get(0);
// Poblar los datos fuente con la fila de encabezado (Fruit, Year, Amount)
// y 9 filas de datos que cubren grape, blueberry, kiwi, cherry entre 2020 y 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);
// Agregar una tabla dinámica en la celda destino E3, llamada "Pivot1", usando el rango fuente A1:C10
let pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = sheet.getPivotTables().get(pivotIndex);
// Asignar campos: Fruit -> Filas, Amount -> Datos
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.ROW, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.DATA, "Amount");
// Aplicar el formato automático preestablecido heredado de XLS "Report5"
// Nota: Esta propiedad solo tiene significado al guardar como .xls.
// Cuando se guarda como .xlsx/.xlsm/.xlsb, Excel ignora AutoFormatType
// y utiliza lo que especifiquen PivotTableStyleType / PivotTableStyleName.
pivotTable.setAutoFormatType(AsposeCells.PivotTableAutoFormatType.REPORT_5);
// Guardar el libro en formato .xls heredado
workbook.save("output.xls");

Aplicar un estilo preestablecido de tabla dinámica con nombre moderno

Definir y aplicar un estilo personalizado de tabla dinámica

Los preajustes integrados no se pueden modificar. Siempre que deba sobrescribir colores, bordes o fuentes, es necesario definir un estilo de tabla dinámica personalizado. El flujo de trabajo consta de tres pasos:

Añada un estilo personalizado a la colección TableStyles del libro mediante Worksheets.getTableStyles().addPivotTableStyle(String name). Esto devuelve el índice del estilo recién creado.
Configure el estilo añadiendo elementos (como WholeTable o GrandTotalRow) mediante TableStyle.tableStyleElements.add(TableStyleElementType) y, a continuación, asigne un Style a cada elemento mediante TableStyleElement.setElementStyle(Style).
Aplique el estilo personalizado a la tabla dinámica estableciendo PivotTable.pivotTableStyleName en el nombre del estilo. No use aquí pivotTableStyleType, ya que esa propiedad selecciona los preajustes integrados.

pivotTableStyleName y pivotTableStyleType no son intercambiables. Use pivotTableStyleType para los preajustes integrados, y pivotTableStyleName para los estilos personalizados que haya definido mediante addPivotTableStyle. Establecer ambos resulta inofensivo, pero solo se representará el que coincida con el origen previsto.

Los valores disponibles de TableStyleElementType incluyen WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels y PageFieldValues. El siguiente ejemplo define un estilo personalizado de tabla dinámica con un borde negro fino en WholeTable y una fuente roja en negrita en GrandTotalRow, luego lo aplica mediante pivotTableStyleName y guarda como .xlsx.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
// Rellenar datos de origen: fila de encabezado + 9 filas de datos (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);
// Agregar tabla dinámica con origen en A1:C10, anclada en E3, llamada "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");
// Paso 1: registrar un nuevo estilo de tabla dinámica personalizado y capturar su índice
let styleIndex = workbook.getWorksheets().getTableStyles().addPivotTableStyle("CustomPivotStyle");
let tableStyle = workbook.getWorksheets().getTableStyles().get(styleIndex);
// Paso 2: agregar un elemento WholeTable y aplicar bordes negros finos en los cuatro lados
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);
// Paso 3: agregar un elemento GrandTotalRow y aplicar fuente roja en negrita
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);
// Paso 4: aplicar el estilo personalizado por nombre (NO por PivotTableStyleType, que es para estilos preestablecidos)
pivotTable.setPivotTableStyleName("CustomPivotStyle");
workbook.save("output.xlsx");

Aplicar un único estilo a cada celda de la tabla dinámica con FormatAll

PivotTable.formatAll(Style) es un acceso directo que aplica un único objeto Style a cada celda de la tabla dinámica, incluidas el área de datos, los encabezados de filas y columnas, y los totales. Todo lo establecido previamente mediante pivotTableStyleType o pivotTableStyleName queda sobrescrito.

formatAll sobrescribe tanto pivotTableStyleType como pivotTableStyleName. Utilícelo solo cuando se requiera una apariencia uniforme e independiente del tema en toda la tabla dinámica.

El siguiente ejemplo crea un Style con un relleno sólido amarillo, una fuente azul oscuro en negrita y bordes negros finos en todos los lados, luego lo aplica con formatAll y guarda como .xlsx.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
// Poblar datos fuente: fila de encabezado (fila 1) + 9 filas de datos (filas 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);
// Agregar tabla dinámica: rango fuente A1:C10, celda de destino E3, nombre "Pivot1"
let pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Asignar campos dinámicos: Fruit -> área de Fila, Year -> área de Columna, Amount -> área de Datos
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Crear un Estilo que será forzado en cada celda de la tabla dinámica
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);
// Aplicar FormatAll: fuerza este único estilo en cada celda de la tabla dinámica,
// sobrescribiendo cualquier PivotTableStyleType / PivotTableStyleName establecido previamente
pivotTable.formatAll(style);
// Guardar el libro en el formato moderno .xlsx
workbook.save("output.xlsx");

¿Qué API de estilos debo usar?

La elección de la API de estilos depende del formato de archivo en el que va a guardar. Utilice la tabla siguiente como referencia rápida.

Formato de archivo de destino	API a usar	Notas
`.xls` (heredado)	`PivotTable.autoFormatType`	Valores de `Aspose.Cells.Pivot.PivotTableAutoFormatType` (por ejemplo, `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Se ignora al guardar como formatos modernos.
`.xlsx` / `.xlsm` / `.xlsb` (moderno, estilo integrado)	`PivotTable.pivotTableStyleType`	Valores de `Aspose.Cells.PivotTableStyleType` (temas claros y oscuros, incluidas las adiciones de Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderno, estilo personalizado)	`PivotTable.pivotTableStyleName` + `Worksheets.getTableStyles().addPivotTableStyle(...)`	Úselo cuando los preajustes integrados no sean suficientes. Configure mediante `TableStyleElement.setElementStyle(...)`.
Cualquier formato (anulación uniforme)	`PivotTable.formatAll(Style)`	Acceso directo que sobrescribe cualquier otra configuración de estilo en toda la tabla dinámica.
En caso de duda, guarde como `.xlsx` y use `pivotTableStyleType` para los temas integrados, o `pivotTableStyleName` para los temas personalizados.

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

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

Agregar un campo a la región de filas o columnas

El método PivotTable.addFieldToArea(PivotFieldType fieldType, String fieldName) mueve un campo base desde los datos de origen hacia una de las cuatro regiones de la tabla dinámica. El argumento fieldType acepta uno de los siguientes valores de PivotFieldType.

ROW — campos colocados verticalmente a la izquierda
COLUMN — campos colocados horizontalmente en la parte superior
DATA — campos cuyos valores se agregan
PAGE — campos utilizados como filtros de informe Una vez agregados los campos, puede acceder a ellos mediante las propiedades PivotTable.getRowFields() y PivotTable.getColumnFields(). Cada propiedad devuelve un PivotFieldCollection. El campo en el índice 0 de RowFields es el campo de fila más externo, y los índices posteriores representan campos anidados dentro de él. La misma convención de indexación se aplica a ColumnFields. El orden de anidamiento de los campos es importante. Agregar Category a la región de filas primero y luego Item produce una tabla dinámica cuya agrupación externa es Category y cuya agrupación interna es Item. Invertir el orden invierte la jerarquía.

Subtotales de campos dinámicos

El método PivotField.setSubtotals(PivotFieldSubtotalType subtotalType, boolean shown) controla qué filas de subtotal aparecen para un campo dinámico. Cada llamada activa o desactiva un único tipo de subtotal de forma independiente. Pasar shown = true muestra el subtotal, mientras que shown = false lo oculta. Dado que cada llamada solo afecta a un tipo, llamar al método varias veces con diferentes valores de subtotalType crea un subconjunto personalizado de subtotales. La enumeración PivotFieldSubtotalType define los tipos de subtotal disponibles.

AUTOMATIC — Aspose.Cells elige la selección predeterminada (normalmente SUM para campos numéricos)
NONE — suprime toda fila de subtotal
SUM
COUNT
AVERAGE
MAX
MIN
PRODUCT
STD_DEV
STD_DEVP
VAR
VARP

Los subtotales solo se representan cuando hay dos o más campos dinámicos en la región de filas (o en la región de columnas). Un único campo no tiene nada significativo para calcular subtotales entre grupos, por lo que las llamadas a setSubtotals no tienen ningún efecto visible en ese caso. Por lo tanto, este artículo coloca dos campos de fila (Category externo, Item interno) en cada ejemplo para que el límite de subtotal entre cada grupo Category sea visible.

Escenario 1 — Subtotales automáticos (predeterminados)

Cuando no llama a setSubtotals en absoluto, Aspose.Cells aplica la selección AUTOMATIC a los campos numéricos. El siguiente ejemplo confirma explícitamente este comportamiento llamando a setSubtotals(PivotFieldSubtotalType.AUTOMATIC, true) en el campo de fila externo Category.

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");

Escenario 2 — Suprimir todos los subtotales (None)

Llamar a setSubtotals(PivotFieldSubtotalType.NONE, true) elimina todas las filas de subtotal de la tabla dinámica, dejando solo las filas de campo y el total general en la parte inferior. Esto es útil cuando desea los datos agrupados sin procesar sin ninguna fila de resumen.

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");

Escenario 3 — Subconjunto personalizado de subtotales (Sum + Average)

No está limitado a un único tipo de subtotal. Cada llamada a setSubtotals opera de forma independiente en un solo tipo, por lo que llamar al método dos veces — una con SUM y otra con AVERAGE — produce un subconjunto personalizado de dos filas de subtotal para cada grupo Category.

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");

Resumen

Los tres escenarios anteriores comparten el mismo conjunto de datos y la misma estructura de tabla dinámica. La única diferencia entre ellos es la llamada a setSubtotals aplicada al campo de fila externo Category. Recuerde la regla de los dos campos: un único campo en una región no tiene nada para calcular subtotales entre grupos, por lo que siempre coloque al menos dos campos en la región de filas o columnas cuando desee que setSubtotals tenga un efecto visible.

Nodejsjava: Campos de Valor en Aspose.Cells for Node.js via Java

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

Los campos de valor son el corazón de toda tabla dinámica, los agregados numéricos que resumen los datos de origen. En Aspose.Cells for Node.js via Java, la región de datos de una tabla dinámica se completa añadiendo campos base a ella mediante PivotTable.addFieldToArea, y cada campo colocado en esa región puede tener su propia función de resumen. Cuando existen dos o más campos de datos, Aspose.Cells expone un campo agregado especial, PivotTable.getValuesField(), que puede colocarse en el eje de fila o columna como un campo base, brindándole un control más preciso sobre cómo aparecen los campos de valor en el diseño.

Agregar un Campo a la Región de Datos

Añadir un campo base a la región de datos (valor) es el primer paso para dar forma a cómo una tabla dinámica agrega los datos de origen. Aspose.Cells expone PivotTable.addFieldToArea(PivotFieldType, string), una sobrecarga que acepta la constante PivotFieldType.DATA y el nombre de la columna de origen. Una vez que se añade un campo a la región de datos, la API lo expone a través de la colección PivotTable.getDataFields(), en el orden en que se añadieron los campos. Por defecto, una columna de origen numérica se resume con ConsolidationFunction.SUM, mientras que una columna no numérica toma como valor predeterminado COUNT.

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");

Cambiar la Función de Resumen

Cada campo colocado en la región de datos se envuelve internamente como una instancia de PivotField, y su propiedad getFunction() devuelve un valor de la enumeración ConsolidationFunction. El mismo setter setFunction() le permite cambiar entre los agregados disponibles, incluyendo SUM, COUNT, AVERAGE, MAX, MIN, PRODUCT, STD_DEV, STD_DEVP, VAR y VARP.

Cambiar Function solo afecta al agregado; la columna de origen no cambia.

Por lo tanto, puede dejar un campo de datos como SUM mientras añade un segundo campo de datos que tenga como destino la misma columna de origen pero que use COUNT o AVERAGE, todo en una sola tabla dinámica.

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");

Trazar Campos de Valor en el Eje de Filas o Columnas

Cuando una tabla dinámica contiene dos o más campos de datos, Aspose.Cells expone un campo virtual adicional llamado PivotTable.getValuesField(). Este campo virtual representa el agregado de cada campo de datos que reside en la región de datos. Puede arrastrarlo a la región de Filas o Columnas como un campo dinámico base, lo cual resulta útil para disponer varias medidas una al lado de la otra.

PivotTable.getValuesField() no funciona si no hay ningún campo de valor o si solo hay uno.

Los escenarios siguientes recorren tres ejemplos de extremo a extremo que demuestran cada capacidad descrita anteriormente contra la misma estructura dinámica.

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: Agregar campos de filtro a una tabla dinámica en Aspose.Cells para .NET

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

Aspose.Cells admite el ciclo de vida completo de los campos de filtro en tablas dinámicas. Puede añadir un campo de filtro mediante una API de alto nivel o mediante la colección de bajo nivel PageFields, y puede controlar el filtro de página en modo de selección única, borrarlo para mostrar todos los elementos de página, o cambiar el campo a selección múltiple para que los usuarios puedan elegir varios elementos de página a la vez a través de la interfaz de casillas de verificación en Excel.

Introducción

Un campo de filtro es un campo dinámico que controla qué subconjunto de los datos de origen se muestra en el cuerpo de la tabla dinámica. Los usuarios finales lo ven como un desplegable en la parte superior de una tabla dinámica renderizada en Excel, y al seleccionar uno de los elementos de página disponibles, el cuerpo de la tabla dinámica se reconstruye de modo que solo se resumen los registros que pertenecen a ese elemento de página. Un campo dinámico se convierte en un campo de filtro cuando se registra como PivotFieldType.Page en lugar de PivotFieldType.Row, PivotFieldType.Column o PivotFieldType.Data. Un campo de filtro puede operar con dos comportamientos. En el comportamiento predeterminado de selección única solo un elemento de página es visible a la vez, por lo que el cuerpo de la tabla dinámica resume exactamente un subconjunto. En el comportamiento de selección múltiple el campo expone una lista de casillas de verificación, y el cuerpo de la tabla dinámica resume la unión de cada elemento de página marcado. El mismo campo de origen puede moverse de un lado a otro entre estos comportamientos alternando una sola propiedad. Aspose.Cells for Node.js via Java expone dos formas equivalentes para registrar un campo de filtro. La API de alto nivel es pivotTable.addFieldToArea(PivotFieldType.Page, "fieldName"), que toma el nombre de la columna de origen y añade el campo en una sola llamada. La API de bajo nivel es pivotTable.getPageFields().add(PivotField), que se utiliza cuando ya tiene una referencia a PivotField y desea añadir la misma instancia de campo al área de filtro. Ambas API terminan rellenando la misma colección PageFields, y el resto de este artículo demuestra cómo elegir entre ellas y cómo controlar cada modo de filtrado.

Añadir un campo de filtro

Hay dos formas de registrar un campo dinámico en el área de filtro. La llamada de alto nivel toma el nombre de la columna de origen como una cadena y es la ruta más común. La llamada de bajo nivel acepta una instancia existente de PivotField y es conveniente cuando la misma instancia de campo debe reutilizarse en múltiples áreas de la tabla dinámica. Ambas llamadas colocan el campo en pivotTable.getPageFields(), tras lo cual aparece como el desplegable de página en la parte superior de la tabla dinámica renderizada.

Añadir un campo de filtro con addFieldToArea

El siguiente ejemplo construye un pequeño conjunto de datos de Fruta / Año / Cantidad, coloca una tabla dinámica en la celda E3 con Fruit en el área de filas, Amount en el área de datos y Year en el área de filtro, actualiza la tabla dinámica y guarda el libro de trabajo.

var workbook = new AsposeCells.Workbook();
var worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");
// Configurar la fila de encabezado
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");
// Poblar 9 filas de datos de muestra: Fruta, Año, Cantidad
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]);
}
// Agregar una tabla dinámica anclada en la celda E3
var pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "PivotTable1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Agregar campos a sus áreas: Fruta como Fila, Cantidad como Datos, Año como Campo de Página
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");
// Actualizar y calcular los datos de la tabla dinámica
pivotTable.calculateData();
// Guardar el libro de trabajo
workbook.save("pageFieldSample.xlsx");

Añadir un campo de filtro con getPageFields().add

Cuando ya trabaja con una instancia de PivotField, puede pasarla directamente a pivotTable.getPageFields().add. La tabla dinámica y el campo de filtro se construyen exactamente como en el escenario anterior; solo se reemplaza el registro final del área de filtro con la llamada a la API de bajo nivel.

let workbook = new AsposeCells.Workbook();
let sheet = workbook.getWorksheets().get(0);
// Encabezados
sheet.getCells().get("A1").putValue("Fruit");
sheet.getCells().get("B1").putValue("Year");
sheet.getCells().get("C1").putValue("Amount");
// Datos de muestra (9 filas)
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);
// Agregar tabla dinámica en E3 cubriendo A1:C10
let pivotIndex = sheet.getPivotTables().add("E3", "A1:C10", "PivotTable1");
let pivotTable = sheet.getPivotTables().get(pivotIndex);
// Fruit -> Fila, Amount -> Datos (Year irá a Página abajo)
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Enfoque de bajo nivel: obtener el PivotField Year existente de BaseFields
// y registrarlo en el área Page mediante PageFields.Add(PivotField).
let yearField = pivotTable.getBaseFields().get("Year");
pivotTable.getPageFields().add(yearField);
// Actualizar para que el nuevo campo de página se refleje en el libro guardado
pivotTable.calculateData();
workbook.save("output.xlsx");

Filtrado de selección única (mostrando un elemento de página)

En el comportamiento predeterminado de selección única, el campo de filtro se renderiza como un único desplegable y el entero PivotField.CurrentPageItem selecciona qué elemento de página controla el cuerpo de la tabla dinámica. Asignar un índice específico selecciona ese único elemento; asignar el centinela especial 0x7FFD (decimal 32765) borra el filtro para que todos los elementos de página se resuman a la vez. La selección única es el modo predeterminado; no necesita habilitarla explícitamente.

Mostrar todos los elementos

Establecer CurrentPageItem al valor mágico 0x7FFD equivale a borrar el filtro de página; el cuerpo de la tabla dinámica resume todos los elementos de página como si no se aplicara ningún filtro.

var workbook = new AsposeCells.Workbook();
var sheet = workbook.getWorksheets().get(0);
// Rellenar datos de Fruta/Año/Cantidad
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]);
    }
}
// Crear tabla dinámica en E3
var pivotTables = sheet.getPivotTables();
var index = pivotTables.add("=A1:C7", "E3", "PivotTable1");
var pivotTable = pivotTables.get(index);
// Configurar campos de la tabla dinámica: Fruta→Fila, Cantidad→Datos, Año→Página
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");
pivotTable.calculateData();
// Limpiar el filtro de página para que todos los elementos del campo de página sean visibles.
// 0x7FFD (decimal 32765) es el valor centinela especial que significa "todos los elementos" —
// equivalente a seleccionar "(Todos)" en el desplegable del campo de página de Excel.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD);
workbook.save("output.xlsx");

Mostrar un elemento específico

Establecer CurrentPageItem a un índice real selecciona solo ese elemento de página. El índice es la posición del elemento en la lista ordenada de elementos del campo de filtro, por lo que, por ejemplo, 1 selecciona el segundo elemento tras ordenar.

var workbook = new AsposeCells.Workbook();
var sheet = workbook.getWorksheets().get(0);
var cells = sheet.getCells();
// Agregar datos de muestra (Fruta/Año/Monto)
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");
// Agregar tabla dinámica en E3
var pivotTables = sheet.getPivotTables();
var pivotIndex = pivotTables.add("A1:C5", "E3", "PivotTable1");
var pivotTable = pivotTables.get(pivotIndex);
// Agregar campos: Fruta→Fila, Monto→Datos, Año→Página
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");
// Operaciones específicas del campo de página
pivotTable.getPageFields().get(0).setCurrentPageItem(1); // 1 = segundo elemento en orden ascendente (por ejemplo, "2021")
// Actualizar y calcular tabla dinámica
pivotTable.calculateData();
workbook.save("output.xlsx");

Filtrado de selección múltiple

El filtrado de selección múltiple convierte el desplegable de página en una lista de casillas de verificación y permite al usuario final elegir varios elementos de página simultáneamente. Aspose.Cells expone dos propiedades que trabajan juntas. PivotField.IsMultipleItemSelectionAllowed debe establecerse en true antes de que la interfaz de selección múltiple surta efecto. Una vez habilitada, PivotItem.IsHidden controla qué elementos aparecen en la lista de casillas de verificación, por lo que puede mostrar todos los elementos o crear una lista blanca solo con elementos específicos. El código a continuación habilita la selección múltiple en el mismo campo de filtro Year construido en el Escenario 1a, y luego muestra dos patrones: la Parte A revela todos los elementos de página dejando IsHidden establecido en false para cada entrada, mientras que la Parte B crea una lista blanca solo con los valores de origen que elija y oculta todo lo demás mediante un bloque switch (pivotItems[i].getStringValue()).

const AsposeCells = require("aspose.cells");
// — La tabla dinámica y el campo de página se construyen exactamente como en
//   Escenario 1a (datos de Fruta/Año/Cantidad, pivote en E3, Fruta→Fila,
//   Cantidad→Datos, Año→Página mediante AddFieldToArea).
//   A continuación aplicamos filtrado de selección múltiple en el campo de página.
const workbook = new AsposeCells.Workbook();
const sheet = workbook.getWorksheets().get(0);
const cells = sheet.getCells();
// Datos de muestra: Fruta | Año | Cantidad
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");
// — Habilitar selección múltiple en el campo de página
pivotTable.getPageFields().get(0).setMultipleItemSelectionAllowed(true);
// Parte A — seleccionar TODOS los elementos (hacer visible cada elemento)
const pivotItems = pivotTable.getPageFields().get(0).getPivotItems();
for (let i = 0; i < pivotItems.getCount(); i++) {
    pivotItems.get(i).setHidden(false);
}
// Parte B — seleccionar solo elementos específicos por valor de origen
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");

Nota: Cuando utilice el filtrado de selección múltiple mediante PivotItem.IsHidden, al menos un PivotItem debe permanecer visible (IsHidden == false). Si todos los elementos están ocultos, Excel se bloqueará al abrir el archivo o renderizará una tabla dinámica en blanco. Verifique siempre que su lista blanca de selección múltiple incluya al menos un elemento de sus datos de origen.

¿Qué API y qué modo debo usar?

La tabla a continuación resume cuándo usar cada API y modo para que pueda elegir la combinación correcta sin leer cada escenario en detalle.

Escenario / Caso de uso	API recomendada	Propiedad utilizada	Notas
Añadir un campo de filtro por nombre de columna de origen (más común)	`pivotTable.addFieldToArea(PivotFieldType.Page, "fieldName")`	n/a	Alto nivel, una sola línea. Use esto a menos que necesite una referencia a `PivotField`.
Añadir un campo de filtro cuando ya tiene un objeto `PivotField`	`pivotTable.getPageFields().add(PivotField)`	n/a	Use cuando el objeto de campo se obtuvo en otro lugar o necesita reutilizarse.
Filtrar a un único elemento de página (modo predeterminado)	`PivotField.CurrentPageItem`	establecer a un índice específico	Por ejemplo, `1` muestra el segundo elemento de la lista ordenada.
Mostrar todos los elementos / borrar el filtro de página	`PivotField.CurrentPageItem`	establecer a `0x7FFD`	El valor mágico `0x7FFD` (decimal 32765) es el centinela para “todos los elementos”.
Habilitar la interfaz de selección múltiple en Excel	`PivotField.IsMultipleItemSelectionAllowed`	establecer en `true`	Requerido antes de que cualquier llamada a `IsHidden` surta efecto.
Ocultar / mostrar elementos individuales en una lista de selección múltiple	`PivotItem.IsHidden`	establecer por elemento	Al menos un elemento debe permanecer visible (`IsHidden == false`).

Recuerde siempre la restricción de visibilidad al configurar el filtrado de selección múltiple. Si cada PivotItem en un campo de filtro de selección múltiple está oculto, Excel se bloqueará al abrirlo o renderizará una tabla dinámica en blanco. Construya su lista blanca contra sus datos de origen para que al menos un elemento permanezca visible, y sus libros de trabajo guardados se abrirán de forma fiable en cualquier máquina.

Documentation – Insertar tabla dinámica

Nodejsjava: Actualizar Tablas Dinámicas y Cachés de Tablas Dinámicas en Aspose.Cells for Node.js via Java

Introducción

Inicio Rápido

Importaciones Requeridas

Actualizar Todas las Tablas Dinámicas del Libro

Actualizar Todas las Tablas Dinámicas en una Sola Hoja de Cálculo

Actualizar una Sola Tabla Dinámica

Cambiaron los Datos de Origen — Use PivotCache.Refresh()

Solo Cambió la Vista/Diseño — Use CalculateData()

Migración desde el Obsoleto PivotTable.RefreshData()

¿Qué API de Actualización Debo Usar?

Errores Comunes

Nodejsjava: Aplicar estilos a tablas dinámicas en Aspose.Cells for Node.js via Java

Introducción

Aplicar un autoformato preestablecido XLS heredado

Aplicar un estilo preestablecido de tabla dinámica con nombre moderno

Definir y aplicar un estilo personalizado de tabla dinámica

Aplicar un único estilo a cada celda de la tabla dinámica con FormatAll

¿Qué API de estilos debo usar?

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

Agregar un campo a la región de filas o columnas

Subtotales de campos dinámicos

Escenario 1 — Subtotales automáticos (predeterminados)

Escenario 2 — Suprimir todos los subtotales (None)

Escenario 3 — Subconjunto personalizado de subtotales (Sum + Average)

Resumen

Nodejsjava: Campos de Valor en Aspose.Cells for Node.js via Java

Agregar un Campo a la Región de Datos

Cambiar la Función de Resumen

Trazar Campos de Valor en el Eje de Filas o Columnas

Nodejsjava: Agregar campos de filtro a una tabla dinámica en Aspose.Cells para .NET

Introducción

Añadir un campo de filtro

Añadir un campo de filtro con addFieldToArea

Añadir un campo de filtro con getPageFields().add

Filtrado de selección única (mostrando un elemento de página)

Mostrar todos los elementos

Mostrar un elemento específico

Filtrado de selección múltiple

¿Qué API y qué modo debo usar?

Cambiaron los Datos de Origen — Use `PivotCache.Refresh()`

Solo Cambió la Vista/Diseño — Use `CalculateData()`

Migración desde el Obsoleto `PivotTable.RefreshData()`