Documentation – Insertar tabla dinámica

Nodejscpp: Dar formato a la tabla dinámica

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

Apariencia de la tabla dinámica

Cómo crear una tabla dinámica explica cómo crear una tabla dinámica simple. Este artículo describe cómo personalizar la apariencia de una tabla dinámica estableciendo diversas propiedades:

Opciones de formato de tabla dinámica
Opciones de formato de campos de tabla dinámica
Opciones de formato de campos de datos

Cómo establecer opciones de formato de tabla dinámica

La clase PivotTable controla la tabla dinámica general y se puede formatear de varias maneras.

Cómo establecer el tipo de autoformato

Microsoft Excel ofrece varios formatos predefinidos de informes. Aspose.Cells for Node.js via C++ soporta estas opciones de formato también. Para acceder a ellos:

Establezca PivotTable.setIsAutoFormat(value) en verdadero.
Asignar una opción de formato de la enumeración PivotTableAutoFormatType.

Cómo establecer opciones de formato

El ejemplo de código a continuación muestra cómo dar formato a la tabla dinámica para mostrar totales generales para filas y columnas, y cómo establecer el orden de los campos del informe. También muestra cómo establecer una cadena personalizada para los valores nulos.

Dar formato manualmente al aspecto visual

Para formatear cómo se ve el informe de tabla dinámica manualmente, en lugar de usar formatos de informe preestablecidos, use los métodos PivotTable.formatAll(style) y PivotTable.format(row, column, style). Cree un objeto de estilo para su formato deseado, por ejemplo:

Cómo establecer opciones de formato de campo de tabla dinámica

La clase PivotField representa un campo en una tabla dinámica y se puede formatear de varias formas. El ejemplo de código a continuación muestra cómo:

Acceder a los campos de fila.
Establecer subtotales.
Establecer orden automático.
Establecer autover.

Cómo establecer el formato de campos de fila/columna/página.

Cómo establecer el formato de campos de datos.

El ejemplo de código a continuación muestra cómo establecer formatos de visualización y formato numérico para los campos de datos.

Cómo limpiar los campos de filtro.

La clase PivotFieldCollection tiene un método llamado clear() que te permite borrar campos de tabla dinámica. Úsalo cuando quieras borrar todos los campos de tabla dinámica en las áreas, por ejemplo, página, columna, fila o datos. El ejemplo de código a continuación muestra cómo borrar todos los campos de tabla dinámica en un área de datos.

Nodejscpp: Crear tablas dinámicas y gráficos dinámicos

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

Una tabla dinámica es un resumen interactivo de registros. Por ejemplo, puede tener cientos de entradas de factura en una lista en una hoja de cálculo. Una tabla dinámica puede totalizar las facturas por cliente, producto o fecha. Con Microsoft Excel es posible reorganizar rápidamente la información en la tabla dinámica arrastrando botones a una nueva posición.

Un gráfico dinámico es una representación gráfica interactiva de los datos en una tabla dinámica. Los gráficos dinámicos se introdujeron en Excel 2000. El uso de un gráfico dinámico facilita aún más la comprensión de los datos, ya que la tabla dinámica crea subtotales y totales automáticamente.

Aspose.Cells for Node.js via C++ soporta tablas dinámicas y gráficos dinámicos.

Agregar tablas dinámicas y gráficos usando Aspose.Cells for Node.js via C++

Aspose.Cells for Node.js via C++ proporciona un conjunto especial de clases utilizadas para crear tablas dinámicas. Estas clases sirven para crear y configurar objetos PivotTable, que actúan como los bloques básicos de un objeto PivotTable:

PivotField, un campo en un informe de tabla dinámica.
PivotFields, una colección de todos los objetos PivotField en una tabla dinámica.
PivotTable, un informe de tabla dinámica en una hoja de cálculo.
PivotTables, una colección de todos los objetos PivotTable en la hoja de cálculo.

Prepararse para usar Aspose.Cells for Node.js via C++

Instala Aspose.Cells for Node.js via C++ desde NPM, usando el comando: $ npm install aspose.cells.node.
También puedes seguir las instrucciones paso a paso sobre cómo instalar “Aspose.Cells for Node.js via C++” en tu entorno de desarrollo.

Cómo agregar una tabla dinámica usando Aspose.Cells for Node.js via C++

Para crear una tabla dinámica usando Aspose.Cells for Node.js via C++:

Añadir algunos datos a las celdas de una hoja de cálculo utilizando el método put_value de un objeto Celda. También puedes utilizar un archivo de plantilla ya lleno de datos. Los datos se utilizarán como fuente de datos de la tabla dinámica.
Agregue una tabla dinámica a la hoja de cálculo llamando al método add de la colección PivotTables (encapsulada en el objeto Worksheet).
Accede al nuevo objeto PivotTable desde la colección PivotTables pasando su índice. # Usa cualquiera de los objetos de tabla dinámica encapsulados en el objeto PivotTable para gestionar la tabla.

A continuación se muestran ejemplos de código.

Cómo agregar un gráfico dinámico usando la biblioteca Aspose.Cells for Node.js via C++

Para crear un gráfico dinámico usando Aspose.Cells for Node.js via C++:

Agregue un gráfico.
Establezca el PivotSource del gráfico para hacer referencia a una tabla dinámica existente en la hoja de cálculo.
Establezca otros atributos.

Nodejscpp: Tabla dinámica y datos fuente

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

Datos fuente de la tabla dinámica

Hay momentos en los que deseas crear informes de Microsoft Excel con tablas dinámicas que toman datos de diferentes fuentes de datos (como una base de datos) que no se conocen en el momento del diseño. Este artículo proporciona un enfoque para cambiar dinámicamente la fuente de datos de una tabla dinámica.

Cambio de la fuente de datos de una tabla dinámica

