Documentation – Insérer un tableau croisé dynamique

Nodejscpp: Formatage du tableau croisé dynamique

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

Apparence du tableau croisé dynamique

Comment créer un tableau croisé dynamique explique comment créer un tableau croisé dynamique simple. Cet article décrit comment personnaliser l’apparence d’un tableau croisé dynamique en définissant diverses propriétés :

Options de formatage du tableau croisé dynamique
Options de formatage des champs de tableau croisé dynamique
Options de formatage des champs de données

Comment définir les options de formatage du tableau croisé dynamique

La classe PivotTable contrôle le tableau croisé dynamique global et peut être formatée de plusieurs manières.

Comment définir le type de mise en forme automatique

Microsoft Excel offre plusieurs formats de rapports pré-configurés. Aspose.Cells for Node.js via C++ prend également en charge ces options de mise en forme. Pour y accéder :

Définissez PivotTable.setIsAutoFormat(value) sur true.
Attribuer une option de mise en forme de l’énumération PivotTableAutoFormatType.

Comment définir les options de mise en forme

L’exemple de code ci-dessous montre comment formater le tableau croisé dynamique pour afficher les totaux généraux pour les lignes et les colonnes, et comment définir l’ordre des champs du rapport. Il montre également comment définir une chaîne personnalisée pour les valeurs nulles.

Aspect et sensation du formatage manuel

Pour formater manuellement l’aspect du rapport de table de données, au lieu d’utiliser des formats de rapport prédéfinis, utilisez les méthodes PivotTable.formatAll(style) et PivotTable.format(row, column, style). Créez un objet de style pour le format souhaité, par exemple :

Comment définir les options de format de champ de table de données

La classe PivotField représente un champ dans une table de données et peut être formatée de plusieurs manières. L’exemple de code ci-dessous montre comment :

Accéder aux champs de lignes.
Définir les sous-totaux.
Définir l’autotri.
Définir l’auto-affichage.

Comment définir le format des champs de lignes/colonnes/page

Comment définir le format des champs de données

L’exemple de code ci-dessous montre comment définir les formats d’affichage et de nombres pour les champs de données.

Comment effacer les champs de table de données

La classe PivotFieldCollection possède une méthode nommée clear() qui vous permet d’effacer les champs de table de données. Utilisez-la lorsque vous voulez effacer tous les champs de table de données dans les zones, par exemple, les pages, les colonnes, les lignes ou les données. L’exemple de code ci-dessous montre comment effacer tous les champs de table de données dans une zone de données.

Nodejscpp: Créer des tableaux croisés dynamiques et des graphiques croisés dynamiques

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

Un tableau croisé dynamique est un résumé interactif des enregistrements. Par exemple, vous pouvez avoir des centaines d’entrées de facture dans une liste dans une feuille de calcul. Un tableau croisé dynamique peut totaliser les factures par client, produit ou date. Avec Microsoft Excel, il est possible de réarranger rapidement les informations dans le tableau croisé dynamique en faisant glisser les boutons vers une nouvelle position.

Un graphique croisé dynamique est une représentation graphique interactive des données dans un tableau croisé dynamique. Les graphiques croisés dynamiques ont été introduits dans Excel 2000. L’utilisation d’un graphique croisé dynamique rend encore plus facile la compréhension des données puisque le tableau croisé dynamique crée automatiquement des sous-totaux et des totaux.

Aspose.Cells for Node.js via C++ supporte tableaux croisés dynamiques et graphismes croisés dynamiques.

Ajouter des tableaux croisés dynamiques et des graphiques en utilisant Aspose.Cells for Node.js via C++

Aspose.Cells for Node.js via C++ fournit un ensemble spécial de classes pour créer des tableaux croisés dynamiques. Ces classes servent à créer et définir des objets PivotTable, qui agissent comme les blocs de construction de base d’un tableau croisé dynamique :

PivotField, un champ dans un rapport de tableau croisé dynamique.
PivotFields, une collection de tous les objets PivotField dans un tableau croisé dynamique.
PivotTable, un rapport de tableau croisé dynamique sur une feuille de calcul.
PivotTables, une collection de tous les objets PivotTable sur la feuille de calcul.

Préparer l’utilisation de Aspose.Cells for Node.js via C++

Installer Aspose.Cells for Node.js via C++ depuis NPM, utiliser la commande : $ npm install aspose.cells.node.
Vous pouvez également suivre les instructions étape par étape pour installer “Aspose.Cells for Node.js via C++” dans votre environnement de développement.

Comment ajouter un tableau croisé dynamique en utilisant Aspose.Cells for Node.js via C++

Pour créer un tableau croisé dynamique avec Aspose.Cells for Node.js via C++ :

Ajoutez des données à des cellules de feuille de calcul en utilisant la méthode put_value d’un objet Cell. Vous pouvez également utiliser un fichier de modèle déjà rempli de données. Les données seront utilisées comme source de données de la table pivotante.
Ajoutez une table pivotante à la feuille de calcul en appelant la méthode add de la collection PivotTables (encapsulée dans l’objet Feuille de calcul).
Accédez au nouvel objet PivotTable depuis la collection PivotTables en passant son index. # Utilisez l’un des objets table pivotante encapsulés dans l’objet PivotTable pour gérer la table.

Des exemples de code sont donnés ci-dessous.

Comment ajouter un graphique croisé dynamique en utilisant la bibliothèque Aspose.Cells for Node.js via C++

Pour créer un PivotChart avec Aspose.Cells for Node.js via C++ :

Ajoutez un graphique.
Définissez la PivotSource du graphique pour qu’elle fasse référence à une table pivotante existante dans la feuille de calcul.
Définissez d’autres attributs.

Nodejscpp: Tableau croisé dynamique et données sources

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

Données source du tableau croisé dynamique

