Documentation – Insérer un tableau croisé dynamique

Nodejsjava: Actualiser les Tableaux Croisés Dynamiques et les Caches de TCD dans Aspose.Cells for Node.js via Java

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

Aspose.Cells fournit une API d’actualisation en couches qui vous permet de recharger les données de tableau croisé dynamique à quatre portées différentes — du classeur entier jusqu’à un seul tableau croisé dynamique. À partir d'Aspose.Cells for Node.js via Java v26.7, la méthode héritée PivotTable.RefreshData() est marquée comme obsolète et doit être remplacée par les API plus efficaces et conscientes du cache décrites dans cet article.

Introduction

L’actualisation d’un tableau croisé dynamique est rarement une opération unique. En arrière-plan, Aspose.Cells maintient une chaîne de données en couches qui connecte vos données source d’origine aux valeurs rendues que vous voyez dans la feuille de calcul. Comprendre cette chaîne est la clé pour choisir la bonne API d’actualisation pour toute situation. La chaîne de données à quatre couches est :

Source de données — les plages de la feuille de calcul d’origine, la requête de base de données ou la plage de consolidation où se trouvent les valeurs brutes.
PivotCache — l’instantané en mémoire des données source. Chaque tableau croisé dynamique est construit au-dessus d’un PivotCache ; c’est là que toutes les données sont collectées et agrégées.
Tableau Croisé Dynamique — l’objet de vue qui définit les champs de ligne, de colonne, de valeur et de filtre. Un PivotTable lit uniquement depuis son PivotCache, jamais directement depuis la source de données.
Cellules — les Cells de la feuille de calcul dans lesquelles le PivotTable rend ses valeurs calculées et ses styles.

PivotCache.SourceType (enum PivotTableSourceType) indique d’où proviennent les données du cache. Depuis la v26.7, PivotCache.Refresh() ne prend en charge que les types de source Sheet et Consolidation — c’est-à-dire les données qui se trouvent dans les plages de la feuille de calcul. Les sources externes (bases de données, connexions externes, etc.) ne sont pas encore actualisables via l’API de cache.

En raison de cette chaîne, il existe deux chemins d’actualisation fondamentaux dans Aspose.Cells :

PivotTable.CalculateData() — recalcule l’affichage d’un PivotTable à partir des données déjà mises en cache, sans aller-retour vers la source de données. Tous les scénarios de cet article utilisent des données source de cellules de feuille de calcul, donc le type de source est Sheet et les opérations d’actualisation se comportent comme décrit.

Démarrage Rapide

Si vous avez juste besoin du code le plus court possible qui actualise tous les tableaux croisés dynamiques du classeur, un seul appel suffit :

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

Tout le reste de cet article explique quand choisir une API plus restreinte à la place.

Imports Requis

const aspose = require('aspose.cells');
Ou pour des imports spécifiques : const { Workbook, Cells, PivotTableSourceType } = require('aspose.cells');

Actualiser Tous les Tableaux Croisés Dynamiques du Classeur

Lorsque vous devez vous assurer que chaque cache de tableau croisé dynamique et chaque tableau croisé dynamique du classeur reflète les dernières données source, l’API la plus simple et la plus complète est Workbook.RefreshAll(). Un seul appel traverse le classeur entier — actualisant chaque PivotCache depuis sa source puis recalculant chaque PivotTable dépendant. C’est l’approche recommandée pour les actualisations générales de documents complets où la performance n’est pas un problème. L’exemple suivant construit un classeur avec une plage source Fruit/Année/Montant, crée un tableau croisé dynamique, modifie certaines valeurs source, puis utilise RefreshAll() pour tout mettre à jour en un seul appel.

const AsposeCells = require("aspose.cells");
// Créer un nouveau classeur
const workbook = new AsposeCells.Workbook();
const worksheet = workbook.getWorksheets().get(0);
// Écrire la ligne d'en-tête dans les cellules A1:C1
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");
// Écrire les lignes de données dans les cellules A2:C9 (8 lignes de données de fruits pour 2020 et 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);
// Ajouter un tableau croisé dynamique : plage source "A1:C9", cellule de destination "E3", nom "Pivot1"
const pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
const pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Affecter les champs du tableau croisé dynamique : Fruit aux lignes, Year aux colonnes, Amount aux données
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Modifier plusieurs valeurs de Amount dans les données source pour simuler des changements
worksheet.getCells().get("C2").putValue(55);
worksheet.getCells().get("C5").putValue(85);
worksheet.getCells().get("C9").putValue(125);
// Actualiser tous les tableaux croisés dynamiques et leurs caches dans le classeur
workbook.refreshAll();
// Enregistrer le classeur
workbook.save("output.xlsx");

Actualiser Tous les Tableaux Croisés Dynamiques sur une Seule Feuille de Calcul

Parfois, vous n’avez besoin que d’actualiser les tableaux croisés dynamiques qui se trouvent sur une feuille de calcul spécifique — par exemple, lorsque les tableaux croisés dynamiques sur d’autres feuilles sont connus pour ne pas être liés et ne doivent pas être touchés. Pour ce cas, Aspose.Cells fournit Worksheet.RefreshPivotTables(), qui est limité à une seule instance de Worksheet.

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

Actualiser un Seul Tableau Croisé Dynamique

Lorsque vous souhaitez un contrôle précis sur un seul tableau croisé dynamique, l’API basée sur le cache vous offre deux options. Le choix entre elles dépend de ce qui a réellement changé : les données source sous-jacentes, ou simplement les paramètres de vue/mise en page du tableau croisé dynamique lui-même.

Données Source Modifiées — Utilisez `PivotCache.Refresh()`