Crear una nueva plantilla de diseño.
1. Crea un nuevo archivo de plantilla de diseñador como se muestra en la captura de pantalla a continuación.
2. Luego define un rango nombrado, DataSource, que se refiere a este rango de celdas.
  
  Creando una plantilla de diseñador y definiendo un rango nombrado, DataSource

Crear una tabla dinámica basada en este rango nombrado.
1. En Microsoft Excel, elige Datos, luego Tabla Dinámica y Informe de Tabla Dinámica.
2. Crear una tabla dinámica basada en el rango nombrado creado en el primer paso.
  
  Creando una tabla dinámica basada en el rango nombrado, DataSource

Arrastra el campo correspondiente a la fila y columna de la tabla dinámica, luego crea la tabla dinámica resultante como en la captura de pantalla a continuación.

Creando una tabla dinámica basada en un campo correspondiente

Haz clic derecho en la tabla dinámica y selecciona Opciones de Tabla.
1. Marca Actualizar al abrir en la configuración de Opciones de Datos.
  
  Configuración de las opciones de la tabla dinámica

Ahora, puedes guardar este archivo como tu archivo de plantilla de diseñador.

Poblar nuevos datos y cambiar la fuente de datos de una tabla dinámica.
1. Una vez que se haya creado la plantilla de diseñador, utiliza el siguiente código para cambiar la fuente de datos de la tabla dinámica.

La ejecución del código de ejemplo a continuación cambia los datos fuente de la tabla dinámica.

Nodejscpp: Agregar campo calculado en tabla dinámica

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

Escenarios de uso posibles

Cuando crea una tabla dinámica basada en datos conocidos, se encuentra con que los datos no son los que desea. Los datos que desea es la combinación de estos datos originales. Por ejemplo, necesita sumar, restar, multiplicar y dividir los datos originales antes de querer los datos. En ese momento, necesita crear un campo calculado y establecer la fórmula correspondiente para el cálculo. Luego realizar algunas estadísticas y otras operaciones en el campo calculado.

Cómo agregar un campo calculado en una tabla dinámica en Excel

Para insertar un campo calculado en una tabla dinámica en Excel, siga estos pasos:

Seleccione la tabla dinámica a la que desea agregar un campo calculado.
Vaya a la pestaña Analizar tabla dinámica en la cinta.
Haga clic en “Campos, elementos y conjuntos” y luego seleccione “Campo calculado” en el menú desplegable.
En el campo “Nombre”, ingrese un nombre para el campo calculado.
En el campo “Fórmula”, ingresa la fórmula para el cálculo que deseas realizar utilizando los nombres adecuados de los campos de la tabla dinámica y los operadores matemáticos correspondientes.
Haga clic en “ok” para crear el campo calculado.
El nuevo campo calculado aparecerá en la Lista de campos de la Tabla Dinámica bajo la sección de Valores.
Arrastre el campo calculado a la sección de Valores de la Tabla Dinámica para mostrar los valores calculados.

Cómo agregar un campo calculado en Tabla dinámica usando la biblioteca Aspose.Cells for Node.js via C++

Agregar campo calculado al archivo Excel usando Aspose.Cells for Node.js via C++. Consulta el siguiente código de ejemplo. Después de ejecutar el ejemplo, se añade una tabla dinámica con campo calculado en la hoja.

Establece los datos originales y crea una tabla dinámica.
Crea el campo calculado de acuerdo con el CampoPivote existente en la tabla dinámica.
Agrega el campo calculado al área de datos.
Finalmente, guarda el libro en formato XLSX de salida.

Código de muestra

Nodejscpp: Actualización de tablas dinámicas en Aspose.Cells for Node.js via C++

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

Aspose.Cells ofrece una API de actualización por capas que permite recargar los datos de tablas dinámicas en cuatro alcances diferentes, desde todo el libro de trabajo hasta una sola tabla dinámica. A partir de Aspose.Cells for Node.js via C++ 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 por capas que conecta los datos de origen originales con los valores renderizados que se ven 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:

Fuente 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 sin procesar.
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 desde su PivotCache, nunca directamente desde la fuente de datos.
Cells — los Cells de la hoja de cálculo en los que la PivotTable renderiza sus valores calculados y estilos.

Un concepto particularmente importante es la caché compartida. Cuando varias tablas dinámicas en un libro de trabajo hacen referencia al mismo rango de origen, comparten una instancia de PivotCache. Una sola PivotCache puede ser referenciada por muchas tablas dinámicas, y actualizar esa caché actualiza cada PivotTable dependiente a la vez.