Il arrive parfois que vous souhaitiez créer des rapports Microsoft Excel avec des tableaux croisés dynamiques prenant des données de différentes sources de données (telles qu’une base de données) qui ne sont pas connues au moment de la conception. Cet article propose une approche pour modifier dynamiquement la source de données d’un tableau croisé dynamique.

Modification des données source d’un tableau croisé dynamique

Création d’un nouveau modèle de concepteur.
1. Créez un nouveau fichier de modèle de concepteur comme sur la capture d’écran ci-dessous.
2. Ensuite, définissez une plage nommée, DataSource, qui fait référence à cette plage de cellules.
  
  Création d’un modèle de concepteur et définition d’une plage nommée, DataSource

Création d’un tableau croisé dynamique basé sur cette plage nommée.
1. Dans Microsoft Excel, choisissez Données, puis Tableau croisé dynamique et Rapport de tableau croisé dynamique.
2. Créez un tableau croisé dynamique basé sur la plage nommée créée à l’étape précédente.
  
  Création d’un tableau croisé dynamique basé sur la plage nommée, DataSource

Faites glisser le champ correspondant pour le placer dans les colonnes et les lignes du tableau croisé dynamique, puis créez le tableau croisé dynamique résultant comme sur la capture d’écran ci-dessous.

Création d’un tableau croisé dynamique basé sur un champ correspondant

Cliquez avec le bouton droit sur le tableau croisé dynamique et sélectionnez Options de tableau.
1. Cochez Actualiser à l’ouverture dans les paramètres Options de données.
  
  Configuration des options de tableau croisé dynamique

Maintenant, vous pouvez enregistrer ce fichier en tant que fichier de modèle de concepteur.

Remplir de nouvelles données et changer les données source d’un tableau croisé dynamique.
1. Une fois que le modèle de concepteur est créé, utilisez le code suivant pour changer les données source du tableau croisé dynamique.

L’exécution du code d’exemple ci-dessous modifie les données source du tableau croisé dynamique.

Nodejscpp: Ajouter un champ calculé dans le tableau croisé dynamique

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

Scénarios d’utilisation possibles

Lorsque vous créez un tableau croisé dynamique basé sur des données connues, vous constatez que les données qui s’y trouvent ne correspondent pas à ce que vous souhaitez. Les données que vous souhaitez sont la combinaison de ces données d’origine. Par exemple, vous devez ajouter, soustraire, multiplier et diviser les données d’origine avant de les vouloir. À ce moment-là, vous devez construire un champ calculé et définir la formule correspondante pour le calcul. Ensuite, effectuez des statistiques et d’autres opérations sur le champ calculé.

Comment ajouter un champ calculé dans un tableau croisé dynamique dans Excel

Insérer un champ calculé dans un tableau croisé dynamique dans Excel, suivez ces étapes :

Sélectionnez le tableau croisé dynamique auquel vous souhaitez ajouter un champ calculé.
Accédez à l’onglet Analyse du tableau croisé dynamique dans le ruban.
Cliquez sur “Champs, éléments et ensembles” puis sélectionnez “Champ calculé” dans le menu déroulant.
Dans le champ “Nom”, entrez un nom pour le champ calculé.
Dans le champ “Formule”, entrez la formule du calcul que vous souhaitez effectuer en utilisant les noms de champ appropriés du tableau croisé dynamique et les opérateurs mathématiques.
Cliquez sur “OK” pour créer le champ calculé.
Le nouveau champ calculé apparaîtra dans la liste des champs du tableau croisé dynamique sous la section “Valeurs”.
Faites glisser le champ calculé dans la section Valeurs du tableau croisé dynamique pour afficher les valeurs calculées.

Comment ajouter un champ calculé dans un tableau croisé dynamique en utilisant la bibliothèque Aspose.Cells for Node.js via C++

Ajouter un champ calculé au fichier Excel en utilisant Aspose.Cells for Node.js via C++. Veuillez voir le code d’exemple suivant. Après avoir exécuté le code, un tableau croisé dynamique avec un champ calculé est ajouté à la feuille.

Définissez les données d’origine et créez un tableau croisé dynamique.
Créez le champ calculé en fonction du PivotField existant dans le tableau croisé dynamique.
Ajoutez le champ calculé à la zone de données.
Enfin, enregistrez le classeur au format XLSX de sortie.

Code d’exemple

Nodejscpp: Actualiser les tableaux croisés dynamiques dans Aspose.Cells for Node.js via C++

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 des tableaux croisés dynamiques à quatre niveaux différents — du classeur entier jusqu’à un seul tableau croisé dynamique. À partir d'Aspose.Cells for Node.js via C++ 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 dans toute situation.

La chaîne de données à quatre niveaux est :

Source de données — les plages de feuilles 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.
PivotTable — l’objet de vue qui définit les champs de ligne, de colonne, de valeur et de filtre. Un PivotTable lit uniquement à partir de son PivotCache, jamais directement depuis la source de données.
Cells — les Cells de la feuille de calcul dans lesquelles le PivotTable rend ses valeurs calculées et ses styles.

Un concept particulièrement important est le cache partagé. Lorsque plusieurs tableaux croisés dynamiques dans un classeur référencent la même plage source, ils partagent une seule instance de PivotCache. Un seul PivotCache peut être référencé par de nombreux tableaux croisés dynamiques, et l’actualisation de ce cache actualise tous les PivotTable dépendants en une seule fois.

