Documentation – Inserisci tabella pivot

Nodejscpp: Formattazione della tabella pivot

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

Aspetto della tabella pivot

Come creare una tabella pivot spiega come creare una semplice tabella pivot. Questo articolo descrive come personalizzare l’aspetto di una tabella pivot impostando diverse proprietà:

Opzioni di formato tabella pivot
Opzioni di formato dei campi pivot
Opzioni di formato del campo dati

Come impostare le opzioni di formato tabella pivot

La classe PivotTable controlla complessivamente la tabella pivot e può essere formattata in vari modi.

Come impostare il tipo di autoformato

Microsoft Excel offre diversi formati di rapporto preimpostati. Aspose.Cells for Node.js via C++ supporta anche queste opzioni di formattazione. Per accedervi:

Imposta PivotTable.setIsAutoFormat(value) su vero.
Assegna un’opzione di formattazione dall’enumerazione PivotTableAutoFormatType.

Come impostare le opzioni di formattazione

Il codice di esempio qui sotto mostra come formattare la tabella pivot per mostrare i totali generali per righe e colonne, e come impostare l’ordine dei campi del report. Mostra inoltre come impostare una stringa personalizzata per i valori nulli.

Formattazione Aspetto e Sensazione Manualmente

Per formattare manualmente l’aspetto del report della tabella pivot, anziché utilizzare formati di report predefiniti, utilizzare i metodi PivotTable.formatAll(style) e PivotTable.format(row, column, style). Creare un oggetto stile per la formattazione desiderata, ad esempio:

Come impostare le opzioni di formato campo pivot

La classe PivotField rappresenta un campo in una tabella pivot e può essere formattata in vari modi. Il codice di esempio qui sotto mostra come:

Accedere ai campi di riga.
Impostare i subtotali.
Impostazione dell’ordinamento automatico.
Impostazione dell’autovisualizzazione.

Come impostare il formato dei campi riga/colonna/pagina

Come impostare il formato dei campi dati

Il campione di codice sottostante mostra come impostare i formati di visualizzazione e il formato numerico per i campi dati.

Come eliminare i campi di un Pivot

Il PivotFieldCollection ha un metodo chiamato clear() che ti consente di eliminare i campi di un Pivot. Usalo quando vuoi eliminare tutti i campi di un Pivot nelle aree, ad esempio, pagina, colonna, riga o dati. Il campione di codice sottostante mostra come eliminare tutti i campi di un Pivot in un’area dati.

Nodejscpp: Creare Tabelle Pivot e Grafici Pivot

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

Una tabella pivot è un riassunto interattivo di record. Ad esempio, potresti avere centinaia di voci di fattura in un elenco in un foglio di lavoro. Una tabella pivot può totalizzare le fatture per cliente, prodotto o data. Con Microsoft Excel è possibile ridisporre rapidamente le informazioni nella tabella pivot trascinando i pulsanti in una nuova posizione.

Un grafico pivot è una rappresentazione grafica interattiva dei dati in una tabella pivot. I grafici pivot sono stati introdotti in Excel 2000. Utilizzando un grafico pivot è ancora più facile capire i dati poiché la tabella pivot crea automaticamente subtotali e totali.

Aspose.Cells for Node.js via C++ supporta tabelle pivot e grafici pivot.

Aggiungi tabelle pivot e grafici usando Aspose.Cells for Node.js via C++

Aspose.Cells for Node.js via C++ fornisce un insieme speciale di classi usate per creare tabelle pivot. Queste classi sono utilizzate per creare e impostare oggetti PivotTable, che fungono da blocchi di costruzione di base per un oggetto PivotTable:

PivotField, un campo in un rapporto di tabella pivot.
PivotFields, una raccolta di tutti gli oggetti PivotField in una tabella pivot.
PivotTable, un rapporto di tabella pivot su un foglio di lavoro.
PivotTables, una raccolta di tutti gli oggetti PivotTable sul foglio di lavoro.

Prepararsi a usare Aspose.Cells for Node.js via C++

Installa Aspose.Cells for Node.js via C++ da NPM, usa il comando: $ npm install aspose.cells.node.
Puoi anche seguire le istruzioni passo passo su come installare “Aspose.Cells for Node.js via C++” nel tuo ambiente di sviluppo.

Come aggiungere una tabella pivot usando Aspose.Cells for Node.js via C++

Per creare una tabella pivot usando Aspose.Cells for Node.js via C++:

Aggiungi alcuni dati alle celle di un foglio di lavoro utilizzando il metodo put_value di un oggetto Cell. Puoi anche utilizzare un file modello già compilato con dati. I dati verranno utilizzati come origine dati della tabella pivot.
Aggiungi una tabella pivot al foglio di lavoro chiamando il metodo add della collezione PivotTables (incapsulato nell’oggetto Worksheet).
Accedi al nuovo oggetto PivotTable dalla collezione PivotTables passando il suo indice. # Usa uno qualsiasi degli oggetti tabella pivot incapsulati nell’oggetto PivotTable per gestire la tabella.

Di seguito sono riportati esempi di codice.

Come aggiungere un grafico pivot usando la libreria Aspose.Cells for Node.js via C++

Per creare un PivotChart usando Aspose.Cells for Node.js via C++:

Aggiungi un grafico.
Imposta il PivotSource del grafico per fare riferimento a una tabella pivot esistente nel foglio di calcolo.
Imposta altri attributi.

Nodejscpp: Tabella Pivot e Dati di Origine

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

Dati di Origine della Tabella Pivot

Ci sono momenti in cui si desidera creare report di Microsoft Excel con tabelle pivot che prendono dati da diverse fonti di dati (come un database) che non sono noti al momento della progettazione. Questo articolo fornisce un approccio per cambiare dinamicamente la fonte dati di una tabella pivot.

Cambiare i Dati di Origine di una Tabella Pivot

Creazione di un nuovo modello di design.
1. Creare un nuovo file di modello di design come nella schermata qui sotto.
2. Definire quindi un intervallo nominato, DataSource, che si riferisce a questo intervallo di celle.
  
  Creazione di un modello di design e definizione di un intervallo nominato, DataSource

Creazione di una Tabella Pivot basata su questo intervallo nominato.
1. In Microsoft Excel, scegliere Dati, quindi Tabella Pivot e Rapporto Tabella Pivot.
2. Creare una tabella pivot basata sull’intervallo nominato creato nel primo passaggio.
  
  Creazione di una tabella pivot basata sull’intervallo nominato, DataSource

Trascinare il campo corrispondente sulla riga e sulla colonna della tabella pivot, quindi creare la tabella pivot risultante come nella schermata qui sotto.

Creazione di una tabella pivot basata su un campo corrispondente

Fare clic con il tasto destro sulla tabella pivot e selezionare Opzioni Tabella.
1. Seleziona Aggiorna all’apertura nelle impostazioni delle Opzioni dati.
  
  Impostare le opzioni della tabella pivot

Ora puoi salvare questo file come il file del modello del tuo designer.

Popolazione di nuovi dati e modifica dei dati di origine di una tabella pivot.
1. Una volta creato il modello del designer, utilizza il codice seguente per modificare i dati di origine della tabella pivot.

Eseguendo il codice di esempio sottostante si cambia il dato di origine della tabella pivot.

Nodejscpp: Aggiungi campo calcolato nella tabella pivot

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

Possibili Scenari di Utilizzo

Quando crei una tabella pivot basata su dati noti, scopri che i dati al suo interno non sono quelli che desideri. I dati che desideri sono la combinazione di questi dati originali. Ad esempio, è necessario aggiungere, sottrarre, moltiplicare e dividere i dati originali prima di volerli. A questo punto, è necessario creare un campo calcolato e impostare la formula corrispondente per il calcolo. Quindi eseguire alcune statistiche e altre operazioni sul campo calcolato.