PivotCache.SourceType (enum 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. Las fuentes externas (bases de datos, conexiones externas, etc.) aún no se pueden actualizar mediante la API de caché.

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

PivotCache.Refresh() — recarga origen → caché Y recalcula todas las PivotTable dependientes en una sola operación.
PivotTable.CalculateData() — recalcula la visualización de una PivotTable a partir de los datos ya en caché, sin necesidad de volver a la fuente de datos.

Todos los escenarios de este artículo utilizan datos de origen de celdas de hojas de cálculo, por lo que el tipo de origen es Sheet y las operaciones de actualización se comportan como se describe.

Importaciones requeridas

Todos los ejemplos de JavaScript en este artículo asumen que el módulo Aspose.Cells for Node.js via C++ ha sido cargado y que los tipos de tablas dinámicas residen en el namespace Aspose.Cells.Pivot. Una configuración típica es:

const AsposeCells = require("aspose.cells.node");
const { PivotFieldType } = AsposeCells; (o acceder mediante AsposeCells.Pivot.PivotFieldType)

Actualizar todas las tablas dinámicas del libro de trabajo

Cuando necesita asegurarse de que cada caché de tablas dinámicas y cada tabla dinámica del libro de trabajo reflejen los datos de origen más recientes, la API más simple y completa es Workbook.RefreshAll(). Una sola llamada recorre todo el libro de trabajo, actualizando cada PivotCache desde su origen y luego recalculando 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 de trabajo con un rango de origen Fruit/Year/Amount, crea una tabla dinámica, modifica algunos valores de origen y luego utiliza RefreshAll() para actualizar todo en una sola llamada.

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

// Escribir 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 en 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"
let pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
let 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é de tablas dinámicas en el libro
workbook.refreshAll();

// Guardar el libro
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 en otras hojas de cálculo no están relacionadas y no deben modificarse. Para este caso, Aspose.Cells proporciona Worksheet.RefreshPivotTables(), que tiene como alcance una sola instancia de Worksheet.

Esto es más selectivo que Workbook.RefreshAll(): solo se actualizan las tablas dinámicas de la hoja de cálculo objetivo, dejando intactas las tablas dinámicas de otras hojas de cálculo.

El siguiente ejemplo completa los mismos datos de origen Fruit/Year/Amount, añade una tabla dinámica en la primera hoja de cálculo, modifica algunos valores de origen y luego actualiza solo las tablas dinámicas en esa hoja de cálculo.

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 tabla dinámica.

Datos de origen modificados — 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é.

Dado que las tablas dinámicas comparten una sola instancia de PivotCache, llamar a PivotCache.Refresh() recalcula todas las tablas dinámicas construidas sobre esa misma caché, no solo aquella a la que hace referencia. Si dos tablas dinámicas comparten el mismo rango de origen, actualizar una caché actualiza ambas.

El siguiente ejemplo crea dos tablas dinámicas en el mismo rango de origen para demostrar este comportamiento de caché compartida, modifica algunos valores de origen y luego actualiza a través de una referencia de caché.

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

// Crear un nuevo libro de trabajo y acceder a la primera hoja de cálculo
const workbook = new AsposeCells.Workbook();
const 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 aproximadamente 9 filas de datos (uva / arándano / kiwi / cereza entre 2020-2021)
worksheet.getCells().get("A2").putValue("Grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(100);

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

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

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

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

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

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

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

// Agregar la primera tabla dinámica "Pivot1" anclada en la celda E3, rango de origen A1:C9
const pivotIndex1 = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
const pivotTable1 = worksheet.getPivotTables().get(pivotIndex1);

// Asignar campos para Pivot1
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Agregar una SEGUNDA tabla dinámica "Pivot2" anclada en E15 usando el MISMO rango de origen A1:C9
// Tanto Pivot1 como Pivot2 comparten un único PivotCache porque el rango de origen es idéntico.
const pivotIndex2 = worksheet.getPivotTables().add("A1:C9", "E15", "Pivot2");
const pivotTable2 = worksheet.getPivotTables().get(pivotIndex2);

// Asignar los mismos campos para Pivot2
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Modificar varios valores de celda de Cantidad en los datos de origen para simular un cambio de datos
worksheet.getCells().get("C2").putValue(150);
worksheet.getCells().get("C4").putValue(350);
worksheet.getCells().get("C7").putValue(650);

// Refrescar el PivotCache compartido.
// Como Pivot1 y Pivot2 comparten el mismo PivotCache, esta única llamada
// refresca AMBAS tablas dinámicas (datos + estilo) desde el origen actualizado.
pivotTable1.getPivotCache().refresh();

// Guardar el libro de trabajo
workbook.save("output.xlsx");

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 una configuración de actualización al abrir), no es necesario volver a la fuente de datos. La caché ya contiene los datos correctos; solo es necesario recalcular la PivotTable renderizada. En este caso, pivotTable.CalculateData() es la opción correcta.

Esto evita la búsqueda innecesaria en el origen y es significativamente más rápido cuando muchas tablas dinámicas comparten la misma caché.

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: Fruit a Fila, Year a Columna, Amount a Datos
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Data, "Amount");

// Modificar una propiedad de vista/diseño — este es un cambio solo de presentación,
// por lo que NO requiere volver a leer los datos de origen a través de PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(false);

// calculateData() vuelve a renderizar la visualización de ESTA tabla dinámica (datos + estilo) desde los
// datos ya almacenados en el PivotCache. Dado que los datos de origen no cambiaron,
// no se realiza ningún viaje de ida y vuelta al origen — solo se recalculan los valores en caché
// en las celdas de la hoja de cálculo.
pivotTable.calculateData();

// Guardar el libro de trabajo en disco
workbook.save("output.xlsx");

Obtener todas las tablas dinámicas que comparten el mismo PivotCache

Un libro de trabajo 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é dada.

Esta es también la forma más directa de confirmar que dos tablas dinámicas realmente comparten la misma instancia de PivotCache: puede comparar las referencias de caché, o simplemente iterar la colección devuelta por GetPivotTables() y observar qué tablas dinámicas aparecen en ella.

El siguiente ejemplo crea dos tablas dinámicas en el mismo rango de origen, verifica que comparten la misma instancia de caché y luego enumera las tablas dinámicas de la caché.

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

Antes de Aspose.Cells for Node.js via C++ 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 RefreshData() por tabla es problemático en libros de trabajo del mundo real:

Recupera datos del origen cada vez que se llama, incluso cuando el origen no ha cambiado.
Cada llamada actualiza toda la caché compartida. Cuando muchas tablas dinámicas comparten una caché, llamar repetidamente a RefreshData() por cada tabla dinámica hace que la misma caché se recupere una y otra vez, lo cual es muy lento.

Los reemplazos recomendados son:

Actualizar TODAS las tablas dinámicas del libro de trabajo → use workbook.refreshAll();
Actualizar ALGUNAS de ellas → use pivotTable.PivotCache.Refresh(); para una caché. Debido a que la caché es compartida, esta sola llamada actualiza cada tabla dinámica construida sobre esa caché. Otras tablas dinámicas que se asientan sobre una caché ya actualizada pueden omitirse de forma segura.
Solo cambió la vista/diseño de la tabla dinámica → use pivotTable.CalculateData(); para volver a renderizar desde la caché existente sin ningún viaje al origen.