PivotCache.SourceType (énumération 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 des plages de feuilles de calcul. Les sources externes (bases de données, connexions externes, etc.) ne sont pas encore actualisables via l’API du cache.

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

PivotCache.Refresh() — recharge la source → cache ET recalcule tous les PivotTable dépendants en une seule opération.
PivotTable.CalculateData() — recalcule l’affichage d’un seul 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 provenant de cellules de feuille de calcul, donc le type de source est Sheet et les opérations d’actualisation se comportent comme décrit.

Imports requis

Tous les exemples JavaScript de cet article supposent que le module Aspose.Cells for Node.js via C++ a été chargé et que les types de tableaux croisés dynamiques se trouvent dans le namespace Aspose.Cells.Pivot. Une configuration typique est :

const AsposeCells = require("aspose.cells.node");
const { PivotFieldType } = AsposeCells; (ou accédez via AsposeCells.Pivot.PivotFieldType)

Actualiser tous les tableaux croisés dynamiques dans le classeur

Lorsque vous devez vous assurer que chaque cache de tableau croisé dynamique et chaque tableau croisé dynamique dans le 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 à partir de 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.

let workbook = new AsposeCells.Workbook();
let 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 sur 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"
let pivotIndex = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Assigner 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 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 chaque tableau croisé dynamique / cache de tableau croisé dynamique dans le classeur
workbook.refreshAll();

// Enregistrer le classeur
workbook.save("output.xlsx");

Actualiser tous les tableaux croisés dynamiques d’une seule feuille de calcul

Parfois, vous n’avez besoin d’actualiser que 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 de calcul sont connus pour être sans rapport et ne doivent pas être touchés. Pour ce cas, Aspose.Cells fournit Worksheet.RefreshPivotTables(), qui est limité à une seule instance de Worksheet.

Ceci est plus sélectif que Workbook.RefreshAll() : seuls les tableaux croisés dynamiques de la feuille de calcul ciblée sont actualisés, laissant intacts tous les tableaux croisés dynamiques des autres feuilles de calcul.

L’exemple suivant remplit les mêmes données source Fruit/Année/Montant, ajoute un tableau croisé dynamique sur la première feuille de calcul, modifie certaines valeurs source, puis actualise uniquement les tableaux croisés dynamiques de cette feuille de calcul.

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 d’affichage/de mise en page du tableau croisé dynamique lui-même.

Les données source ont changé — 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.

Parce que les tableaux croisés dynamiques partagent une seule instance de PivotCache, l’appel de PivotCache.Refresh() recalcule tous les tableaux croisés dynamiques construits sur ce même cache — pas seulement celui que vous référencez. Si deux tableaux croisés dynamiques partagent la même plage source, l’actualisation d’un cache actualise les deux.

L’exemple suivant crée deux tableaux croisés dynamiques sur la même plage source pour démontrer ce comportement de cache partagé, modifie certaines valeurs source, puis actualise via une référence de cache.

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

// Créer un nouveau classeur et accéder à la première feuille de calcul
const workbook = new AsposeCells.Workbook();
const 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 environ 9 lignes de données (raisin / myrtille / kiwi / cerise sur 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);

// Ajouter le premier tableau croisé dynamique "Pivot1" ancré à la cellule E3, plage source A1:C9
const pivotIndex1 = worksheet.getPivotTables().add("A1:C9", "E3", "Pivot1");
const pivotTable1 = worksheet.getPivotTables().get(pivotIndex1);

// Attribuer les champs pour Pivot1
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable1.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Ajouter un SECOND tableau croisé dynamique "Pivot2" ancré à E15 en utilisant la MÊME plage source A1:C9
// Pivot1 et Pivot2 partagent un seul PivotCache car la plage source est identique.
const pivotIndex2 = worksheet.getPivotTables().add("A1:C9", "E15", "Pivot2");
const pivotTable2 = worksheet.getPivotTables().get(pivotIndex2);

// Attribuer les mêmes champs pour Pivot2
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable2.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Modifier plusieurs valeurs de cellules Montant dans les données source pour simuler un changement de données
worksheet.getCells().get("C2").putValue(150);
worksheet.getCells().get("C4").putValue(350);
worksheet.getCells().get("C7").putValue(650);

// Actualiser le PivotCache partagé.
// Parce que Pivot1 et Pivot2 partagent le même PivotCache, cet appel unique
// actualise LES DEUX tableaux croisés dynamiques (données + style) à partir de la source mise à jour.
pivotTable1.getPivotCache().refresh();

// Enregistrer le classeur
workbook.save("output.xlsx");

Seuls l’affichage/la mise en page ont changé — Utilisez `CalculateData()`

Si les données source n’ont pas changé mais que seuls les paramètres d’affichage 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.

Cela évite la récupération inutile de la source et est significativement plus rapide lorsque de nombreux tableaux croisés dynamiques partagent le même cache.

L’exemple suivant modifie une propriété non-source du tableau croisé dynamique, puis appelle CalculateData() pour le restituer à partir du 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é dans la cellule de destination E3, provenant de 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.Pivot.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.Pivot.PivotFieldType.Data, "Amount");

// Modifier une propriété d'affichage/mise en page — c'est un changement uniquement de présentation,
// donc cela ne nécessite PAS de relire les données source via PivotCache.Refresh().
pivotTable.setRefreshDataOnOpeningFile(false);

// CalculateData() réaffiche l'affichage (données + style) DE CE tableau croisé dynamique à partir des
// données déjà contenues 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");

Obtenir tous les tableaux croisés dynamiques partageant le même PivotCache

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 lots, 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é.

C’est également le moyen le plus direct de confirmer que deux tableaux croisés dynamiques partagent bien la même instance de PivotCache : vous pouvez comparer les références du cache, ou simplement itérer la collection renvoyée par GetPivotTables() et observer quels tableaux croisés dynamiques y apparaissent.

L’exemple suivant crée deux tableaux croisés dynamiques sur la même plage source, vérifie qu’ils partagent la même instance de cache, puis énumère les tableaux croisés dynamiques du cache.

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