Come aggiungere un campo calcolato nella tabella pivot in Excel

Inserisci un campo calcolato in una tabella pivot in Excel, segui questi passaggi:

Seleziona la tabella pivot a cui desideri aggiungere un campo calcolato.
Vai alla scheda Analizza tabella pivot nel menu a nastro.
Fai clic su “Campi, elementi e set” e quindi seleziona “Campo calcolato” dal menu a discesa.
Nel campo “Nome”, inserire un nome per il campo calcolato.
Nel campo “Formula”, inserire la formula per il calcolo che si desidera eseguire utilizzando i nomi dei campi del PivotTable appropriati e gli operatori matematici.
Fare clic su “ok” per creare il campo calcolato.
Il nuovo campo calcolato apparirà nell’elenco dei campi del PivotTable nella sezione dei Valori.
Trascinare il campo calcolato nella sezione dei Valori del PivotTable per visualizzare i valori calcolati.

Come aggiungere un campo calcolato in una tabella pivot usando la libreria Aspose.Cells for Node.js via C++

Aggiungi un campo calcolato al file Excel usando Aspose.Cells for Node.js via C++. Consulta il seguente esempio di codice. Dopo aver eseguito il codice di esempio, verrà aggiunta una tabella pivot con campo calcolato al foglio di lavoro.

Impostare i dati originali e creare una tabella pivot.
Creare il campo calcolato in base al PivotField esistente nella tabella pivot.
Aggiungere il campo calcolato all’area dati.
Infine, salvare il libro di lavoro nel formato output XLSX.

Codice di Esempio

Nodejscpp: Aggiornamento delle tabelle pivot in Aspose.Cells for Node.js via C++

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

Aspose.Cells fornisce un’API di aggiornamento a più livelli che consente di ricaricare i dati pivot in quattro ambiti diversi — dall’intera cartella di lavoro fino a una singola tabella pivot. A partire da Aspose.Cells for Node.js via C++ v26.7, il metodo legacy PivotTable.RefreshData() è contrassegnato come obsoleto e dovrebbe essere sostituito con le API più efficienti e consapevoli della cache descritte in questo articolo.

Introduzione

L’aggiornamento di una tabella pivot raramente è una singola operazione. Dietro le quinte, Aspose.Cells mantiene una catena di dati a più livelli che collega i dati di origine originali ai valori visualizzati nel foglio di lavoro. Comprendere questa catena è la chiave per scegliere l’API di aggiornamento giusta per ogni situazione.

La catena di dati a quattro livelli è:

Origine dati — gli intervalli originali del foglio di lavoro, le query di database o gli intervalli di consolidamento in cui risiedono i valori grezzi.
PivotCache — l’istantanea in memoria dei dati di origine. Ogni tabella pivot è costruita sopra un PivotCache; è qui che tutti i dati vengono raccolti e aggregati.
PivotTable — l’oggetto vista che definisce i campi riga, colonna, valore e filtro. Una PivotTable legge solo dal proprio PivotCache, mai direttamente dall’origine dati.
Cells — le Cells del foglio di lavoro in cui la PivotTable rende i valori calcolati e gli stili.

Un concetto particolarmente importante è la cache condivisa. Quando più tabelle pivot in una cartella di lavoro fanno riferimento allo stesso intervallo di origine, condividono una singola istanza di PivotCache. Un singolo PivotCache può essere referenziato da molte tabelle pivot, e l’aggiornamento di quella cache aggiorna immediatamente ogni PivotTable dipendente.

PivotCache.SourceType (enum PivotTableSourceType) indica da dove provengono i dati della cache. A partire da v26.7, PivotCache.Refresh() supporta solo i tipi di origine Sheet e Consolidation — ovvero dati che risiedono negli intervalli del foglio di lavoro. Le origini esterne (database, connessioni esterne, ecc.) non sono ancora aggiornabili tramite l’API della cache.

A causa di questa catena, esistono due percorsi di aggiornamento fondamentali in Aspose.Cells:

PivotCache.Refresh() — ricarica l’origine nella cache E ricalcola tutte le PivotTable dipendenti in un’unica operazione.
PivotTable.CalculateData() — ricalcola la visualizzazione di una PivotTable dai dati già memorizzati nella cache, senza tornare all’origine dati.

Tutti gli scenari in questo articolo utilizzano dati di origine provenienti da celle del foglio di lavoro, quindi il tipo di origine è Sheet e le operazioni di aggiornamento si comportano come descritto.

Importazioni richieste

Tutti gli esempi JavaScript in questo articolo presuppongono che il modulo Aspose.Cells for Node.js via C++ sia stato caricato e che i tipi pivot risiedano nel namespace Aspose.Cells.Pivot. Una configurazione tipica è:

const AsposeCells = require("aspose.cells.node");
const { PivotFieldType } = AsposeCells; (oppure accedere tramite AsposeCells.Pivot.PivotFieldType)

Aggiornare tutte le tabelle pivot nella cartella di lavoro

Quando è necessario garantire che ogni cache pivot e ogni tabella pivot nella cartella di lavoro rifletta i dati di origine più recenti, l’API più semplice e completa è Workbook.RefreshAll(). Una singola chiamata attraversa l’intera cartella di lavoro — aggiornando ogni PivotCache dalla propria origine e quindi ricalcolando ogni PivotTable dipendente. Questo è l’approccio consigliato per aggiornamenti generali e completi del documento in cui le prestazioni non sono un problema.

L’esempio seguente crea una cartella di lavoro con un intervallo di origine Frutto/Anno/Importo, crea una tabella pivot, modifica alcuni valori di origine e quindi utilizza RefreshAll() per portare tutto aggiornato in un’unica chiamata.

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

// Scrivi la riga di intestazione nelle celle A1:C1
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Scrivi le righe di dati nelle celle A2:C9 (8 righe di dati sulla frutta per il 2020 e il 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);

// Aggiungi una tabella pivot: intervallo di origine "A1:C9", cella di destinazione "E3", nome "Pivot1"
let pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Assegna i campi pivot: Fruit a Righe, Year a Colonne, Amount a Dati
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Modifica diversi valori di Amount nei dati di origine per simulare le modifiche
worksheet.getCells().get("C2").putValue(55);
worksheet.getCells().get("C5").putValue(85);
worksheet.getCells().get("C9").putValue(125);

// Aggiorna ogni tabella pivot / cache pivot nella cartella di lavoro
workbook.refreshAll();

// Salva la cartella di lavoro
workbook.save("output.xlsx");

Aggiornare tutte le tabelle pivot su un singolo foglio di lavoro

A volte è necessario aggiornare solo le tabelle pivot che si trovano su un foglio di lavoro specifico — ad esempio, quando le tabelle pivot su altri fogli di lavoro non sono correlate e non devono essere toccate. Per questo caso, Aspose.Cells fornisce Worksheet.RefreshPivotTables(), che è limitato a una singola istanza di Worksheet.

Questo è più selettivo rispetto a Workbook.RefreshAll(): vengono aggiornate solo le tabelle pivot nel foglio di lavoro di destinazione, lasciando intatte le tabelle pivot negli altri fogli di lavoro.

L’esempio seguente popola gli stessi dati di origine Frutto/Anno/Importo, aggiunge una tabella pivot sul primo foglio di lavoro, modifica alcuni valori di origine e quindi aggiorna solo le tabelle pivot su quel foglio di lavoro.

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

Aggiornare una singola tabella pivot