El siguiente ejemplo demuestra el nuevo patrón eficiente para libros de trabajo con múltiples tablas dinámicas que comparten una sola caché.

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

// --- Construir los datos de origen: Fruta / Año / Cantidad (encabezado + 9 filas) ---
sheet.getCells().get("A1").putValue("Fruit");
sheet.getCells().get("B1").putValue("Year");
sheet.getCells().get("C1").putValue("Amount");

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

// --- Agregar la primera tabla dinámica (Pivot1) en la celda de destino E3 ---
let idx1 = sheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
let pivotTable1 = sheet.getPivotTables().get(idx1);
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// --- Agregar la SEGUNDA tabla dinámica (Pivot2) sobre el MISMO rango de origen ---
// Tanto Pivot1 como Pivot2 comparten UN único PivotCache subyacente.
// Este es exactamente el escenario donde el enfoque antiguo de RefreshData()
// por tabla se vuelve ineficiente: refrescar una tabla vuelve a obtener
// todo el caché compartido, por lo que refrescar N tablas realiza la misma
// obtención costosa N veces.
let idx2 = sheet.getPivotTables().add("A1:C9", "E15", "Pivot2");
let pivotTable2 = sheet.getPivotTables().get(idx2);
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// --- Modificar varios valores de Cantidad en los datos de origen ---
sheet.getCells().get("C2").putValue(5000);   // Uva    2020
sheet.getCells().get("C5").putValue(7500);   // Cereza 2020
sheet.getCells().get("C9").putValue(9500);   // Cereza 2021

// --- Patrón OBSOLETO (anterior a 26.7) — PivotTable.RefreshData() ---
// pivotTable1.RefreshData();  // vuelve a obtener desde el origen, refresca todo el caché
// pivotTable2.RefreshData();  // vuelve a obtener DE NUEVO — ¡el caché ya está actualizado!
// Cada llamada reconstruye el caché compartido, por lo que N tablas = N obtenciones redundantes.

// --- NUEVO patrón v26.7+: refrescar el caché UNA VEZ, luego re-renderizar según sea necesario ---
// Una llamada a PivotCache.Refresh() extrae los valores modificados al caché
// compartido Y recalcula la visualización de CADA tabla dinámica que lo referencia.
// Debido a que Pivot1 y Pivot2 comparten un único PivotCache, esta única llamada
// actualiza ambas tablas — no se requiere un segundo viaje de ida y vuelta al origen.
pivotTable1.getPivotCache().refresh();

// CalculateData() solo re-renderiza la visualización de una tabla dinámica
// (datos + estilo) a partir de los datos ya contenidos en el caché — NO toca
// el origen. Lo llamamos en Pivot2 aquí puramente para demostrar la API:
// después de que el caché se ha refrescado una vez, cualquier tabla dependiente
// puede re-renderizarse sin volver al origen. Use CalculateData() por sí solo
// cuando solo la configuración de vista/diseño de la tabla dinámica haya cambiado
// y el caché esté actualizado.
pivotTable2.calculateData();

workbook.save("output.xlsx");

¿Qué API de actualización debo usar?

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

Objetivo	API recomendada	Notas
Actualizar todo en el libro de trabajo	`Workbook.RefreshAll()`	Una llamada; cubre todas las cachés y tablas.
Actualizar solo las tablas dinámicas en una sola hoja	`Worksheet.RefreshPivotTables()`	Con alcance en una hoja de cálculo.
Los datos de origen cambiaron para una caché	`pivotTable.PivotCache.Refresh()`	Actualiza TODAS las tablas dinámicas en esa caché compartida.
Solo cambió la configuración de vista/diseño	`pivotTable.CalculateData()`	Omite el viaje innecesario al origen.
Listar todas las tablas dinámicas en una caché compartida	`pivotCache.GetPivotTables()`	Use para enumerar antes de la actualización por lotes.

En la práctica, prefiera las API basadas en caché sobre el obsoleto RefreshData() por tabla. Son conscientes de las cachés compartidas, evitan búsquedas redundantes en el origen y le permiten elegir el alcance más pequeño que satisfaga su requisito de actualización.

Nodejscpp: Aplicar estilos a tablas dinámicas en Aspose.Cells para .NET

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

Aspose.Cells admite la aplicación tanto de autoformatos heredados de tablas dinámicas (diseñados para archivos .xls) como de estilos modernos con nombre o personalizados para tablas dinámicas (diseñados para archivos .xlsx, .xlsm y .xlsb). La API que debe llamar 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 APIs de estilo 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 puede volver a guardarse como .xlsx, y en ese caso se aplica la API de estilo moderna en lugar de la heredada.

Para la salida heredada en .xls, use la propiedad PivotTable.AutoFormatType junto con la enumeración Aspose.Cells.Pivot.PivotTableAutoFormatType. Esta API corresponde al selector de autoformato que el Excel clásico ofrecía para las tablas dinámicas.

Para la salida moderna en .xlsx, .xlsm y .xlsb, hay dos variantes de API de estilo disponibles:

PivotTable.PivotTableStyleType selecciona uno de los estilos con nombre integrados (temas claros y oscuros, incluidos los estilos añadidos en Excel 2017). Estos valores preestablecidos son de solo lectura.
PivotTable.PivotTableStyleName selecciona un estilo personalizado que usted mismo define mediante Workbook.Worksheets.TableStyles.AddPivotTableStyle(...). Los estilos personalizados son necesarios siempre que desee modificar colores, bordes o fuentes más allá de lo que ofrecen los valores preestablecidos.