Avant Aspose.Cells for Node.js via C++ v26.7, la méthode standard pour actualiser un tableau croisé dynamique consistait à 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é.
Chaque appel actualise le cache partagé entier. Lorsque de nombreux tableaux croisés dynamiques partagent un cache, l’appel répété de RefreshData() par tableau croisé dynamique provoque la récupération répétée du même cache, ce qui est très lent.

Les remplacements recommandés sont :

Actualiser TOUS les tableaux croisés dynamiques dans le classeur → utilisez workbook.refreshAll();
Actualiser CERTAINS d’entre eux → utilisez pivotTable.PivotCache.Refresh(); pour un cache. Parce que le cache est partagé, cet appel unique met à jour chaque tableau croisé dynamique construit au-dessus de ce cache. Les autres tableaux croisés dynamiques qui reposent sur un cache déjà actualisé peuvent être ignorés en toute sécurité.
Seuls l’affichage/la mise en page du tableau croisé dynamique ont changé → utilisez pivotTable.CalculateData(); pour restituer à partir du cache existant sans aucun aller-retour vers la source.

L’exemple suivant démontre le nouveau modèle efficace pour les classeurs avec plusieurs tableaux croisés dynamiques partageant un seul cache.

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

// --- Construction des données sources : Fruit / Année / Montant (en-tête + 9 lignes) ---
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);

// --- Ajout du premier tableau croisé dynamique (Pivot1) à la cellule de destination 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");

// --- Ajout du SECOND tableau croisé dynamique (Pivot2) sur la MÊME plage source ---
// Pivot1 et Pivot2 partagent UN SEUL PivotCache sous-jacent.
// C'est exactement le scénario où l'approche héritée RefreshData() par table
// devient inefficace : actualiser une table récupère à nouveau l'ensemble du
// cache partagé, donc actualiser N tables effectue la même récupération coûteuse N fois.
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");

// --- Modifier plusieurs valeurs de Montant dans les données sources ---
sheet.getCells().get("C2").putValue(5000);   // Raisin 2020
sheet.getCells().get("C5").putValue(7500);   // Cerise 2020
sheet.getCells().get("C9").putValue(9500);   // Cerise 2021

// --- Modèle OBSOLÈTE (avant 26.7) — PivotTable.RefreshData() ---
// pivotTable1.RefreshData();  // récupère à nouveau depuis la source, actualise tout le cache
// pivotTable2.RefreshData();  // récupère À NOUVEAU — le cache est déjà frais !
// Chaque appel reconstruit le cache partagé, donc N tables = N récupérations redondantes.

// --- NOUVEAU modèle v26.7+ : actualiser le cache UNE FOIS, puis ré-afficher si nécessaire ---
// Un seul appel à PivotCache.Refresh() extrait les valeurs modifiées dans le cache partagé
// ET recalcule l'affichage de CHAQUE tableau croisé dynamique qui le référence.
// Comme Pivot1 et Pivot2 partagent un même PivotCache, cet appel unique met à jour
// les deux tables — aucun second aller-retour vers la source n'est nécessaire.
pivotTable1.getPivotCache().refresh();

// CalculateData() ne ré-affiche que l'affichage d'un tableau croisé dynamique (données + style)
// à partir des données déjà détenues dans le cache — il ne touche PAS à la source.
// Nous l'appelons sur Pivot2 ici uniquement pour démontrer l'API : après que le cache
// a été actualisé une fois, toute table dépendante peut être ré-affichée sans
// revenir à la source. Utilisez CalculateData() seul lorsque seuls les
// paramètres d'affichage/de mise en page du tableau croisé ont changé et que le cache est à jour.
pivotTable2.calculateData();

workbook.save("output.xlsx");

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 seul appel ; couvre tous les caches et tableaux.
Actualiser uniquement les tableaux croisés dynamiques d’une seule feuille	`Worksheet.RefreshPivotTables()`	Limité à une seule feuille de calcul.
Les données source ont changé pour un cache	`pivotTable.PivotCache.Refresh()`	Actualise TOUS les tableaux croisés dynamiques de ce cache partagé.
Seuls les paramètres d’affichage/mise en page ont changé	`pivotTable.CalculateData()`	Évite l’aller-retour inutile vers la source.
Lister tous les tableaux croisés dynamiques d’un cache partagé	`pivotCache.GetPivotTables()`	À utiliser pour énumérer avant une actualisation en masse.

En pratique, préférez les API basées sur le cache plutôt que l’obsolète RefreshData() par tableau. Elles sont conscientes des caches partagés, elles évitent les récupérations redondantes de la source, et elles vous permettent de choisir la plus petite portée qui satisfait votre besoin d’actualisation.

Nodejscpp: Appliquer des styles aux tableaux croisés dynamiques dans Aspose.Cells pour .NET

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

Aspose.Cells prend en charge l’application à la fois des anciens autoformats de tableau croisé dynamique (destinés aux fichiers .xls) et des styles modernes nommés ou personnalisés 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é en .xlsx, et dans ce cas c’est l’API de style moderne qui s’applique, plutôt que l’API héritée.

Pour la sortie .xls héritée, utilisez la propriété PivotTable.AutoFormatType conjointement avec l’énumération Aspose.Cells.Pivot.PivotTableAutoFormatType. Cette API correspond au sélecteur d’autoformat qu’Excel classique proposait pour les tableaux croisés dynamiques.

Pour la sortie moderne .xlsx, .xlsm et .xlsb, deux variantes d’API de style sont disponibles :

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 Workbook.Worksheets.TableStyles.AddPivotTableStyle(...). Les styles personnalisés sont nécessaires dès que vous souhaitez modifier les couleurs, les bordures ou les polices au-delà de ce que les préréglages offrent.