Quando si desidera un controllo granulare su una singola tabella pivot, l’API basata sulla cache offre due opzioni. La scelta tra esse dipende da cosa è effettivamente cambiato: i dati di origine sottostanti, o solo le impostazioni di vista/layout della tabella pivot stessa.

Dati di origine modificati — Usare `PivotCache.Refresh()`

Se i dati di origine sottostanti sono cambiati, il giusto punto di ingresso è pivotTable.PivotCache.Refresh(). Questa chiamata rilegge i dati di origine nella cache e quindi ricalcola ogni PivotTable che dipende da quella cache.

Poiché le tabelle pivot condividono una singola istanza di PivotCache, chiamare PivotCache.Refresh() ricalcola tutte le tabelle pivot costruite su quella stessa cache — non solo quella a cui fai riferimento. Se due tabelle pivot condividono lo stesso intervallo di origine, l’aggiornamento di una cache aggiorna entrambe.

L’esempio seguente crea due tabelle pivot sullo stesso intervallo di origine per dimostrare questo comportamento di cache condivisa, modifica alcuni valori di origine e quindi aggiorna tramite un riferimento di cache.

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

// Crea una nuova cartella di lavoro e accedi al primo foglio di lavoro
const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);

// Scrivi la riga di intestazione: Frutto / Anno / Quantità
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Scrivi circa 9 righe di dati (uva / mirtillo / kiwi / ciliegia per 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);

// Aggiungi la prima tabella pivot "Pivot1" ancorata alla cella E3, intervallo di origine A1:C9
const pivotIndex1 = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
const pivotTable1 = worksheet.getPivotTables().get(pivotIndex1);

// Assegna i campi per Pivot1
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Aggiungi una SECONDA tabella pivot "Pivot2" ancorata a E15 usando lo STESSO intervallo di origine A1:C9
// Sia Pivot1 che Pivot2 condividono un singolo PivotCache perché l'intervallo di origine è identico.
const pivotIndex2 = worksheet.getPivotTables().add("A1:C9", "E15", "Pivot2");
const pivotTable2 = worksheet.getPivotTables().get(pivotIndex2);

// Assegna gli stessi campi per Pivot2
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Modifica diversi valori delle celle Quantità nei dati di origine per simulare una modifica dei dati
worksheet.getCells().get("C2").putValue(150);
worksheet.getCells().get("C4").putValue(350);
worksheet.getCells().get("C7").putValue(650);

// Aggiorna il PivotCache condiviso.
// Poiché Pivot1 e Pivot2 condividono lo stesso PivotCache, questa singola chiamata
// aggiorna ENTRAMBE le tabelle pivot (dati + stile) dall'origine aggiornata.
pivotTable1.getPivotCache().refresh();

// Salva la cartella di lavoro
workbook.save("output.xlsx");

Solo vista/layout modificati — Usare `CalculateData()`

Se i dati di origine non sono cambiati ma solo le impostazioni di vista o layout della tabella pivot sono state modificate (ad esempio, un campo è stato spostato in un’area diversa, o un’impostazione di aggiornamento all’apertura è stata attivata/disattivata), non è necessario tornare all’origine dati. La cache contiene già i dati corretti; solo la PivotTable renderizzata deve essere ricalcolata. In questo caso, pivotTable.CalculateData() è la scelta giusta.

Questo evita l’inutile recupero dall’origine ed è significativamente più veloce quando molte tabelle pivot condividono la stessa cache.

L’esempio seguente modifica una proprietà non di origine della tabella pivot e quindi chiama CalculateData() per renderizzarla di nuovo dalla cache esistente.

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

// Scrivi la riga di intestazione Frutto / Anno / Importo
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Scrivi 8 righe di dati (righe 2-9, corrispondenti all'intervallo sorgente 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);

// Aggiungi una tabella pivot denominata "Pivot1" posizionata nella cella di destinazione E3, con origine da A1:C9
var pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Assegna i campi: Fruit a Riga, Year a Colonna, Amount a Dati
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Data, "Amount");

// Modifica una proprietà di visualizzazione/layout — si tratta di una modifica solo di presentazione,
// quindi NON richiede la rilettura dei dati sorgente tramite PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(false);

// CalculateData() ridisegna la visualizzazione di QUESTA tabella pivot (dati + stile) dai
// dati già presenti nella PivotCache. Poiché i dati sorgente non sono cambiati,
// non viene eseguito alcun round-trip verso la sorgente — vengono ricalcolati solo i valori memorizzati nella cache
// nelle celle del foglio di lavoro.
pivotTable.calculateData();

// Salva la cartella di lavoro su disco
workbook.save("output.xlsx");

Ottenere tutte le tabelle pivot che condividono lo stesso PivotCache

Una cartella di lavoro spesso contiene molte tabelle pivot che si trovano tutte sopra una cache condivisa. Per enumerarle — ad esempio, prima di eseguire un aggiornamento in batch, o per diagnosticare l’impatto della cache condivisa — utilizzare PivotCache.GetPivotTables(). Questo metodo restituisce la raccolta di tutte le PivotTable che dipendono dalla cache data.

Questo è anche il modo più diretto per confermare che due tabelle pivot condividono effettivamente la stessa istanza di PivotCache: è possibile confrontare i riferimenti della cache, o semplicemente iterare la raccolta restituita da GetPivotTables() e osservare quali tabelle pivot appaiono in essa.

L’esempio seguente crea due tabelle pivot sullo stesso intervallo di origine, verifica che condividono la stessa istanza di cache e quindi enumera le tabelle pivot della cache.

Migrazione dall’obsoleto `PivotTable.RefreshData()`

Prima di Aspose.Cells for Node.js via C++ v26.7, il modo standard per aggiornare una tabella pivot era chiamare PivotTable.RefreshData() su ciascuna tabella pivot individualmente. A partire da v26.7, quel metodo è contrassegnato come obsoleto e dovrebbe essere sostituito con le API consapevoli della cache descritte sopra.

Ci sono due motivi per cui l’approccio per-tabella RefreshData() è problematico nelle cartelle di lavoro reali:

Recupera i dati dall’origine ogni volta che viene chiamato, anche quando l’origine non è cambiata.
Ogni chiamata aggiorna l’intera cache condivisa. Quando molte tabelle pivot condividono una cache, chiamare ripetutamente RefreshData() per ogni tabella pivot fa sì che la stessa cache venga recuperata più e più volte, il che è molto lento.

Le sostituzioni consigliate sono:

Aggiornare TUTTE le tabelle pivot nella cartella di lavoro → utilizzare workbook.refreshAll();
Aggiornare ALCUNE di esse → utilizzare pivotTable.PivotCache.Refresh(); per una cache. Poiché la cache è condivisa, questa singola chiamata aggiorna ogni tabella pivot costruita sopra quella cache. Altre tabelle pivot che si trovano su una cache già aggiornata possono essere tranquillamente saltate.
Solo la vista/layout della pivot è cambiata → utilizzare pivotTable.CalculateData(); per renderizzare di nuovo dalla cache esistente senza alcun round-trip all’origine.

L’esempio seguente dimostra il nuovo modello efficiente per cartelle di lavoro con più tabelle pivot che condividono una singola cache.

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

// --- Costruisce i dati sorgente: Frutta / Anno / Importo (intestazione + 9 righe) ---
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);

// --- Aggiunge la prima tabella pivot (Pivot1) nella cella di destinazione 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");

// --- Aggiunge la SECONDA tabella pivot (Pivot2) sullo STESSO intervallo sorgente ---
// Sia Pivot1 che Pivot2 condividono UN unico PivotCache sottostante.
// Questo è esattamente lo scenario in cui l'approccio legacy RefreshData()
// per singola tabella diventa inefficiente: aggiornare una tabella recupera
// nuovamente l'intera cache condivisa, quindi aggiornare N tabelle comporta
// lo stesso recupero dispendioso N volte.
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");

