Documentation – Infoga pivot tabell

Nodejscpp: Formatera Pivot tabell

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

Pivottabellens utseende

Hur man skapar en pivottabell förklarar hur man skapar en enkel pivottabell. Den här artikeln beskriver hur man anpassar en pivottabells utseende genom att ställa in olika egenskaper:

Pivottabellformatalternativ
Alternativ för pivottabellfältformat
Alternativ för datafältformat

Hur man ställer in pivottabellsformatalternativ

Klassen PivotTable kontrollerar den övergripande pivottabellen och kan formateras på olika sätt.

Hur man ställer in automatiskt format typ

Microsoft Excel erbjuder ett antal förinställda rapportformat. Aspose.Cells for Node.js via C++ stöder även dessa formateringsalternativ. För att komma åt dem:

Ställ in PivotTable.setIsAutoFormat(value) till true.
Tilldela ett formateringsalternativ från uppräkningen PivotTableAutoFormatType.

Hur man ställer in formateringsalternativ

Kodprovet nedan visar hur man formaterar pivottabellen för att visa totaler för rader och kolumner, och hur man ställer in rapportens fältsortering. Det visar också hur man ställer in en anpassad sträng för nollvärden.

Manuell formatering av utseende

För att manuellt formatera hur pivottabelrapporten ser ut, istället för att använda förinställda rapportformat, använd PivotTable.formatAll(style)- och PivotTable.format(row, column, style)-metoderna. Skapa en stilobjekt för önskad formatering, till exempel:

Hur man ställer in pivottabellsfältformatalternativ

Klassen PivotField representerar ett fält i en pivottabell och kan formateras på olika sätt. Kodprovet nedan visar hur man:

Tillgång till radfält.
Inställning av delsummer.
Inställning av autosortering.
Inställning av autoshow.

Hur man ställer in rad/kolumn/sida fältformat

Hur man ställer in datafältformat

Kodprovet nedan visar hur man ställer in visningsformat och nummerformat för datafält.

Hur man rensar pivottabellsfält

Klassen PivotFieldCollection har en metod som heter clear() som låter dig rensa pivottabellsfält. Använd den när du vill rensa alla pivottabellfält i områdena, till exempel sida, kolumn, rad eller data. Kodprovet nedan visar hur man rensar alla pivottabellfält i ett dataområde.

Nodejscpp: Skapa pivottabeller och pivotdiagram

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

En pivottabell är en interaktiv sammanfattning av poster. Till exempel kan du ha hundratals faktura-poster i en lista i ett kalkylblad. En pivottabell kan summera fakturorna efter kund, produkt eller datum. Med Microsoft Excel är det möjligt att snabbt omorganisera informationen i pivottabellen genom att dra knappar till en ny position.

Ett pivotdiagram är en interaktiv grafisk representation av data i en pivottabell. Pivotdiagram introducerades i Excel 2000. Att använda ett pivotdiagram gör det ännu enklare att förstå data eftersom pivottabellen skapar delsummer och totaler automatiskt.

Aspose.Cells for Node.js via C++ stöder pivot-tabeller och pivot-diagram.

Lägg till pivot-tabeller och diagram med Aspose.Cells for Node.js via C++

Aspose.Cells for Node.js via C++ tillhandahåller en särskild uppsättning klasser för att skapa pivot-tabeller. Dessa klasser används för att skapa och ställa in PivotTable-objekt, som fungerar som grundläggande byggstenar för en PivotTable:

PivotField, ett fält i en pivottabellrapport.
PivotFields, en samling av alla PivotField-objekt i en pivottabell.
PivotTable, en pivottabellrapport på ett kalkylblad.
PivotTables, en samling av alla PivotTable-objekt på kalkylbladet.

Förbered att använda Aspose.Cells for Node.js via C++

Installera Aspose.Cells for Node.js via C++ från NPM, använd kommandot: $ npm install aspose.cells.node.
Du kan också följa steg-för-steg-instruktionerna för att installera “Aspose.Cells for Node.js via C++” i din utvecklarmiljö.

Hur man lägger till en Pivot-tabell med Aspose.Cells for Node.js via C++

För att skapa en pivot-tabell med Aspose.Cells for Node.js via C++:

Lägg till lite data i ett kalkylbladsceller med hjälp av en Cell-objekts put_value-metod. Du använder också en mallfil som redan är ifylld med data. Datan kommer att användas som pivottabellens datakälla.
Lägg till en pivot tabell till arbetsbladet genom att anropa PivotTables -samlingens add-metod (inkapslad i Worksheet-objektet).
Hämta det nya PivotTable-objektet från PivotTables-samlingen genom att ange dess index. # Använd något av de pivottabellobjekt som är inkapslade i PivotTable-objektet för att hantera tabellen.

Kodexempel ges nedan.

Hur man lägger till ett Pivot-diagram med Aspose.Cells for Node.js via C++-biblioteket

För att skapa ett PivotDiagram med Aspose.Cells for Node.js via C++:

Lägg till en graf.
Ange grafens PivotSource så att den hänvisar till en befintlig pivot tabell i kalkylarket.
Ange andra attribut.

Nodejscpp: Pivot tabell och källdata

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

Pivot-tabellens källdata

Det finns tillfällen då du vill skapa Microsoft Excel-rapporter med pivottabeller som hämtar data från olika datakällor (t.ex. en databas) som inte är kända vid design-tid. Denna artikel ger en metod för att dynamiskt ändra en pivot-tabells datakälla.

Ändra en pivot-tabells källdata

Skapa en ny designer-mall.
1. Skapa en ny designer-mallfil enligt skärmbilden nedan.
2. Definiera sedan ett namngivet område, Datakälla, som hänvisar till detta cellområde.
  
  Skapa en designer-mall & definiera ett namngivet område, Datakälla

Skapa en pivot-tabell baserad på detta namngivna område.
1. I Microsoft Excel, välj Data, sedan Pivottabell och PivotDiagramrapport.
2. Skapa en pivottabell baserad på det namngivna området som skapats i det första steget.
  
  Skapa en pivottabell baserad på det namngivna området, DataSource

Dra det motsvarande fältet till pivottabellraden och kolumnen, skapa sedan den resulterande pivottabellen enligt skärmdumpen nedan.

Skapa en pivottabell baserad på ett motsvarande fält

Högerklicka på pivottabellen och välj Tabelloptioner.
1. Markera Uppdatera vid öppning i inställningarna för Dataalternativ.
  
  Inställning av pivottabellalternativ

Nu kan du spara den här filen som din designer-mallfil.

Försörjning av ny data och ändring av källdata för en pivottabell.
1. När den designer-mall är skapad, använd följande kod för att ändra källan till pivottabellen.

Genom att köra den här exempelkoden nedan ändras källan till pivottabellen.

Nodejscpp: Lägg till beräknat fält i pivottabell

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

Möjliga användningsscenario