De plus, PivotTable.FormatAll(Style) est un raccourci qui applique un seul objet Style à chaque cellule du tableau croisé dynamique, en remplaçant tout ce qui a été défini via l’une ou l’autre des API de nom de style ci-dessus. Cela est utile lorsqu’une apparence uniforme est requise, indépendamment du thème sous-jacent.

Apply a Legacy XLS Preset Autoformat

PivotTable.AutoFormatType accepte une valeur issue de l’énumération Aspose.Cells.Pivot.PivotTableAutoFormatType. Les valeurs disponibles vont de Report1 à Report10, ainsi que Classic et Table1 à Table10.

AutoFormatType n’est pris en compte que lorsque le classeur est enregistré au format .xls. Lorsque le même classeur est enregistré au format .xlsx, .xlsm ou .xlsb, Excel ignore cette propriété et se rabat sur les paramètres PivotTableStyleType et PivotTableStyleName.

L’exemple suivant charge un nouveau classeur, renseigne les données d’exemple Fruit/Année/Montant, ajoute un tableau croisé dynamique, applique PivotTableAutoFormatType.Report5, puis 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 Excel classique pour des tableaux croisés dynamiques à une dimension avec uniquement des champs de ligne et des valeurs — ils n’ont pas de style intégré 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 ci-dessous, qui sont conçus pour la disposition bidimensionnelle qu’utilise Excel moderne.

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

// Scénario 1 : Appliquer un autoformat prédéfini XLS hérité
// API utilisée : PivotTable.AutoFormatType
// Format de fichier cible : .xls (héritée)
// Pour des exemples complets et des fichiers de données, veuillez aller sur https://github.com/aspose-cells/Aspose.Cells-for-.NET

// Créer un nouveau classeur
const workbook = new AsposeCells.Workbook();

// Obtenir la première feuille de calcul
const 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 pour 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
const pivotIndex = sheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
const pivotTable = sheet.getPivotTables().get(pivotIndex);

// Assigner les champs : Fruit -> Lignes, Année -> Colonnes, Montant -> Données
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Appliquer l'autoformat prédéfini XLS hérité "Report5"
// Remarque : 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écifie PivotTableStyleType / PivotTableStyleName.
pivotTable.setAutoFormatType(AsposeCells.PivotTableAutoFormatType.Report5);

// Enregistrer le classeur au format .xls hérité
workbook.save("output.xls");

Apply a Modern Named Preset Pivot Table Style

PivotTable.PivotTableStyleType accepte une valeur issue de l’énumération Aspose.Cells.PivotTableStyleType. L’énumération couvre les thèmes clairs PivotTableStyleLight1 à PivotTableStyleLight28 et les thèmes sombres PivotTableStyleDark1 à PivotTableStyleDark28. Les styles ajoutés dans Excel 2017 (la seconde vague de thèmes clairs et sombres) sont accessibles via la même énumération.

Il s’agit de l’API recommandée pour tout format de fichier moderne. Contrairement à l’autoformat hérité, le style sélectionné ici est rendu fidèlement par Excel et survit aux aller-retours avec d’autres outils Office.

L’exemple suivant utilise les mêmes données Fruit/Année/Montant, crée un tableau croisé dynamique identique, applique PivotTableStyleDark1, puis enregistre le classeur au format .xlsx.

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

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

// 9 lignes de données Fruit / Année / Montant
worksheet.getCells().get("A2").putValue("Grape");
worksheet.getCells().get("B2").putValue(2020);
worksheet.getCells().get("C2").putValue(100);

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

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

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

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

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

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

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

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

// Ajouter un tableau croisé dynamique en E3 nommé "Pivot1", sourcé depuis A1:C10
let pivotIndex = worksheet.getPivotTables().add("A1:C10", "E3", "Pivot1");
let pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Affecter les champs du tableau croisé : Fruit -> zone de lignes, Année -> zone de colonnes, Montant -> zone de données
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Appliquer un style de tableau croisé dynamique prédéfini nommé moderne d'Excel 2007+.
// PivotTableStyleType est l'API correcte pour les fichiers .xlsx / .xlsm / .xlsb ; AutoFormatType
// est ignoré par Excel pour ces formats. PivotTableStyleDark1 appartient à la famille
// à thème sombre (PivotTableStyleDark1..PivotTableStyleDark28), et la même énumération expose également
// les nouveaux thèmes clairs/sombres d'Excel 2017 (PivotTableStyleLight1..Light28 / Dark1..Dark28).
pivotTable.setPivotTableStyleType(AsposeCells.PivotTableStyleType.PivotTableStyleDark1);

// Enregistrer au format moderne .xlsx — c'est le format pour lequel PivotTableStyleType est significatif.
workbook.save("output.xlsx");

Define and Apply a Custom Pivot Table Style

Les préréglages intégrés ne peuvent pas être modifiés. Dès 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 Workbook.Worksheets.TableStyles.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 affectez 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 des 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 sans effet, mais seul celui correspondant à la source prévue est rendu.

Les valeurs TableStyleElementType disponibles 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 le classeur au format .xlsx.

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

// Remplir les données source : 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é à 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 personnalisé de tableau croisé dynamique 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.WholeTable);
let wholeTableElement = tableStyle.getTableStyleElements().get(wholeTableElementIndex);
let wholeTableStyle = workbook.createStyle();
wholeTableStyle.getBorders().get(AsposeCells.BorderType.TopBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.TopBorder).setColor(AsposeCells.Color.Black);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.BottomBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.BottomBorder).setColor(AsposeCells.Color.Black);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.LeftBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.LeftBorder).setColor(AsposeCells.Color.Black);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.RightBorder).setLineStyle(AsposeCells.CellBorderType.Thin);
wholeTableStyle.getBorders().get(AsposeCells.BorderType.RightBorder).setColor(AsposeCells.Color.Black);
wholeTableElement.setElementStyle(wholeTableStyle);

