Documentation – Inserisci tabella pivot

Nodejsjava: Applica stili alle tabelle pivot in Aspose.Cells for Node.js via Java

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

Aspose.Cells supporta sia le formattazioni automatiche legacy per tabelle pivot (destinate ai file .xls) sia gli stili moderni con nome o personalizzati per tabelle pivot (destinati ai file .xlsx, .xlsm e .xlsb). L’API da chiamare dipende dal formato del file in cui la cartella di lavoro viene salvata, non dal formato da cui è stata caricata.

Introduzione

Aspose.Cells espone due API di stile parallele per le tabelle pivot. La scelta tra di esse è determinata dal formato del file in cui salvi la cartella di lavoro, non dal formato da cui la leggi. 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.

PivotTable.pivotTableStyleType seleziona uno degli stili predefiniti con nome (temi chiari e scuri, inclusi gli stili aggiunti in Excel 2017). Questi preset sono in sola lettura.
PivotTable.pivotTableStyleName seleziona uno stile personalizzato che definisci tu stesso tramite Worksheets.getTableStyles().addPivotTableStyle(...). Gli stili personalizzati sono necessari ogni volta che desideri modificare colori, bordi o font 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 effettuata tramite una delle due API basate sul nome dello stile. Ciò è utile quando è richiesto un aspetto uniforme indipendentemente dal tema sottostante.

Applica 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. L’esempio seguente carica una cartella di lavoro nuova, 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? Le formattazioni automatiche della serie Report (Report1–Report10, Table1–Table10) sono state progettate nel classico Excel per tabelle pivot a dimensione singola con solo campi riga e valori, non hanno uno stile predefinito per le intestazioni dei campi colonna. Se la tua tabella pivot necessita di campi colonna, utilizza invece gli stili preimpostati moderni PivotTableStyleType dallo Scenario 2, che sono progettati per il layout bidimensionale utilizzato dal moderno Excel.

let workbook = new AsposeCells.Workbook();
// Ottieni il primo foglio di lavoro
let sheet = workbook.getWorksheets().get(0);
// Popola i dati di origine con una riga di intestazione (Fruit, Year, Amount)
// 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", utilizzando l'intervallo di origine A1:C10
let pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = sheet.getPivotTables().get(pivotIndex);
// Assegna i campi: Fruit -> Righe, Amount -> Dati
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.ROW, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.DATA, "Amount");
// Applica il formato automatico preimpostato legacy XLS "Report5"
// Nota: questa proprietà ha significato solo quando si salva come .xls.
// Quando si salva come .xlsx/.xlsm/.xlsb, Excel ignora AutoFormatType
// e utilizza qualsiasi cosa specificata da PivotTableStyleType / PivotTableStyleName.
pivotTable.setAutoFormatType(AsposeCells.PivotTableAutoFormatType.REPORT_5);
// Salva la cartella di lavoro nel formato legacy .xls
workbook.save("output.xls");

Applica uno stile preimpostato moderno con nome per tabelle pivot

Definire e applicare uno stile personalizzato per tabelle pivot

I preset predefiniti non possono essere modificati. Ogni volta che hai bisogno di sovrascrivere colori, bordi o font, devi definire uno stile personalizzato per tabelle pivot. Il flusso di lavoro prevede tre passaggi:

Aggiungi uno stile personalizzato alla collezione TableStyles della cartella di lavoro tramite Worksheets.getTableStyles().addPivotTableStyle(String name). Questo restituisce l’indice dello stile appena creato.
Configura lo stile aggiungendo elementi (come WholeTable o GrandTotalRow) tramite TableStyle.tableStyleElements.add(TableStyleElementType), quindi assegna un Style a ciascun elemento tramite TableStyleElement.setElementStyle(Style).
Applica lo stile personalizzato alla tabella pivot impostando PivotTable.pivotTableStyleName sul nome dello stile. Non utilizzare pivotTableStyleType qui, poiché quella proprietà seleziona i preset predefiniti.

pivotTableStyleName e pivotTableStyleType non sono intercambiabili. Usa pivotTableStyleType per i preset predefiniti e pivotTableStyleName per gli stili personalizzati che hai definito tramite addPivotTableStyle. Impostare entrambi è innocuo, ma viene reso solo quello corrispondente alla sorgente prevista.