När du skapar en pivottabell baserad på kända data finner du att datan i den inte är det du vill ha. Den data du vill ha är kombinationen av denna ursprungliga data. Till exempel behöver du lägga till, subtrahera, multiplicera och dividera den ursprungliga datan innan du vill ha datan. Vid den här tiden behöver du bygga ett beräknat fält och ställa in motsvarande formel för beräkning. Utför sedan vissa statistik och andra operationer på det beräknade fältet.

Hur man lägger till beräknat fält i pivot-tabell i Excel

Så här lägger du till ett beräknat fält i en pivot-tabell i Excel, följ dessa steg:

Välj pivottabellen som du vill lägga till ett beräknat fält i.
Gå till fliken Pivottabell analysera på menyfliken.
Klicka på “Fält, artiklar och uppsättningar” och välj sedan “Beräknat fält” i rullgardinsmenyn.
I fältet “Namn” anger du ett namn för det beräknade fältet.
I fältet “Formel” anger du formeln för beräkningen du vill utföra med hjälp av lämpliga PivotTable-fältnamn och matematiska operatorer.
Klicka på “ok” för att skapa det beräknade fältet.
Det nya beräknade fältet kommer att visas i PivotTable Field List under avsnittet Värden.
Dra det beräknade fältet till värdesektionen i PivotTable för att visa de beräknade värdena.

Hur man lägger till ett beräknat fält i pivottabell med Aspose.Cells for Node.js via C++ biblioteket

Lägg till beräknat fält till Excel-fil med Aspose.Cells for Node.js via C++. Se följande exempel kod. Efter att ha kört exempel-koden läggs en pivottabell med beräknat fält till bladet.

Ange originaldata och skapa en pivot-tabell.
Skapa det beräknade fältet enligt det befintliga PivotField i pivot-tabellen.
Lägg till det beräknade fältet i dataområdet.
Slutligen sparas arbetsboken i utdata XLSX-format.

Exempelkod

Nodejscpp: Tillämpa stilar på pivottabeller i Aspose.Cells för .NET

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

Aspose.Cells stöder tillämpning av både äldre pivot-autoformat (avsedda för .xls-filer) och moderna namngivna eller anpassade pivottabellstilar (avsedda för .xlsx-, .xlsm- och .xlsb-filer). Vilken API du bör anropa beror på filformatet som arbetsboken sparas till, inte formatet den laddades från.

Introduktion

Aspose.Cells exponerar två parallella stil-API:er för pivottabeller. Valet mellan dem styrs av filformatet du sparar arbetsboken till, inte av formatet du läser den från. En arbetsbok som laddats från en .xls-fil kan sparas om som .xlsx, och i det fallet gäller det moderna stil-API:et snarare än det äldre.

För äldre .xls-utdata, använd egenskapen PivotTable.AutoFormatType tillsammans med enumerationen Aspose.Cells.Pivot.PivotTableAutoFormatType. Detta API motsvarar autoformatväljaren som klassisk Excel erbjöd för pivottabeller.

För moderna .xlsx-, .xlsm- och .xlsb-utdata finns två varianter av stil-API tillgängliga:

PivotTable.PivotTableStyleType väljer en av de inbyggda namngivna stilarna (ljusa och mörka teman, inklusive stilarna som lades till i Excel 2017). Dessa förinställningar är skrivskyddade.
PivotTable.PivotTableStyleName väljer en anpassad stil som du definierar själv genom Workbook.Worksheets.TableStyles.AddPivotTableStyle(...). Anpassade stilar krävs när du vill ändra färger, kantlinjer eller teckensnitt utöver vad förinställningarna erbjuder.

Dessutom är PivotTable.FormatAll(Style) en genväg som tillämpar ett enda Style-objekt på varje cell i pivoten, och åsidosätter det som är inställt genom någon av stilinamns-API:erna ovan. Detta är användbart när ett enhetligt utseende krävs oavsett det underliggande temat.

Tillämpa en äldre XLS-förinställd autoformat

PivotTable.AutoFormatType accepterar ett värde från enumerationen Aspose.Cells.Pivot.PivotTableAutoFormatType. De tillgängliga värdena är Report1 till Report10, Classic, och Table1 till Table10.

AutoFormatType respekteras endast när arbetsboken sparas som .xls. När samma arbetsbok sparas som .xlsx, .xlsm eller .xlsb, ignorerar Excel denna egenskap och faller tillbaka på inställningarna PivotTableStyleType och PivotTableStyleName.

Följande exempel laddar en ny arbetsbok, fyller i Fruit/Year/Amount-exempeldata, lägger till en pivottabell, tillämpar PivotTableAutoFormatType.Report5, och sparar resultatet som .xls.

Varför inga kolumnfält? Autoformaten i Report-serien (Report1 till Report10, Table1 till Table10) designades i klassiska Excel för endimensionella pivottabeller med endast radfält och värden — de har ingen inbyggd formatering för kolumnfält-rubriker. Om din pivottabell behöver kolumnfält, använd de moderna PivotTableStyleType-förinställningarna från Scenario 2 nedan istället, som är designade för den tvådimensionella layout som moderna Excel använder.

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

// Scenario 1: Tillämpa ett äldre XLS-förinställt autoformat
// API som används: PivotTable.AutoFormatType
// Målfilsformat: .xls (äldre)
// För fullständiga exempel och datafiler, gå till https://github.com/aspose-cells/Aspose.Cells-for-.NET

// Skapa en ny arbetsbok
const workbook = new AsposeCells.Workbook();

// Hämta det första kalkylbladet
const sheet = workbook.getWorksheets().get(0);

// Fyll källdatan med rubrikrad (Fruit, Year, Amount)
// och 9 datarader som täcker grape, blueberry, kiwi, cherry över 2020 och 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);

// Lägg till en pivottabell vid destinationscell E3, med namnet "Pivot1", med hjälp av källintervall A1:C10
const pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
const pivotTable = sheet.getPivotTables().get(pivotIndex);

// Tilldela fält: Fruit -> Rader, Year -> Kolumner, Amount -> Data
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Tillämpa det äldre XLS-förinställda autoformatet "Report5"
// Obs: Den här egenskapen är endast meningsfull när man sparar som .xls.
// När man sparar som .xlsx/.xlsm/.xlsb ignorerar Excel AutoFormatType
// och använder det som PivotTableStyleType / PivotTableStyleName anger.
pivotTable.setAutoFormatType(AsposeCells.PivotTableAutoFormatType.Report5);

// Spara arbetsboken i äldre .xls-format
workbook.save("output.xls");

Tillämpa en modern namngiven förinställd pivottabellstil

PivotTable.PivotTableStyleType accepterar ett värde från enumerationen Aspose.Cells.PivotTableStyleType. Enumerationen täcker ljusa teman PivotTableStyleLight1 till PivotTableStyleLight28 och mörka teman PivotTableStyleDark1 till PivotTableStyleDark28. Stilarna som lades till i Excel 2017 (den andra vågen av ljusa och mörka teman) nås genom samma enumeration.