// --- Modifica diversi valori di Importo nei dati sorgente ---
sheet.getCells().get("C2").putValue(5000);   // Grape  2020
sheet.getCells().get("C5").putValue(7500);   // Cherry 2020
sheet.getCells().get("C9").putValue(9500);   // Cherry 2021

// --- Pattern OBSOLETO (pre-26.7) — PivotTable.RefreshData() ---
// pivotTable1.RefreshData();  // recupera dalla sorgente, aggiorna l'intera cache
// pivotTable2.RefreshData();  // recupera DI NUOVO — la cache è già aggiornata!
// Ogni chiamata ricostruisce la cache condivisa, quindi N tabelle = N recuperi ridondanti.

// --- NUOVO pattern v26.7+: aggiorna la cache UNA VOLTA, poi rirenderizza se necessario ---
// Una singola chiamata a PivotCache.Refresh() recupera i valori modificati nella
// cache condivisa E ricalcola la visualizzazione di OGNI tabella pivot che vi fa riferimento.
// Poiché Pivot1 e Pivot2 condividono un unico PivotCache, questa singola chiamata
// aggiorna entrambe le tabelle — non è richiesto un secondo round-trip alla sorgente.
pivotTable1.getPivotCache().refresh();

// CalculateData() rirenderizza solo la visualizzazione di una tabella pivot
// (dati + stile) dai dati già presenti nella cache — NON tocca la sorgente.
// Lo chiamiamo su Pivot2 qui solo per dimostrare l'API: dopo che la cache
// è stata aggiornata una volta, qualsiasi tabella dipendente può essere
// rirenderizzata senza tornare alla sorgente. Usa CalculateData() da sola
// quando sono cambiate solo le impostazioni di vista/layout della tabella
// pivot e la cache è aggiornata.
pivotTable2.calculateData();

workbook.save("output.xlsx");

Quale API di aggiornamento dovrei usare?

La tabella seguente riassume le API di aggiornamento disponibili e quando scegliere ciascuna.

Obiettivo	API consigliata	Note
Aggiornare tutto nella cartella di lavoro	`Workbook.RefreshAll()`	Una chiamata; copre tutte le cache e le tabelle.
Aggiornare solo le tabelle pivot su un singolo foglio	`Worksheet.RefreshPivotTables()`	Limitato a un foglio di lavoro.
Dati di origine modificati per una cache	`pivotTable.PivotCache.Refresh()`	Aggiorna TUTTE le tabelle pivot su quella cache condivisa.
Solo le impostazioni di vista/layout sono cambiate	`pivotTable.CalculateData()`	Evita l’inutile round-trip all’origine.
Elencare tutte le tabelle pivot su una cache condivisa	`pivotCache.GetPivotTables()`	Utilizzare per enumerare prima dell’aggiornamento in blocco.

In pratica, preferire le API basate sulla cache rispetto all’obsoleto RefreshData() per tabella. Sono consapevoli delle cache condivise, evitano recuperi ridondanti dall’origine e consentono di scegliere l’ambito più piccolo che soddisfa il requisito di aggiornamento.

Nodejscpp: Applicare stili alle tabelle pivot in Aspose.Cells per .NET

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

Aspose.Cells supports applying both legacy pivot autoformats (intended for .xls files) and modern named or custom pivot table styles (intended for .xlsx, .xlsm, and .xlsb files). The API you should call depends on the file format the workbook is saved to, not the format it was loaded from.

Introduzione

Aspose.Cells espone due API di stile parallele per le tabelle pivot. La scelta tra di esse dipende dal formato di file in cui si salva la cartella di lavoro, non dal formato da cui è stata letta. Una cartella di lavoro caricata da un file .xls può essere salvata nuovamente come .xlsx, e in tal caso si applica l’API di stile moderna anziché quella legacy.

Per l’output legacy .xls, utilizzare la proprietà PivotTable.AutoFormatType insieme all’enumerazione Aspose.Cells.Pivot.PivotTableAutoFormatType. Questa API corrisponde al selettore di formattazione automatica offerto dalla versione classica di Excel per le tabelle pivot.

Per l’output moderno .xlsx, .xlsm e .xlsb, sono disponibili due varianti dell’API di stile:

PivotTable.PivotTableStyleType seleziona uno degli stili predefiniti denominati (temi chiari e scuri, inclusi gli stili aggiunti in Excel 2017). Questi preset sono di sola lettura.
PivotTable.PivotTableStyleName seleziona uno stile personalizzato definito dall’utente tramite Workbook.Worksheets.TableStyles.AddPivotTableStyle(...). Gli stili personalizzati sono necessari ogni volta che si desidera modificare colori, bordi o caratteri oltre quanto offerto dai preset.

Inoltre, PivotTable.FormatAll(Style) è una scorciatoia che applica un singolo oggetto Style a ogni cella della tabella pivot, sovrascrivendo qualsiasi impostazione definita tramite una delle API basate sul nome dello stile sopra indicate. Questo è utile quando è richiesto un aspetto uniforme indipendentemente dal tema sottostante.

Applicare una formattazione automatica preimpostata XLS legacy

PivotTable.AutoFormatType accetta un valore dall’enumerazione Aspose.Cells.Pivot.PivotTableAutoFormatType. I valori disponibili sono Report1 fino a Report10, Classic, e Table1 fino a Table10.

AutoFormatType viene rispettato solo quando la cartella di lavoro viene salvata come .xls. Quando la stessa cartella di lavoro viene salvata come .xlsx, .xlsm o .xlsb, Excel ignora questa proprietà e ricorre alle impostazioni PivotTableStyleType e PivotTableStyleName.

Il seguente esempio carica una nuova cartella di lavoro, popola i dati di esempio Frutto/Anno/Importo, aggiunge una tabella pivot, applica PivotTableAutoFormatType.Report5 e salva il risultato come .xls.

Perché nessun campo colonna? Gli autoformati della serie Report (Report1 fino a Report10, Table1 fino a Table10) erano progettati in Excel classico per tabelle pivot monodimensionali con soli campi riga e valori — non hanno uno stile integrato per le intestazioni dei campi colonna. Se la tua tabella pivot richiede campi colonna, usa i preset moderni PivotTableStyleType dello Scenario 2 qui sotto, progettati per il layout bidimensionale usato da Excel moderno.

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

// Scenario 1: Applica un formato automatico preimpostato XLS legacy
// API in uso: PivotTable.AutoFormatType
// Formato file di destinazione: .xls (legacy)
// Per esempi completi e file di dati, visitare https://github.com/aspose-cells/Aspose.Cells-for-.NET

// Crea una nuova cartella di lavoro
const workbook = new AsposeCells.Workbook();

// Ottieni il primo foglio di lavoro
const sheet = workbook.getWorksheets().get(0);

// Popola i dati di origine con la riga di intestazione (Frutto, Anno, Importo)
// e 9 righe di dati che coprono uva, mirtillo, kiwi, ciliegia negli anni 2020 e 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);

// Aggiungi una tabella pivot nella cella di destinazione E3, denominata "Pivot1", usando l'intervallo di origine A1:C10
const pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
const pivotTable = sheet.getPivotTables().get(pivotIndex);

// Assegna i campi: Frutto -> Righe, Anno -> Colonne, Importo -> Dati
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Applica il formato automatico preimpostato XLS legacy "Report5"
// Nota: questa proprietà è significativa solo quando si salva come .xls.
// Quando si salva come .xlsx/.xlsm/.xlsb, Excel ignora AutoFormatType
// e utilizza qualsiasi PivotTableStyleType / PivotTableStyleName specifichi.
pivotTable.setAutoFormatType(AsposeCells.PivotTableAutoFormatType.Report5);