I valori di TableStyleElementType disponibili includono WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels e PageFieldValues. L’esempio seguente definisce uno stile personalizzato per tabelle pivot con un bordo sottile nero su WholeTable e un font 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 sorgente: riga di 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);
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);
// Aggiungi tabella pivot con origine da A1:C10, ancorata in E3, denominata "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");
// Passo 1: registra un nuovo stile personalizzato per tabella pivot e cattura il suo indice
let styleIndex = workbook.getWorksheets().getTableStyles().addPivotTableStyle("CustomPivotStyle");
let tableStyle = workbook.getWorksheets().getTableStyles().get(styleIndex);
// Passo 2: aggiungi un elemento WholeTable e applica bordi neri sottili su tutti e quattro i lati
let wholeTableElementIndex = tableStyle.getTableStyleElements().add(AsposeCells.TableStyleElementType.WHOLE_TABLE);
let wholeTableElement = tableStyle.getTableStyleElements().get(wholeTableElementIndex);
let wholeTableStyle = workbook.createStyle();
let topBorder = wholeTableStyle.getBorders().get(AsposeCells.BorderType.TOP_BORDER);
topBorder.setLineStyle(AsposeCells.CellBorderType.THIN);
topBorder.setColor(AsposeCells.Color.BLACK);
let bottomBorder = wholeTableStyle.getBorders().get(AsposeCells.BorderType.BOTTOM_BORDER);
bottomBorder.setLineStyle(AsposeCells.CellBorderType.THIN);
bottomBorder.setColor(AsposeCells.Color.BLACK);
let leftBorder = wholeTableStyle.getBorders().get(AsposeCells.BorderType.LEFT_BORDER);
leftBorder.setLineStyle(AsposeCells.CellBorderType.THIN);
leftBorder.setColor(AsposeCells.Color.BLACK);
let rightBorder = wholeTableStyle.getBorders().get(AsposeCells.BorderType.RIGHT_BORDER);
rightBorder.setLineStyle(AsposeCells.CellBorderType.THIN);
rightBorder.setColor(AsposeCells.Color.BLACK);
wholeTableElement.setElementStyle(wholeTableStyle);
// Passo 3: aggiungi un elemento GrandTotalRow e applica un font rosso in grassetto
let grandTotalElementIndex = tableStyle.getTableStyleElements().add(AsposeCells.TableStyleElementType.GRAND_TOTAL_ROW);
let grandTotalElement = tableStyle.getTableStyleElements().get(grandTotalElementIndex);
let grandTotalStyle = workbook.createStyle();
grandTotalStyle.getFont().setBold(true);
grandTotalStyle.getFont().setColor(AsposeCells.Color.RED);
grandTotalElement.setElementStyle(grandTotalStyle);
// Passo 4: applica lo stile personalizzato per nome (NON tramite PivotTableStyleType, che è per i preset predefiniti)
pivotTable.setPivotTableStyleName("CustomPivotStyle");
workbook.save("output.xlsx");

Applicare uno 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 dei dati, le intestazioni di riga e colonna e i totali. Qualsiasi cosa precedentemente impostata tramite pivotTableStyleType o pivotTableStyleName viene sovrascritta.

formatAll sovrascrive sia pivotTableStyleType che pivotTableStyleName. Usalo solo quando è richiesto un aspetto uniforme, indipendente dal tema, nell’intera tabella pivot.

L’esempio seguente crea un Style con riempimento solido giallo, un font blu scuro in grassetto e bordi sottili neri 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 Style 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 .xlsx moderno
workbook.save("output.xlsx");

Quale API di stile dovrei usare?