// Étape 3 : ajouter un élément GrandTotalRow et appliquer une police rouge en gras
let grandTotalElementIndex = tableStyle.getTableStyleElements().add(AsposeCells.TableStyleElementType.GrandTotalRow);
let grandTotalElement = tableStyle.getTableStyleElements().get(grandTotalElementIndex);
let grandTotalStyle = workbook.createStyle();
grandTotalStyle.getFont().setIsBold(true);
grandTotalStyle.getFont().setColor(AsposeCells.Color.Red);
grandTotalElement.setElementStyle(grandTotalStyle);

// Étape 4 : appliquer le style personnalisé par nom (PAS par PivotTableStyleType, qui est réservé aux préréglages intégrés)
pivotTable.setPivotTableStyleName("CustomPivotStyle");

workbook.save("output.xlsx");

Apply One Style to Every Pivot Cell with FormatAll

PivotTable.FormatAll(Style) est un raccourci qui applique un seul objet Style à chaque cellule du tableau croisé dynamique, y compris la zone de données, les en-têtes de lignes et de colonnes, ainsi que les totaux. Tout ce qui a été défini précédemment via PivotTableStyleType ou PivotTableStyleName est remplacé.

FormatAll remplace à la fois PivotTableStyleType et PivotTableStyleName. Utilisez-le uniquement lorsqu’une apparence uniforme et indépendante du thème est requise pour 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 le classeur 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, Year -> zone Colonnes, Amount -> zone Données
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Row, "Fruit");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Column, "Year");
pivotTable.addFieldToArea(AsposeCells.PivotFieldType.Data, "Amount");

// Construire 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 .xlsx moderne
workbook.save("output.xlsx");

Which Style API Should I Use?

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	Remarques
`.xls` (hérité)	`PivotTable.AutoFormatType`	Valeurs issues de `Aspose.Cells.Pivot.PivotTableAutoFormatType` (par ex. `Report1`–`Report10`, `Classic`, `Table1`–`Table10`). Ignorée lors de l’enregistrement dans un format moderne.
`.xlsx` / `.xlsm` / `.xlsb` (moderne, style intégré)	`PivotTable.PivotTableStyleType`	Valeurs issues de `Aspose.Cells.PivotTableStyleType` (thèmes clairs/sombres, y compris les ajouts d’Excel 2017).
`.xlsx` / `.xlsm` / `.xlsb` (moderne, style personnalisé)	`PivotTable.PivotTableStyleName` + `Worksheets.TableStyles.AddPivotTableStyle(...)`	À utiliser lorsque les préréglages intégrés ne suffisent pas. Configurer via `TableStyleElement.SetElementStyle(...)`.
Tout format (substitution uniforme)	`PivotTable.FormatAll(Style)`	Raccourci qui remplace tout autre paramètre de style dans 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.

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

Ajout d’un champ à la région de ligne ou de colonne

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

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

Après l’ajout des champs, vous pouvez y accéder via les propriétés PivotTable.RowFields et PivotTable.ColumnFields. 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 de ligne en premier, puis de Item, produit un tableau croisé dynamique dont le regroupement externe est Category et dont le regroupement interne est Item. L’inversion de l’ordre inverse la hiérarchie.

Sous-totaux des champs croisés

La méthode PivotField.SetSubtotals(PivotFieldSubtotalType subtotalType, bool shown) contrôle quelles lignes de sous-total apparaissent pour un champ croisé. Chaque appel bascule un seul type de sous-total indépendamment. Le passage de shown = true affiche le sous-total, tandis que shown = false le masque. Comme chaque appel n’affecte qu’un seul type, l’appel de la méthode plusieurs fois avec différentes valeurs 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-total
Sum
Count
Average
Max
Min
Product
StdDev
StdDevp
Var
Varp

Les sous-totaux ne s’affichent que lorsqu’il y a deux champs croisés ou plus dans la région de ligne (ou dans la région de colonne). Un seul champ n’a rien de significatif à sous-totaliser entre les valeurs, donc 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 limite 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 Category externe.

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-total du tableau croisé dynamique, ne laissant que les lignes de champ et le total général en bas. Ceci est utile lorsque vous souhaitez obtenir les données groupées brutes sans aucune ligne de synthèse.

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

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 type, donc l’appel de la méthode deux fois — une fois avec Sum et une fois avec Average — produit un sous-ensemble personnalisé de deux lignes de sous-total 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 ensemble 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 Category externe. Rappelez-vous la règle des deux champs : un seul champ dans une région n’a rien à sous-totaliser entre les valeurs, donc placez toujours au moins deux champs dans la région de ligne ou de colonne lorsque vous souhaitez que SetSubtotals ait un effet visible.

Nodejscpp: Gérer les champs de valeur d'un tableau croisé dynamique dans Aspose.Cells pour .NET

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

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

L’ajout d’un champ de base à la zone de données (valeur) est 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 synthétisé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");

// En-têtes dans 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");

// Lignes de données A2:D9 utilisant des boucles imbriquées avec branchement sur 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;
 }
 }
}

// Ajouter un tableau croisé dynamique à F3 avec le nom PivotTable1
const pivotIndex = worksheet.getPivotTables().add("A1:D9", "F3", "PivotTable1", true, false);
const pivotTable = worksheet.getPivotTables().get(pivotIndex);

// Disposition du tableau croisé : Category et Item en ligne, Year en colonne, Amount comme champ de données
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");

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() vous permet de basculer entre les agrégats disponibles, notamment Sum, Count, Average, Max, Min, Product, StdDev, StdDevp, Var et Varp.

La modification de la fonction de synthèse affecte uniquement l’agrégat, la colonne source ne change pas.