Si les données source sous-jacentes ont changé, le bon point d’entrée est pivotTable.PivotCache.Refresh(). Cet appel relit les données source dans le cache puis recalcule chaque PivotTable qui dépend de ce cache.

Seule la Vue/Mise en Page Modifiée — Utilisez `CalculateData()`

Si les données source n’ont pas changé mais que seuls les paramètres de vue ou de mise en page du tableau croisé dynamique ont été modifiés (par exemple, un champ a été déplacé vers une zone différente, ou un paramètre d’actualisation à l’ouverture a été activé), il n’est pas nécessaire de faire un aller-retour vers la source de données. Le cache contient déjà les bonnes données ; seul le PivotTable rendu nécessite un recalcul. Dans ce cas, pivotTable.CalculateData() est le bon choix. L’exemple suivant modifie une propriété non-source du tableau croisé dynamique puis appelle CalculateData() pour le rendre à nouveau depuis le cache existant.

var workbook = new AsposeCells.Workbook();
var worksheet = workbook.getWorksheets().get(0);
// Écrire la ligne d'en-tête Fruit / Année / Montant
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");
// Écrire 8 lignes de données (lignes 2-9, correspondant à la plage source 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);
// Ajouter un tableau croisé dynamique nommé "Pivot1" placé à la cellule de destination E3, sourçant depuis A1:C9
var pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Assigner les champs : Fruit à Ligne, Année à Colonne, Montant à Données
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Modifier une propriété d'affichage/mise en page — il s'agit d'un changement uniquement de présentation,
// donc elle ne nécessite PAS de relire les données source via PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(false);
// CalculateData() restitue l'affichage de CE tableau croisé dynamique (données + style) à partir des
// données déjà détenues dans le PivotCache. Comme les données source n'ont pas changé,
// aucun aller-retour vers la source n'est effectué — seules les valeurs mises en cache sont recalculées
// dans les cellules de la feuille de calcul.
pivotTable.calculateData();
// Enregistrer le classeur sur le disque
workbook.save("output.xlsx");

Un classeur contient souvent de nombreux tableaux croisés dynamiques qui reposent tous sur un cache partagé. Pour les énumérer — par exemple, avant d’effectuer une actualisation par lot, ou pour diagnostiquer l’impact du cache partagé — utilisez PivotCache.GetPivotTables(). Cette méthode renvoie la collection de chaque PivotTable qui dépend du cache donné.

Migration depuis l’Obsolète `PivotTable.RefreshData()`

Avant Aspose.Cells for Node.js via Java v26.7, la façon standard d’actualiser un tableau croisé dynamique était d’appeler PivotTable.RefreshData() sur chaque tableau croisé dynamique individuellement. Depuis la v26.7, cette méthode est marquée comme obsolète et doit être remplacée par les API conscientes du cache décrites ci-dessus. Il y a deux raisons pour lesquelles l’approche RefreshData() par tableau est problématique dans les classeurs du monde réel :

Elle récupère les données depuis la source à chaque appel, même lorsque la source n’a pas changé. Les remplacements recommandés sont : L’exemple suivant démontre le nouveau modèle efficace pour les classeurs avec plusieurs tableaux croisés dynamiques partageant un seul cache.

Quelle API d’Actualisation Dois-Je Utiliser ?

Le tableau ci-dessous résume les API d’actualisation disponibles et quand choisir chacune d’elles.

Objectif	API Recommandée	Notes
Actualiser tout dans le classeur	`Workbook.RefreshAll()`	Un appel ; couvre tous les caches et tableaux.
Actualiser uniquement les tableaux croisés dynamiques sur une seule feuille	`Worksheet.RefreshPivotTables()`	Limité à une feuille de calcul.
Données source modifiées pour un cache	`pivotTable.PivotCache.Refresh()`	Actualise TOUS les tableaux croisés dynamiques sur ce cache partagé.
Seuls les paramètres de vue/mise en page ont changé	`pivotTable.CalculateData()`	Évite l’aller-retour inutile vers la source.
Lister tous les tableaux croisés dynamiques sur un cache partagé	`pivotCache.GetPivotTables()`	À utiliser pour énumérer avant une actualisation en bloc.
En pratique, préférez les API basées sur le cache à l’obsolète `RefreshData()` par tableau. Elles sont conscientes des caches partagés, évitent les récupérations redondantes depuis la source, et vous permettent de choisir la plus petite portée qui satisfait votre exigence d’actualisation.

Pièges Courants

Oublier d’actualiser avant d’enregistrer. Un tableau croisé dynamique n’écrit ses valeurs rendues dans la feuille de calcul que lorsque sa chaîne de données est actualisée. Si vous modifiez des cellules source, appelez PivotCache.Refresh() (ou Workbook.RefreshAll()) avant Workbook.save(), sinon le fichier enregistré contiendra encore les anciennes valeurs agrégées.
Appeler l’obsolète RefreshData() par tableau. Dans la v26.7, PivotTable.RefreshData() est marqué comme obsolète et récupère la source à chaque appel. Avec plusieurs tableaux croisés dynamiques partageant un cache, cela signifie N récupérations redondantes depuis la source. Remplacez par un seul PivotCache.Refresh() suivi de CalculateData() par tableau.
Actualiser quand seule la mise en page a changé. Si vous n’avez modifié que la vue d’un tableau croisé dynamique (ordre des colonnes, ConsolidationFunction, etc.) sans toucher aux données source, PivotCache.Refresh() est inutile et lent. Appelez pivotTable.CalculateData() pour rendre à nouveau depuis le cache existant.
Source externe non prise en charge par PivotCache.Refresh(). Si la source du tableau croisé dynamique provient d’une connexion externe (base de données, cube OLAP, etc.), PivotCache.Refresh() ne peut pas l’actualiser dans la v26.7 — elle ne prend actuellement en charge que les types de source Sheet et Consolidation. Pour les sources externes, rouvrez le classeur ou reconstruisez le cache depuis la source.