La scelta dell’API di stile dipende dal formato del file in cui stai salvando. Usa 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 nei 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.getTableStyles().addPivotTableStyle(...)`	Usare 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 nell’intera tabella pivot.
In caso di dubbio, salva come `.xlsx` e usa `pivotTableStyleType` per i temi predefiniti, oppure `pivotTableStyleName` per i temi personalizzati.

Nodejsjava: Refresh Pivot Tables and Pivot Caches in Aspose.Cells for Node.js via Java

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

Aspose.Cells fornisce un’API di aggiornamento a più livelli che consente di ricaricare i dati delle tabelle 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 Java v26.7, il metodo legacy PivotTable.RefreshData() è contrassegnato come obsoleto e deve essere sostituito con le API più efficienti e consapevoli della cache descritte in questo articolo.

Introduzione

Aggiornare una tabella pivot raramente è un’operazione singola. Dietro le quinte, Aspose.Cells mantiene una catena dati a più livelli che collega i dati sorgente originali ai valori renderizzati che si vedono nel foglio di lavoro. Comprendere questa catena è la chiave per scegliere l’API di aggiornamento giusta per ogni situazione. La catena dati a quattro livelli è:

Data Source — gli intervalli originali del foglio di lavoro, la query del database o l’intervallo di consolidamento in cui risiedono i valori grezzi.
PivotCache — l’istantanea in memoria dei dati sorgente. Ogni tabella pivot è costruita sopra una 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 dalla sua PivotCache, mai direttamente dalla fonte dati.
Cells — le Cells del foglio di lavoro in cui la PivotTable rende i valori calcolati e gli stili.

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

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

PivotTable.CalculateData() — ricalcola la visualizzazione di una PivotTable dai dati già in cache, senza tornare alla fonte dati. Tutti gli scenari in questo articolo utilizzano dati sorgente da celle del foglio di lavoro, quindi il tipo di sorgente è Sheet e le operazioni di aggiornamento si comportano come descritto.

Avvio rapido

Se hai bisogno solo del codice più breve possibile che aggiorni ogni pivot nella cartella di lavoro, una singola chiamata è sufficiente:

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

Tutto il resto in questo articolo spiega quando scegliere invece un’API più ristretta.

Importazioni richieste

const aspose = require('aspose.cells');
Oppure per importazioni specifiche: const { Workbook, Cells, PivotTableSourceType } = require('aspose.cells');

Aggiornare tutte le tabelle pivot nella cartella di lavoro

Quando è necessario garantire che ogni pivot cache e ogni tabella pivot nella cartella di lavoro riflettano i dati sorgente più recenti, l’API più semplice e completa è Workbook.RefreshAll(). Una singola chiamata attraversa l’intera cartella di lavoro, aggiornando ogni PivotCache dalla sua sorgente 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 sorgente Frutto/Anno/Importo, crea una tabella pivot, modifica alcuni valori sorgente e quindi utilizza RefreshAll() per portare tutto aggiornato in una singola chiamata.

const AsposeCells = require("aspose.cells");
// Crea una nuova cartella di lavoro
const workbook = new AsposeCells.Workbook();
const 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"
const pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
const pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Assegna i campi pivot: Frutta a Righe, Anno a Colonne, Importo a Dati
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Modifica diversi valori di Importo 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 sono note per non essere correlate e non devono essere toccate. Per questo caso, Aspose.Cells fornisce Worksheet.RefreshPivotTables(), che è limitato a una singola istanza di Worksheet.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");
worksheet.getCells().get("A2").putValue("grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(100);
worksheet.getCells().get("A3").putValue("blueberry");
worksheet.getCells().get("B3").putValue(2021);
worksheet.getCells().get("C3").putValue(150);
worksheet.getCells().get("A4").putValue("kiwi");
worksheet.getCells().get("B4").putValue(2020);
worksheet.getCells().get("C4").putValue(200);
worksheet.getCells().get("A5").putValue("cherry");
worksheet.getCells().get("B5").putValue(2021);
worksheet.getCells().get("C5").putValue(120);
worksheet.getCells().get("A6").putValue("grape");
worksheet.getCells().get("B6").putValue(2021);
worksheet.getCells().get("C6").putValue(180);
worksheet.getCells().get("A7").putValue("blueberry");
worksheet.getCells().get("B7").putValue(2020);
worksheet.getCells().get("C7").putValue(130);
worksheet.getCells().get("A8").putValue("kiwi");
worksheet.getCells().get("B8").putValue(2021);
worksheet.getCells().get("C8").putValue(220);
worksheet.getCells().get("A9").putValue("cherry");
worksheet.getCells().get("B9").putValue(2020);
worksheet.getCells().get("C9").putValue(140);
let pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
worksheet.getCells().get("C2").putValue(300);
worksheet.getCells().get("C5").putValue(250);
worksheet.getCells().get("C9").putValue(400);
worksheet.refreshPivotTables();
workbook.save("output.xlsx");

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 ciò che è effettivamente cambiato: i dati sorgente sottostanti, o solo le impostazioni di vista/layout della tabella pivot stessa.

Dati sorgente cambiati — Usa `PivotCache.Refresh()`

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

Solo vista/layout cambiati — Usa `CalculateData()`

Se i dati sorgente non sono cambiati ma sono state modificate solo le impostazioni di vista o layout della tabella pivot (ad esempio, un campo è stato spostato in un’area diversa, o un’impostazione di aggiornamento all’apertura è stata attivata), non è necessario tornare alla fonte dati. La cache contiene già i dati corretti; solo la PivotTable renderizzata deve essere ricalcolata. In questo caso, pivotTable.CalculateData() è la scelta giusta. L’esempio seguente modifica una proprietà non sorgente della tabella pivot e quindi chiama CalculateData() per renderizzarla nuovamente 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.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Modifica una proprietà di visualizzazione/layout — si tratta di una modifica solo di presentazione,
// quindi NON richiede una rilettura dei dati sorgente tramite PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(false);
// calculateData() ri-renderizza 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");

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 ogni PivotTable che dipende dalla cache data.

Migrazione dall’obsoleto `PivotTable.RefreshData()`

Prima di Aspose.Cells for Node.js via Java v26.7, il modo standard per aggiornare una tabella pivot era chiamare PivotTable.RefreshData() su ogni tabella pivot individualmente. Dalla v26.7, quel metodo è contrassegnato come obsoleto e deve essere sostituito con le API consapevoli della cache descritte sopra. Ci sono due motivi per cui l’approccio RefreshData() per tabella è problematico nelle cartelle di lavoro reali:

Recupera nuovamente i dati dalla sorgente ogni volta che viene chiamato, anche quando la sorgente non è cambiata. Le sostituzioni consigliate sono: L’esempio seguente dimostra il nuovo schema efficiente per cartelle di lavoro con più tabelle pivot che condividono una singola cache.

Quale API di aggiornamento devo 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 sorgente cambiati per una cache	`pivotTable.PivotCache.Refresh()`	Aggiorna TUTTE le tabelle pivot su quella cache condivisa.
Solo impostazioni di vista/layout cambiate	`pivotTable.CalculateData()`	Evita il round-trip non necessario alla sorgente.
Elencare tutte le tabelle pivot su una cache condivisa	`pivotCache.GetPivotTables()`	Da usare per enumerare prima dell’aggiornamento in blocco.
In pratica, preferisci le API basate sulla cache rispetto all’obsoleto `RefreshData()` per tabella. Sono consapevoli delle cache condivise, evitano recuperi sorgente ridondanti e ti consentono di scegliere il più piccolo ambito che soddisfa il tuo requisito di aggiornamento.

Insidie comuni

Dimenticare di aggiornare prima di salvare. Una tabella pivot scrive i suoi valori renderizzati nel foglio di lavoro solo quando la sua catena dati viene aggiornata. Se modifichi le celle sorgente, chiama PivotCache.Refresh() (o Workbook.RefreshAll()) prima di Workbook.save(), altrimenti il file salvato contiene ancora i vecchi valori aggregati.
Chiamare l’obsoleto RefreshData() per tabella. Nella v26.7, PivotTable.RefreshData() è contrassegnato come obsoleto e recupera la sorgente per ogni chiamata. Con più tabelle pivot che condividono una cache, questo significa N recuperi sorgente ridondanti. Sostituisci con una singola PivotCache.Refresh() seguita da CalculateData() per tabella.
Aggiornare quando è cambiato solo il layout. Se hai cambiato solo la vista di una tabella pivot (ordine delle colonne, ConsolidationFunction, ecc.) senza toccare i dati sorgente, PivotCache.Refresh() è inutile e lento. Chiama pivotTable.CalculateData() per renderizzare nuovamente dalla cache esistente.
Sorgente esterna non supportata da PivotCache.Refresh(). Se la sorgente della tabella pivot proviene da una connessione esterna (database, cubo OLAP, ecc.), PivotCache.Refresh() non può aggiornarla nella v26.7 — attualmente supporta solo i tipi di sorgente Sheet e Consolidation. Per le sorgenti esterne, riaprire la cartella di lavoro o ricostruire la cache dalla sorgente.

Nodejsjava: 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 pivot. L’argomento fieldType accetta uno dei seguenti valori di PivotFieldType.

ROW — campi disposti verticalmente a sinistra
COLUMN — campi disposti orizzontalmente in alto
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.getRowFields() e PivotTable.getColumnFields(). Ciascuna proprietà restituisce un PivotFieldCollection. Il campo all’indice 0 di RowFields è il campo riga più esterno, e gli indici successivi rappresentano i campi nidificati al suo interno. La stessa convenzione di indicizzazione si applica a ColumnFields. L’ordine di nidificazione dei campi è importante. Aggiungendo Category all’area riga per primo e poi Item si ottiene una 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, boolean shown) controlla quali righe di subtotale vengono visualizzate per un campo pivot. Ogni chiamata attiva o disattiva un singolo tipo di subtotale in modo indipendente. Passando shown = true si visualizza il subtotale, mentre shown = false lo nasconde. Poiché ogni chiamata riguarda un solo tipo, invocare il metodo più volte con valori diversi di subtotalType consente di costruire un sottoinsieme personalizzato di subtotali. L’enum PivotFieldSubtotalType definisce i tipi di subtotale disponibili.

AUTOMATIC — Aspose.Cells sceglie la selezione predefinita (in genere SUM per i campi numerici)
NONE — elimina ogni riga di subtotale
SUM
COUNT
AVERAGE
MAX
MIN
PRODUCT
STD_DEV
STD_DEVP
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 in quel caso le chiamate a setSubtotals non hanno alcun effetto visibile. Questo articolo pertanto inserisce due campi riga (Category esterno, Item interno) in ogni esempio, così che il confine di subtotale tra ciascun gruppo Category sia visibile.

Scenario 1 — Subtotali automatici (predefiniti)

Quando non si invoca 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)

Chiamando setSubtotals(PivotFieldSubtotalType.NONE, true) si rimuovono tutte le righe di subtotale dalla pivot, lasciando solo le righe dei campi e il totale generale in fondo. Questo è utile quando si desiderano i dati raggruppati grezzi senza alcuna riga di riepilogo.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");
let headers = ["Category", "Item", "Year", "Amount"];
for (let j = 0; j < headers.length; j++)
{
    worksheet.getCells().get(0, j).putValue(headers[j]);
}
let data = [
    ["Fruit", "Apple", 2020, 100],
    ["Fruit", "Apple", 2021, 150],
    ["Fruit", "Banana", 2020, 80],
    ["Fruit", "Banana", 2021, 90],
    ["Vegetable", "Carrot", 2020, 50],
    ["Vegetable", "Carrot", 2021, 60],
    ["Vegetable", "Daikon", 2020, 40],
    ["Vegetable", "Daikon", 2021, 45]
];
for (let i = 0; i < data.length; i++)
{
    for (let j = 0; j < data[i].length; j++)
    {
        worksheet.getCells().get(i + 1, j).putValue(data[i][j]);
    }
}
let pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
let categoryField = pivotTable.getRowFields().get(0);
categoryField.setSubtotals(AsposeCells.PivotFieldSubtotalType.None, true);
pivotTable.calculateData();
workbook.save("output_none.xlsx");

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 solo tipo, quindi invocare il metodo due volte — una volta con SUM e una volta 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 dataset e la stessa struttura di tabella pivot. L’unica differenza tra essi è la chiamata a setSubtotals applicata al campo riga esterno Category. Ricorda la regola dei due campi: un singolo campo in un’area non ha nulla da subtotalizzare tra un gruppo e l’altro, quindi posiziona sempre almeno due campi nell’area riga o colonna quando desideri che setSubtotals abbia un effetto visibile.

Nodejsjava: Campi Valore in Aspose.Cells for Node.js via Java

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

I campi valore sono il cuore di ogni tabella pivot, le aggregazioni numeriche che riepilogano i dati di origine. In Aspose.Cells for Node.js via Java, l’area dati di una tabella pivot viene popolata aggiungendovi campi base tramite PivotTable.addFieldToArea, e ogni campo posizionato in tale area può avere la propria funzione di riepilogo. Quando esistono due o più campi dati, Aspose.Cells espone uno speciale campo aggregato, PivotTable.getValuesField(), che può essere posizionato sull’asse Riga o Colonna come campo base, offrendoti un controllo più preciso su come i campi valore appaiono nel layout.

Aggiunta di un Campo all’Area Dati

L’aggiunta di un campo 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 aggiunto un campo 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 riepilogata con ConsolidationFunction.SUM, mentre una colonna non numerica utilizza COUNT come impostazione predefinita.

const AsposeCells = require("aspose.cells");
const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");
const headers = ["Category", "Item", "Year", "Amount"];
for (let j = 0; j < headers.length; j++) {
    worksheet.getCells().get(0, j).putValue(headers[j]);
}
const data = [
    ["Fruit",     "Apple",  2020, 100],
    ["Fruit",     "Apple",  2021, 150],
    ["Fruit",     "Banana", 2020,  80],
    ["Fruit",     "Banana", 2021,  90],
    ["Vegetable", "Carrot", 2020,  50],
    ["Vegetable", "Carrot", 2021,  60],
    ["Vegetable", "Daikon", 2020,  40],
    ["Vegetable", "Daikon", 2021,  45]
];
for (let i = 0; i < data.length; i++) {
    for (let j = 0; j < data[i].length; j++) {
        worksheet.getCells().get(i + 1, j).putValue(data[i][j]);
    }
}
const pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1", true, false);
const pivotTable = worksheet.getPivotTables().get(pivotIndex);
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.calculateData();
workbook.save("output_drag.xlsx");

Modifica della Funzione di Riepilogo

Ogni campo posizionato nell’area dati viene incapsulato internamente come istanza di PivotField e la sua proprietà getFunction() restituisce un valore dall’enumerazione ConsolidationFunction. Lo stesso setter setFunction() consente di passare tra gli aggregati disponibili, inclusi SUM, COUNT, AVERAGE, MAX, MIN, PRODUCT, STD_DEV, STD_DEVP, VAR e VARP.

La modifica di Function influisce solo sull’aggregato, la colonna di origine non cambia.

È quindi possibile lasciare un campo dati come SUM mentre si aggiunge un secondo campo dati che fa riferimento alla stessa colonna di origine ma utilizza COUNT o AVERAGE, il tutto in un’unica tabella pivot.

const AsposeCells = require("aspose.cells");
const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");
const headers = ["Category", "Item", "Year", "Amount"];
for (let j = 0; j < headers.length; j++) {
    worksheet.getCells().get(0, j).putValue(headers[j]);
}
const data = [
    ["Fruit",     "Apple",  2020, 100],
    ["Fruit",     "Apple",  2021, 150],
    ["Fruit",     "Banana", 2020,  80],
    ["Fruit",     "Banana", 2021,  90],
    ["Vegetable", "Carrot", 2020,  50],
    ["Vegetable", "Carrot", 2021,  60],
    ["Vegetable", "Daikon", 2020,  40],
    ["Vegetable", "Daikon", 2021,  45]
];
for (let i = 0; i < data.length; i++) {
    for (let j = 0; j < data[i].length; j++) {
        worksheet.getCells().get(i + 1, j).putValue(data[i][j]);
    }
}
const pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1", true, false);
const pivotTable = worksheet.getPivotTables().get(pivotIndex);
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.getDataFields().get(1).setFunction(AsposeCells.ConsolidationFunction.Count);
pivotTable.calculateData();
workbook.save("output_function.xlsx");

Posizionamento dei 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’aggregato di ogni campo dati presente nell’area dati. È possibile trascinarlo nell’area Riga o Colonna come campo pivot base, utile per disporre più misure affiancate.

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

Gli scenari seguenti illustrano tre esempi end-to-end che dimostrano ciascuna capacità descritta sopra sulla stessa struttura di tabella pivot.

const AsposeCells = require("aspose.cells");
const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");
const headers = ["Category", "Item", "Year", "Amount"];
for (let j = 0; j < headers.length; j++) {
    worksheet.getCells().get(0, j).putValue(headers[j]);
}
const data = [
    ["Fruit",     "Apple",  2020, 100],
    ["Fruit",     "Apple",  2021, 150],
    ["Fruit",     "Banana", 2020,  80],
    ["Fruit",     "Banana", 2021,  90],
    ["Vegetable", "Carrot", 2020,  50],
    ["Vegetable", "Carrot", 2021,  60],
    ["Vegetable", "Daikon", 2020,  40],
    ["Vegetable", "Daikon", 2021,  45]
];
for (let i = 0; i < data.length; i++) {
    for (let j = 0; j < data[i].length; j++) {
        worksheet.getCells().get(i + 1, j).putValue(data[i][j]);
    }
}
const pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1", true, false);
const pivotTable = worksheet.getPivotTables().get(pivotIndex);
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Category");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Item");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.getDataFields().get(1).setFunction(AsposeCells.ConsolidationFunction.Count);
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, pivotTable.getValuesField());
pivotTable.calculateData();
workbook.save("output_plot.xlsx");

Nodejsjava: 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. È possibile aggiungere un campo filtro tramite un’API di alto livello oppure tramite la raccolta di livello inferiore PageFields, e gestire il filtro pagina in modalità selezione singola, cancellarlo 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 con 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 tabella pivot. Gli utenti finali lo vedono come un menu a discesa nella parte superiore di una tabella pivot visualizzata in Excel, e selezionare uno degli elementi della pagina disponibili ricostruisce il corpo della tabella pivot in modo che vengano riepilogati solo i record appartenenti a quell’elemento della pagina. Un campo pivot diventa un campo filtro quando viene registrato come PivotFieldType.Page anziché come PivotFieldType.Row, PivotFieldType.Column o PivotFieldType.Data. Un campo filtro può operare in due modalità. Nella modalità predefinita selezione singola è visibile un solo elemento della pagina alla volta, quindi il corpo della tabella pivot riepiloga esattamente un sottoinsieme. Nella modalità selezione multipla il campo espone un elenco con caselle di controllo e il corpo della tabella pivot riepiloga l’unione di tutti gli elementi della pagina selezionati. Lo stesso campo di origine può essere spostato avanti e indietro tra queste modalità attivando/disattivando una singola proprietà. Aspose.Cells for Node.js via Java espone due modi equivalenti per registrare un campo filtro. L’API di alto livello è pivotTable.addFieldToArea(PivotFieldType.Page, "fieldName"), che accetta il nome della colonna di origine e aggiunge il campo in una singola chiamata. L’API di livello inferiore è pivotTable.getPageFields().add(PivotField), che viene utilizzata quando si ha già un riferimento a un PivotField e si desidera aggiungere la stessa istanza del campo all’area filtro. Entrambe le API finiscono per popolare la stessa raccolta PageFields, e il resto di questo articolo mostra come scegliere tra esse e come gestire ciascuna modalità di filtraggio.

Aggiunta di un campo filtro

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

Aggiunta di un campo filtro con addFieldToArea

L’esempio seguente crea un piccolo set di dati Frutto / Anno / Importo, posiziona una tabella pivot alla cella E3 con Fruit nell’area riga, Amount nell’area dati e Year nell’area filtro, aggiorna la tabella 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 loro 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");

Aggiunta di un campo filtro con getPageFields().add

Quando si lavora già con un’istanza di PivotField, è possibile passarla direttamente a pivotTable.getPageFields().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);
// Aggiunge la tabella pivot in 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 Pagina qui sotto)
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Approccio di basso livello: recupera il PivotField Year esistente da BaseFields
// e lo registra nell'area Pagina tramite PageFields.Add(PivotField).
let yearField = pivotTable.getBaseFields().get("Year");
pivotTable.getPageFields().add(yearField);
// Aggiorna in modo che il nuovo campo pagina venga riflesso nella cartella di lavoro salvata
pivotTable.calculateData();
workbook.save("output.xlsx");

Filtro a selezione singola (mostra un singolo elemento della pagina)

Nella modalità predefinita di selezione singola, il campo filtro viene visualizzato come un singolo menu a discesa e l’intero PivotField.CurrentPageItem seleziona quale elemento della pagina guida il corpo della tabella pivot. L’assegnazione di un indice specifico seleziona quell’unico elemento; l’assegnazione del valore sentinella speciale 0x7FFD (decimale 32765) cancella il filtro così che ogni elemento della pagina venga riepilogato contemporaneamente. La selezione singola è l’impostazione predefinita; non è necessario abilitarla esplicitamente.

Mostra tutti gli elementi

Impostare CurrentPageItem sul valore magico 0x7FFD equivale a cancellare il filtro pagina; il corpo della tabella pivot riepiloga ogni elemento della pagina come se non fosse applicato alcun filtro.

var workbook = new AsposeCells.Workbook();
var sheet = workbook.getWorksheets().get(0);
// Popola i dati Frutto/Anno/Quantità
sheet.getCells().get("A1").putValue("Fruit");
sheet.getCells().get("B1").putValue("Year");
sheet.getCells().get("C1").putValue("Amount");
var data = [
    ["Apple", 2022, 100],
    ["Apple", 2023, 150],
    ["Banana", 2022, 80],
    ["Banana", 2023, 120],
    ["Cherry", 2022, 200],
    ["Cherry", 2023, 250]
];
for (var r = 0; r < data.length; r++) {
    for (var c = 0; c < data[r].length; c++) {
        sheet.getCells().get(r + 1, c).putValue(data[r][c]);
    }
}
// Crea una tabella pivot in E3
var pivotTables = sheet.getPivotTables();
var index = pivotTables.add("=A1:C7", "E3", "PivotTable1");
var pivotTable = pivotTables.get(index);
// Configura i campi pivot: Frutto→Riga, Quantità→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 "(Tutto)" nel menu a discesa del campo pagina di Excel.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD);
workbook.save("output.xlsx");

Mostra un elemento specifico

Impostare CurrentPageItem su un indice reale seleziona solo quell’elemento della 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").setValue("Fruit");
cells.get("B1").setValue("Year");
cells.get("C1").setValue("Amount");
cells.get("A2").setValue("Apple");
cells.get("B2").setValue("2020");
cells.get("C2").setValue("100");
cells.get("A3").setValue("Apple");
cells.get("B3").setValue("2021");
cells.get("C3").setValue("150");
cells.get("A4").setValue("Banana");
cells.get("B4").setValue("2020");
cells.get("C4").setValue("200");
cells.get("A5").setValue("Banana");
cells.get("B5").setValue("2021");
cells.get("C5").setValue("250");
// 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");

Filtro a selezione multipla

Il filtro a selezione multipla trasforma il menu a discesa della pagina in un elenco con caselle di controllo e consente all’utente finale di selezionare più elementi della pagina contemporaneamente. Aspose.Cells espone due proprietà che lavorano insieme. PivotField.IsMultipleItemSelectionAllowed deve essere impostato su true prima che l’interfaccia di selezione multipla abbia effetto. Dopo che è abilitata, PivotItem.IsHidden controlla quali elementi appaiono nell’elenco con caselle di controllo, quindi è possibile mostrare ogni elemento oppure consentire solo elementi specifici. Il codice seguente abilita la selezione multipla sullo stesso campo filtro Year costruito nello Scenario 1a, e poi mostra due schemi, la Parte A rivela ogni elemento della 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()).

const AsposeCells = require("aspose.cells");
// — La tabella pivot e il campo pagina sono costruiti esattamente come in
//   Scenario 1a (dati Frutto/Anno/Importo, pivot in E3, Frutto→Riga,
//   Importo→Dati, Anno→Pagina tramite AddFieldToArea).
//   Qui sotto applichiamo il filtro a selezione multipla sul campo pagina.
const workbook = new AsposeCells.Workbook();
const sheet = workbook.getWorksheets().get(0);
const cells = sheet.getCells();
// Dati di esempio: Frutto | Anno | Importo
cells.get(0, 0).putValue("Fruit");
cells.get(0, 1).putValue("Year");
cells.get(0, 2).putValue("Amount");
const data = [
    ["apple",  "2019", "100"],
    ["apple",  "2020", "150"],
    ["apple",  "2021", "200"],
    ["banana", "2019", "110"],
    ["banana", "2020", "160"],
    ["banana", "2021", "210"],
    ["grape",  "2019", "120"],
    ["grape",  "2020", "170"],
    ["grape",  "2021", "220"]
];
for (let i = 0; i < data.length; i++) {
    cells.get(i + 1, 0).putValue(data[i][0]);
    cells.get(i + 1, 1).putValue(parseInt(data[i][1]));
    cells.get(i + 1, 2).putValue(parseInt(data[i][2]));
}
const pivotSheet = workbook.getWorksheets().add("Pivot");
const pivots = pivotSheet.getPivotTables();
const pivotIndex = pivots.add("E3", "A1:C10", "PivotTable1");
const pivotTable = pivots.get(pivotIndex);
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.ROW, "Fruit");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.DATA, "Amount");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.PAGE, "Year");
// — Abilita la selezione multipla sul campo pagina
pivotTable.getPageFields().get(0).setMultipleItemSelectionAllowed(true);
// Parte A — seleziona TUTTI gli elementi (rendi visibile ogni elemento)
const pivotItems = pivotTable.getPageFields().get(0).getPivotItems();
for (let i = 0; i < pivotItems.getCount(); i++) {
    pivotItems.get(i).setHidden(false);
}
// Parte B — seleziona solo elementi specifici tramite il 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).setHidden(false);
            break;
        default:
            pivotItems.get(i).setHidden(true);
            break;
    }
}
pivotTable.calculateData();
workbook.save("output.xlsx");

Nota: Quando si utilizza il filtro 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 visualizza una tabella pivot vuota. Verificare sempre che la lista di elementi consentiti per la selezione multipla includa almeno un elemento dei dati di origine.

Quale API e quale modalità devo usare?

La tabella seguente riassume quando utilizzare ciascuna API e modalità, in modo da poter scegliere la giusta combinazione senza 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. Utilizzare questa opzione a meno che non sia necessario un riferimento a `PivotField`.
Aggiungere un campo filtro quando si ha già un oggetto `PivotField`	`pivotTable.getPageFields().add(PivotField)`	n/d	Da usare quando l’oggetto campo è stato ottenuto altrove o deve essere riutilizzato.
Filtrare su un singolo elemento della pagina (modalità predefinita)	`PivotField.CurrentPageItem`	impostare su un indice specifico	Ad esempio, `1` mostra il secondo elemento nell’elenco ordinato.
Mostra tutti gli elementi / cancella il filtro pagina	`PivotField.CurrentPageItem`	impostare su `0x7FFD`	Il valore magico `0x7FFD` (decimale 32765) è la sentinella per “tutti gli elementi”.
Abilitare l’interfaccia di 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 ciascun elemento	Almeno un elemento deve rimanere visibile (`IsHidden == false`).

Ricordare sempre il vincolo di visibilità quando si configura il filtro a selezione multipla. Se ogni PivotItem in un campo filtro a selezione multipla è nascosto, Excel si blocca all’apertura oppure visualizza una tabella pivot vuota. Costruire la lista di elementi consentiti basandosi sui dati di origine in modo che almeno un elemento rimanga visibile, e le cartelle di lavoro salvate si apriranno in modo affidabile su ogni macchina.

Documentation – Inserisci tabella pivot

Nodejsjava: Applica stili alle tabelle pivot in Aspose.Cells for Node.js via Java

Introduzione

Applica una formattazione automatica preimpostata XLS legacy

Applica uno stile preimpostato moderno con nome per tabelle pivot

Definire e applicare uno stile personalizzato per tabelle pivot

Applicare uno stile a ogni cella della tabella pivot con FormatAll

Quale API di stile dovrei usare?

Nodejsjava: Refresh Pivot Tables and Pivot Caches in Aspose.Cells for Node.js via Java

Introduzione

Avvio rapido

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 sorgente cambiati — Usa PivotCache.Refresh()

Solo vista/layout cambiati — Usa CalculateData()

Migrazione dall’obsoleto PivotTable.RefreshData()

Quale API di aggiornamento devo usare?

Insidie comuni

Nodejsjava: 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

Nodejsjava: Campi Valore in Aspose.Cells for Node.js via Java

Aggiunta di un Campo all’Area Dati

Modifica della Funzione di Riepilogo

Posizionamento dei Campi Valore sull’Asse Riga o Colonna

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

Introduzione

Aggiunta di un campo filtro

Aggiunta di un campo filtro con addFieldToArea

Aggiunta di un campo filtro con getPageFields().add

Filtro a selezione singola (mostra un singolo elemento della pagina)

Mostra tutti gli elementi

Mostra un elemento specifico

Filtro a selezione multipla

Quale API e quale modalità devo usare?

Dati sorgente cambiati — Usa `PivotCache.Refresh()`

Solo vista/layout cambiati — Usa `CalculateData()`

Migrazione dall’obsoleto `PivotTable.RefreshData()`