Vous pouvez donc laisser un champ de données avec 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.

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

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

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

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

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

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

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

pivotTable.calculateData();

workbook.save("output_function.xlsx");

Tracer les champs de valeur sur l’axe Ligne ou Colonne

Lorsqu’un tableau croisé dynamique contient au moins deux champs de données, 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 présent dans la zone de données. Vous pouvez le faire glisser dans la zone Ligne ou Colonne 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 seulement un.

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

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: 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 de commodité de haut niveau ou via la collection PageFields de bas niveau, et vous pouvez piloter le filtre en mode sélection unique, l’effacer pour afficher chaque élément de page, ou basculer le champ en sélection multiple afin que les utilisateurs puissent choisir plusieurs éléments de page à la fois via l’interface utilisateur à cases à cocher dans Excel.

Introduction

Un champ de filtre est un champ pivot qui contrôle quel sous-ensemble des données source le corps du tableau croisé dynamique affiche. Les utilisateurs finaux le voient comme une liste déroulante en haut d’un tableau croisé dynamique rendu dans Excel, et la sélection de l’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 résumés. Un champ pivot 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 de sélection unique, seul un élément de page est visible à la fois, de sorte que le corps du tableau croisé dynamique résume exactement un sous-ensemble. Dans le comportement de sélection multiple, le champ expose une liste de cases à cocher, et le corps du tableau croisé dynamique résume l’union de chaque élément de page coché. Le même champ source peut basculer entre ces comportements en activant/désactivant une seule propriété.

Aspose.Cells for Node.js via C++ expose deux façons équivalentes d’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.pageFields.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 remplir la même collection PageFields, et le reste de cet article démontre comment choisir entre elles et comment piloter chaque mode de filtrage.

Ajout d’un champ de filtre

Il existe deux façons d’enregistrer un champ pivot dans la zone de filtre. L’appel de haut niveau prend le nom de la colonne source sous forme de chaîne et constitue le chemin le plus courant. L’appel de bas niveau accepte une instance PivotField existante et est pratique lorsque le même objet champ doit être réutilisé dans plusieurs zones pivot. Les deux appels placent le champ dans PivotTable.pageFields, 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 / Année / Montant, place un tableau croisé dynamique à la cellule E3 avec Fruit dans la zone de ligne, Amount dans la zone de 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 pageFields.add

Lorsque vous travaillez déjà avec une instance PivotField, vous pouvez la transmettre directement à PivotTable.pageFields.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 de 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 élément de page)

Dans le comportement par défaut de sélection unique, le champ de filtre est rendu sous forme de liste déroulante unique et l’entier PivotField.currentPageItem sélectionne quel élément de page pilote le corps du tableau croisé dynamique. L’attribution d’un index spécifique sélectionne cet élément ; l’attribution de la sentinelle spéciale 0x7FFD (décimale 32765) efface le filtre afin que chaque élément de page soit résumé simultanément. La sélection unique est la valeur par défaut ; vous n’avez pas besoin de l’activer explicitement.

Affichage de tous les éléments

Définir currentPageItem sur la valeur magique 0x7FFD équivaut à effacer le filtre : le corps du tableau croisé dynamique résume chaque élément de page comme si aucun filtre n’était appliqué.

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

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]);
    }
}

// Créer un tableau croisé dynamique à E3
let pivotTables = sheet.getPivotTables();
let index = pivotTables.add("=A1:C7", "E3", "PivotTable1");
let pivotTable = pivotTables.get(index);

// Configurer les champs du tableau croisé : Fruit→Ligne, Amount→Données, Year→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 afin 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 la liste déroulante du champ de page d'Excel.
pivotTable.getPageFields().get(0).setCurrentPageItem(0x7FFD);

workbook.save("output.xlsx");

Affichage d’un élément spécifique

Définir currentPageItem sur un index réel ne sélectionne qu’un seul élément de page. L’index est la position de l’élément dans la liste triée des éléments du champ de filtre, donc 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").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");

// 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, Amount→Données, Year→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é, PivotItem.isHidden contrôle quels éléments apparaissent dans la liste de cases à cocher, de sorte que vous pouvez afficher chaque élément ou 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 montre deux modèles : 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()).

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

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

// — Activer la sélection multiple sur le champ de page
pivotTable.getPageFields().get(0).setIsMultipleItemSelectionAllowed(true);

// Partie A — sélectionner TOUS les éléments (rendre chaque élément visible)
let pivotItems = pivotTable.getPageFields().get(0).getPivotItems();
for (let i = 0; i < pivotItems.getCount(); i++) {
    pivotItems.get(i).setIsHidden(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).setIsHidden(false);
            break;
        default:
            pivotItems.get(i).setIsHidden(true);
            break;
    }
}

pivotTable.calculateData();

workbook.save("output.xlsx");