Nodejsjava: Appliquer des styles aux Tableaux Croisés Dynamiques dans Aspose.Cells for Node.js via Java

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

Aspose.Cells prend en charge l’application à la fois des autoformats de tableau croisé dynamique hérités (destinés aux fichiers .xls) et des styles nommés ou personnalisés modernes de tableau croisé dynamique (destinés aux fichiers .xlsx, .xlsm et .xlsb). L’API à appeler dépend du format de fichier dans lequel le classeur est enregistré, et non du format à partir duquel il a été chargé.

Introduction

Aspose.Cells expose deux API de style parallèles pour les Tableaux Croisés Dynamiques. Le choix entre elles dépend du format de fichier dans lequel vous enregistrez le classeur, et non du format à partir duquel vous le lisez. Un classeur chargé à partir d’un fichier .xls peut être réenregistré au format .xlsx ; dans ce cas, c’est l’API de style moderne qui s’applique, et non l’API héritée.

PivotTable.pivotTableStyleType sélectionne l’un des styles nommés intégrés (thèmes clairs et sombres, y compris les styles ajoutés dans Excel 2017). Ces préréglages sont en lecture seule.
PivotTable.pivotTableStyleName sélectionne un style personnalisé que vous définissez vous-même via Worksheets.getTableStyles().addPivotTableStyle(...). Les styles personnalisés sont nécessaires chaque fois que vous souhaitez modifier les couleurs, les bordures ou les polices au-delà de ce que proposent les préréglages. De plus, PivotTable.formatAll(Style) est un raccourci qui applique un unique objet Style à toutes les cellules du tableau croisé dynamique, remplaçant tout ce qui a été défini via l’une ou l’autre des API de nom de style ci-dessus. Ceci est utile lorsqu’une apparence uniforme est requise, quel que soit le thème sous-jacent.

Appliquer un autoformat prédéfini XLS hérité

PivotTable.autoFormatType accepte une valeur de l’énumération Aspose.Cells.Pivot.PivotTableAutoFormatType. Les valeurs disponibles sont Report1 à Report10, Classic, et Table1 à Table10. L’exemple suivant charge un nouveau classeur, remplit les données d’exemple Fruit/Année/Montant, ajoute un Tableau Croisé Dynamique, applique PivotTableAutoFormatType.Report5 et enregistre le résultat au format .xls.

Pourquoi pas de champs de colonne ? Les autoformats de la série Report (Report1 à Report10, Table1 à Table10) ont été conçus dans l’Excel classique pour les Tableaux Croisés Dynamiques unidimensionnels comportant uniquement des champs de ligne et des valeurs ; ils ne disposent pas de mise en forme intégrée pour les en-têtes de champs de colonne. Si votre tableau croisé dynamique nécessite des champs de colonne, utilisez plutôt les préréglages modernes PivotTableStyleType du Scénario 2, qui sont conçus pour la disposition bidimensionnelle utilisée par Excel moderne.

let workbook = new AsposeCells.Workbook();
// Obtenir la première feuille de calcul
let sheet = workbook.getWorksheets().get(0);
// Remplir les données sources avec une ligne d'en-tête (Fruit, Année, Montant)
// et 9 lignes de données couvrant raisin, myrtille, kiwi, cerise sur 2020 et 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);
// Ajouter un tableau croisé dynamique à la cellule de destination E3, nommé "Pivot1", en utilisant la plage source A1:C10
let pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = sheet.getPivotTables().get(pivotIndex);
// Assigner les champs : Fruit -> Lignes, Montant -> Données
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.ROW, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.DATA, "Amount");
// Appliquer l'autoformat prédéfini hérité XLS "Report5"
// Note : Cette propriété n'a de sens que lors de l'enregistrement en .xls.
// Lors de l'enregistrement en .xlsx/.xlsm/.xlsb, Excel ignore AutoFormatType
// et utilise ce que spécifient PivotTableStyleType / PivotTableStyleName.
pivotTable.setAutoFormatType(AsposeCells.PivotTableAutoFormatType.REPORT_5);
// Enregistrer le classeur au format .xls hérité
workbook.save("output.xls");

Appliquer un style de tableau croisé dynamique prédéfini nommé moderne

Définir et appliquer un style personnalisé de tableau croisé dynamique

Les préréglages intégrés ne peuvent pas être modifiés. Chaque fois que vous devez redéfinir les couleurs, les bordures ou les polices, vous devez définir un style de tableau croisé dynamique personnalisé. Le flux de travail comporte trois étapes :

Ajoutez un style personnalisé à la collection TableStyles du classeur via Worksheets.getTableStyles().addPivotTableStyle(String name). Cela renvoie l’index du style nouvellement créé.
Configurez le style en ajoutant des éléments (tels que WholeTable ou GrandTotalRow) via TableStyle.tableStyleElements.add(TableStyleElementType), puis attribuez un Style à chaque élément via TableStyleElement.setElementStyle(Style).
Appliquez le style personnalisé au tableau croisé dynamique en définissant PivotTable.pivotTableStyleName sur le nom du style. N’utilisez pas pivotTableStyleType ici, car cette propriété sélectionne les préréglages intégrés.