Además, PivotTable.FormatAll(Style) es un acceso directo que aplica un único objeto Style a todas las celdas de la tabla dinámica, sobrescribiendo lo que se haya establecido mediante cualquiera de las APIs de nombre de estilo anteriores. Esto resulta útil cuando se requiere una apariencia uniforme independientemente del tema subyacente.

Aplicar un autoformato preestablecido heredado de XLS

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.

AutoFormatType solo se respeta cuando el libro se guarda como .xls. Cuando el mismo libro se guarda como .xlsx, .xlsm o .xlsb, Excel ignora esta propiedad y recurre a la configuración de PivotTableStyleType y PivotTableStyleName.

El siguiente ejemplo carga un libro nuevo, completa los datos de muestra de Fruta/Año/Importe, 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) se diseñaron en el Excel clásico para tablas dinámicas unidimensionales con solo campos de fila y valores — no tienen estilo integrado para los encabezados de campos de columna. Si tu tabla dinámica necesita campos de columna, usa los preajustes modernos PivotTableStyleType del Escenario 2 a continuación, que están diseñados para el diseño bidimensional que usa el Excel moderno.

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

// Escenario 1: Aplicar un autoformato preestablecido XLS heredado
// API en uso: PivotTable.AutoFormatType
// Formato de archivo de destino: .xls (heredado)
// Para ejemplos completos y archivos de datos, vaya a https://github.com/aspose-cells/Aspose.Cells-for-.NET

// Crear un nuevo libro
const workbook = new AsposeCells.Workbook();

// Obtener la primera hoja de cálculo
const sheet = workbook.getWorksheets().get(0);

// Rellenar los datos de origen con la fila de encabezado (Fruta, Año, Cantidad)
// y 9 filas de datos que cubren uva, arándano, kiwi, cereza 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 de destino E3, llamada "Pivot1", usando el rango de origen A1:C10
const pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
const pivotTable = sheet.getPivotTables().get(pivotIndex);

// Asignar campos: Fruta -> Filas, Año -> Columnas, Cantidad -> Datos
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Aplicar el autoformato preestablecido "Report5" del XLS heredado
// Nota: Esta propiedad solo es significativa al guardar como .xls.
// Cuando se guarda como .xlsx/.xlsm/.xlsb, Excel ignora AutoFormatType
// y usa lo que especifique PivotTableStyleType / PivotTableStyleName.
pivotTable.setAutoFormatType(AsposeCells.PivotTableAutoFormatType.Report5);

// Guardar el libro en formato .xls heredado
workbook.save("output.xls");

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

PivotTable.PivotTableStyleType acepta un valor de la enumeración Aspose.Cells.PivotTableStyleType. La enumeración cubre los temas claros PivotTableStyleLight1 a PivotTableStyleLight28 y los temas oscuros PivotTableStyleDark1 a PivotTableStyleDark28. Los estilos añadidos en Excel 2017 (la segunda ola de temas claros y oscuros) son accesibles a través de la misma enumeración.

Esta es la API recomendada para cualquier formato de archivo moderno. A diferencia del autoformato heredado, el estilo seleccionado aquí se representa fielmente en Excel y sobrevive a idas y vueltas a través de otras herramientas de Office.

El siguiente ejemplo usa los mismos datos de Fruta/Año/Importe, crea una tabla dinámica idéntica, aplica PivotTableStyleDark1 y guarda el libro como .xlsx.

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

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

// 9 filas de datos de Fruta / Año / Cantidad
worksheet.getCells().get("A2").putValue("Grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(100);

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

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

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

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

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

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

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

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

// Agregar una tabla dinámica en E3 llamada "Pivot1", con origen en A1:C10
let pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Asignar campos de la tabla dinámica: Fruta -> área de Filas, Año -> área de Columnas, Cantidad -> área de Datos
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Aplicar un estilo de tabla dinámica preestablecido con nombre moderno de Excel 2007+.
// PivotTableStyleType es la API correcta para archivos .xlsx / .xlsm / .xlsb; AutoFormatType
// es ignorado por Excel para esos formatos. PivotTableStyleDark1 pertenece a la familia del tema oscuro
// (PivotTableStyleDark1..PivotTableStyleDark28), y el mismo enum también expone los
// temas claros/oscuros más nuevos de Excel 2017 (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivotTable.setPivotTableStyleType(AsposeCells.PivotTableStyleType.PivotTableStyleDark1);

// Guardar como .xlsx moderno — este es el formato para el cual PivotTableStyleType es significativo.
workbook.save("output.xlsx");

Definir y aplicar un estilo de tabla dinámica personalizado

Los valores preestablecidos integrados no se pueden modificar. Siempre que necesite sobrescribir colores, bordes o fuentes, debe definir un estilo de tabla dinámica personalizado. El flujo de trabajo tiene tres pasos:

Añada un estilo personalizado a la colección TableStyles del libro mediante Workbook.Worksheets.TableStyles.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 luego asigne un Style a cada elemento mediante TableStyleElement.SetElementStyle(Style).
Aplique el estilo personalizado a la tabla dinámica estableciendo PivotTable.PivotTableStyleName con el nombre del estilo. No use PivotTableStyleType aquí, ya que esa propiedad selecciona los valores preestablecidos integrados.

PivotTableStyleName y PivotTableStyleType no son intercambiables. Use PivotTableStyleType para los valores preestablecidos integrados, y PivotTableStyleName para los estilos personalizados que haya definido mediante AddPivotTableStyle. Establecer ambos es inofensivo, pero solo se representa 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 de tabla dinámica personalizado 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);