Detta är det rekommenderade API:et för alla moderna filformat. Till skillnad från den äldre autoformaten renderas stilen som väljs här troget av Excel och överlever rundresor genom andra Office-verktyg.

Följande exempel använder samma Fruit/Year/Amount-data, skapar en identisk pivottabell, tillämpar PivotTableStyleDark1, och sparar arbetsboken som .xlsx.

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

// Rubrikrad: Frukt / År / Belopp
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// 9 datarader med Frukt / År / Belopp
worksheet.getCells().get("A2").putValue("Grape");
worksheet.getCells().get("B2").putValue(2020);

Definiera och tillämpa en anpassad pivottabellstil

De inbyggda förinställningarna kan inte modifieras. Närhelst du behöver åsidosätta färger, kantlinjer eller teckensnitt, måste du definiera en anpassad pivotstil. Arbetsflödet har tre steg:

Lägg till en anpassad stil i arbetsbokens TableStyles-samling via Workbook.Worksheets.TableStyles.AddPivotTableStyle(string name). Detta returnerar indexet för den nyskapade stilen.
Konfigurera stilen genom att lägga till element (såsom WholeTable eller GrandTotalRow) genom TableStyle.TableStyleElements.Add(TableStyleElementType), tilldela sedan en Style till varje element via TableStyleElement.SetElementStyle(Style).
Tillämpa den anpassade stilen på pivoten genom att sätta PivotTable.PivotTableStyleName till stilens namn. Använd inte PivotTableStyleType här, eftersom den egenskapen väljer inbyggda förinställningar.

PivotTableStyleName och PivotTableStyleType är inte utbytbara. Använd PivotTableStyleType för inbyggda förinställningar, och PivotTableStyleName för anpassade stilar som du har definierat genom AddPivotTableStyle. Att sätta båda är ofarligt, men endast den som matchar den avsedda källan renderas.

De tillgängliga TableStyleElementType-värdena inkluderar WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels och PageFieldValues.

Följande exempel definierar en anpassad pivotstil med en tunn svart kantlinje på WholeTable och ett fetstilt rött teckensnitt på GrandTotalRow, tillämpar den sedan via PivotTableStyleName och sparar som .xlsx.

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

// Fyll i källdata: rubrikrad + 9 datarader (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);

Tillämpa en stil på varje pivotcell med FormatAll

PivotTable.FormatAll(Style) är en genväg som tillämpar ett enda Style-objekt på varje cell i pivottabellen, inklusive dataområdet, rad- och kolumnrubriker samt totaler. Det som tidigare ställts in genom PivotTableStyleType eller PivotTableStyleName åsidosätts.

FormatAll åsidosätter både PivotTableStyleType och PivotTableStyleName. Använd den endast när ett enhetligt, temaneutralt utseende krävs över hela pivoten.

Följande exempel skapar en Style med gul solid fyllning, ett fetstilt mörkblått teckensnitt och tunna svarta kantlinjer på alla sidor, tillämpar den sedan med FormatAll och sparar som .xlsx.

Vilket stil-API ska jag använda?

Valet av stil-API beror på filformatet du sparar till. Använd tabellen nedan som en snabbreferens.