pivotTableStyleName et pivotTableStyleType ne sont pas interchangeables. Utilisez pivotTableStyleType pour les préréglages intégrés, et pivotTableStyleName pour les styles personnalisés que vous avez définis via addPivotTableStyle. Définir les deux est inoffensif, mais seul celui qui correspond à la source prévue est rendu.

Les valeurs disponibles de TableStyleElementType incluent WholeTable, FirstRow, LastRow, FirstColumn, LastColumn, GrandTotalRow, GrandTotalColumn, PageFieldLabels et PageFieldValues. L’exemple suivant définit un style de tableau croisé dynamique personnalisé avec une fine bordure noire sur WholeTable et une police rouge en gras sur GrandTotalRow, puis l’applique via pivotTableStyleName et enregistre au format .xlsx.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
// Remplir les données sources : ligne d'en-tête + 9 lignes de données (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);
// Ajouter un tableau croisé dynamique à partir de A1:C10, ancré en E3, nommé "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");
// Étape 1 : enregistrer un nouveau style de tableau croisé dynamique personnalisé et capturer son index
let styleIndex = workbook.getWorksheets().getTableStyles().addPivotTableStyle("CustomPivotStyle");
let tableStyle = workbook.getWorksheets().getTableStyles().get(styleIndex);
// Étape 2 : ajouter un élément WholeTable et appliquer des bordures noires fines sur les quatre côtés
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);
// Étape 3 : ajouter un élément GrandTotalRow et appliquer une police rouge en gras
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);
// Étape 4 : appliquer le style personnalisé par nom (PAS par PivotTableStyleType, qui est pour les préréglages intégrés)
pivotTable.setPivotTableStyleName("CustomPivotStyle");
workbook.save("output.xlsx");

Appliquer un seul style à chaque cellule du tableau croisé dynamique avec FormatAll

PivotTable.formatAll(Style) est un raccourci qui applique un unique objet Style à toutes les cellules du Tableau Croisé Dynamique, y compris la zone de données, les en-têtes de ligne et de colonne, ainsi que les totaux. Tout ce qui a été précédemment défini via pivotTableStyleType ou pivotTableStyleName est remplacé.

formatAll remplace à la fois pivotTableStyleType et pivotTableStyleName. Utilisez-le uniquement lorsqu’une apparence uniforme, indépendante du thème, est requise sur l’ensemble du tableau croisé dynamique.

L’exemple suivant crée un Style avec un remplissage uni jaune, une police bleu foncé en gras et de fines bordures noires sur tous les côtés, puis l’applique avec formatAll et enregistre au format .xlsx.

let workbook = new AsposeCells.Workbook();
let worksheet = workbook.getWorksheets().get(0);
// Remplir les données sources : ligne d'en-tête (ligne 1) + 9 lignes de données (lignes 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);
// Ajouter un tableau croisé dynamique : plage source A1:C10, cellule de destination E3, nom "Pivot1"
let pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Assigner les champs du tableau croisé dynamique : Fruit -> zone Lignes, Année -> zone Colonnes, Montant -> zone Données
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Créer un Style qui sera appliqué de force sur chaque cellule du tableau croisé dynamique
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);
// Appliquer FormatAll : force ce style unique sur chaque cellule du tableau croisé dynamique,
// écrasant tout PivotTableStyleType / PivotTableStyleName précédemment défini
pivotTable.formatAll(style);
// Enregistrer le classeur au format moderne .xlsx
workbook.save("output.xlsx");

Quelle API de style dois-je utiliser ?

Le choix de l’API de style dépend du format de fichier dans lequel vous enregistrez. Utilisez le tableau ci-dessous comme référence rapide.