// Poblar datos fuente: 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.WholeTable);
let wholeTableElement = tableStyle.getTableStyleElements().get(wholeTableElementIndex);
let wholeTableStyle = workbook.createStyle();
wholeTableStyle.getBorders().get(AsposeCells.BorderType.TopBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.TopBorder).setColor(AsposeCells.Color.Black);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.BottomBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.BottomBorder).setColor(AsposeCells.Color.Black);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.LeftBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.LeftBorder).setColor(AsposeCells.Color.Black);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.RightBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.RightBorder).setColor(AsposeCells.Color.Black);
wholeTableElement.setElementStyle(wholeTableStyle);

// Paso 3: agregar un elemento GrandTotalRow y aplicar fuente roja en negrita
let grandTotalElementIndex = tableStyle.getTableStyleElements().add(AsposeCells.TableStyleElementType.GrandTotalRow);
let grandTotalElement = tableStyle.getTableStyleElements().get(grandTotalElementIndex);
let grandTotalStyle = workbook.createStyle();
grandTotalStyle.getFont().setIsBold(true);
grandTotalStyle.getFont().setColor(AsposeCells.Color.Red);
grandTotalElement.setElementStyle(grandTotalStyle);

// Paso 4: aplicar el estilo personalizado por nombre (NO por PivotTableStyleType, que es para ajustes preestablecidos integrados)
pivotTable.setPivotTableStyleName("CustomPivotStyle");

workbook.save("output.xlsx");

Aplicar un único estilo a todas las celdas de la tabla dinámica con FormatAll

PivotTable.FormatAll(Style) es un acceso directo que aplica un único objeto Style a todas las celdas de la tabla dinámica, incluyendo el área de datos, los encabezados de fila y columna, y los totales. Lo que se haya establecido previamente mediante PivotTableStyleType o PivotTableStyleName queda sobrescrito.

FormatAll sobrescribe tanto PivotTableStyleType como PivotTableStyleName. Úselo 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 de origen: 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 de origen 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");

// Construir un Estilo que se forzará sobre 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 sobre cada celda de la tabla dinámica,
// anulando cualquier PivotTableStyleType / PivotTableStyleName establecido previamente
pivotTable.formatAll(style);

// Guardar el libro en el formato moderno .xlsx
workbook.save("output.xlsx");

¿Qué API de estilo debo usar?