Målfilformat	API att använda	Anteckningar
`.xls` (äldre)	`PivotTable.AutoFormatType`	Värden från `Aspose.Cells.Pivot.PivotTableAutoFormatType` (t.ex. `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Ignoreras vid sparande i moderna format.
`.xlsx` / `.xlsm` / `.xlsb` (modern, inbyggd stil)	`PivotTable.PivotTableStyleType`	Värden från `Aspose.Cells.PivotTableStyleType` (ljusa/mörka teman, inklusive tillägg i Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (modern, anpassad stil)	`PivotTable.PivotTableStyleName` + `Worksheets.TableStyles.AddPivotTableStyle(...)`	Använd när de inbyggda förinställningarna inte räcker. Konfigurera via `TableStyleElement.SetElementStyle(...)`.
Alla format (enhetlig åsidosättning)	`PivotTable.FormatAll(Style)`	Genväg som åsidosätter alla andra stilinställningar över hela pivoten.

Vid tvivel, spara som .xlsx och använd PivotTableStyleType för inbyggda teman, eller PivotTableStyleName för anpassade teman.

Nodejscpp: Uppdatera pivottabeller i Aspose.Cells for Node.js via C++

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

Aspose.Cells tillhandahåller ett lagerbaserat uppdaterings-API som låter dig ladda om pivotdata i fyra olika omfattningar — från hela arbetsboken ner till en enskild pivottabell. Från och med Aspose.Cells for Node.js via C++ v26.7 är den äldre metoden PivotTable.RefreshData() markerad som föråldrad och bör ersättas med de mer effektiva, cache-medvetna API:er som beskrivs i den här artikeln.

Introduktion

Att uppdatera en pivottabell är sällan en enskild operation. Bakom kulisserna underhåller Aspose.Cells en lagerbaserad datakedja som kopplar samman dina ursprungliga källdata med de renderade värden du ser i kalkylbladet. Att förstå denna kedja är nyckeln till att välja rätt uppdaterings-API för alla situationer.

Den fyrlagers datakedjan är:

Datakälla — de ursprungliga kalkylbladsintervallen, databasfrågan eller konsolideringsintervallet där de råa värdena finns.
PivotCache — den minnesbaserade ögonblicksbilden av källdatan. Varje pivottabell är byggd ovanpå en PivotCache; det är här all data samlas in och aggregeras.
PivotTable — vyobjektet som definierar rad-, kolumn-, värde- och filterfält. En PivotTable läser endast från sin PivotCache, aldrig direkt från datakällan.
Cells — kalkylbladets Cells som PivotTable renderar sina beräknade värden och stilar till.

Ett särskilt viktigt koncept är den delade cachen. När flera pivottabeller i en arbetsbok refererar till samma källintervall delar de en PivotCache-instans. En enda PivotCache kan refereras av många pivottabeller, och att uppdatera denna cache uppdaterar varje beroende PivotTable på en gång.

PivotCache.SourceType (enum PivotTableSourceType) anger var cachedatan kom ifrån. Från och med v26.7 stöder PivotCache.Refresh() endast källtyperna Sheet och Consolidation — det vill säga data som finns i kalkylbladsintervall. Externa källor (databaser, externa anslutningar etc.) är ännu inte möjliga att uppdatera via cache-API:et.

På grund av denna kedja finns det två grundläggande uppdateringsvägar i Aspose.Cells:

PivotCache.Refresh() — laddar om källan → cache OCH beräknar om alla beroende PivotTables i en enda operation.
PivotTable.CalculateData() — beräknar om en PivotTables visning från redan cachad data, utan att gå tillbaka till datakällan.

Alla scenarier i den här artikeln använder kalkylbladsceller som källdata, så källtypen är Sheet och uppdateringsoperationer beter sig som beskrivet.

Nödvändiga importer

Alla JavaScript-exempel i den här artikeln förutsätter att Aspose.Cells for Node.js via C++-modulen har laddats och att pivottyperna finns i namnrymden Aspose.Cells.Pivot. En typisk uppsättning är:

const AsposeCells = require("aspose.cells.node");
const { PivotFieldType } = AsposeCells; (eller åtkomst via AsposeCells.Pivot.PivotFieldType)

Uppdatera alla pivottabeller i arbetsboken

När du behöver säkerställa att varje pivotcache och varje pivottabell i arbetsboken återspeglar den senaste källdatan är det enklaste och mest omfattande API:et Workbook.RefreshAll(). Ett enda anrop traverserar hela arbetsboken — uppdaterar varje PivotCache från sin källa och beräknar sedan om varje beroende PivotTable. Detta är den rekommenderade metoden för allmänna, fullständiga dokumentuppdateringar där prestanda inte är ett problem.

Följande exempel bygger en arbetsbok med ett källintervall Fruit/Year/Amount, skapar en pivottabell, modifierar några källvärden och använder sedan RefreshAll() för att uppdatera allt i ett enda anrop.

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

// Skriv rubrikrad i cellerna A1:C1
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Skriv datarader i cellerna A2:C9 (8 rader med fruktdata för 2020 och 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);

// Lägg till en pivottabell: källområde "A1:C9", destinationscell "E3", namn "Pivot1"
let pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Tilldela pivotfält: Fruit till Rader, Year till Kolumner, Amount till Data
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Ändra flera Amount-värden i källdatan för att simulera ändringar
worksheet.getCells().get("C2").putValue(55);
worksheet.getCells().get("C5").putValue(85);
worksheet.getCells().get("C9").putValue(125);

// Uppdatera alla pivottabeller / pivotcacher i arbetsboken
workbook.refreshAll();

// Spara arbetsboken
workbook.save("output.xlsx");

Uppdatera alla pivottabeller på ett enskilt kalkylblad

Ibland behöver du bara uppdatera pivottabellerna som finns på ett specifikt kalkylblad — till exempel när pivottabeller på andra kalkylblad är kända för att vara orelaterade och inte bör röras. För detta fall tillhandahåller Aspose.Cells Worksheet.RefreshPivotTables(), som är begränsad till en enskild Worksheet-instans.

Detta är mer selektivt än Workbook.RefreshAll(): endast pivottabellerna på det riktade kalkylbladet uppdateras, medan pivottabeller på andra kalkylblad lämnas orörda.

Följande exempel fyller i samma källdata Fruit/Year/Amount, lägger till en pivottabell på det första kalkylbladet, modifierar några källvärden och uppdaterar sedan endast pivottabellerna på det kalkylbladet.

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

Uppdatera en enskild pivottabell

När du vill ha finkornig kontroll över en enskild pivottabell ger det cachebaserade API:et dig två alternativ. Valet mellan dem beror på vad som faktiskt har ändrats: den underliggande källdatan, eller bara vy-/layoutinställningarna för pivottabellen själv.

Källdata har ändrats — Använd `PivotCache.Refresh()`

Om den underliggande källdatan har ändrats är rätt startpunkt pivotTable.PivotCache.Refresh(). Detta anrop läser om källdatan till cachen och beräknar sedan om varje PivotTable som är beroende av den cachen.

Eftersom pivottabeller delar en enda PivotCache-instans, beräknar ett anrop till PivotCache.Refresh() om alla pivottabeller som är byggda på samma cache — inte bara den du refererar till. Om två pivottabeller delar samma källintervall, uppdaterar en cache-uppdatering båda.

Följande exempel skapar två pivottabeller på samma källintervall för att demonstrera detta delade cache-beteende, modifierar några källvärden och uppdaterar sedan genom en cache-referens.

tags at the start. But the developer says no XML tags either: "Do NOT use 

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

// Skapa en ny arbetsbok och öppna det första kalkylbladet
const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);

// Skriv rubrikrad: Frukt / År / Belopp
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Skriv ungefär 9 datarader (druva / blåbär / kiwi / körsbär över 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);

// Lägg till den första pivottabellen "Pivot1" förankrad vid cell E3, källintervall A1:C9
const pivotIndex1 = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
const pivotTable1 = worksheet.getPivotTables().get(pivotIndex1);

// Tilldela fält för Pivot1
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Lägg till en ANDRA pivottabell "Pivot2" förankrad vid E15 med SAMMA källintervall A1:C9
// Både Pivot1 och Pivot2 delar en enda PivotCache eftersom källintervallet är identiskt.
const pivotIndex2 = worksheet.getPivotTables().add("A1:C9", "E15", "Pivot2");
const pivotTable2 = worksheet.getPivotTables().get(pivotIndex2);

// Tilldela samma fält för Pivot2
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Ändra flera Belopp-cellvärden i källdatan för att simulera en dataförändring
worksheet.getCells().get("C2").putValue(150);
worksheet.getCells().get("C4").putValue(350);
worksheet.getCells().get("C7").putValue(650);

// Uppdatera den delade PivotCache.
// Eftersom Pivot1 och Pivot2 delar samma PivotCache, gör detta enda anrop
// att BÅDA pivottabellerna (data + stil) uppdateras från den uppdaterade källan.
pivotTable1.getPivotCache().refresh();

// Spara arbetsboken
workbook.save("output.xlsx");

Endast vy/layout har ändrats — Använd `CalculateData()`

Om källdatan inte har ändrats men bara pivottabellens vy- eller layoutinställningar har modifierats (till exempel har ett fält flyttats till ett annat område, eller en refresh-on-open-inställning har växlats), finns det inget behov av att gå tillbaka till datakällan. Cachen har redan rätt data; endast den renderade PivotTable behöver beräknas om. I detta fall är pivotTable.CalculateData() rätt val.

Detta undviker den onödiga källhämtningen och är betydligt snabbare när många pivottabeller delar samma cache.

Följande exempel modifierar en icke-källegenskap för pivottabellen och anropar sedan CalculateData() för att rendera om den från den befintliga cachen.

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

// Skriv rubrikrad för Frukt / År / Belopp
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Skriv 8 datarader (raderna 2-9, som passar källintervallet 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);

// Lägg till en pivottabell med namnet "Pivot1" placerad i målcell E3, med källa från A1:C9
var pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Tilldela fält: Frukt till Rad, År till Kolumn, Belopp till Data
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Data, "Amount");

// Ändra en egenskap för vy/layout — detta är en ändring som endast påverkar presentationen,
// så det kräver INTE att källdatan läses igen via PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(false);

// CalculateData() renderar om DENNA pivottabells visning (data + stil) från den
// data som redan finns i PivotCache. Eftersom källdatan inte ändrades,
// utförs ingen tur och retur till källan — endast de cachade värdena beräknas om
// till kalkylbladsceller.
pivotTable.calculateData();

// Spara arbetsboken till disk
workbook.save("output.xlsx");

Hämta alla pivottabeller som delar samma PivotCache

En arbetsbok innehåller ofta många pivottabeller som alla sitter ovanpå en delad cache. För att räkna upp dem — till exempel innan du utför en batchuppdatering, eller för att diagnostisera delad cache-påverkan — använd PivotCache.GetPivotTables(). Denna metod returnerar samlingen av varje PivotTable som är beroende av den givna cachen.

Detta är också det mest direkta sättet att bekräfta att två pivottabeller verkligen delar samma PivotCache-instans: du kan jämföra cache-referenser, eller helt enkelt iterera samlingen som returneras av GetPivotTables() och observera vilka pivottabeller som visas i den.

Följande exempel skapar två pivottabeller på samma källintervall, verifierar att de delar samma cache-instans och räknar sedan upp cacheens pivottabeller.

Migrera från den föråldrade `PivotTable.RefreshData()`

Före Aspose.Cells for Node.js via C++ v26.7 var standardsättet att uppdatera en pivottabell att anropa PivotTable.RefreshData() på varje pivottabell individuellt. Från och med v26.7 är den metoden markerad som föråldrad och bör ersättas med de cache-medvetna API:er som beskrivs ovan.

Det finns två skäl till att tabell-för-tabell-metoden RefreshData() är problematisk i verkliga arbetsböcker:

Den hämtar data från källan varje gång den anropas, även när källan inte har ändrats.
Varje anrop uppdaterar hela den delade cachen. När många pivottabeller delar en cache, orsakar upprepade anrop till RefreshData() per pivottabell att samma cache hämtas om och om igen, vilket är mycket långsamt.

De rekommenderade ersättningarna är:

Uppdatera ALLA pivottabeller i arbetsboken → använd workbook.refreshAll();
Uppdatera NÅGRA av dem → använd pivotTable.PivotCache.Refresh(); för en cache. Eftersom cachen delas, uppdaterar detta enda anrop varje pivottabell som är byggd ovanpå den cachen. Andra pivottabeller som sitter på en redan uppdaterad cache kan säkert hoppas över.
Endast pivotvyn/layouten har ändrats → använd pivotTable.CalculateData(); för att rendera om från den befintliga cachen utan någon källhämtning.

Följande exempel demonstrerar det nya effektiva mönstret för arbetsböcker med flera pivottabeller som delar en enda cache.

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

// --- Bygg källdatan: Frukt / År / Belopp (rubrik + 9 rader) ---
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);

// --- Lägg till den första pivottabellen (Pivot1) vid målcell 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");

// --- Lägg till den ANDRA pivottabellen (Pivot2) på SAMMA källintervall ---
// Både Pivot1 och Pivot2 delar ETT underliggande PivotCache.
// Detta är exakt scenariot där det äldre tabellvisa tillvägagångssättet
// med RefreshData() blir ineffektivt: att uppdatera en tabell hämtar om
// hela det delade cachet, så att uppdatera N tabeller gör samma dyra
// hämtning N gånger.
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");

// --- Ändra flera Amount-värden i källdatan ---
sheet.getCells().get("C2").putValue(5000);   // Grape  2020
sheet.getCells().get("C5").putValue(7500);   // Cherry 2020
sheet.getCells().get("C9").putValue(9500);   // Cherry 2021

// --- FÖRÅLDRAT mönster (före 26.7) — PivotTable.RefreshData() ---
// pivotTable1.RefreshData();  // hämtar om från källan, uppdaterar hela cachet
// pivotTable2.RefreshData();  // hämtar om IGEN — cachet är redan färskt!
// Varje anrop bygger om det delade cachet, så N tabeller = N redundanta hämtningar.

// --- NYTT mönster i v26.7+: uppdatera cachet EN GÅNG, rendera sedan om vid behov ---
// Ett anrop till PivotCache.Refresh() hämtar de ändrade värdena till det
// delade cachet OCH beräknar om visningen av VARJE pivottabell som refererar
// till det. Eftersom Pivot1 och Pivot2 delar ett PivotCache uppdaterar detta
// enda anrop båda tabellerna — ingen andra källhämtning krävs.
pivotTable1.getPivotCache().refresh();

// CalculateData() renderar bara om en pivottabells visning (data + stil)
// från datan som redan finns i cachet — den rör INTE källan.
// Vi anropar den på Pivot2 här enbart för att demonstrera API:et: efter att
// cachet har uppdaterats en gång kan vilken beroende tabell som helst
// renderas om utan att gå tillbaka till källan. Använd CalculateData()
// enskilt när bara pivottabellens vy-/layoutinställningar har ändrats
// och cachet är aktuellt.
pivotTable2.calculateData();

workbook.save("output.xlsx");

Vilket uppdaterings-API ska jag använda?

Tabellen nedan sammanfattar de tillgängliga uppdaterings-API:erna och när du ska välja varje.

Mål	Rekommenderat API	Anteckningar
Uppdatera allt i arbetsboken	`Workbook.RefreshAll()`	Ett anrop; täcker alla cachar och tabeller.
Uppdatera endast pivottabeller på ett enskilt blad	`Worksheet.RefreshPivotTables()`	Begränsat till ett kalkylblad.
Källdata har ändrats för en cache	`pivotTable.PivotCache.Refresh()`	Uppdaterar ALLA pivottabeller på den delade cachen.
Endast vy-/layoutinställningar har ändrats	`pivotTable.CalculateData()`	Hoppar över onödig källhämtning.
Lista alla pivottabeller på en delad cache	`pivotCache.GetPivotTables()`	Använd för att räkna upp innan bulkuppdatering.

I praktiken, föredra de cachebaserade API:erna framför den föråldrade tabell-för-tabell-metoden RefreshData(). De är medvetna om delade cachar, de undviker redundanta källhämtningar, och de låter dig välja den minsta omfattningen som uppfyller ditt uppdateringskrav.

Nodejscpp: Lägga till rad- och kolumnfält i en pivottabell i Aspose.Cells för .NET

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

Lägga till ett fält i rad- eller kolumnområdet

Metoden PivotTable.AddFieldToArea(PivotFieldType fieldType, string fieldName) flyttar ett basfält från källdatan till ett av de fyra pivotområdena. Argumentet fieldType accepterar ett av följande PivotFieldType-värden.

Row — fält placerade vertikalt till vänster
Column — fält placerade horisontellt överst
Data — fält vars värden aggregeras
Page — fält som används som rapportfilter

När fälten har lagts till kan du komma åt dem via egenskaperna PivotTable.RowFields och PivotTable.ColumnFields. Varje egenskap returnerar en PivotFieldCollection. Fältet vid index 0 i RowFields är det yttersta radfältet, och efterföljande index representerar fält som är kapslade inuti det. Samma indexeringskonvention gäller för ColumnFields.

Ordningen på fältens kapsling är viktig. Om du lägger till Category i radområdet först och sedan Item skapas en pivot vars yttre gruppering är Category och vars inre gruppering är Item. Om du vänder på ordningen vänds hierarkin.

Pivotfältssubtotaler

Metoden PivotField.SetSubtotals(PivotFieldSubtotalType subtotalType, bool shown) styr vilka subtotalrader som visas för ett pivotfält. Varje anrop växlar en enskild subtotaltyp oberoende. Om du skickar shown = true visas subtotalen, medan shown = false döljer den. Eftersom varje anrop endast påverkar en typ, kan du bygga en anpassad delmängd av subtotaler genom att anropa metoden flera gånger med olika subtotalType-värden.

Enum PivotFieldSubtotalType definierar de tillgängliga subtotaltyperna.

Automatic — Aspose.Cells väljer standardvalet (vanligtvis Sum för numeriska fält)
None — undertryck alla subtotalrader
Sum
Count
Average
Max
Min
Product
StdDev
StdDevp
Var
Varp

Subtotaler renderas endast när det finns två eller flera pivotfält i radområdet (eller i kolumnområdet). Ett enskilt fält har inget meningsfullt att subtotalera mellan, så SetSubtotals-anrop har ingen synlig effekt i det fallet. Den här artikeln placerar därför två radfält (Category ytter, Item inre) i varje exempel så att subtotalgränsen mellan varje Category-grupp syns.

Scenario 1 — Automatiska (standard) subtotaler

När du inte anropar SetSubtotals alls tillämpar Aspose.Cells Automatic-valet på numeriska fält. Följande exempel bekräftar uttryckligen detta beteende genom att anropa SetSubtotals(PivotFieldSubtotalType.Automatic, true) på det yttre Category-radfältet.

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 — Undertrycka alla subtotaler (None)

Om du anropar SetSubtotals(PivotFieldSubtotalType.None, true) tas varje subtotalrad bort från pivoten, vilket bara lämnar fältraderna och den totala summan längst ner. Detta är användbart när du vill ha den råa grupperade datan utan några sammanfattningsrader.

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 — Anpassad uppsättning av subtotaler (Sum + Average)

Du är inte begränsad till en enskild subtotaltyp. Varje SetSubtotals-anrop fungerar oberoende på en typ, så om du anropar metoden två gånger — en gång med Sum och en gång med Average — skapas en anpassad uppsättning av två subtotalrader för varje Category-grupp.

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

Sammanfattning

De tre scenarierna ovan delar samma dataset och pivottabellstruktur. Den enda skillnaden mellan dem är SetSubtotals-anropet som tillämpas på det yttre Category-radfältet. Kom ihåg regeln om två fält: ett enskilt fält i ett område har inget att subtotalera mellan, så placera alltid minst två fält i rad- eller kolumnområdet när du vill att SetSubtotals ska ha en synlig effekt.

Nodejscpp: Hantera värdefält i en pivottabell i Aspose.Cells för .NET

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

Lägga till ett fält i dataregionen

Att lägga till ett basfält i data-(värde)regionen är det första steget i att forma hur en pivottabell aggregerar din källdata. Aspose.Cells exponerar PivotTable.addFieldToArea(PivotFieldType, string), en överlagring som accepterar konstanten PivotFieldType.Data och källkolumnens namn. När ett fält har lagts till i dataregionen, exponeras det via samlingen PivotTable.getDataFields(), i den ordning som fälten lades till. Som standard sammanfattas en numerisk källkolumn med ConsolidationFunction.Sum, medan en icke-numerisk kolumn som standard blir Count.

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

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

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

// Datarader A2:D9 med nästlade loopar som grenar på 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;
 }
 }
}

// Lägg till pivottabell vid F3 med namnet PivotTable1
const pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1", true, false);
const pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Pivotlayout: Kategori och Objekt på Rad, År på Kolumn, Belopp som datafält
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");

Ändra summeringsfunktionen

Varje fält som placeras i dataregionen är internt inpackat som en PivotField-instans, och dess getFunction()-egenskap returnerar ett värde från enumerationen ConsolidationFunction. Samma setFunction()-setter låter dig växla mellan de tillgängliga aggregaten, inklusive Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var och Varp.

Att ändra summeringsfunktionen påverkar bara aggregatet, källkolumnen ändras inte.

Du kan alltså lämna ett datafält som Sum medan du lägger till ett andra datafält som riktar sig mot samma källkolumn men använder Count eller Average, allt i en enda 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");

Placera värdefält på rad- eller kolumnaxeln

När en pivottabell innehåller två eller flera datafält, exponerar Aspose.Cells ytterligare ett virtuellt fält kallat PivotTable.getValuesField. Detta virtuella fält representerar aggregatet av varje datafält som finns i dataregionen. Du kan dra in det i rad- eller kolumnregionen som ett baspivotfält, vilket är användbart för att lägga ut flera mått sida vid sida.

PivotTable.getValuesField() fungerar inte om det inte finns något eller endast ett värdefält.

Scenarierna nedan går igenom tre kompletta exempel som demonstrerar varje funktion som beskrivs ovan mot samma pivotstruktur.

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: Lägga till filterfält i en pivottabell i Aspose.Cells för .NET

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

Aspose.Cells stöder hela livscykeln för filterfält i pivottabeller. Du kan lägga till ett filterfält via ett högnivå-API eller via den lägre nivåns PageFields-samling, och du kan styra sidfiltret i enkelvalsläge, rensa det för att visa varje sidobjekt, eller växla fältet till flerval så att användare kan välja flera sidobjekt samtidigt via kryssrutegränssnittet i Excel.

Introduktion

Ett filterfält är ett pivotfält som styr vilken delmängd av källdatan pivotens innehåll visar. Slutanvändare ser det som en rullgardinsmeny överst i en renderad pivot i Excel, och att välja ett av de tillgängliga sidobjekten bygger om pivotens innehåll så att endast posterna som tillhör det sidobjektet sammanfattas. Ett pivotfält blir ett filterfält när det registreras som PivotFieldType.Page snarare än PivotFieldType.Row, PivotFieldType.Column eller PivotFieldType.Data.

Ett filterfält kan fungera i två beteenden. I standardbeteendet enkelval är endast ett sidobjekt synligt åt gången, så pivotens innehåll sammanfattar exakt en delmängd. I beteendet flerval exponerar fältet en kryssrutelista, och pivotens innehåll sammanfattar unionen av varje markerat sidobjekt. Samma källfält kan flyttas fram och tillbaka mellan dessa beteenden genom att växla en enskild egenskap.

Aspose.Cells for Node.js via C++ exponerar två likvärdiga sätt att registrera ett filterfält. Det högnivå-API är PivotTable.addFieldToArea(PivotFieldType.Page, "fieldName"), som tar källkolumnnamnet och lägger till fältet i ett enda anrop. Det lägre nivåns API är PivotTable.pageFields.add(PivotField), som används när du redan har en PivotField-referens och vill lägga till samma fältinstans i filterområdet. Båda API:erna fyller slutligen samma PageFields-samling, och resten av denna artikel demonstrerar hur man väljer mellan dem och hur man styr varje filtreringsläge.

Lägga till ett filterfält

Det finns två sätt att registrera ett pivotfält i filterområdet. Det högnivå-anropet tar källkolumnnamnet som en sträng och är den vanligaste vägen. Det lägre nivåns anrop accepterar en befintlig PivotField-instans och är bekvämt när samma fältobjekt måste återanvändas över flera pivotområden. Båda anropen placerar fältet i PivotTable.pageFields, varefter det visas som sidans rullgardinsmeny överst i den renderade pivoten.

Lägga till ett filterfält med addFieldToArea

Följande exempel bygger ett litet Fruit / Year / Amount-dataset, placerar en pivottabell vid cell E3 med Fruit i radområdet, Amount i dataområdet och Year i filterområdet, uppdaterar pivoten och sparar arbetsboken.

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

// Ställ in rubrikraden
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");

// Fylla i 9 rader med exempeldata: Frukt, År, Belopp
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]);
}

// Lägg till en pivottabell förankrad vid cell E3
var pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "PivotTable1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Lägg till fält i deras områden: Frukt som Rad, Belopp som Data, År som Sidfält
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");

// Uppdatera och beräkna pivottabellens data
pivotTable.calculateData();

// Spara arbetsboken
workbook.save("pageFieldSample.xlsx");

Lägga till ett filterfält med pageFields.add

När du redan arbetar med en PivotField-instans kan du skicka den direkt till PivotTable.pageFields.add. Pivottabellen och filterfältet konstrueras exakt som i föregående scenario; endast den slutliga registreringen i filterområdet ersätts med det lägre nivåns API-anrop.

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

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

// Exempeldata (9 rader)
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);

// Lägg till pivottabell vid E3 som täcker A1:C10
let pivotIndex = sheet.getPivotTables().add("E3", "A1:C10", "PivotTable1");
let pivotTable = sheet.getPivotTables().get(pivotIndex);

// Frukt -> Rad, Belopp -> Data (År kommer att läggas till Sida nedan)
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Lågnivåstrategi: hämta det befintliga År PivotField från BaseFields
// och registrera det i Sid-området via PageFields.Add(PivotField).
let yearField = pivotTable.getBaseFields().get("Year");
pivotTable.getPageFields().add(yearField);

// Uppdatera så att det nya sidfältet återspeglas i den sparade arbetsboken
pivotTable.calculateData();

workbook.save("output.xlsx");

Enkelvalsfiltrering (Visa ett sidobjekt)

I standardbeteendet enkelval renderas filterfältet som en enda rullgardinsmeny och heltalsvärdet PivotField.currentPageItem väljer vilket sidobjekt som styr pivotens innehåll. Att tilldela ett specifikt index väljer det objektet; att tilldela den speciella sentinelvärdet 0x7FFD (decimalt 32765) rensar filtret så att alla sidobjekt sammanfattas samtidigt. Enkelval är standard; du behöver inte aktivera det explicit.

Visa alla objekt

Att sätta currentPageItem till det magiska värdet 0x7FFD är likvärdigt med att rensa sidfiltret: pivotens innehåll sammanfattar alla sidobjekt som om inget filter tillämpades.

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

// Fylla i Fruit/Year/Amount-data
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]);
    }
}

// Skapa pivottabell vid E3
let pivotTables = sheet.getPivotTables();
let index = pivotTables.add("=A1:C7", "E3", "PivotTable1");
let pivotTable = pivotTables.get(index);

// Konfigurera pivotfält: Fruit→Rad, Amount→Data, Year→Sida
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");

pivotTable.calculateData();

// Rensa sidfiltret så att alla objekt i sidfältet visas.
// 0x7FFD (decimal 32765) är det speciella sentinelvärdet som betyder "alla objekt" —
// motsvarande att välja "(Alla)" i Excels sidfält-rullgardinsmeny.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD);

workbook.save("output.xlsx");

Visa ett specifikt objekt

Att sätta currentPageItem till ett riktigt index väljer bara det sidobjektet. Indexet är positionen för objektet i filterfältets sorterade objektlista, så till exempel 1 väljer det andra objektet efter sortering.

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

// Lägg till exempeldata (Frukt/År/Belopp)
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");

// Lägg till pivottabell vid E3
var pivotTables = sheet.getPivotTables();
var pivotIndex = pivotTables.add("A1:C5", "E3", "PivotTable1");
var pivotTable = pivotTables.get(pivotIndex);

// Lägg till fält: Frukt→Rad, Belopp→Data, År→Sida
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");

// Sidfältsspecifika operationer
pivotTable.getPageFields().get(0).setCurrentPageItem(1); // 1 = andra objektet i sorterad ordning (t.ex. "2021")

// Uppdatera och beräkna pivottabell
pivotTable.calculateData();

workbook.save("output.xlsx");

Flervalsfiltrering

Flervalsfiltrering förvandlar sidans rullgardinsmeny till en kryssrutelista och låter slutanvändaren välja flera sidobjekt samtidigt. Aspose.Cells exponerar två egenskaper som fungerar tillsammans. PivotField.isMultipleItemSelectionAllowed måste sättas till true innan flervalsgränssnittet över huvud taget aktiveras. När det är aktiverat styr PivotItem.isHidden vilka objekt som visas i kryssrutelistan, så du kan antingen visa varje objekt eller vitlista endast specifika objekt.

Koden nedan aktiverar flerval på samma Year-filterfält som byggdes i Scenario 1a, och visar sedan två mönster: Del A avslöjar alla sidobjekt genom att låta isHidden vara satt till false för varje post, medan Del B vitlistar endast de källvärden du väljer och döljer allt annat genom ett switch (pivotItems[i].getStringValue())-block.

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

// Exempeldata: Frukt | År | Belopp
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");

// — Aktivera flerval på sidfältet
pivotTable.getPageFields().get(0).setIsMultipleItemSelectionAllowed(true);

// Del A — välj ALLA objekt (gör alla objekt synliga)
let pivotItems = pivotTable.getPageFields().get(0).getPivotItems();
for (let i = 0; i < pivotItems.getCount(); i++) {
    pivotItems.get(i).setIsHidden(false);
}

// Del B — välj endast specifika objekt efter källvärde
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");

Obs: När du använder flervalsfiltrering via PivotItem.isHidden, måste minst en PivotItem förbli synlig (isHidden == false). Om varje objekt är dolt kraschar Excel antingen när filen öppnas eller renderar en tom pivot. Verifiera alltid att din flervalsvitlista inkluderar minst ett objekt från din källdata.

Vilket API och vilket läge ska jag använda?

Tabellen nedan sammanfattar när du ska använda varje API och läge så att du kan välja rätt kombination utan att läsa varje scenario i detalj.

Scenario / Användningsfall	Rekommenderat API	Använd egenskap	Anteckningar
Lägg till ett filterfält via källkolumnnamn (vanligast)	`PivotTable.addFieldToArea(PivotFieldType.Page, "fieldName")`	n/a	Högnivå, en rad. Använd detta om du inte behöver en `PivotField`-referens.
Lägg till ett filterfält när du redan har ett `PivotField`-objekt	`PivotTable.pageFields.add(PivotField)`	n/a	Använd när fältobjektet erhölls någon annanstans eller behöver återanvändas.
Filtrera till ett enskilt sidobjekt (standardläge)	`PivotField.currentPageItem`	sätt till ett specifikt index	Till exempel visar `1` det andra objektet i den sorterade listan.
Visa alla objekt / rensa sidfiltret	`PivotField.currentPageItem`	sätt till `0x7FFD`	Det magiska värdet `0x7FFD` (decimalt 32765) är sentinelvärdet för “alla objekt”.
Aktivera flervalsgränssnitt i Excel	`PivotField.isMultipleItemSelectionAllowed`	sätt till `true`	Krävs innan några `isHidden`-anrop får effekt.
Dölj / visa enskilda objekt i en flervalslista	`PivotItem.isHidden`	sätt per objekt	Minst ett objekt måste förbli synligt (`isHidden == false`).

Kom alltid ihåg synlighetsbegränsningen när du konfigurerar flervalsfiltrering. Om varje PivotItem i ett flervals-filterfält är dolt, kraschar Excel vid öppning eller renderar en tom pivot. Bygg din vitlista mot din källdata så att minst ett objekt förblir synligt, och dina sparade arbetsböcker kommer att öppnas tillförlitligt på varje maskin.

Nodejscpp: Ta bort pivottabell från ett arbetsblad

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

Aspose.Cells for Node.js via C++ tillhandahåller en funktion för att ta bort eller radera pivot-tabell från ett kalkylblad. Du kan ta bort pivot-tabellen med hjälp av pivot-tabell-objektet eller dess position. Använd Worksheet.getPivotTables().remove(pivotTable)-metoden för att ta bort pivot-tabellen med pivot-tabell-objekt och Worksheet.getPivotTables().removeAt(index, keepData)-metoden för att ta bort pivot-tabell-objektet med dess position inom pivot-tabellssamlingen.

Hur man tar bort pivot-tabell från kalkylblad med Aspose.Cells for Node.js via C++

Följande kodexempel tar bort två pivottabeller från arbetsbladet. Först tar det bort pivottabellen med hjälp av Worksheet.getPivotTables().remove(pivotTable) -metoden och sedan tar det bort pivottabellen med hjälp av Worksheet.getPivotTables().removeAt(index, keepData) -metoden

Nodejscpp: Spara pivottabell i ODS fil

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

Aspose.Cells for Node.js via C++ ger möjlighet att spara pivottabeller i ODS-filer. För detta konverterar du bara en arbetsbok med befintlig pivottabell eller skapar en ny pivottabell och sparar filen i ODS-format. Se till att anropa PivotTable.calculateData innan du sparar för att säkerställa att pivottabellen renderas i den exporterade ODS-filen. Följande kodsnutt visar hur man sparar pivottabellen i ODS-fil.

Exempelkod

Utdatafilen som genererats av ovanstående kod är bifogad för din referens.

Utgångs-ODS-fil

Documentation – Infoga pivot tabell

Nodejscpp: Formatera Pivot tabell

Pivottabellens utseende

Hur man ställer in pivottabellsformatalternativ

Hur man ställer in automatiskt format typ

Hur man ställer in formateringsalternativ

Manuell formatering av utseende

Hur man ställer in pivottabellsfältformatalternativ

Hur man ställer in rad/kolumn/sida fältformat

Hur man ställer in datafältformat

Hur man rensar pivottabellsfält

Nodejscpp: Skapa pivottabeller och pivotdiagram

Lägg till pivot-tabeller och diagram med Aspose.Cells for Node.js via C++

Förbered att använda Aspose.Cells for Node.js via C++

Hur man lägger till en Pivot-tabell med Aspose.Cells for Node.js via C++

Hur man lägger till ett Pivot-diagram med Aspose.Cells for Node.js via C++-biblioteket

Nodejscpp: Pivot tabell och källdata

Pivot-tabellens källdata

Ändra en pivot-tabells källdata

Nodejscpp: Lägg till beräknat fält i pivottabell

Möjliga användningsscenario

Hur man lägger till beräknat fält i pivot-tabell i Excel

Hur man lägger till ett beräknat fält i pivottabell med Aspose.Cells for Node.js via C++ biblioteket

Exempelkod

Nodejscpp: Tillämpa stilar på pivottabeller i Aspose.Cells för .NET

Introduktion

Tillämpa en äldre XLS-förinställd autoformat

Tillämpa en modern namngiven förinställd pivottabellstil

Definiera och tillämpa en anpassad pivottabellstil

Tillämpa en stil på varje pivotcell med FormatAll

Vilket stil-API ska jag använda?

Nodejscpp: Uppdatera pivottabeller i Aspose.Cells for Node.js via C++

Introduktion

Nödvändiga importer

Uppdatera alla pivottabeller i arbetsboken

Uppdatera alla pivottabeller på ett enskilt kalkylblad

Uppdatera en enskild pivottabell

Källdata har ändrats — Använd PivotCache.Refresh()

Endast vy/layout har ändrats — Använd CalculateData()

Hämta alla pivottabeller som delar samma PivotCache

Migrera från den föråldrade PivotTable.RefreshData()

Vilket uppdaterings-API ska jag använda?

Nodejscpp: Lägga till rad- och kolumnfält i en pivottabell i Aspose.Cells för .NET

Lägga till ett fält i rad- eller kolumnområdet

Pivotfältssubtotaler

Scenario 1 — Automatiska (standard) subtotaler

Scenario 2 — Undertrycka alla subtotaler (None)

Scenario 3 — Anpassad uppsättning av subtotaler (Sum + Average)

Sammanfattning

Nodejscpp: Hantera värdefält i en pivottabell i Aspose.Cells för .NET

Lägga till ett fält i dataregionen

Ändra summeringsfunktionen

Placera värdefält på rad- eller kolumnaxeln

Nodejscpp: Lägga till filterfält i en pivottabell i Aspose.Cells för .NET

Introduktion

Lägga till ett filterfält

Lägga till ett filterfält med addFieldToArea

Lägga till ett filterfält med pageFields.add

Enkelvalsfiltrering (Visa ett sidobjekt)

Visa alla objekt

Visa ett specifikt objekt

Flervalsfiltrering

Vilket API och vilket läge ska jag använda?

Nodejscpp: Ta bort pivottabell från ett arbetsblad

Hur man tar bort pivot-tabell från kalkylblad med Aspose.Cells for Node.js via C++

Nodejscpp: Spara pivottabell i ODS fil

Exempelkod

Källdata har ändrats — Använd `PivotCache.Refresh()`

Endast vy/layout har ändrats — Använd `CalculateData()`

Migrera från den föråldrade `PivotTable.RefreshData()`