Format de fichier cible	API à utiliser	Notes
`.xls` (hérité)	`PivotTable.autoFormatType`	Valeurs de `Aspose.Cells.Pivot.PivotTableAutoFormatType` (par ex. `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Ignoré lors de l’enregistrement dans des formats modernes.
`.xlsx` / `.xlsm` / `.xlsb` (moderne, style intégré)	`PivotTable.pivotTableStyleType`	Valeurs de `Aspose.Cells.PivotTableStyleType` (thèmes clairs/sombres, y compris les ajouts d’Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderne, style personnalisé)	`PivotTable.pivotTableStyleName` + `Worksheets.getTableStyles().addPivotTableStyle(...)`	À utiliser lorsque les préréglages intégrés ne suffisent pas. Configurez via `TableStyleElement.setElementStyle(...)`.
Tout format (substitution uniforme)	`PivotTable.formatAll(Style)`	Raccourci qui remplace tous les autres paramètres de style sur l’ensemble du tableau croisé dynamique.
En cas de doute, enregistrez au format `.xlsx` et utilisez `pivotTableStyleType` pour les thèmes intégrés, ou `pivotTableStyleName` pour les thèmes personnalisés.

Nodejsjava: Ajouter des champs de ligne et de colonne à un tableau croisé dynamique dans Aspose.Cells pour .NET

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

Ajouter un champ à la région des lignes ou des colonnes

La méthode PivotTable.addFieldToArea(PivotFieldType fieldType, String fieldName) déplace un champ de base depuis les données sources vers l’une des quatre régions du tableau croisé dynamique. L’argument fieldType accepte l’une des valeurs suivantes de PivotFieldType.

ROW — champs placés verticalement à gauche
COLUMN — champs placés horizontalement en haut
DATA — champs dont les valeurs sont agrégées
PAGE — champs utilisés comme filtres de rapport Une fois les champs ajoutés, vous pouvez y accéder via les propriétés PivotTable.getRowFields() et PivotTable.getColumnFields(). Chaque propriété renvoie une PivotFieldCollection. Le champ à l’index 0 de RowFields est le champ de ligne le plus externe, et les indices suivants représentent les champs imbriqués à l’intérieur. La même convention d’indexation s’applique à ColumnFields. L’ordre d’imbrication des champs est important. L’ajout de Category à la région des lignes en premier, puis de Item, produit un tableau croisé dont le regroupement externe est Category et dont le regroupement interne est Item. Inverser l’ordre inverse la hiérarchie.

Sous-totaux des champs dynamiques

La méthode PivotField.setSubtotals(PivotFieldSubtotalType subtotalType, boolean shown) contrôle les lignes de sous-totaux qui s’affichent pour un champ dynamique. Chaque appel active ou désactive indépendamment un seul type de sous-total. Passer shown = true affiche le sous-total, tandis que shown = false le masque. Comme chaque appel n’affecte qu’un seul type, appeler la méthode plusieurs fois avec différentes valeurs de subtotalType permet de construire un sous-ensemble personnalisé de sous-totaux. L’énumération PivotFieldSubtotalType définit les types de sous-totaux disponibles.

AUTOMATIC — Aspose.Cells choisit la sélection par défaut (généralement SUM pour les champs numériques)
NONE — supprime toutes les lignes de sous-totaux
SUM
COUNT
AVERAGE
MAX
MIN
PRODUCT
STD_DEV
STD_DEVP
VAR
VARP

Les sous-totaux ne s’affichent que lorsqu’il y a au moins deux champs dynamiques dans la région des lignes (ou dans la région des colonnes). Un seul champ n’a rien de significatif à sous-totaliser entre ses valeurs, de sorte que les appels à setSubtotals n’ont aucun effet visible dans ce cas. Cet article place donc deux champs de ligne (Category externe, Item interne) dans chaque exemple afin que la frontière de sous-total entre chaque groupe Category soit visible.

Scénario 1 — Sous-totaux automatiques (par défaut)

Lorsque vous n’appelez pas du tout setSubtotals, Aspose.Cells applique la sélection AUTOMATIC aux champs numériques. L’exemple suivant confirme explicitement ce comportement en appelant setSubtotals(PivotFieldSubtotalType.AUTOMATIC, true) sur le champ de ligne externe 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");

Scénario 2 — Suppression de tous les sous-totaux (None)

L’appel de setSubtotals(PivotFieldSubtotalType.NONE, true) supprime toutes les lignes de sous-totaux du tableau croisé dynamique, ne laissant que les lignes de champ et le total général en bas. Cela est utile lorsque vous souhaitez obtenir les données regroupées brutes sans aucune ligne de synthèse.

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

Scénario 3 — Sous-ensemble personnalisé de sous-totaux (Sum + Average)

Vous n’êtes pas limité à un seul type de sous-total. Chaque appel à setSubtotals opère indépendamment sur un seul type. Ainsi, appeler la méthode deux fois — une fois avec SUM et une fois avec AVERAGE — produit un sous-ensemble personnalisé de deux lignes de sous-totaux pour chaque groupe 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");

Récapitulatif

Les trois scénarios ci-dessus partagent le même jeu de données et la même structure de tableau croisé dynamique. La seule différence entre eux est l’appel à setSubtotals appliqué au champ de ligne externe Category. Rappelez-vous la règle des deux champs : un seul champ dans une région n’a rien à sous-totaliser, alors placez toujours au moins deux champs dans la région des lignes ou des colonnes lorsque vous souhaitez que setSubtotals ait un effet visible.

Nodejsjava: Champs de valeur dans Aspose.Cells for Node.js via Java

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

Les champs de valeur constituent le cœur de chaque tableau croisé dynamique, ce sont les agrégats numériques qui résument les données sources. Dans Aspose.Cells for Node.js via Java, la zone de données d’un tableau croisé dynamique est alimentée en y ajoutant des champs de base via PivotTable.addFieldToArea, et chaque champ placé dans cette zone peut disposer de sa propre fonction de synthèse. Lorsque deux champs de données ou plus existent, Aspose.Cells expose un champ agrégé spécial, PivotTable.getValuesField(), qui peut être tracé sur l’axe des Lignes ou des Colonnes en tant que champ de base, vous offrant un contrôle plus fin sur l’apparence des champs de valeur dans la disposition.

Ajout d’un champ à la zone de données

L’ajout d’un champ de base à la zone de données (valeurs) constitue la première étape pour définir la manière dont un tableau croisé dynamique agrège vos données sources. Aspose.Cells expose PivotTable.addFieldToArea(PivotFieldType, string), une surcharge qui accepte la constante PivotFieldType.DATA et le nom de la colonne source. Une fois qu’un champ est ajouté à la zone de données, l’API l’expose via la collection PivotTable.getDataFields(), dans l’ordre dans lequel les champs ont été ajoutés. Par défaut, une colonne source numérique est résumée avec ConsolidationFunction.SUM, tandis qu’une colonne non numérique utilise COUNT par défaut.

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

Modification de la fonction de synthèse

Chaque champ placé dans la zone de données est encapsulé en interne sous forme d’instance PivotField, et sa propriété getFunction() renvoie une valeur de l’énumération ConsolidationFunction. Le même setter setFunction() permet de basculer entre les agrégats disponibles, notamment SUM, COUNT, AVERAGE, MAX, MIN, PRODUCT, STD_DEV, STD_DEVP, VAR et VARP.

La modification de Function n’affecte que l’agrégat, la colonne source ne change pas.

Vous pouvez donc conserver un champ de données en tant que SUM tout en ajoutant un second champ de données qui cible la même colonne source mais utilise COUNT ou AVERAGE, le tout dans un seul tableau croisé dynamique.

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

Tracé des champs de valeur sur l’axe des Lignes ou des Colonnes

Lorsqu’un tableau croisé dynamique contient deux champs de données ou plus, Aspose.Cells expose un champ virtuel supplémentaire appelé PivotTable.getValuesField(). Ce champ virtuel représente l’agrégat de chaque champ de données qui se trouve dans la zone de données. Vous pouvez le faire glisser dans la zone des Lignes ou des Colonnes en tant que champ de base du tableau croisé dynamique, ce qui est utile pour disposer plusieurs mesures côte à côte.

PivotTable.getValuesField() ne fonctionne pas s’il n’y a aucun champ de valeur ou s’il n’y en a qu’un seul.

Les scénarios ci-dessous présentent trois exemples de bout en bout qui illustrent chaque fonctionnalité décrite ci-dessus sur la même structure de tableau croisé dynamique.

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: Ajouter des champs de filtre à un tableau croisé dynamique dans Aspose.Cells pour .NET

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

Aspose.Cells prend en charge le cycle de vie complet des champs de filtre dans les tableaux croisés dynamiques. Vous pouvez ajouter un champ de filtre via une API pratique de haut niveau ou via la collection de bas niveau PageFields, et vous pouvez piloter le filtre en mode sélection unique, le réinitialiser pour afficher chaque élément de page, ou basculer le champ vers la sélection multiple afin que les utilisateurs puissent choisir plusieurs éléments de page à la fois via l’interface à cases à cocher dans Excel.

Introduction

Un champ de filtre est un champ de tableau croisé dynamique qui contrôle quel sous-ensemble des données source est affiché dans le corps du tableau croisé dynamique. Les utilisateurs finaux le voient sous la forme d’une liste déroulante en haut d’un tableau croisé dynamique rendu dans Excel, et la sélection d’un des éléments de page disponibles reconstruit le corps du tableau croisé dynamique de sorte que seuls les enregistrements appartenant à cet élément de page soient synthétisés. Un champ de tableau croisé dynamique devient un champ de filtre lorsqu’il est enregistré en tant que PivotFieldType.Page plutôt que PivotFieldType.Row, PivotFieldType.Column ou PivotFieldType.Data. Un champ de filtre peut fonctionner selon deux comportements. Dans le comportement par défaut en sélection unique, un seul élément de page est visible à la fois, de sorte que le corps du tableau croisé dynamique synthétise exactement un sous-ensemble. Dans le comportement en sélection multiple, le champ expose une liste de cases à cocher, et le corps du tableau croisé dynamique synthétise l’union de chaque élément de page coché. Le même champ source peut être déplacé d’avant en arrière entre ces comportements en activant ou désactivant une seule propriété. Aspose.Cells for Node.js via Java expose deux méthodes équivalentes pour enregistrer un champ de filtre. L’API de haut niveau est pivotTable.addFieldToArea(PivotFieldType.Page, "fieldName"), qui prend le nom de la colonne source et ajoute le champ en un seul appel. L’API de bas niveau est pivotTable.getPageFields().add(PivotField), qui est utilisée lorsque vous détenez déjà une référence PivotField et souhaitez ajouter la même instance de champ à la zone de filtre. Les deux API finissent par alimenter la même collection PageFields, et la suite de cet article montre comment choisir entre elles et comment piloter chaque mode de filtrage.

Ajout d’un champ de filtre

Il existe deux manières d’enregistrer un champ de tableau croisé dynamique dans la zone de filtre. L’appel de haut niveau prend le nom de la colonne source sous forme de chaîne de caractères et constitue le chemin le plus courant. L’appel de bas niveau accepte une instance PivotField existante et s’avère pratique lorsque le même objet de champ doit être réutilisé dans plusieurs zones du tableau croisé dynamique. Les deux appels placent le champ dans pivotTable.getPageFields(), après quoi il apparaît comme la liste déroulante de page en haut du tableau croisé dynamique rendu.

Ajout d’un champ de filtre avec addFieldToArea

L’exemple suivant construit un petit jeu de données Fruit / Year / Amount, place un tableau croisé dynamique à la cellule E3 avec Fruit dans la zone des lignes, Amount dans la zone des données et Year dans la zone de filtre, actualise le tableau croisé dynamique et enregistre le classeur.

var workbook = new AsposeCells.Workbook();
var worksheet = workbook.getWorksheets().get(0);
worksheet.setName("Data");
// Configurer la ligne d'en-tête
worksheet.getCells().get("A1").putValue("Fruit");
worksheet.getCells().get("B1").putValue("Year");
worksheet.getCells().get("C1").putValue("Amount");
// Remplir 9 lignes de données d'exemple : Fruit, Année, Montant
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]);
}
// Ajouter un tableau croisé dynamique ancré à la cellule E3
var pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "PivotTable1");
var pivotTable = worksheet.getPivotTables().get(pivotIndex);
// Ajouter des champs à leurs zones : Fruit comme Ligne, Montant comme Données, Année comme champ Page
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");
// Actualiser et calculer les données du tableau croisé dynamique
pivotTable.calculateData();
// Enregistrer le classeur
workbook.save("pageFieldSample.xlsx");

Ajout d’un champ de filtre avec getPageFields().add

Lorsque vous travaillez déjà avec une instance PivotField, vous pouvez la transmettre directement à pivotTable.getPageFields().add. Le tableau croisé dynamique et le champ de filtre sont construits exactement comme dans le scénario précédent ; seul l’enregistrement final dans la zone de filtre est remplacé par l’appel d’API de bas niveau.

let workbook = new AsposeCells.Workbook();
let sheet = workbook.getWorksheets().get(0);
// En-têtes
sheet.getCells().get("A1").putValue("Fruit");
sheet.getCells().get("B1").putValue("Year");
sheet.getCells().get("C1").putValue("Amount");
// Données d'exemple (9 lignes)
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);
// Ajouter un tableau croisé dynamique à E3 couvrant A1:C10
let pivotIndex = sheet.getPivotTables().add("E3", "A1:C10", "PivotTable1");
let pivotTable = sheet.getPivotTables().get(pivotIndex);
// Fruit -> Ligne, Montant -> Données (Année ira à Page ci-dessous)
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
// Approche bas niveau : récupérer le PivotField Année existant depuis BaseFields
// et l'enregistrer dans la zone Page via PageFields.Add(PivotField).
let yearField = pivotTable.getBaseFields().get("Year");
pivotTable.getPageFields().add(yearField);
// Actualiser pour que le nouveau champ de page soit reflété dans le classeur enregistré
pivotTable.calculateData();
workbook.save("output.xlsx");

Filtrage à sélection unique (affichage d’un seul élément de page)

Dans le comportement par défaut en sélection unique, le champ de filtre s’affiche sous la forme d’une liste déroulante unique et l’entier PivotField.CurrentPageItem sélectionne l’élément de page qui pilote le corps du tableau croisé dynamique. L’affectation d’un index spécifique sélectionne cet unique élément ; l’affectation de la valeur sentinelle spéciale 0x7FFD (32765 en décimal) réinitialise le filtre de sorte que chaque élément de page soit synthétisé en une seule fois. La sélection unique est le mode par défaut ; vous n’avez pas besoin de l’activer explicitement.

Affichage de tous les éléments

Le réglage de CurrentPageItem à la valeur magique 0x7FFD équivaut à réinitialiser le filtre ; le corps du tableau croisé dynamique synthétise chaque élément de page comme si aucun filtre n’était appliqué.

var workbook = new AsposeCells.Workbook();
var sheet = workbook.getWorksheets().get(0);
// Remplir les données Fruit/Année/Montant
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]);
    }
}
// Créer un tableau croisé dynamique à E3
var pivotTables = sheet.getPivotTables();
var index = pivotTables.add("=A1:C7", "E3", "PivotTable1");
var pivotTable = pivotTables.get(index);
// Configurer les champs du tableau croisé : Fruit→Ligne, Montant→Données, Année→Page
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");
pivotTable.calculateData();
// Effacer le filtre de page pour que chaque élément du champ de page soit visible.
// 0x7FFD (32765 en décimal) est la valeur sentinelle spéciale qui signifie "tous les éléments" —
// équivalent à sélectionner "(Tous)" dans le menu déroulant du champ de page d'Excel.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD);
workbook.save("output.xlsx");

Affichage d’un élément spécifique

Le réglage de CurrentPageItem à un index réel sélectionne uniquement cet élément de page. L’index correspond à la position de l’élément dans la liste triée des éléments du champ de filtre ; ainsi, par exemple, 1 sélectionne le deuxième élément après le tri.

var workbook = new AsposeCells.Workbook();
var sheet = workbook.getWorksheets().get(0);
var cells = sheet.getCells();
// Ajouter des données d'exemple (Fruit/Année/Montant)
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");
// Ajouter un tableau croisé dynamique à E3
var pivotTables = sheet.getPivotTables();
var pivotIndex = pivotTables.add("A1:C5", "E3", "PivotTable1");
var pivotTable = pivotTables.get(pivotIndex);
// Ajouter des champs : Fruit→Ligne, Montant→Données, Année→Page
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Page, "Year");
// Opérations spécifiques au champ de page
pivotTable.getPageFields().get(0).setCurrentPageItem(1); // 1 = deuxième élément dans l'ordre trié (par ex. "2021")
// Actualiser et calculer le tableau croisé dynamique
pivotTable.calculateData();
workbook.save("output.xlsx");

Filtrage à sélection multiple

Le filtrage à sélection multiple transforme la liste déroulante de page en une liste de cases à cocher et permet à l’utilisateur final de sélectionner simultanément plusieurs éléments de page. Aspose.Cells expose deux propriétés qui fonctionnent ensemble. PivotField.IsMultipleItemSelectionAllowed doit être défini sur true avant que l’interface utilisateur de sélection multiple ne prenne effet. Une fois activée, PivotItem.IsHidden contrôle quels éléments apparaissent dans la liste de cases à cocher, ce qui vous permet d’afficher chaque élément ou de n’autoriser que des éléments spécifiques. Le code ci-dessous active la sélection multiple sur le même champ de filtre Year construit dans le scénario 1a, puis présente deux schémas : la partie A révèle chaque élément de page en laissant IsHidden défini sur false pour chaque entrée, tandis que la partie B n’autorise que les valeurs source que vous choisissez et masque tout le reste via un bloc switch (pivotItems[i].getStringValue()).

const AsposeCells = require("aspose.cells");
// — Le tableau croisé dynamique et le champ de page sont construits exactement comme dans
//   le scénario 1a (données Fruit/Année/Montant, pivot à E3, Fruit→Ligne,
//   Montant→Données, Année→Page via AddFieldToArea).
//   Ci-dessous, nous appliquons un filtrage à sélection multiple sur le champ de page.
const workbook = new AsposeCells.Workbook();
const sheet = workbook.getWorksheets().get(0);
const cells = sheet.getCells();
// Données d'exemple : Fruit | Année | Montant
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");
// — Activer la sélection multiple sur le champ de page
pivotTable.getPageFields().get(0).setMultipleItemSelectionAllowed(true);
// Partie A — sélectionner TOUS les éléments (rendre chaque élément visible)
const pivotItems = pivotTable.getPageFields().get(0).getPivotItems();
for (let i = 0; i < pivotItems.getCount(); i++) {
    pivotItems.get(i).setHidden(false);
}
// Partie B — sélectionner uniquement des éléments spécifiques par valeur source
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");

Remarque : Lorsque vous utilisez le filtrage à sélection multiple via PivotItem.IsHidden, au moins un PivotItem doit rester visible (IsHidden == false). Si tous les éléments sont masqués, Excel plante à l’ouverture du fichier ou affiche un tableau croisé dynamique vide. Vérifiez toujours que votre liste d’éléments autorisés en sélection multiple inclut au moins un élément de vos données source.

Quelle API et quel mode dois-je utiliser ?

Le tableau ci-dessous résume quand utiliser chaque API et chaque mode afin que vous puissiez choisir la bonne combinaison sans avoir à lire chaque scénario en détail.

Scénario / Cas d’utilisation	API recommandée	Propriété utilisée	Notes
Ajouter un champ de filtre par nom de colonne source (le plus courant)	`pivotTable.addFieldToArea(PivotFieldType.Page, "fieldName")`	n/a	Haut niveau, une seule ligne. Utilisez cette option sauf si vous avez besoin d’une référence `PivotField`.
Ajouter un champ de filtre lorsque vous disposez déjà d’un objet `PivotField`	`pivotTable.getPageFields().add(PivotField)`	n/a	À utiliser lorsque l’objet de champ a été obtenu ailleurs ou doit être réutilisé.
Filtrer sur un seul élément de page (mode par défaut)	`PivotField.CurrentPageItem`	défini sur un index spécifique	Par exemple, `1` affiche le deuxième élément dans la liste triée.
Afficher tous les éléments / réinitialiser le filtre	`PivotField.CurrentPageItem`	défini sur `0x7FFD`	La valeur magique `0x7FFD` (32765 en décimal) est la sentinelle pour « tous les éléments ».
Activer l’interface de sélection multiple dans Excel	`PivotField.IsMultipleItemSelectionAllowed`	défini sur `true`	Requis avant que tout appel à `IsHidden` ne prenne effet.
Masquer / afficher des éléments individuels dans une liste à sélection multiple	`PivotItem.IsHidden`	défini par élément	Au moins un élément doit rester visible (`IsHidden == false`).

Gardez toujours à l’esprit la contrainte de visibilité lors de la configuration du filtrage à sélection multiple. Si chaque PivotItem d’un champ de filtre à sélection multiple est masqué, Excel plante à l’ouverture ou affiche un tableau croisé dynamique vide. Construisez votre liste d’éléments autorisés à partir de vos données source afin qu’au moins un élément reste visible, et vos classeurs enregistrés s’ouvriront de manière fiable sur chaque machine.

Documentation – Insérer un tableau croisé dynamique

Nodejsjava: Actualiser les Tableaux Croisés Dynamiques et les Caches de TCD dans Aspose.Cells for Node.js via Java

Introduction

Démarrage Rapide

Imports Requis

Actualiser Tous les Tableaux Croisés Dynamiques du Classeur

Actualiser Tous les Tableaux Croisés Dynamiques sur une Seule Feuille de Calcul

Actualiser un Seul Tableau Croisé Dynamique

Données Source Modifiées — Utilisez PivotCache.Refresh()

Seule la Vue/Mise en Page Modifiée — Utilisez CalculateData()

Migration depuis l’Obsolète PivotTable.RefreshData()

Quelle API d’Actualisation Dois-Je Utiliser ?

Pièges Courants

Nodejsjava: Appliquer des styles aux Tableaux Croisés Dynamiques dans Aspose.Cells for Node.js via Java

Introduction

Appliquer un autoformat prédéfini XLS hérité

Appliquer un style de tableau croisé dynamique prédéfini nommé moderne

Définir et appliquer un style personnalisé de tableau croisé dynamique

Appliquer un seul style à chaque cellule du tableau croisé dynamique avec FormatAll

Quelle API de style dois-je utiliser ?

Nodejsjava: Ajouter des champs de ligne et de colonne à un tableau croisé dynamique dans Aspose.Cells pour .NET

Ajouter un champ à la région des lignes ou des colonnes

Sous-totaux des champs dynamiques

Scénario 1 — Sous-totaux automatiques (par défaut)

Scénario 2 — Suppression de tous les sous-totaux (None)

Scénario 3 — Sous-ensemble personnalisé de sous-totaux (Sum + Average)

Récapitulatif

Nodejsjava: Champs de valeur dans Aspose.Cells for Node.js via Java

Ajout d’un champ à la zone de données

Modification de la fonction de synthèse

Tracé des champs de valeur sur l’axe des Lignes ou des Colonnes

Nodejsjava: Ajouter des champs de filtre à un tableau croisé dynamique dans Aspose.Cells pour .NET

Introduction

Ajout d’un champ de filtre

Ajout d’un champ de filtre avec addFieldToArea

Ajout d’un champ de filtre avec getPageFields().add

Filtrage à sélection unique (affichage d’un seul élément de page)

Affichage de tous les éléments

Affichage d’un élément spécifique

Filtrage à sélection multiple

Quelle API et quel mode dois-je utiliser ?

Données Source Modifiées — Utilisez `PivotCache.Refresh()`

Seule la Vue/Mise en Page Modifiée — Utilisez `CalculateData()`

Migration depuis l’Obsolète `PivotTable.RefreshData()`