La elección de la API de estilo depende del formato de archivo en el que está guardando. Use 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 en 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.TableStyles.AddPivotTableStyle(...)`	Use cuando los valores preestablecidos integrados no son suficientes. Configure mediante `TableStyleElement.SetElementStyle(...)`.
Cualquier formato (sobrescritura 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 temas integrados, o PivotTableStyleName para temas personalizados.

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

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

Añadir un campo a la región de fila o columna

El método PivotTable.AddFieldToArea(PivotFieldType fieldType, string fieldName) mueve un campo base desde los datos de origen a 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

Después de añadir los campos, puede acceder a ellos a través de las propiedades PivotTable.RowFields y PivotTable.ColumnFields. Cada propiedad devuelve un PivotFieldCollection. El campo en el índice 0 de RowFields es el campo de fila más externo, y los índices siguientes 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. Añadir Category a la región de fila 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, bool shown) controla qué filas de subtotal aparecen para un campo dinámico. Cada llamada activa 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 construye un subconjunto personalizado de subtotales.

La enumeración PivotFieldSubtotalType define los tipos de subtotales disponibles.

Automatic — Aspose.Cells elige la selección predeterminada (normalmente Sum para campos numéricos)
None — suprime todas las filas de subtotal
Sum
Count
Average
Max
Min
Product
StdDev
StdDevp
Var
Varp

Los subtotales solo se representan cuando hay dos o más campos dinámicos en la región de fila (o en la región de columna). Un solo campo no tiene nada significativo entre lo que calcular un subtotal, por lo que las llamadas a SetSubtotals no tienen un efecto visible en ese caso. Por lo tanto, este artículo coloca dos campos de fila (Category exterior, Item interior) en cada ejemplo para que el límite de subtotal entre cada grupo de 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 exterior 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 campos y el total general en la parte inferior. Esto es útil cuando desea los datos agrupados en bruto sin ninguna fila de resumen.

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

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

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

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

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

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

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

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

workbook.save("output_none.xlsx");

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

No está limitado a un solo tipo de subtotal. Cada llamada a SetSubtotals opera de forma independiente sobre un tipo, por lo que llamar al método dos veces — una vez 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 exterior Category. Recuerde la regla de los dos campos: un solo campo en una región no tiene nada entre lo que calcular un subtotal, así que coloque siempre al menos dos campos en la región de fila o columna cuando quiera que SetSubtotals tenga un efecto visible.

Nodejscpp: Administrar campos de valor de una tabla dinámica en Aspose.Cells para .NET

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

Añadir 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 un campo se añade 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 usa Count por defecto.

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

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

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

// Filas de datos A2:D9 usando bucles anidados ramificándose en j
for (let i = 1; i <= 8; i++) {
 for (let j = 0; j < 4; j++) {
 switch (j) {
 case 0:
 worksheet.getCells().get(i, j).putValue(i <= 4 ? "Fruit" : "Vegetable");
 break;
 case 1:
 if (i === 1 || i === 2) worksheet.getCells().get(i, j).putValue("Apple");
 else if (i === 3 || i === 4) worksheet.getCells().get(i, j).putValue("Banana");
 else if (i === 5 || i === 6) worksheet.getCells().get(i, j).putValue("Carrot");
 else worksheet.getCells().get(i, j).putValue("Daikon");
 break;
 case 2:
 worksheet.getCells().get(i, j).putValue(2020 + ((i - 1) % 2));
 break;
 case 3:
 if (i === 1) worksheet.getCells().get(i, j).putValue(100);
 else if (i === 2) worksheet.getCells().get(i, j).putValue(150);
 else if (i === 3) worksheet.getCells().get(i, j).putValue(80);
 else if (i === 4) worksheet.getCells().get(i, j).putValue(90);
 else if (i === 5) worksheet.getCells().get(i, j).putValue(50);
 else if (i === 6) worksheet.getCells().get(i, j).putValue(60);
 else if (i === 7) worksheet.getCells().get(i, j).putValue(40);
 else worksheet.getCells().get(i, j).putValue(45);
 break;
 }
 }
}

// Agregar tabla dinámica en F3 con el nombre PivotTable1
const pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1", true, false);
const pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Diseño de tabla dinámica: Categoría y Elemento en Fila, Año en Columna, Monto como campo de datos
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Data, "Amount");

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

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 las agregaciones disponibles, incluyendo Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var y Varp.

Cambiar la función de resumen solo afecta a la agregación, 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 apunte a la misma columna de origen pero use Count o Average, todo en una sola tabla dinámica.

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

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

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

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

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

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

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

pivotTable.calculateData();

workbook.save("output_function.xlsx");

Colocar campos de valor en el eje de fila o columna

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 la agregación de cada campo de datos que reside en la región de datos. Puede arrastrarlo a la región de fila o columna como un campo dinámico base, lo que resulta útil para disponer varias medidas en paralelo.

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

Los escenarios a continuación recorren tres ejemplos de extremo a extremo que demuestran cada capacidad descrita anteriormente sobre la misma estructura de tabla dinámica.

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

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

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

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

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

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

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

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

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

Nodejscpp: 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 las tablas dinámicas. Puede agregar un campo de filtro mediante una API de conveniencia 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, limpiarlo para mostrar todos los elementos de la 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 muestra el cuerpo de la tabla dinámica. Los usuarios finales lo ven como una lista 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 manera 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 en 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 hacia adelante y hacia atrás entre estos comportamientos alternando una sola propiedad.

Aspose.Cells for Node.js via C++ expone dos formas equivalentes de 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 agrega el campo en una sola llamada. La API de bajo nivel es PivotTable.pageFields.add(PivotField), que se utiliza cuando ya tiene una referencia PivotField y desea agregar la misma instancia de campo al área de filtro. Ambas APIs terminan poblando 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.

Agregar 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 dinámicas. Ambas llamadas colocan el campo en PivotTable.pageFields, tras lo cual aparece como la lista desplegable de página en la parte superior de la tabla dinámica renderizada.

Agregar 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 encabezados
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 Dato, 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
workbook.save("pageFieldSample.xlsx");

Agregar un campo de filtro con pageFields.add

Cuando ya trabaja con una instancia PivotField, puede pasarla directamente a PivotTable.pageFields.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 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);

// Fruta -> Fila, Cantidad -> Datos (Año irá a Página abajo)
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Enfoque de bajo nivel: obtener el PivotField de Año existente desde BaseFields
// y registrarlo en el área de Página 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 (mostrar un elemento de página)

En el comportamiento predeterminado de selección única, el campo de filtro se renderiza como una sola lista 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 elige ese único elemento; asignar el centinela especial 0x7FFD (decimal 32765) limpia el filtro para que todos los elementos de página se resuman a la vez. La selección única es el valor predeterminado; no necesita habilitarla explícitamente.

Mostrar todos los elementos

Establecer currentPageItem en el valor mágico 0x7FFD equivale a limpiar 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.

let workbook = new AsposeCells.Workbook();
let 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");

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

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

// Crear tabla dinámica en E3
let pivotTables = sheet.getPivotTables();
let index = pivotTables.add("=A1:C7", "E3", "PivotTable1");
let pivotTable = pivotTables.get(index);

// Configurar campos dinámicos: 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 cada elemento del campo de página sea visible.
// 0x7FFD (decimal 32765) es el valor centinela especial que significa "todos los elementos" —
// equivalente a seleccionar "(Todos)" en el menú 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 en un índice real selecciona solo ese elemento de página. El índice es la posición del elemento en la lista de elementos ordenada del campo de filtro, por lo que, por ejemplo, 1 selecciona el segundo elemento después de 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").putValue("Fruit");
cells.get("B1").putValue("Year");
cells.get("C1").putValue("Amount");

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

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

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

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

// 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 de clasificación (por ejemplo, "2021")

// Actualizar y calcular la tabla dinámica
pivotTable.calculateData();

workbook.save("output.xlsx");

Filtrado de selección múltiple

El filtrado de selección múltiple convierte la lista desplegable de la 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 funcionan 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 permitir solo 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 cada elemento de página al dejar isHidden establecido en false para cada entrada, mientras que la Parte B permite solo los valores de origen que elija y oculta todo lo demás mediante un bloque switch (pivotItems[i].getStringValue()).

let workbook = new AsposeCells.Workbook();
let sheet = workbook.getWorksheets().get(0);
let 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");

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

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

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

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

// — Habilitar selección múltiple en el campo de página
pivotTable.getPageFields().get(0).setIsMultipleItemSelectionAllowed(true);

// Parte A — seleccionar TODOS los elementos (hacer visible cada elemento)
let pivotItems = pivotTable.getPageFields().get(0).getPivotItems();
for (let i = 0; i < pivotItems.getCount(); i++) {
    pivotItems.get(i).setIsHidden(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).setIsHidden(false);
            break;
        default:
            pivotItems.get(i).setIsHidden(true);
            break;
    }
}

pivotTable.calculateData();

workbook.save("output.xlsx");

Nota: Al usar el filtrado de selección múltiple a través de PivotItem.isHidden, al menos un PivotItem debe permanecer visible (isHidden == false). Si todos los elementos están ocultos, Excel se bloquea al abrir el archivo o renderiza una tabla dinámica en blanco. Siempre verifique que su lista permitida 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
Agregar un campo de filtro por nombre de columna de origen (lo 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 `PivotField`.
Agregar un campo de filtro cuando ya tiene un objeto `PivotField`	`PivotTable.pageFields.add(PivotField)`	n/a	Use cuando el objeto de campo se obtuvo en otro lugar o necesita reutilizarse.
Filtrar a un solo elemento de página (modo predeterminado)	`PivotField.currentPageItem`	establecer en un índice específico	Por ejemplo, `1` muestra el segundo elemento en la lista ordenada.
Mostrar todos los elementos / limpiar el filtro de página	`PivotField.currentPageItem`	establecer en `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 todos los PivotItem en un campo de filtro de selección múltiple están ocultos, Excel se bloquea al abrir o renderiza una tabla dinámica en blanco. Construya su lista permitida contra sus datos de origen para que al menos un elemento permanezca visible, y sus libros de trabajo guardados se abrirán de manera confiable en cualquier máquina.