// Salva la cartella di lavoro nel formato legacy .xls
workbook.save("output.xls");

Applicare uno stile di tabella pivot preimpostato denominato moderno

PivotTable.PivotTableStyleType accetta un valore dall’enumerazione Aspose.Cells.PivotTableStyleType. L’enumerazione copre i temi chiari da PivotTableStyleLight1 a PivotTableStyleLight28 e i temi scuri da PivotTableStyleDark1 a PivotTableStyleDark28. Gli stili aggiunti in Excel 2017 (la seconda ondata di temi chiari e scuri) sono raggiungibili tramite la stessa enumerazione.

Questa è l’API consigliata per qualsiasi formato di file moderno. A differenza della formattazione automatica legacy, lo stile qui selezionato viene reso fedelmente da Excel e sopravvive ai passaggi attraverso altri strumenti Office.

Il seguente esempio utilizza gli stessi dati Frutto/Anno/Importo, crea una tabella pivot identica, applica PivotTableStyleDark1 e salva la cartella di lavoro come .xlsx.

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

// Riga di intestazione: Frutto / Anno / Importo
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// 9 righe di dati di Frutto / Anno / Importo
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);

// Aggiungi una tabella pivot in E3 denominata "Pivot1", con origine da A1:C10
let pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Assegna i campi pivot: Frutto -> area Righe, Anno -> area Colonne, Importo -> area Dati
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Applica uno stile pivot preimpostato denominato moderno di Excel 2007+.
// PivotTableStyleType è l'API corretta per i file .xlsx / .xlsm / .xlsb; AutoFormatType
// viene ignorato da Excel per quei formati. PivotTableStyleDark1 appartiene alla famiglia
// del tema scuro (PivotTableStyleDark1..PivotTableStyleDark28), e la stessa enum espone anche i
// nuovi temi chiari/scuri di Excel 2017 (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivotTable.setPivotTableStyleType(AsposeCells.PivotTableStyleType.PivotTableStyleDark1);

// Salva come .xlsx moderno — questo è il formato per cui PivotTableStyleType è significativo.
workbook.save("output.xlsx");

Definire e applicare uno stile di tabella pivot personalizzato

I preset predefiniti non possono essere modificati. Ogni volta che è necessario sovrascrivere colori, bordi o caratteri, è necessario definire uno stile pivot personalizzato. Il flusso di lavoro prevede tre passaggi:

Aggiungere uno stile personalizzato alla raccolta TableStyles della cartella di lavoro tramite Workbook.Worksheets.TableStyles.AddPivotTableStyle(string name). Viene restituito l’indice dello stile appena creato.
Configurare lo stile aggiungendo elementi (come WholeTable o GrandTotalRow) tramite TableStyle.TableStyleElements.Add(TableStyleElementType), quindi assegnare un Style a ciascun elemento tramite TableStyleElement.SetElementStyle(Style).
Applicare lo stile personalizzato alla tabella pivot impostando PivotTable.PivotTableStyleName sul nome dello stile. Non utilizzare PivotTableStyleType qui, poiché tale proprietà seleziona i preset predefiniti.

PivotTableStyleName e PivotTableStyleType non sono intercambiabili. Utilizzare PivotTableStyleType per i preset predefiniti e PivotTableStyleName per gli stili personalizzati definiti tramite AddPivotTableStyle. Impostare entrambi è innocuo, ma viene reso solo quello corrispondente alla sorgente prevista.

I valori disponibili di TableStyleElementType includono WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels e PageFieldValues.

Il seguente esempio definisce uno stile pivot personalizzato con un bordo nero sottile su WholeTable e un carattere rosso in grassetto su GrandTotalRow, quindi lo applica tramite PivotTableStyleName e salva come .xlsx.

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

// Popola i dati di origine: riga intestazione + 9 righe di dati (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);

Applicare un unico stile a ogni cella della tabella pivot con FormatAll

PivotTable.FormatAll(Style) è una scorciatoia che applica un singolo oggetto Style a ogni cella della tabella pivot, inclusi l’area dati, le intestazioni di riga e colonna e i totali. Qualsiasi impostazione precedente definita tramite PivotTableStyleType o PivotTableStyleName viene sovrascritta.

FormatAll sovrascrive sia PivotTableStyleType che PivotTableStyleName. Utilizzarlo solo quando è richiesto un aspetto uniforme e indipendente dal tema in tutta la tabella pivot.

Il seguente esempio crea uno Style con riempimento giallo solido, carattere blu scuro in grassetto e bordi neri sottili su tutti i lati, quindi lo applica con FormatAll e salva come .xlsx.

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

// Popola i dati di origine: riga di intestazione (riga 1) + 9 righe di dati (righe 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);

// Aggiungi tabella pivot: intervallo di origine A1:C10, cella di destinazione E3, nome "Pivot1"
let pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Assegna i campi pivot: Fruit -> area Righe, Year -> area Colonne, Amount -> area Dati
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Crea uno Stile che verrà applicato a ogni cella della tabella pivot
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);

// Applica FormatAll: forza questo singolo stile su ogni cella della tabella pivot,
// sovrascrivendo qualsiasi PivotTableStyleType / PivotTableStyleName precedentemente impostato
pivotTable.formatAll(style);

// Salva la cartella di lavoro nel formato moderno .xlsx
workbook.save("output.xlsx");

Quale API di stile devo usare?

La scelta dell’API di stile dipende dal formato di file in cui si sta salvando. Utilizzare la tabella seguente come riferimento rapido.