Remarque : Lors de l’utilisation du filtrage à sélection multiple via PivotItem.isHidden, au moins un PivotItem doit rester visible (isHidden == false). Si chaque élément est masqué, Excel se plante à l’ouverture du fichier ou affiche un tableau croisé dynamique vide. Vérifiez toujours que votre liste d’autorisation de 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 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 ceci sauf si vous avez besoin d’une référence `PivotField`.
Ajouter un champ de filtre lorsque vous avez déjà un objet `PivotField`	`PivotTable.pageFields.add(PivotField)`	n/a	À utiliser lorsque l’objet champ a été obtenu ailleurs ou doit être réutilisé.
Filtrer à 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 de la liste triée.
Afficher tous les éléments / effacer le filtre	`PivotField.currentPageItem`	défini sur `0x7FFD`	La valeur magique `0x7FFD` (décimale 32765) est la sentinelle pour « tous les éléments ».
Activer l’interface utilisateur de sélection multiple dans Excel	`PivotField.isMultipleItemSelectionAllowed`	défini sur `true`	Requis avant que les appels `isHidden` ne prennent 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`).

N’oubliez jamais la contrainte de visibilité lors de la configuration du filtrage à sélection multiple. Si chaque PivotItem dans un champ de filtre à sélection multiple est masqué, Excel se plante à l’ouverture ou affiche un tableau croisé dynamique vide. Construisez votre liste d’autorisation par rapport à 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.

Nodejscpp: Supprimer le tableau croisé dynamique d une feuille de calcul

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

Aspose.Cells for Node.js via C++ offre une fonctionnalité pour supprimer ou retirer un tableau croisé dynamique d’une feuille de calcul. Vous pouvez supprimer le tableau croisé dynamique en utilisant l’objet tableau croisé dynamique ou sa position. Veuillez utiliser la méthode Worksheet.getPivotTables().remove(pivotTable) pour supprimer le tableau croisé dynamique en utilisant l’objet tableau croisé dynamique et la méthode Worksheet.getPivotTables().removeAt(index, keepData) pour supprimer l’objet tableau croisé dynamique en utilisant sa position dans la collection.

Comment supprimer un tableau croisé dynamique d’une feuille de calcul en utilisant Aspose.Cells for Node.js via C++

Le code d’exemple suivant supprime deux tableaux croisés dynamiques de la feuille de calcul. D’abord, il supprime un tableau croisé dynamique en utilisant la méthode Worksheet.getPivotTables().remove(pivotTable) et ensuite il supprime un tableau croisé dynamique en utilisant la méthode Worksheet.getPivotTables().removeAt(index, keepData)

Nodejscpp: Enregistrer un tableau croisé dynamique dans un fichier ODS

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

Aspose.Cells for Node.js via C++ offre la possibilité d’enregistrer un tableau croisé dynamique en fichiers ODS. Pour cela, vous pouvez simplement convertir un classeur contenant un tableau croisé dynamique existant ou en créer un nouveau, puis sauvegarder le fichier au format ODS. Assurez-vous d’appeler PivotTable.calculateData avant de sauvegarder pour garantir que le tableau croisé dynamique est bien rendu dans le fichier ODS de sortie. Le code suivant montre comment sauvegarder un tableau croisé dynamique dans un fichier ODS.

Code d’exemple

Le fichier de sortie généré par le code ci-dessus est joint à titre de référence.

Fichier ODS de sortie

Documentation – Insérer un tableau croisé dynamique

Nodejscpp: Formatage du tableau croisé dynamique

Apparence du tableau croisé dynamique

Comment définir les options de formatage du tableau croisé dynamique

Comment définir le type de mise en forme automatique

Comment définir les options de mise en forme

Aspect et sensation du formatage manuel

Comment définir les options de format de champ de table de données

Comment définir le format des champs de lignes/colonnes/page

Comment définir le format des champs de données

Comment effacer les champs de table de données

Nodejscpp: Créer des tableaux croisés dynamiques et des graphiques croisés dynamiques

Ajouter des tableaux croisés dynamiques et des graphiques en utilisant Aspose.Cells for Node.js via C++

Préparer l’utilisation de Aspose.Cells for Node.js via C++

Comment ajouter un tableau croisé dynamique en utilisant Aspose.Cells for Node.js via C++

Comment ajouter un graphique croisé dynamique en utilisant la bibliothèque Aspose.Cells for Node.js via C++

Nodejscpp: Tableau croisé dynamique et données sources

Données source du tableau croisé dynamique

Modification des données source d’un tableau croisé dynamique

Nodejscpp: Ajouter un champ calculé dans le tableau croisé dynamique

Scénarios d’utilisation possibles

Comment ajouter un champ calculé dans un tableau croisé dynamique dans Excel

Comment ajouter un champ calculé dans un tableau croisé dynamique en utilisant la bibliothèque Aspose.Cells for Node.js via C++

Code d’exemple

Nodejscpp: Actualiser les tableaux croisés dynamiques dans Aspose.Cells for Node.js via C++

Introduction

Imports requis

Actualiser tous les tableaux croisés dynamiques dans le classeur

Actualiser tous les tableaux croisés dynamiques d’une seule feuille de calcul

Actualiser un seul tableau croisé dynamique

Les données source ont changé — Utilisez PivotCache.Refresh()

Seuls l’affichage/la mise en page ont changé — Utilisez CalculateData()

Obtenir tous les tableaux croisés dynamiques partageant le même PivotCache

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

Quelle API d’actualisation dois-je utiliser ?

Nodejscpp: Appliquer des styles aux tableaux croisés dynamiques dans Aspose.Cells pour .NET

Introduction

Apply a Legacy XLS Preset Autoformat

Apply a Modern Named Preset Pivot Table Style

Define and Apply a Custom Pivot Table Style

Apply One Style to Every Pivot Cell with FormatAll

Which Style API Should I Use?

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

Ajout d’un champ à la région de ligne ou de colonne

Sous-totaux des champs croisés

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

Nodejscpp: Gérer les champs de valeur d'un tableau croisé dynamique dans Aspose.Cells pour .NET

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

Modification de la fonction de synthèse

Tracer les champs de valeur sur l’axe Ligne ou Colonne

Nodejscpp: 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 pageFields.add

Filtrage à sélection unique (affichage d’un é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 ?

Nodejscpp: Supprimer le tableau croisé dynamique d une feuille de calcul

Comment supprimer un tableau croisé dynamique d’une feuille de calcul en utilisant Aspose.Cells for Node.js via C++

Nodejscpp: Enregistrer un tableau croisé dynamique dans un fichier ODS

Code d’exemple

Les données source ont changé — Utilisez `PivotCache.Refresh()`

Seuls l’affichage/la mise en page ont changé — Utilisez `CalculateData()`

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