Nodejscpp: Eliminar la tabla dinámica de una hoja de cálculo

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

Aspose.Cells for Node.js via C++ ofrece una función para eliminar o borrar una tabla dinámica de una hoja de trabajo. Puedes borrar la tabla dinámica usando el objeto de la tabla dinámica o su posición. Por favor, usa el método Worksheet.getPivotTables().remove(pivotTable) para eliminar la tabla dinámica usando el objeto de la tabla dinámica y el método Worksheet.getPivotTables().removeAt(index, keepData) para eliminar la tabla dinámica usando su posición dentro de la colección de tablas dinámicas.

Cómo eliminar la tabla dinámica de la hoja de cálculo usando Aspose.Cells for Node.js via C++

El siguiente código de muestra elimina dos tablas dinámicas de la hoja de cálculo. Primero elimina la tabla dinámica usando el método Worksheet.getPivotTables().remove(pivotTable) y luego elimina la tabla dinámica usando el método Worksheet.getPivotTables().removeAt(index, keepData)

Nodejscpp: Guardar tabla dinámica en archivo ODS

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

Aspose.Cells for Node.js via C++ proporciona la capacidad de guardar la tabla dinámica en archivos ODS. Para ello, simplemente convierte un libro de trabajo con una tabla dinámica existente o crea una nueva y guarda el archivo en formato ODS. Asegúrate de llamar a PivotTable.calculateData antes de guardar para garantizar que la tabla dinámica se renderice en el archivo ODS de salida. El siguiente fragmento de código demuestra cómo guardar la tabla dinámica en un archivo ODS.

Código de Muestra

El archivo de salida generado del código anterior está adjunto para su referencia.

Archivo ODS de salida

Documentation – Insertar tabla dinámica

Nodejscpp: Dar formato a la tabla dinámica

Apariencia de la tabla dinámica

Cómo establecer opciones de formato de tabla dinámica

Cómo establecer el tipo de autoformato

Cómo establecer opciones de formato

Dar formato manualmente al aspecto visual

Cómo establecer opciones de formato de campo de tabla dinámica

Cómo establecer el formato de campos de fila/columna/página.

Cómo establecer el formato de campos de datos.

Cómo limpiar los campos de filtro.

Nodejscpp: Crear tablas dinámicas y gráficos dinámicos

Agregar tablas dinámicas y gráficos usando Aspose.Cells for Node.js via C++

Prepararse para usar Aspose.Cells for Node.js via C++

Cómo agregar una tabla dinámica usando Aspose.Cells for Node.js via C++

Cómo agregar un gráfico dinámico usando la biblioteca Aspose.Cells for Node.js via C++

Nodejscpp: Tabla dinámica y datos fuente

Datos fuente de la tabla dinámica

Cambio de la fuente de datos de una tabla dinámica

Nodejscpp: Agregar campo calculado en tabla dinámica

Escenarios de uso posibles

Cómo agregar un campo calculado en una tabla dinámica en Excel

Cómo agregar un campo calculado en Tabla dinámica usando la biblioteca Aspose.Cells for Node.js via C++

Código de muestra

Nodejscpp: Actualización de tablas dinámicas en Aspose.Cells for Node.js via C++

Introducción

Importaciones requeridas

Actualizar todas las tablas dinámicas del libro de trabajo

Actualizar todas las tablas dinámicas en una sola hoja de cálculo

Actualizar una sola tabla dinámica

Datos de origen modificados — Use PivotCache.Refresh()

Solo cambió la vista/diseño — Use CalculateData()

Obtener todas las tablas dinámicas que comparten el mismo PivotCache

Migración desde el obsoleto PivotTable.RefreshData()

¿Qué API de actualización debo usar?

Nodejscpp: Aplicar estilos a tablas dinámicas en Aspose.Cells para .NET

Introducción

Aplicar un autoformato preestablecido heredado de XLS

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

Definir y aplicar un estilo de tabla dinámica personalizado

Aplicar un único estilo a todas las celdas de la tabla dinámica con FormatAll

¿Qué API de estilo debo usar?

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

Añadir un campo a la región de fila o columna

Subtotales de campos dinámicos

Escenario 1 — Subtotales automáticos (predeterminados)

Escenario 2 — Suprimir todos los subtotales (None)

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

Resumen

Nodejscpp: Administrar campos de valor de una tabla dinámica en Aspose.Cells para .NET

Añadir un campo a la región de datos

Cambiar la función de resumen

Colocar campos de valor en el eje de fila o columna

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

Introducción

Agregar un campo de filtro

Agregar un campo de filtro con addFieldToArea

Agregar un campo de filtro con pageFields.add

Filtrado de selección única (mostrar 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?

Nodejscpp: Eliminar la tabla dinámica de una hoja de cálculo

Cómo eliminar la tabla dinámica de la hoja de cálculo usando Aspose.Cells for Node.js via C++

Nodejscpp: Guardar tabla dinámica en archivo ODS

Código de Muestra

Datos de origen modificados — Use `PivotCache.Refresh()`

Solo cambió la vista/diseño — Use `CalculateData()`

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