Formato file di destinazione	API da utilizzare	Note
`.xls` (legacy)	`PivotTable.AutoFormatType`	Valori da `Aspose.Cells.Pivot.PivotTableAutoFormatType` (ad es. `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Ignorato quando si salva in formati moderni.
`.xlsx` / `.xlsm` / `.xlsb` (moderno, stile predefinito)	`PivotTable.PivotTableStyleType`	Valori da `Aspose.Cells.PivotTableStyleType` (temi chiari/scuri, incluse le aggiunte di Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderno, stile personalizzato)	`PivotTable.PivotTableStyleName` + `Worksheets.TableStyles.AddPivotTableStyle(...)`	Utilizzare quando i preset predefiniti non sono sufficienti. Configurare tramite `TableStyleElement.SetElementStyle(...)`.
Qualsiasi formato (sovrascrittura uniforme)	`PivotTable.FormatAll(Style)`	Scorciatoia che sovrascrive ogni altra impostazione di stile in tutta la tabella pivot.

In caso di dubbio, salvare come .xlsx e utilizzare PivotTableStyleType per i temi predefiniti oppure PivotTableStyleName per i temi personalizzati.

Nodejscpp: Aggiungere campi riga e colonna a una tabella pivot in Aspose.Cells per .NET

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

Aggiungere un campo all’area riga o colonna

Il metodo PivotTable.AddFieldToArea(PivotFieldType fieldType, string fieldName) sposta un campo di base dai dati di origine in una delle quattro aree della tabella pivot. L’argomento fieldType accetta uno dei seguenti valori di PivotFieldType.

Row — campi posizionati verticalmente sulla sinistra
Column — campi posizionati orizzontalmente nella parte superiore
Data — campi i cui valori vengono aggregati
Page — campi utilizzati come filtri del report

Dopo aver aggiunto i campi, è possibile accedervi tramite le proprietà PivotTable.RowFields e PivotTable.ColumnFields. Ogni proprietà restituisce un PivotFieldCollection. Il campo all’indice 0 di RowFields è il campo riga più esterno, e gli indici successivi rappresentano i campi annidati al suo interno. La stessa convenzione di indicizzazione si applica a ColumnFields.

L’ordine di annidamento dei campi è importante. Aggiungere Category all’area riga per primo e poi Item produce una tabella pivot il cui raggruppamento esterno è Category e il cui raggruppamento interno è Item. Invertendo l’ordine si inverte la gerarchia.

Subtotali dei campi pivot

Il metodo PivotField.SetSubtotals(PivotFieldSubtotalType subtotalType, bool shown) controlla quali righe di subtotale vengono visualizzate per un campo pivot. Ogni chiamata attiva/disattiva un singolo tipo di subtotale in modo indipendente. Passando shown = true si visualizza il subtotale, mentre shown = false lo nasconde. Poiché ogni chiamata influisce su un solo tipo, chiamare il metodo più volte con valori di subtotalType diversi consente di creare un sottoinsieme personalizzato di subtotali.

L’enumerazione PivotFieldSubtotalType definisce i tipi di subtotale disponibili.

Automatic — Aspose.Cells sceglie la selezione predefinita (tipicamente Sum per i campi numerici)
None — elimina ogni riga di subtotale
Sum
Count
Average
Max
Min
Product
StdDev
StdDevp
Var
Varp

I subtotali vengono visualizzati solo quando sono presenti due o più campi pivot nell’area riga (o nell’area colonna). Un singolo campo non ha nulla di significativo da subtotalizzare tra un gruppo e l’altro, quindi le chiamate a SetSubtotals non hanno alcun effetto visibile in tal caso. Questo articolo, pertanto, inserisce due campi riga (Category esterno, Item interno) in ogni esempio, in modo che il confine di subtotale tra ciascun gruppo Category sia visibile.

Scenario 1 — Subtotali automatici (predefiniti)

Quando non si chiama affatto SetSubtotals, Aspose.Cells applica la selezione Automatic ai campi numerici. L’esempio seguente conferma esplicitamente questo comportamento chiamando SetSubtotals(PivotFieldSubtotalType.Automatic, true) sul campo riga esterno 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");

Scenario 2 — Eliminazione di tutti i subtotali (None)

Chiamare SetSubtotals(PivotFieldSubtotalType.None, true) rimuove ogni riga di subtotale dalla tabella pivot, lasciando solo le righe dei campi e il totale generale in fondo. Ciò è utile quando si desidera raggruppare i dati grezzi senza alcuna riga di riepilogo.

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

Scenario 3 — Sottoinsieme di subtotali personalizzato (Sum + Average)

Non si è limitati a un singolo tipo di subtotale. Ogni chiamata a SetSubtotals agisce in modo indipendente su un singolo tipo, quindi chiamare il metodo due volte — una con Sum e una con Average — produce un sottoinsieme personalizzato di due righe di subtotale per ciascun gruppo 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");

Riepilogo

I tre scenari precedenti condividono lo stesso set di dati e la stessa struttura di tabella pivot. L’unica differenza tra essi è la chiamata a SetSubtotals applicata al campo riga esterno Category. Ricordare la regola dei due campi: un singolo campo in un’area non ha nulla da subtotalizzare tra un gruppo e l’altro, quindi è sempre necessario inserire almeno due campi nell’area riga o colonna quando si desidera che SetSubtotals abbia un effetto visibile.

Nodejscpp: Gestire i campi valore di una tabella pivot in Aspose.Cells per .NET

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

Aggiungere un campo all’area dati

Aggiungere un campo di base all’area dati (valore) è il primo passo per definire come una tabella pivot aggrega i dati di origine. Aspose.Cells espone PivotTable.addFieldToArea(PivotFieldType, string), un overload che accetta la costante PivotFieldType.Data e il nome della colonna di origine. Una volta che un campo viene aggiunto all’area dati, l’API lo espone tramite la raccolta PivotTable.getDataFields(), nell’ordine in cui i campi sono stati aggiunti. Per impostazione predefinita, una colonna di origine numerica viene sintetizzata con ConsolidationFunction.Sum, mentre una colonna non numerica utilizza Count come valore predefinito.

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

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

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

// Righe di dati A2:D9 utilizzando cicli annidati con branching su 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;
 }
 }
}

// Aggiungi tabella pivot in F3 con nome PivotTable1
const pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1", true, false);
const pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Layout pivot: Category e Item su Riga, Year su Colonna, Amount come campo dati
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");

Modificare la funzione di riepilogo

Ogni campo inserito nell’area dati viene incapsulato internamente come un’istanza di PivotField, e la sua proprietà getFunction() restituisce un valore dall’enum ConsolidationFunction. Lo stesso setter setFunction() ti consente di passare tra le aggregazioni disponibili, tra cui Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var e Varp.

La modifica della funzione di riepilogo influisce solo sull’aggregazione, la colonna di origine non cambia.

Puoi quindi mantenere un campo dati come Sum mentre aggiungi un secondo campo dati che fa riferimento alla stessa colonna di origine ma utilizza Count o Average, tutto in un’unica pivot.

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

Posizionare i campi valore sull’asse Riga o Colonna

Quando una tabella pivot contiene due o più campi dati, Aspose.Cells espone un ulteriore campo virtuale chiamato PivotTable.getValuesField. Questo campo virtuale rappresenta l’aggregazione di ogni campo dati che risiede nell’area dati. Puoi trascinarlo nell’area Riga o Colonna come campo pivot di base, utile per affiancare più misure.

PivotTable.getValuesField() non funziona se non c’è alcun campo valore o se ne esiste solo uno.

Gli scenari seguenti illustrano tre esempi end-to-end che dimostrano ciascuna funzionalità descritta sopra applicata alla stessa struttura pivot.

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: Aggiungere campi filtro a una tabella pivot in Aspose.Cells per .NET

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

Aspose.Cells supporta l’intero ciclo di vita dei campi filtro nelle tabelle pivot. Puoi aggiungere un campo filtro tramite un’API di alto livello o tramite la collezione di livello inferiore PageFields, e puoi gestire il filtro pagina in modalità a selezione singola, azzerarlo per mostrare ogni elemento della pagina, oppure commutare il campo sulla selezione multipla in modo che gli utenti possano selezionare più elementi della pagina contemporaneamente tramite l’interfaccia a caselle di controllo in Excel.

Introduzione

Un campo filtro è un campo pivot che controlla quale sottoinsieme dei dati di origine viene visualizzato nel corpo della pivot. Gli utenti finali lo vedono come un menu a discesa nella parte superiore di una pivot renderizzata in Excel, e selezionare uno degli elementi di pagina disponibili ricostruisce il corpo della pivot in modo che vengano riepilogati solo i record appartenenti a quell’elemento di pagina. Un campo pivot diventa un campo filtro quando viene registrato come PivotFieldType.Page anziché PivotFieldType.Row, PivotFieldType.Column o PivotFieldType.Data.

Un campo filtro può operare in due modalità. Nella modalità predefinita a selezione singola è visibile un solo elemento di pagina alla volta, quindi il corpo della pivot riassume esattamente un sottoinsieme. Nella modalità a selezione multipla il campo espone un elenco di caselle di controllo, e il corpo della pivot riassume l’unione di ogni elemento di pagina selezionato. Lo stesso campo di origine può essere spostato avanti e indietro tra queste modalità attivando o disattivando una singola proprietà.

Aspose.Cells for Node.js via C++ espone due modi equivalenti per registrare un campo filtro. L’API di alto livello è PivotTable.addFieldToArea(PivotFieldType.Page, "fieldName"), che prende il nome della colonna di origine e aggiunge il campo in una singola chiamata. L’API di livello inferiore è PivotTable.pageFields.add(PivotField), che viene utilizzata quando si dispone già di un riferimento PivotField e si desidera aggiungere la stessa istanza di campo all’area filtro. Entrambe le API finiscono per popolare la stessa collezione PageFields, e il resto di questo articolo mostra come scegliere tra esse e come gestire ciascuna modalità di filtraggio.

Aggiungere un campo filtro

Esistono due modi per registrare un campo pivot nell’area filtro. La chiamata di alto livello prende il nome della colonna di origine come stringa ed è il percorso più comune. La chiamata di livello inferiore accetta un’istanza PivotField esistente ed è comoda quando lo stesso oggetto campo deve essere riutilizzato su più aree pivot. Entrambe le chiamate inseriscono il campo in PivotTable.pageFields, dopodiché appare come menu a discesa della pagina nella parte superiore della pivot renderizzata.

Aggiungere un campo filtro con addFieldToArea

L’esempio seguente crea un piccolo set di dati Frutta / Anno / Importo, posiziona una tabella pivot nella cella E3 con Fruit nell’area riga, Amount nell’area dati e Year nell’area filtro, aggiorna la pivot e salva la cartella di lavoro.

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

// Imposta la riga di intestazione
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Popola 9 righe di dati di esempio: Frutto, Anno, Quantità
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]);
}

// Aggiungi una tabella pivot ancorata alla cella E3
var pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "PivotTable1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Aggiungi campi alle rispettive aree: Frutto come Riga, Quantità come Dati, Anno come campo Pagina
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");

// Aggiorna e calcola i dati della tabella pivot
pivotTable.calculateData();

// Salva la cartella di lavoro
workbook.save("pageFieldSample.xlsx");

Aggiungere un campo filtro con pageFields.add

Quando si lavora già con un’istanza PivotField, è possibile passarla direttamente a PivotTable.pageFields.add. La tabella pivot e il campo filtro vengono costruiti esattamente come nello scenario precedente; solo la registrazione finale nell’area filtro viene sostituita con la chiamata API di livello inferiore.

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

// Intestazioni
sheet.getCells().get("A1").putValue("Fruit");
sheet.getCells().get("B1").putValue("Year");
sheet.getCells().get("C1").putValue("Amount");

// Dati di esempio (9 righe)
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);

// Aggiungi tabella pivot a partire da E3 coprendo A1:C10
let pivotIndex = sheet.getPivotTables().add("E3", "A1:C10", "PivotTable1");
let pivotTable = sheet.getPivotTables().get(pivotIndex);

// Fruit -> Riga, Amount -> Dati (Year verrà inserito nell'area Page qui sotto)
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Approccio a basso livello: recupera il PivotField Year esistente dai BaseFields
// e registralo nell'area Page tramite PageFields.Add(PivotField).
let yearField = pivotTable.getBaseFields().get("Year");
pivotTable.getPageFields().add(yearField);

// Aggiorna la tabella pivot in modo che il nuovo campo di pagina venga riflesso nel workbook salvato
pivotTable.calculateData();

workbook.save("output.xlsx");

Filtraggio a selezione singola (mostrare un elemento di pagina)

Nella modalità predefinita a selezione singola, il campo filtro viene renderizzato come un singolo menu a discesa e l’intero PivotField.currentPageItem seleziona quale elemento di pagina guida il corpo della pivot. Assegnando un indice specifico si seleziona quell’unico elemento; assegnando il valore sentinella speciale 0x7FFD (decimale 32765) si azzera il filtro in modo che ogni elemento di pagina venga riepilogato contemporaneamente. La selezione singola è la modalità predefinita; non è necessario abilitarla esplicitamente.

Mostrare tutti gli elementi

Impostare currentPageItem sul valore magico 0x7FFD equivale ad azzerare il filtro pagina: il corpo della pivot riassume ogni elemento di pagina come se non fosse applicato alcun filtro.

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

// Popola i dati Frutto/Anno/Importo
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]);
    }
}

// Crea una tabella pivot in E3
let pivotTables = sheet.getPivotTables();
let index = pivotTables.add("=A1:C7", "E3", "PivotTable1");
let pivotTable = pivotTables.get(index);

// Configura i campi pivot: Frutto→Riga, Importo→Dati, Anno→Pagina
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");

pivotTable.calculateData();

// Cancella il filtro della pagina in modo che ogni elemento nel campo pagina sia visibile.
// 0x7FFD (decimale 32765) è il valore sentinella speciale che significa "tutti gli elementi" —
// equivalente a selezionare "(Tutti)" nel menu a tendina del campo pagina di Excel.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD);

workbook.save("output.xlsx");

Mostrare un elemento specifico

Impostare currentPageItem su un indice reale seleziona solo quell’unico elemento di pagina. L’indice è la posizione dell’elemento nell’elenco ordinato degli elementi del campo filtro, quindi ad esempio 1 seleziona il secondo elemento dopo l’ordinamento.

var workbook = new AsposeCells.Workbook();
var sheet = workbook.getWorksheets().get(0);
var cells = sheet.getCells();

// Aggiungi dati di esempio (Frutto/Anno/Importo)
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");

// Aggiungi tabella pivot in E3
var pivotTables = sheet.getPivotTables();
var pivotIndex = pivotTables.add("A1:C5", "E3", "PivotTable1");
var pivotTable = pivotTables.get(pivotIndex);

// Aggiungi campi: Frutto→Riga, Importo→Dati, Anno→Pagina
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");

// Operazioni specifiche del campo pagina
pivotTable.getPageFields().get(0).setCurrentPageItem(1); // 1 = secondo elemento nell'ordine ordinato (es. "2021")

// Aggiorna e calcola la tabella pivot
pivotTable.calculateData();

workbook.save("output.xlsx");

Filtraggio a selezione multipla

Il filtraggio a selezione multipla trasforma il menu a discesa della pagina in un elenco di caselle di controllo e consente all’utente finale di selezionare più elementi di pagina contemporaneamente. Aspose.Cells espone due proprietà che lavorano insieme. PivotField.isMultipleItemSelectionAllowed deve essere impostato su true prima che l’interfaccia a selezione multipla abbia effetto. Dopo averlo abilitato, PivotItem.isHidden controlla quali elementi appaiono nell’elenco delle caselle di controllo, quindi è possibile mostrare ogni elemento o consentire solo elementi specifici.

Il codice seguente abilita la selezione multipla sullo stesso campo filtro Year costruito nello Scenario 1a, e quindi mostra due pattern: la Parte A rivela ogni elemento di pagina lasciando isHidden impostato su false per ogni voce, mentre la Parte B consente solo i valori di origine scelti e nasconde tutto il resto tramite un blocco switch (pivotItems[i].getStringValue()).

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

// Dati di esempio: Frutta | Anno | Quantità
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");

// — Abilita la selezione multipla sul campo pagina
pivotTable.getPageFields().get(0).setIsMultipleItemSelectionAllowed(true);

// Parte A — seleziona TUTTI gli elementi (rendi visibile ogni elemento)
let pivotItems = pivotTable.getPageFields().get(0).getPivotItems();
for (let i = 0; i < pivotItems.getCount(); i++) {
    pivotItems.get(i).setIsHidden(false);
}

// Parte B — seleziona solo elementi specifici per valore di origine
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: Quando si utilizza il filtraggio a selezione multipla tramite PivotItem.isHidden, almeno un PivotItem deve rimanere visibile (isHidden == false). Se ogni elemento è nascosto, Excel si blocca all’apertura del file oppure renderizza una pivot vuota. Verifica sempre che la tua whitelist a selezione multipla includa almeno un elemento dei tuoi dati di origine.

Quale API e quale modalità devo usare?

La tabella seguente riassume quando utilizzare ciascuna API e modalità, così puoi scegliere la combinazione giusta senza dover leggere ogni scenario nel dettaglio.

Scenario / Caso d’uso	API consigliata	Proprietà utilizzata	Note
Aggiungere un campo filtro tramite il nome della colonna di origine (caso più comune)	`PivotTable.addFieldToArea(PivotFieldType.Page, "fieldName")`	n/d	Alto livello, una sola riga. Usalo a meno che tu non abbia bisogno di un riferimento `PivotField`.
Aggiungere un campo filtro quando si dispone già di un oggetto `PivotField`	`PivotTable.pageFields.add(PivotField)`	n/d	Usalo quando l’oggetto campo è stato ottenuto altrove o deve essere riutilizzato.
Filtrare su un singolo elemento di pagina (modalità predefinita)	`PivotField.currentPageItem`	impostare su un indice specifico	Ad esempio, `1` mostra il secondo elemento nell’elenco ordinato.
Mostrare tutti gli elementi / azzerare il filtro pagina	`PivotField.currentPageItem`	impostare su `0x7FFD`	Il valore magico `0x7FFD` (decimale 32765) è la sentinella per “tutti gli elementi”.
Abilitare l’interfaccia a selezione multipla in Excel	`PivotField.isMultipleItemSelectionAllowed`	impostare su `true`	Richiesto prima che qualsiasi chiamata a `isHidden` abbia effetto.
Nascondere / mostrare singoli elementi in un elenco a selezione multipla	`PivotItem.isHidden`	impostare per ogni elemento	Almeno un elemento deve rimanere visibile (`isHidden == false`).

Ricorda sempre il vincolo di visibilità quando configuri il filtraggio a selezione multipla. Se ogni PivotItem in un campo filtro a selezione multipla è nascosto, Excel si blocca all’apertura oppure renderizza una pivot vuota. Costruisci la tua whitelist sui tuoi dati di origine in modo che almeno un elemento rimanga visibile, e le tue cartelle di lavoro salvate si apriranno in modo affidabile su ogni macchina.

Nodejscpp: Elimina la tabella pivot da un foglio di lavoro

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

Aspose.Cells for Node.js via C++ offre una funzione per eliminare o rimuovere la tabella pivot da un foglio di lavoro. È possibile eliminare la tabella pivot utilizzando l’oggetto tabella pivot o la sua posizione. Si prega di usare il metodo Worksheet.getPivotTables().remove(pivotTable) per eliminare la tabella pivot utilizzando l’oggetto tabella pivot e il metodo Worksheet.getPivotTables().removeAt(index, keepData) per eliminarlo usando la sua posizione all’interno della collezione di tabelle pivot.

Come eliminare la tabella pivot dal foglio di lavoro usando Aspose.Cells for Node.js via C++

Il codice di esempio seguente elimina due tabelle pivot dal foglio di lavoro. Prima rimuove la tabella pivot utilizzando il metodo Worksheet.getPivotTables().remove(pivotTable) e poi rimuove la tabella pivot utilizzando il metodo Worksheet.getPivotTables().removeAt(index, keepData)

Nodejscpp: Salva tabella pivot nel file ODS

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

Aspose.Cells for Node.js via C++ consente di salvare le tabelle pivot in file ODS. Per farlo, basta convertire un file di lavoro con una tabella pivot esistente o crearne una nuova e salvare il file in formato ODS. Assicurarsi di chiamare PivotTable.calculateData prima di salvare per garantire che la tabella pivot venga renderizzata nel file ODS di output. Il seguente esempio di codice mostra come salvare una tabella pivot in un file ODS.

Codice di esempio

Il file di output generato dal codice precedente è allegato per il tuo riferimento.

File ODS di output

Documentation – Inserisci tabella pivot

Nodejscpp: Formattazione della tabella pivot

Aspetto della tabella pivot

Come impostare le opzioni di formato tabella pivot

Come impostare il tipo di autoformato

Come impostare le opzioni di formattazione

Formattazione Aspetto e Sensazione Manualmente

Come impostare le opzioni di formato campo pivot

Come impostare il formato dei campi riga/colonna/pagina

Come impostare il formato dei campi dati

Come eliminare i campi di un Pivot

Nodejscpp: Creare Tabelle Pivot e Grafici Pivot

Aggiungi tabelle pivot e grafici usando Aspose.Cells for Node.js via C++

Prepararsi a usare Aspose.Cells for Node.js via C++

Come aggiungere una tabella pivot usando Aspose.Cells for Node.js via C++

Come aggiungere un grafico pivot usando la libreria Aspose.Cells for Node.js via C++

Nodejscpp: Tabella Pivot e Dati di Origine

Dati di Origine della Tabella Pivot

Cambiare i Dati di Origine di una Tabella Pivot

Nodejscpp: Aggiungi campo calcolato nella tabella pivot

Possibili Scenari di Utilizzo

Come aggiungere un campo calcolato nella tabella pivot in Excel

Come aggiungere un campo calcolato in una tabella pivot usando la libreria Aspose.Cells for Node.js via C++

Codice di Esempio

Nodejscpp: Aggiornamento delle tabelle pivot in Aspose.Cells for Node.js via C++

Introduzione

Importazioni richieste

Aggiornare tutte le tabelle pivot nella cartella di lavoro

Aggiornare tutte le tabelle pivot su un singolo foglio di lavoro

Aggiornare una singola tabella pivot

Dati di origine modificati — Usare PivotCache.Refresh()

Solo vista/layout modificati — Usare CalculateData()

Ottenere tutte le tabelle pivot che condividono lo stesso PivotCache

Migrazione dall’obsoleto PivotTable.RefreshData()

Quale API di aggiornamento dovrei usare?

Nodejscpp: Applicare stili alle tabelle pivot in Aspose.Cells per .NET

Introduzione

Applicare una formattazione automatica preimpostata XLS legacy

Applicare uno stile di tabella pivot preimpostato denominato moderno

Definire e applicare uno stile di tabella pivot personalizzato

Applicare un unico stile a ogni cella della tabella pivot con FormatAll

Quale API di stile devo usare?

Nodejscpp: Aggiungere campi riga e colonna a una tabella pivot in Aspose.Cells per .NET

Aggiungere un campo all’area riga o colonna

Subtotali dei campi pivot

Scenario 1 — Subtotali automatici (predefiniti)

Scenario 2 — Eliminazione di tutti i subtotali (None)

Scenario 3 — Sottoinsieme di subtotali personalizzato (Sum + Average)

Riepilogo

Nodejscpp: Gestire i campi valore di una tabella pivot in Aspose.Cells per .NET

Aggiungere un campo all’area dati

Modificare la funzione di riepilogo

Posizionare i campi valore sull’asse Riga o Colonna

Nodejscpp: Aggiungere campi filtro a una tabella pivot in Aspose.Cells per .NET

Introduzione

Aggiungere un campo filtro

Aggiungere un campo filtro con addFieldToArea

Aggiungere un campo filtro con pageFields.add

Filtraggio a selezione singola (mostrare un elemento di pagina)

Mostrare tutti gli elementi

Mostrare un elemento specifico

Filtraggio a selezione multipla

Quale API e quale modalità devo usare?

Nodejscpp: Elimina la tabella pivot da un foglio di lavoro

Come eliminare la tabella pivot dal foglio di lavoro usando Aspose.Cells for Node.js via C++

Nodejscpp: Salva tabella pivot nel file ODS

Codice di esempio

Dati di origine modificati — Usare `PivotCache.Refresh()`

Solo vista/layout modificati — Usare `CalculateData()`

Migrazione dall’obsoleto `PivotTable.RefreshData()`