exceljs
v4.4.0
Lisez, manipulez et écrivez des données et des styles de feuilles de calcul au format XLSX et JSON.
Rétro-ingénierie à partir de fichiers de feuilles de calcul Excel en tant que projet.
npm install exceljsLes contributions sont les bienvenues ! Cela m'aide à savoir quelles fonctionnalités sont souhaitées ou quels bugs causent le plus de problèmes.
J'ai juste une demande ; Si vous soumettez une pull request pour un correctif de bug, veuillez ajouter un test unitaire ou un test d'intégration (dans le dossier spec) qui détecte le problème. Même un PR dont le test échoue est très bien - je peux analyser ce que fait le test et corriger le code à partir de cela.
Remarque : Veuillez essayer d'éviter de modifier la version du package dans un PR. Les versions sont mises à jour lors de leur sortie et toute modification entraînera très probablement des collisions de fusion.
Pour être clair, toutes les contributions ajoutées à cette bibliothèque seront incluses dans la licence MIT de la bibliothèque.
const ExcelJS = require ( 'exceljs' ) ; Pour utiliser le code transpilé ES5, par exemple pour les versions node.js antérieures à 10, utilisez le chemin dist/es5.
const ExcelJS = require ( 'exceljs/dist/es5' ) ;Remarque : La version ES5 a une dépendance implicite sur un certain nombre de polyfills qui ne sont plus explicitement ajoutés par Exceljs. Vous devrez ajouter "core-js" et "regenerator-runtime" à vos dépendances et inclure les exigences suivantes dans votre code avant l'importation Exceljs :
// polyfills required by exceljs
require ( 'core-js/modules/es.promise' ) ;
require ( 'core-js/modules/es.string.includes' ) ;
require ( 'core-js/modules/es.object.assign' ) ;
require ( 'core-js/modules/es.object.keys' ) ;
require ( 'core-js/modules/es.symbol' ) ;
require ( 'core-js/modules/es.symbol.async-iterator' ) ;
require ( 'regenerator-runtime/runtime' ) ;
const ExcelJS = require ( 'exceljs/dist/es5' ) ;Pour IE 11, vous aurez également besoin d'un polyfill pour prendre en charge les modèles d'expressions régulières Unicode. Par exemple,
const rewritePattern = require ( 'regexpu-core' ) ;
const { generateRegexpuOptions } = require ( '@babel/helper-create-regexp-features-plugin/lib/util' ) ;
const { RegExp } = global ;
try {
new RegExp ( 'a' , 'u' ) ;
} catch ( err ) {
global . RegExp = function ( pattern , flags ) {
if ( flags && flags . includes ( 'u' ) ) {
return new RegExp ( rewritePattern ( pattern , flags , generateRegexpuOptions ( { flags , pattern } ) ) ) ;
}
return new RegExp ( pattern , flags ) ;
} ;
global . RegExp . prototype = RegExp . prototype ;
} ExcelJS publie deux bundles navigateurs dans le dossier dist/ :
Un avec des dépendances implicites sur les polyfills core-js...
< script src =" https://cdnjs.cloudflare.com/ajax/libs/babel-polyfill/6.26.0/polyfill.js " > </ script >
< script src =" exceljs.js " > </ script >Et un sans...
< script src =" --your-project's-pollyfills-here-- " > </ script >
< script src =" exceljs.bare.js " > </ script > const workbook = new ExcelJS . Workbook ( ) ; workbook . creator = 'Me' ;
workbook . lastModifiedBy = 'Her' ;
workbook . created = new Date ( 1985 , 8 , 30 ) ;
workbook . modified = new Date ( ) ;
workbook . lastPrinted = new Date ( 2016 , 9 , 27 ) ; // Set workbook dates to 1904 date system
workbook . properties . date1904 = true ; // Force workbook calculation on load
workbook . calcProperties . fullCalcOnLoad = true ; Les vues Classeur contrôlent le nombre de fenêtres distinctes qu'Excel ouvrira lors de l'affichage du classeur.
workbook . views = [
{
x : 0 , y : 0 , width : 10000 , height : 20000 ,
firstSheet : 0 , activeTab : 1 , visibility : 'visible'
}
] const sheet = workbook . addWorksheet ( 'My Sheet' ) ;Utilisez le deuxième paramètre de la fonction addWorksheet pour spécifier les options de la feuille de calcul.
Par exemple:
// create a sheet with red tab colour
const sheet = workbook . addWorksheet ( 'My Sheet' , { properties : { tabColor : { argb : 'FFC0000' } } } ) ;
// create a sheet where the grid lines are hidden
const sheet = workbook . addWorksheet ( 'My Sheet' , { views : [ { showGridLines : false } ] } ) ;
// create a sheet with the first row and column frozen
const sheet = workbook . addWorksheet ( 'My Sheet' , { views : [ { state : 'frozen' , xSplit : 1 , ySplit : 1 } ] } ) ;
// Create worksheets with headers and footers
const sheet = workbook . addWorksheet ( 'My Sheet' , {
headerFooter : { firstHeader : "Hello Exceljs" , firstFooter : "Hello World" }
} ) ;
// create new sheet with pageSetup settings for A4 - landscape
const worksheet = workbook . addWorksheet ( 'My Sheet' , {
pageSetup : { paperSize : 9 , orientation : 'landscape' }
} ) ; Utilisez l' id de la feuille de calcul pour supprimer la feuille du classeur.
Par exemple:
// Create a worksheet
const sheet = workbook . addWorksheet ( 'My Sheet' ) ;
// Remove the worksheet using worksheet id
workbook . removeWorksheet ( sheet . id ) // Iterate over all sheets
// Note: workbook.worksheets.forEach will still work but this is better
workbook . eachSheet ( function ( worksheet , sheetId ) {
// ...
} ) ;
// fetch sheet by name
const worksheet = workbook . getWorksheet ( 'My Sheet' ) ;
// fetch sheet by id
// INFO: Be careful when using it!
// It tries to access to `worksheet.id` field. Sometimes (really very often) workbook has worksheets with id not starting from 1.
// For instance It happens when any worksheet has been deleted.
// It's much more safety when you assume that ids are random. And stop to use this function.
// If you need to access all worksheets in a loop please look to the next example.
const worksheet = workbook . getWorksheet ( 1 ) ;
// access by `worksheets` array:
workbook . worksheets [ 0 ] ; //the first one; Il est important de savoir que workbook.getWorksheet(1) != Workbook.worksheets[0] et workbook.getWorksheet(1) != Workbook.worksheets[1] , car workbook.worksheets[0].id peut avoir n'importe quelle valeur.
// make worksheet visible
worksheet . state = 'visible' ;
// make worksheet hidden
worksheet . state = 'hidden' ;
// make worksheet hidden from 'hide/unhide' dialog
worksheet . state = 'veryHidden' ; Les feuilles de calcul prennent en charge un compartiment de propriétés pour permettre le contrôle de certaines fonctionnalités de la feuille de calcul.
// create new sheet with properties
const worksheet = workbook . addWorksheet ( 'sheet' , { properties : { tabColor : { argb : 'FF00FF00' } } } ) ;
// create a new sheet writer with properties
const worksheetWriter = workbookWriter . addWorksheet ( 'sheet' , { properties : { outlineLevelCol : 1 } } ) ;
// adjust properties afterwards (not supported by worksheet-writer)
worksheet . properties . outlineLevelCol = 2 ;
worksheet . properties . defaultRowHeight = 15 ;Propriétés prises en charge
| Nom | Défaut | Description |
|---|---|---|
| ongletCouleur | indéfini | Couleur des onglets |
| contourNiveauCol | 0 | Le niveau hiérarchique des colonnes de la feuille de calcul |
| contourNiveauRow | 0 | Le niveau de plan des lignes de la feuille de calcul |
| hauteur de ligne par défaut | 15 | Hauteur de ligne par défaut |
| largeurColpar défaut | (facultatif) | Largeur de colonne par défaut |
| dyDescente | 55 | À déterminer |
De nouvelles mesures ont été ajoutées à la feuille de calcul...
| Nom | Description |
|---|---|
| nombre de lignes | Taille totale des lignes du document. Égal au numéro de ligne de la dernière ligne contenant des valeurs. |
| nombre de lignes réel | Nombre de lignes contenant des valeurs. Si une ligne au milieu du document est vide, elle ne sera pas incluse dans le décompte. |
| nombre de colonnes | La taille totale des colonnes du document. Égal au nombre maximal de cellules de toutes les lignes |
| nombre de colonnes réel | Nombre de colonnes contenant des valeurs. |
Toutes les propriétés pouvant affecter l'impression d'une feuille sont conservées dans un objet pageSetup sur la feuille.
// create new sheet with pageSetup settings for A4 - landscape
const worksheet = workbook . addWorksheet ( 'sheet' , {
pageSetup : { paperSize : 9 , orientation : 'landscape' }
} ) ;
// create a new sheet writer with pageSetup settings for fit-to-page
const worksheetWriter = workbookWriter . addWorksheet ( 'sheet' , {
pageSetup : { fitToPage : true , fitToHeight : 5 , fitToWidth : 7 }
} ) ;
// adjust pageSetup settings afterwards
worksheet . pageSetup . margins = {
left : 0.7 , right : 0.7 ,
top : 0.75 , bottom : 0.75 ,
header : 0.3 , footer : 0.3
} ;
// Set Print Area for a sheet
worksheet . pageSetup . printArea = 'A1:G20' ;
// Set multiple Print Areas by separating print areas with '&&'
worksheet . pageSetup . printArea = 'A1:G10&&A11:G20' ;
// Repeat specific rows on every printed page
worksheet . pageSetup . printTitlesRow = '1:3' ;
// Repeat specific columns on every printed page
worksheet . pageSetup . printTitlesColumn = 'A:C' ;Paramètres de configuration de page pris en charge
| Nom | Défaut | Description |
|---|---|---|
| marges | Espace blanc sur les bordures de la page. Les unités sont en pouces. | |
| orientation | 'portrait' | Orientation de la page - c'est-à-dire plus haute (portrait) ou plus large (paysage) |
| horizontalDpi | 4294967295 | Points horizontaux par pouce. La valeur par défaut est -1 |
| verticalDpi | 4294967295 | Points verticaux par pouce. La valeur par défaut est -1 |
| ajuster à la page | S'il faut utiliser fitToWidth et fitToHeight ou les paramètres d'échelle. La valeur par défaut est basée sur la présence de ces paramètres dans l'objet pageSetup - si les deux sont présents, l'échelle l'emporte (c'est-à-dire que la valeur par défaut sera fausse) | |
| pageCommande | 'vers le basPuisPlus' | Quel ordre imprimer les pages - l'un des ['downThenOver', 'overThenDown'] |
| noirEtBlanc | FAUX | Imprimer sans couleur |
| brouillon | FAUX | Imprimer avec moins de qualité (et d'encre) |
| celluleCommentaires | 'Aucun' | Où placer les commentaires : un des ['atEnd', 'asDisplayed', 'None'] |
| erreurs | 'affiché' | Où afficher les erreurs - l'un des ['tiret', 'vide', 'NA', 'affiché'] |
| échelle | 100 | Valeur en pourcentage pour augmenter ou réduire la taille de l’impression. Actif lorsque fitToPage est faux |
| ajuster à la largeur | 1 | Sur quelle largeur de pages la feuille doit-elle être imprimée. Actif lorsque fitToPage est vrai |
| ajuster à la hauteur | 1 | Sur quelle hauteur de pages la feuille doit-elle être imprimée. Actif lorsque fitToPage est vrai |
| Taille du papier | Quel format de papier utiliser (voir ci-dessous) | |
| showRowColHeaders | FAUX | S'il faut afficher les numéros de ligne et les lettres de colonne |
| showGridLines | FAUX | S'il faut afficher les lignes de quadrillage |
| premier numéro de page | Quel numéro utiliser pour la première page | |
| horizontalCentré | FAUX | S'il faut centrer les données de la feuille horizontalement |
| verticalCentré | FAUX | S'il faut centrer les données de la feuille verticalement |
Exemples de formats de papier
| Nom | Valeur |
|---|---|
| Lettre | indéfini |
| Légal | 5 |
| Exécutif | 7 |
| A3 | 8 |
| A4 | 9 |
| A5 | 11 |
| B5 (JIS) | 13 |
| Enveloppe #10 | 20 |
| Enveloppe DL | 27 |
| Enveloppe C5 | 28 |
| Enveloppe B5 | 34 |
| Enveloppe Monarque | 37 |
| Double carte postale japonaise tournée | 82 |
| 16K 197x273mm | 119 |
Voici comment ajouter des en-têtes et des pieds de page. Le contenu ajouté est principalement du texte, tel que l'heure, l'introduction, les informations sur le fichier, etc., et vous pouvez définir le style du texte. De plus, vous pouvez définir des textes différents pour la première page et même la page.
Remarque : Les images ne sont actuellement pas prises en charge.
// Create worksheets with headers and footers
var sheet = workbook . addWorksheet ( 'sheet' , {
headerFooter : { firstHeader : "Hello Exceljs" , firstFooter : "Hello World" }
} ) ;
// Create worksheets with headers and footers
var worksheetWriter = workbookWriter . addWorksheet ( 'sheet' , {
headerFooter : { firstHeader : "Hello Exceljs" , firstFooter : "Hello World" }
} ) ;
// Set footer (default centered), result: "Page 2 of 16"
worksheet . headerFooter . oddFooter = "Page &P of &N" ;
// Set the footer (default centered) to bold, resulting in: "Page 2 of 16"
worksheet . headerFooter . oddFooter = "Page &P of &N" ;
// Set the left footer to 18px and italicize. Result: "Page 2 of 16"
worksheet . headerFooter . oddFooter = "&LPage &P of &N" ;
// Set the middle header to gray Aril, the result: "52 exceljs"
worksheet . headerFooter . oddHeader = "&C&KCCCCCC&"Aril"52 exceljs" ;
// Set the left, center, and right text of the footer. Result: “Exceljs” in the footer left. “demo.xlsx” in the footer center. “Page 2” in the footer right
worksheet . headerFooter . oddFooter = "&Lexceljs&C&F&RPage &P" ;
// Add different header & footer for the first page
worksheet . headerFooter . differentFirst = true ;
worksheet . headerFooter . firstHeader = "Hello Exceljs" ;
worksheet . headerFooter . firstFooter = "Hello World"Paramètres d'en-tête et de pied de page pris en charge
| Nom | Défaut | Description |
|---|---|---|
| différentPremier | FAUX | Définissez la valeur de differentFirst sur true, ce qui indique que les en-têtes/pieds de page de la première page sont différents des autres pages. |
| différentOddPair | FAUX | Définissez la valeur de differentOddEven sur true, ce qui indique que les en-têtes/pieds de page des pages paires et impaires sont différents |
| en-tête impair | nul | Définir la chaîne d'en-tête pour les pages impaires (par défaut), pourrait formater la chaîne |
| pied de page impair | nul | Définir une chaîne de pied de page pour les pages impaires (par défaut), pourrait formater la chaîne |
| mêmeEn-tête | nul | Définir une chaîne d'en-tête pour les pages paires, pourrait formater la chaîne |
| mêmepied de page | nul | Définir une chaîne de pied de page pour les pages paires, pourrait formater la chaîne |
| premierEn-tête | nul | Définir la chaîne d'en-tête pour la première page, pourrait formater la chaîne |
| premierpied de page | nul | Définir une chaîne de pied de page pour la première page, pourrait formater la chaîne |
Commandes de script
| Commandes | Description |
|---|---|
| &L | Définir la position vers la gauche |
| &C | Régler la position au centre |
| &R | Définir la position vers la droite |
| &P | Le numéro de la page actuelle |
| &N | Le nombre total de pages |
| &D | La date actuelle |
| &T | L'heure actuelle |
| &G | Une photo |
| &UN | Le nom de la feuille de calcul |
| &F | Le nom du fichier |
| &B | Mettre le texte en gras |
| &JE | Mettre le texte en italique |
| &U | Souligner le texte |
| &"nom de la police" | nom de la police, par exemple & "Aril" |
| &taille de police | taille de police, par exemple 12 |
| &KHEXCode | couleur de police, par exemple &KCCCCCC |
Les feuilles de calcul prennent désormais en charge une liste de vues qui contrôlent la façon dont Excel présente la feuille :
Chaque vue prend également en charge diverses propriétés :
| Nom | Défaut | Description |
|---|---|---|
| État | 'normale' | Contrôle l'état d'affichage : normal, gelé ou divisé. |
| droiteÀGauche | FAUX | Définit l'orientation de la vue de la feuille de calcul de droite à gauche |
| cellule active | indéfini | La cellule actuellement sélectionnée |
| showRègle | vrai | Affiche ou masque la règle dans la mise en page |
| showRowColHeaders | vrai | Affiche ou masque les en-têtes de lignes et de colonnes (par exemple A1, B1 en haut et 1,2,3 à gauche |
| showGridLines | vrai | Affiche ou masque le quadrillage (affiché pour les cellules où les bordures n'ont pas été définies) |
| zoomÉchelle | 100 | Zoom en pourcentage à utiliser pour la vue |
| zoomÉchelleNormal | 100 | Zoom normal pour la vue |
| style | indéfini | Style de présentation : pageBreakPreview ou pageLayout. Remarque pageLayout n'est pas compatible avec les vues gelées |
Les vues gelées prennent en charge les propriétés supplémentaires suivantes :
| Nom | Défaut | Description |
|---|---|---|
| xSplit | 0 | Combien de colonnes geler. Pour geler uniquement les lignes, définissez-le sur 0 ou sur undefined |
| ySplit | 0 | Combien de lignes geler. Pour geler uniquement les colonnes, définissez-le sur 0 ou sur undefined |
| cellule supérieuregauche | spécial | Quelle cellule sera en haut à gauche dans le volet inférieur droit. Remarque : il ne peut pas s'agir d'une cellule gelée. Par défaut, la première cellule non gelée |
worksheet . views = [
{ state : 'frozen' , xSplit : 2 , ySplit : 3 , topLeftCell : 'G10' , activeCell : 'A1' }
] ;Les vues fractionnées prennent en charge les propriétés supplémentaires suivantes :
| Nom | Défaut | Description |
|---|---|---|
| xSplit | 0 | Combien de points à partir de la gauche pour placer le séparateur. Pour diviser verticalement, définissez-le sur 0 ou non défini |
| ySplit | 0 | Combien de points à partir du haut pour placer le séparateur. Pour diviser horizontalement, définissez-le sur 0 ou non défini |
| cellule supérieuregauche | indéfini | Quelle cellule sera en haut à gauche dans le volet inférieur droit. |
| volet actif | indéfini | Quel volet sera actif : topLeft, topRight, bottomLeft et bottomRight ? |
worksheet . views = [
{ state : 'split' , xSplit : 2000 , ySplit : 3000 , topLeftCell : 'G10' , activeCell : 'A1' }
] ; Il est possible d'appliquer un filtre automatique à votre feuille de calcul.
worksheet . autoFilter = 'A1:C1' ;Bien que la chaîne de plage soit la forme standard du filtre automatique, la feuille de calcul prendra également en charge les valeurs suivantes :
// Set an auto filter from A1 to C1
worksheet . autoFilter = {
from : 'A1' ,
to : 'C1' ,
}
// Set an auto filter from the cell in row 3 and column 1
// to the cell in row 5 and column 12
worksheet . autoFilter = {
from : {
row : 3 ,
column : 1
} ,
to : {
row : 5 ,
column : 12
}
}
// Set an auto filter from D3 to the
// cell in row 7 and column 5
worksheet . autoFilter = {
from : 'D3' ,
to : {
row : 7 ,
column : 5
}
} // Add column headers and define column keys and widths
// Note: these column structures are a workbook-building convenience only,
// apart from the column width, they will not be fully persisted.
worksheet . columns = [
{ header : 'Id' , key : 'id' , width : 10 } ,
{ header : 'Name' , key : 'name' , width : 32 } ,
{ header : 'D.O.B.' , key : 'DOB' , width : 10 , outlineLevel : 1 }
] ;
// Access an individual columns by key, letter and 1-based column number
const idCol = worksheet . getColumn ( 'id' ) ;
const nameCol = worksheet . getColumn ( 'B' ) ;
const dobCol = worksheet . getColumn ( 3 ) ;
// set column properties
// Note: will overwrite cell value C1
dobCol . header = 'Date of Birth' ;
// Note: this will overwrite cell values C1:C2
dobCol . header = [ 'Date of Birth' , 'A.K.A. D.O.B.' ] ;
// from this point on, this column will be indexed by 'dob' and not 'DOB'
dobCol . key = 'dob' ;
dobCol . width = 15 ;
// Hide the column if you'd like
dobCol . hidden = true ;
// set an outline level for columns
worksheet . getColumn ( 4 ) . outlineLevel = 0 ;
worksheet . getColumn ( 5 ) . outlineLevel = 1 ;
// columns support a readonly field to indicate the collapsed state based on outlineLevel
expect ( worksheet . getColumn ( 4 ) . collapsed ) . to . equal ( false ) ;
expect ( worksheet . getColumn ( 5 ) . collapsed ) . to . equal ( true ) ;
// iterate over all current cells in this column
dobCol . eachCell ( function ( cell , rowNumber ) {
// ...
} ) ;
// iterate over all current cells in this column including empty cells
dobCol . eachCell ( { includeEmpty : true } , function ( cell , rowNumber ) {
// ...
} ) ;
// add a column of new values
worksheet . getColumn ( 6 ) . values = [ 1 , 2 , 3 , 4 , 5 ] ;
// add a sparse column of values
worksheet . getColumn ( 7 ) . values = [ , , 2 , 3 , , 5 , , 7 , , , , 11 ] ;
// cut one or more columns (columns to the right are shifted left)
// If column properties have been defined, they will be cut or moved accordingly
// Known Issue: If a splice causes any merged cells to move, the results may be unpredictable
worksheet . spliceColumns ( 3 , 2 ) ;
// remove one column and insert two more.
// Note: columns 4 and above will be shifted right by 1 column.
// Also: If the worksheet has more rows than values in the column inserts,
// the rows will still be shifted as if the values existed
const newCol3Values = [ 1 , 2 , 3 , 4 , 5 ] ;
const newCol4Values = [ 'one' , 'two' , 'three' , 'four' , 'five' ] ;
worksheet . spliceColumns ( 3 , 1 , newCol3Values , newCol4Values ) ; // Get a row object. If it doesn't already exist, a new empty one will be returned
const row = worksheet . getRow ( 5 ) ;
// Get multiple row objects. If it doesn't already exist, new empty ones will be returned
const rows = worksheet . getRows ( 5 , 2 ) ; // start, length (>0, else undefined is returned)
// Get the last editable row in a worksheet (or undefined if there are none)
const row = worksheet . lastRow ;
// Set a specific row height
row . height = 42.5 ;
// make row hidden
row . hidden = true ;
// set an outline level for rows
worksheet . getRow ( 4 ) . outlineLevel = 0 ;
worksheet . getRow ( 5 ) . outlineLevel = 1 ;
// rows support a readonly field to indicate the collapsed state based on outlineLevel
expect ( worksheet . getRow ( 4 ) . collapsed ) . to . equal ( false ) ;
expect ( worksheet . getRow ( 5 ) . collapsed ) . to . equal ( true ) ;
row . getCell ( 1 ) . value = 5 ; // A5's value set to 5
row . getCell ( 'name' ) . value = 'Zeb' ; // B5's value set to 'Zeb' - assuming column 2 is still keyed by name
row . getCell ( 'C' ) . value = new Date ( ) ; // C5's value set to now
// Get a row as a sparse array
// Note: interface change: worksheet.getRow(4) ==> worksheet.getRow(4).values
row = worksheet . getRow ( 4 ) . values ;
expect ( row [ 5 ] ) . toEqual ( 'Kyle' ) ;
// assign row values by contiguous array (where array element 0 has a value)
row . values = [ 1 , 2 , 3 ] ;
expect ( row . getCell ( 1 ) . value ) . toEqual ( 1 ) ;
expect ( row . getCell ( 2 ) . value ) . toEqual ( 2 ) ;
expect ( row . getCell ( 3 ) . value ) . toEqual ( 3 ) ;
// assign row values by sparse array (where array element 0 is undefined)
const values = [ ]
values [ 5 ] = 7 ;
values [ 10 ] = 'Hello, World!' ;
row . values = values ;
expect ( row . getCell ( 1 ) . value ) . toBeNull ( ) ;
expect ( row . getCell ( 5 ) . value ) . toEqual ( 7 ) ;
expect ( row . getCell ( 10 ) . value ) . toEqual ( 'Hello, World!' ) ;
// assign row values by object, using column keys
row . values = {
id : 13 ,
name : 'Thing 1' ,
dob : new Date ( )
} ;
// Insert a page break below the row
row . addPageBreak ( ) ;
// Iterate over all rows that have values in a worksheet
worksheet . eachRow ( function ( row , rowNumber ) {
console . log ( 'Row ' + rowNumber + ' = ' + JSON . stringify ( row . values ) ) ;
} ) ;
// Iterate over all rows (including empty rows) in a worksheet
worksheet . eachRow ( { includeEmpty : true } , function ( row , rowNumber ) {
console . log ( 'Row ' + rowNumber + ' = ' + JSON . stringify ( row . values ) ) ;
} ) ;
// Iterate over all non-null cells in a row
row . eachCell ( function ( cell , colNumber ) {
console . log ( 'Cell ' + colNumber + ' = ' + cell . value ) ;
} ) ;
// Iterate over all cells in a row (including empty cells)
row . eachCell ( { includeEmpty : true } , function ( cell , colNumber ) {
console . log ( 'Cell ' + colNumber + ' = ' + cell . value ) ;
} ) ;
// Commit a completed row to stream
row . commit ( ) ;
// row metrics
const rowSize = row . cellCount ;
const numValues = row . actualCellCount ; // Add a couple of Rows by key-value, after the last current row, using the column keys
worksheet . addRow ( { id : 1 , name : 'John Doe' , dob : new Date ( 1970 , 1 , 1 ) } ) ;
worksheet . addRow ( { id : 2 , name : 'Jane Doe' , dob : new Date ( 1965 , 1 , 7 ) } ) ;
// Add a row by contiguous Array (assign to columns A, B & C)
worksheet . addRow ( [ 3 , 'Sam' , new Date ( ) ] ) ;
// Add a row by sparse Array (assign to columns A, E & I)
const rowValues = [ ] ;
rowValues [ 1 ] = 4 ;
rowValues [ 5 ] = 'Kyle' ;
rowValues [ 9 ] = new Date ( ) ;
worksheet . addRow ( rowValues ) ;
// Add a row with inherited style
// This new row will have same style as last row
// And return as row object
const newRow = worksheet . addRow ( rowValues , 'i' ) ;
// Add an array of rows
const rows = [
[ 5 , 'Bob' , new Date ( ) ] , // row by array
{ id : 6 , name : 'Barbara' , dob : new Date ( ) }
] ;
// add new rows and return them as array of row objects
const newRows = worksheet . addRows ( rows ) ;
// Add an array of rows with inherited style
// These new rows will have same styles as last row
// and return them as array of row objects
const newRowsStyled = worksheet . addRows ( rows , 'i' ) ;| Paramètre | Description | Valeur par défaut |
|---|---|---|
| valeurs | Les nouvelles valeurs de ligne | |
| style | 'i' pour hériter de la ligne ci-dessus, 'i+' pour inclure des cellules vides, 'n' pour aucune | 'n' |
const cell = worksheet . getCell ( 'C3' ) ;
// Modify/Add individual cell
cell . value = new Date ( 1968 , 5 , 1 ) ;
// query a cell's type
expect ( cell . type ) . toEqual ( Excel . ValueType . Date ) ;
// use string value of cell
myInput . value = cell . text ;
// use html-safe string for rendering...
const html = '<div>' + cell . html + '</div>' ; // merge a range of cells
worksheet . mergeCells ( 'A4:B5' ) ;
// ... merged cells are linked
worksheet . getCell ( 'B5' ) . value = 'Hello, World!' ;
expect ( worksheet . getCell ( 'B5' ) . value ) . toBe ( worksheet . getCell ( 'A4' ) . value ) ;
expect ( worksheet . getCell ( 'B5' ) . master ) . toBe ( worksheet . getCell ( 'A4' ) ) ;
// ... merged cells share the same style object
expect ( worksheet . getCell ( 'B5' ) . style ) . toBe ( worksheet . getCell ( 'A4' ) . style ) ;
worksheet . getCell ( 'B5' ) . style . font = myFonts . arial ;
expect ( worksheet . getCell ( 'A4' ) . style . font ) . toBe ( myFonts . arial ) ;
// unmerging the cells breaks the style links
worksheet . unMergeCells ( 'A4' ) ;
expect ( worksheet . getCell ( 'B5' ) . style ) . not . toBe ( worksheet . getCell ( 'A4' ) . style ) ;
expect ( worksheet . getCell ( 'B5' ) . style . font ) . not . toBe ( myFonts . arial ) ;
// merge by top-left, bottom-right
worksheet . mergeCells ( 'K10' , 'M12' ) ;
// merge by start row, start column, end row, end column (equivalent to K10:M12)
worksheet . mergeCells ( 10 , 11 , 12 , 13 ) ; insertRow ( pos , value , style = 'n' )
insertRows ( pos , values , style = 'n' )
// Insert a couple of Rows by key-value, shifting down rows every time
worksheet . insertRow ( 1 , { id : 1 , name : 'John Doe' , dob : new Date ( 1970 , 1 , 1 ) } ) ;
worksheet . insertRow ( 1 , { id : 2 , name : 'Jane Doe' , dob : new Date ( 1965 , 1 , 7 ) } ) ;
// Insert a row by contiguous Array (assign to columns A, B & C)
worksheet . insertRow ( 1 , [ 3 , 'Sam' , new Date ( ) ] ) ;
// Insert a row by sparse Array (assign to columns A, E & I)
var rowValues = [ ] ;
rowValues [ 1 ] = 4 ;
rowValues [ 5 ] = 'Kyle' ;
rowValues [ 9 ] = new Date ( ) ;
// insert new row and return as row object
const insertedRow = worksheet . insertRow ( 1 , rowValues ) ;
// Insert a row, with inherited style
// This new row will have same style as row on top of it
// And return as row object
const insertedRowInherited = worksheet . insertRow ( 1 , rowValues , 'i' ) ;
// Insert a row, keeping original style
// This new row will have same style as it was previously
// And return as row object
const insertedRowOriginal = worksheet . insertRow ( 1 , rowValues , 'o' ) ;
// Insert an array of rows, in position 1, shifting down current position 1 and later rows by 2 rows
var rows = [
[ 5 , 'Bob' , new Date ( ) ] , // row by array
{ id : 6 , name : 'Barbara' , dob : new Date ( ) }
] ;
// insert new rows and return them as array of row objects
const insertedRows = worksheet . insertRows ( 1 , rows ) ;
// Insert an array of rows, with inherited style
// These new rows will have same style as row on top of it
// And return them as array of row objects
const insertedRowsInherited = worksheet . insertRows ( 1 , rows , 'i' ) ;
// Insert an array of rows, keeping original style
// These new rows will have same style as it was previously in 'pos' position
const insertedRowsOriginal = worksheet . insertRows ( 1 , rows , 'o' ) ;| Paramètre | Description | Valeur par défaut |
|---|---|---|
| position | Numéro de ligne où vous souhaitez insérer, en poussant toutes les lignes vers le bas | |
| valeurs | Les nouvelles valeurs de ligne | |
| style | 'i' pour hériter de la ligne ci-dessus, 'i+' pour inclure des cellules vides, 'o' pour le style d'origine, 'o+' pour inclure des cellules vides, 'n' pour aucune | 'n' |
// Cut one or more rows (rows below are shifted up)
// Known Issue: If a splice causes any merged cells to move, the results may be unpredictable
worksheet . spliceRows ( 4 , 3 ) ;
// remove one row and insert two more.
// Note: rows 4 and below will be shifted down by 1 row.
const newRow3Values = [ 1 , 2 , 3 , 4 , 5 ] ;
const newRow4Values = [ 'one' , 'two' , 'three' , 'four' , 'five' ] ;
worksheet . spliceRows ( 3 , 1 , newRow3Values , newRow4Values ) ;
// Cut one or more cells (cells to the right are shifted left)
// Note: this operation will not affect other rows
row . splice ( 3 , 2 ) ;
// remove one cell and insert two more (cells to the right of the cut cell will be shifted right)
row . splice ( 4 , 1 , 'new value 1' , 'new value 2' ) ;| Paramètre | Description | Valeur par défaut |
|---|---|---|
| commencer | Point de départ à partir duquel effectuer l'épissage | |
| compter | Nombre de lignes/cellules à supprimer | |
| ...inserts | Nouvelles valeurs de ligne/cellule à insérer |
duplicateRow ( start , amount = 1 , insert = true )
const wb = new ExcelJS . Workbook ( ) ;
const ws = wb . addWorksheet ( 'duplicateTest' ) ;
ws . getCell ( 'A1' ) . value = 'One' ;
ws . getCell ( 'A2' ) . value = 'Two' ;
ws . getCell ( 'A3' ) . value = 'Three' ;
ws . getCell ( 'A4' ) . value = 'Four' ;
// This line will duplicate the row 'One' twice but it will replace rows 'Two' and 'Three'
// if third param was true so it would insert 2 new rows with the values and styles of row 'One'
ws . duplicateRow ( 1 , 2 , false ) ;| Paramètre | Description | Valeur par défaut |
|---|---|---|
| commencer | Numéro de ligne que vous souhaitez dupliquer (le premier dans Excel est 1) | |
| montant | Les fois où vous souhaitez dupliquer la ligne | 1 |
| insérer | true si vous souhaitez insérer de nouvelles lignes pour les doublons, ou false si vous souhaitez les remplacer | vrai |
Des cellules individuelles (ou plusieurs groupes de cellules) peuvent se voir attribuer des noms. Les noms peuvent être utilisés dans les formules et la validation des données (et probablement plus).
// assign (or get) a name for a cell (will overwrite any other names that cell had)
worksheet . getCell ( 'A1' ) . name = 'PI' ;
expect ( worksheet . getCell ( 'A1' ) . name ) . to . equal ( 'PI' ) ;
// assign (or get) an array of names for a cell (cells can have more than one name)
worksheet . getCell ( 'A1' ) . names = [ 'thing1' , 'thing2' ] ;
expect ( worksheet . getCell ( 'A1' ) . names ) . to . have . members ( [ 'thing1' , 'thing2' ] ) ;
// remove a name from a cell
worksheet . getCell ( 'A1' ) . removeName ( 'thing1' ) ;
expect ( worksheet . getCell ( 'A1' ) . names ) . to . have . members ( [ 'thing2' ] ) ; Les cellules peuvent définir quelles valeurs sont valides ou non et fournir des invites à l'utilisateur pour l'aider à les guider.
Les types de validation peuvent être l’un des suivants :
| Taper | Description |
|---|---|
| liste | Définissez un ensemble discret de valeurs valides. Excel les proposera dans une liste déroulante pour une saisie facile |
| entier | La valeur doit être un nombre entier |
| décimal | La valeur doit être un nombre décimal |
| longueur du texte | La valeur peut être du texte mais la longueur est contrôlée |
| coutume | Une formule personnalisée contrôle les valeurs valides |
Pour les types autres que liste ou personnalisé, les opérateurs suivants affectent la validation :
| Opérateur | Description |
|---|---|
| entre | Les valeurs doivent se situer entre les résultats de la formule |
| pasEntre | Les valeurs ne doivent pas se situer entre les résultats de la formule |
| égal | La valeur doit être égale au résultat de la formule |
| pasÉgal | La valeur ne doit pas être égale au résultat de la formule |
| supérieur à | La valeur doit être supérieure au résultat de la formule |
| moins que | La valeur doit être inférieure au résultat de la formule |
| supérieur à ou égal | La valeur doit être supérieure ou égale au résultat de la formule |
| moins que ou égal | La valeur doit être inférieure ou égale au résultat de la formule |
// Specify list of valid values (One, Two, Three, Four).
// Excel will provide a dropdown with these values.
worksheet . getCell ( 'A1' ) . dataValidation = {
type : 'list' ,
allowBlank : true ,
formulae : [ '"One,Two,Three,Four"' ]
} ;
// Specify list of valid values from a range.
// Excel will provide a dropdown with these values.
worksheet . getCell ( 'A1' ) . dataValidation = {
type : 'list' ,
allowBlank : true ,
formulae : [ '$D$5:$F$5' ]
} ;
// Specify Cell must be a whole number that is not 5.
// Show the user an appropriate error message if they get it wrong
worksheet . getCell ( 'A1' ) . dataValidation = {
type : 'whole' ,
operator : 'notEqual' ,
showErrorMessage : true ,
formulae : [ 5 ] ,
errorStyle : 'error' ,
errorTitle : 'Five' ,
error : 'The value must not be Five'
} ;
// Specify Cell must be a decimal number between 1.5 and 7.
// Add 'tooltip' to help guid the user
worksheet . getCell ( 'A1' ) . dataValidation = {
type : 'decimal' ,
operator : 'between' ,
allowBlank : true ,
showInputMessage : true ,
formulae : [ 1.5 , 7 ] ,
promptTitle : 'Decimal' ,
prompt : 'The value must between 1.5 and 7'
} ;
// Specify Cell must be have a text length less than 15
worksheet . getCell ( 'A1' ) . dataValidation = {
type : 'textLength' ,
operator : 'lessThan' ,
showErrorMessage : true ,
allowBlank : true ,
formulae : [ 15 ]
} ;
// Specify Cell must be have be a date before 1st Jan 2016
worksheet . getCell ( 'A1' ) . dataValidation = {
type : 'date' ,
operator : 'lessThan' ,
showErrorMessage : true ,
allowBlank : true ,
formulae : [ new Date ( 2016 , 0 , 1 ) ]
} ; Ajouter un commentaire de style ancien à une cellule
// plain text note
worksheet . getCell ( 'A1' ) . note = 'Hello, ExcelJS!' ;
// colourful formatted note
ws . getCell ( 'B1' ) . note = {
texts : [
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 0 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : 'This is ' } ,
{ 'font' : { 'italic' : true , 'size' : 12 , 'color' : { 'theme' : 0 } , 'name' : 'Calibri' , 'scheme' : 'minor' } , 'text' : 'a' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : ' ' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'argb' : 'FFFF6600' } , 'name' : 'Calibri' , 'scheme' : 'minor' } , 'text' : 'colorful' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : ' text ' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'argb' : 'FFCCFFCC' } , 'name' : 'Calibri' , 'scheme' : 'minor' } , 'text' : 'with' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : ' in-cell ' } ,
{ 'font' : { 'bold' : true , 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : 'format' } ,
] ,
margins : {
insetmode : 'custom' ,
inset : [ 0.25 , 0.25 , 0.35 , 0.35 ]
} ,
protection : {
locked : True ,
lockText : False
} ,
editAs : 'twoCells' ,
} ;Le tableau suivant définit les propriétés prises en charge par les commentaires de cellule.
| Champ | Requis | Valeur par défaut | Description |
|---|---|---|---|
| textes | Oui | Le texte du commentaire | |
| marges | N | {} | Détermine la valeur des marges pour les commentaires de cellule automatiques ou personnalisés |
| protection | N | {} | Spécification de l'état de verrouillage des objets et du texte de l'objet à l'aide des attributs de protection |
| modifierEn tant que | N | 'absolu' | Utilisez l'attribut 'editAs' pour spécifier comment l'annotation est ancrée à la cellule |
Déterminez le mode de réglage de la marge de page de l'annotation de cellule, mode automatique ou personnalisé.
ws . getCell ( 'B1' ) . note . margins = {
insetmode : 'custom' ,
inset : [ 0.25 , 0.25 , 0.35 , 0.35 ]
}| Propriété | Requis | Valeur par défaut | Description |
|---|---|---|---|
| mode incrusté | N | 'auto' | Détermine si les marges des commentaires sont définies automatiquement et si la valeur est « auto » ou « personnalisée » |
| encart | N | [0,13, 0,13, 0,25, 0,25] | Espaces sur les bordures du commentaire. Les unités sont en centimètres. La direction est gauche, haut, droite, bas |
Remarque : Ce paramètre inset prend effet uniquement lorsque la valeur de insetmode est « personnalisé ».
Spécifier l'état de verrouillage des objets et du texte de l'objet à l'aide des attributs de protection.
ws . getCell ( 'B1' ) . note . protection = {
locked : 'False' ,
lockText : 'False' ,
} ;| Propriété | Requis | Valeur par défaut | Description |
|---|---|---|---|
| fermé | N | 'Vrai' | Cet élément précise que l'objet est verrouillé lorsque la feuille est protégée |
| verrouillerTexte | N | 'Vrai' | Cet élément précise que le texte de l'objet est verrouillé |
Remarque : Les objets verrouillés ne sont valides que lorsque la feuille de calcul est protégée.
Les commentaires de cellule peuvent également avoir la propriété « editAs » qui contrôlera la manière dont les commentaires sont ancrés dans la ou les cellules. Il peut avoir l'une des valeurs suivantes :
ws . getCell ( 'B1' ) . note . editAs = 'twoCells' ;| Valeur | Description |
|---|---|
| deuxCellules | Il précise que la taille et la position de la note varient selon les cellules |
| uneCellules | Il précise que la taille de la note est fixe et que la position change avec la cellule |
| absolu | C'est la valeur par défaut. Les commentaires ne seront pas déplacés ni dimensionnés avec des cellules |
Les tableaux permettent la manipulation dans la feuille de données tabulaires.
Pour ajouter un tableau à une feuille de calcul, définissez un modèle de tableau et appelez addTable :
// add a table to a sheet
ws . addTable ( {
name : 'MyTable' ,
ref : 'A1' ,
headerRow : true ,
totalsRow : true ,
style : {
theme : 'TableStyleDark3' ,
showRowStripes : true ,
} ,
columns : [
{ name : 'Date' , totalsRowLabel : 'Totals:' , filterButton : true } ,
{ name : 'Amount' , totalsRowFunction : 'sum' , filterButton : false } ,
] ,
rows : [
[ new Date ( '2019-07-20' ) , 70.10 ] ,
[ new Date ( '2019-07-21' ) , 70.60 ] ,
[ new Date ( '2019-07-22' ) , 70.10 ] ,
] ,
} ) ;Remarque : L'ajout d'un tableau à une feuille de calcul modifiera la feuille en plaçant des en-têtes et des données de ligne dans la feuille. Toutes les données de la feuille couvertes par le tableau résultant (y compris les en-têtes et les totaux) seront écrasées.
Le tableau suivant définit les propriétés prises en charge par les tables.
| Propriété du tableau | Description | Requis | Valeur par défaut |
|---|---|---|---|
| nom | Le nom du tableau | Oui | |
| displayName | Le nom d'affichage de la table | N | nom |
| réf | Cellule supérieure gauche du tableau | Oui | |
| en-têteRow | Afficher les en-têtes en haut du tableau | N | vrai |
| totauxLigne | Afficher les totaux en bas du tableau | N | FAUX |
| style | Propriétés de style supplémentaires | N | {} |
| colonnes | Définitions de colonnes | Oui | |
| lignes | Lignes de données | Oui |
Le tableau suivant définit les propriétés prises en charge dans la propriété de style de tableau.
| Propriété de style | Description | Requis | Valeur par défaut |
|---|---|---|---|
| thème | Le thème des couleurs de la table | N | 'TableStyleMoyen2' |
| showPremièreColonne | Mettez en surbrillance la première colonne (gras) | N | FAUX |
| showDernièreColonne | Mettez en surbrillance la dernière colonne (gras) | N | FAUX |
| showRowStripes | Lignes alternatives affichées avec une couleur d'arrière-plan | N | FAUX |
| showColumnStripes | Lignes alternatives affichées avec une couleur d'arrière-plan | N | FAUX |
Le tableau suivant définit les propriétés prises en charge dans chaque colonne du tableau.
| Propriété de colonne | Description | Requis | Valeur par défaut |
|---|---|---|---|
| nom | Le nom de la colonne, également utilisé dans l'en-tête | Oui | |
| boutonFiltre | Commute le contrôle du filtre dans l'en-tête | N | FAUX |
| totauxRowLabel | Étiquette pour décrire la ligne des totaux (première colonne) | N | 'Total' |
| totauxRowFunction | Nom de la fonction de totaux | N | 'aucun' |
| totauxLigneFormule | Formule facultative pour les fonctions personnalisées | N |
Le tableau suivant répertorie les valeurs valides pour la propriété totalsRowFunction définie par les colonnes. Si une valeur autre que « personnalisée » est utilisée, il n'est pas nécessaire d'inclure la formule associée car elle sera insérée par le tableau.
| Fonctions de totaux | Description |
|---|---|
| aucun | Aucune fonction de totaux pour cette colonne |
| moyenne | Calculer la moyenne de la colonne |
| nombreNums | Comptez les entrées qui sont des nombres |
| compter | Nombre d'entrées |
| maximum | La valeur maximale dans cette colonne |
| min | La valeur minimale dans cette colonne |
| Développeurstd | L'écart type pour cette colonne |
| var | La variance pour cette colonne |
| somme | La somme des entrées pour cette colonne |
| coutume | Une formule personnalisée. Nécessite une valeur totalsRowFormula associée. |
Les noms de thème valides suivent le modèle suivant :
Les nuances, les nombres peuvent être l'un des suivants :
Pour aucun thème, utilisez la valeur null.
Remarque : les thèmes de tableaux personnalisés ne sont pas encore pris en charge par Exceljs.
Les tableaux prennent en charge un ensemble de fonctions de manipulation qui permettent d'ajouter ou de supprimer des données et de modifier certaines propriétés. Étant donné que bon nombre de ces opérations peuvent avoir des effets sur la feuille, les modifications doivent être validées une fois terminées.
Toutes les valeurs d'index du tableau sont basées sur zéro, donc le numéro de la première ligne et le numéro de la première colonne sont 0.
Ajout ou suppression d'en-têtes et de totaux
const table = ws . getTable ( 'MyTable' ) ;
// turn header row on
table . headerRow = true ;
// turn totals row off
table . totalsRow = false ;
// commit the table changes into the sheet
table . commit ( ) ;Déplacer une table
const table = ws . getTable ( 'MyTable' ) ;
// table top-left move to D4
table . ref = 'D4' ;
// commit the table changes into the sheet
table . commit ( ) ;Ajout et suppression de lignes
const table = ws . getTable ( 'MyTable' ) ;
// remove first two rows
table . removeRows ( 0 , 2 ) ;
// insert new rows at index 5
table . addRow ( [ new Date ( '2019-08-05' ) , 5 , 'Mid' ] , 5 ) ;
// append new row to bottom of table
table . addRow ( [ new Date ( '2019-08-10' ) , 10 , 'End' ] ) ;
// commit the table changes into the sheet
table . commit ( ) ;Ajout et suppression de colonnes
const table = ws . getTable ( 'MyTable' ) ;
// remove second column
table . removeColumns ( 1 , 1 ) ;
// insert new column (with data) at index 1
table . addColumn (
{ name : 'Letter' , totalsRowFunction : 'custom' , totalsRowFormula : 'ROW()' , totalsRowResult : 6 , filterButton : true } ,
[ 'a' , 'b' , 'c' , 'd' ] ,
2
) ;
// commit the table changes into the sheet
table . commit ( ) ;Modifier les propriétés de la colonne
const table = ws . getTable ( 'MyTable' ) ;
// Get Column Wrapper for second column
const column = table . getColumn ( 1 ) ;
// set some properties
column . name = 'Code' ;
column . filterButton = true ;
column . style = { font : { bold : true , name : 'Comic Sans MS' } } ;
column . totalsRowLabel = 'Totals' ;
column . totalsRowFunction = 'custom' ;
column . totalsRowFormula = 'ROW()' ;
column . totalsRowResult = 10 ;
// commit the table changes into the sheet
table . commit ( ) ; Les cellules, lignes et colonnes prennent chacune en charge un riche ensemble de styles et de formats qui affectent la façon dont les cellules sont affichées.
Les styles sont définis en attribuant les propriétés suivantes :
// assign a style to a cell
ws . getCell ( 'A1' ) . numFmt = '0.00%' ;
// Apply styles to worksheet columns
ws . columns = [
{ header : 'Id' , key : 'id' , width : 10 } ,
{ header : 'Name' , key : 'name' , width : 32 , style : { font : { name : 'Arial Black' } } } ,
{ header : 'D.O.B.' , key : 'DOB' , width : 10 , style : { numFmt : 'dd/mm/yyyy' } }
] ;
// Set Column 3 to Currency Format
ws . getColumn ( 3 ) . numFmt = '"£"#,##0.00;[Red]-"£"#,##0.00' ;
// Set Row 2 to Comic Sans.
ws . getRow ( 2 ) . font = { name : 'Comic Sans MS' , family : 4 , size : 16 , underline : 'double' , bold : true } ;Lorsqu'un style est appliqué à une ligne ou une colonne, il sera appliqué à toutes les cellules actuellement existantes dans cette ligne ou cette colonne. De plus, toute nouvelle cellule créée héritera de ses styles initiaux de la ligne et de la colonne à laquelle elle appartient.
Si la ligne et la colonne d'une cellule définissent toutes deux un style spécifique (par exemple, la police), la cellule utilisera le style de ligne plutôt que le style de colonne. Cependant, si la ligne et la colonne définissent des styles différents (par exemple column.numFmt et row.font), la cellule héritera de la police de la ligne et du numFmt de la colonne.
Attention : toutes les propriétés ci-dessus (à l'exception de numFmt, qui est une chaîne), sont des structures d'objets JS. Si le même objet de style est affecté à plusieurs entités de feuille de calcul, chaque entité partagera le même objet de style. Si l'objet de style est modifié ultérieurement avant que la feuille de calcul ne soit sérialisée, toutes les entités faisant référence à cet objet de style seront également modifiées. Ce comportement vise à prioriser les performances en réduisant le nombre d'objets JS créés. Si vous souhaitez que les objets de style soient indépendants, vous devrez les cloner avant de les attribuer. De plus, par défaut, lorsqu'un document est lu à partir d'un fichier (ou d'un flux), si les entités de feuille de calcul partagent des styles similaires, elles feront également référence au même objet de style.
// display value as '1 3/5'
ws . getCell ( 'A1' ) . value = 1.6 ;
ws . getCell ( 'A1' ) . numFmt = '# ?/?' ;
// display value as '1.60%'
ws . getCell ( 'B1' ) . value = 0.016 ;
ws . getCell ( 'B1' ) . numFmt = '0.00%' ; // for the wannabe graphic designers out there
ws . getCell ( 'A1' ) . font = {
name : 'Comic Sans MS' ,
family : 4 ,
size : 16 ,
underline : true ,
bold : true
} ;
// for the graduate graphic designers...
ws . getCell ( 'A2' ) . font = {
name : 'Arial Black' ,
color : { argb : 'FF00FF00' } ,
family : 2 ,
size : 14 ,
italic : true
} ;
// for the vertical align
ws . getCell ( 'A3' ) . font = {
vertAlign : 'superscript'
} ;
// note: the cell will store a reference to the font object assigned.
// If the font object is changed afterwards, the cell font will change also...
const font = { name : 'Arial' , size : 12 } ;
ws . getCell ( 'A3' ) . font = font ;
font . size = 20 ; // Cell A3 now has font size 20!
// Cells that share similar fonts may reference the same font object after
// the workbook is read from file or stream| Propriété de police | Description | Exemple(s) de valeur(s) |
|---|---|---|
| nom | Nom de la police. | "Arial", "Calibri", etc. |
| famille | Famille de polices de secours. Une valeur entière. | 1 - Serif, 2 - Sans Serif, 3 - Mono, Autres - inconnu |
| schème | Schéma de police. | « mineur », « majeur », « aucun » |
| jeu de caractères | Jeu de caractères de police. Une valeur entière. | 1, 2, etc |
| taille | Taille de la police. Une valeur entière. | 9, 10, 12, 16, etc. |
| couleur | Description de la couleur, un objet contenant une valeur ARVB. | { argb : 'FFFF0000'} |
| audacieux | Poids de la police | vrai, faux |
| italique | Pente de la police | vrai, faux |
| souligner | Style de soulignement de la police | vrai, faux, 'aucun', 'single', 'double', 'singleAccounting', 'doubleAccounting' |
| grève | Police | vrai, faux |
| contour | Aperçu de la police | vrai, faux |
| vertAlign | Alignement vertical | 'exposant', 'indice' |
// set cell alignment to top-left, middle-center, bottom-right
ws . getCell ( 'A1' ) . alignment = { vertical : 'top' , horizontal : 'left' } ;
ws . getCell ( 'B1' ) . alignment = { vertical : 'middle' , horizontal : 'center' } ;
ws . getCell ( 'C1' ) . alignment = { vertical : 'bottom' , horizontal : 'right' } ;
// set cell to wrap-text
ws . getCell ( 'D1' ) . alignment = { wrapText : true } ;
// set cell indent to 1
ws . getCell ( 'E1' ) . alignment = { indent : 1 } ;
// set cell text rotation to 30deg upwards, 45deg downwards and vertical text
ws . getCell ( 'F1' ) . alignment = { textRotation : 30 } ;
ws . getCell ( 'G1' ) . alignment = { textRotation : - 45 } ;
ws . getCell ( 'H1' ) . alignment = { textRotation : 'vertical' } ;Valeurs de propriété d'alignement valides
| horizontal | verticale | envelopper le texte | rétrécirPourAjuster | retrait | lectureOrdre | rotation du texte |
|---|---|---|---|---|---|---|
| gauche | haut | vrai | vrai | entier | rtl | 0 à 90 |
| centre | milieu | FAUX | FAUX | litres | -1 à -90 | |
| droite | bas | verticale | ||||
| remplir | distribué | |||||
| justifier | justifier | |||||
| centreContinu | ||||||
| distribué |
// set single thin border around A1
ws . getCell ( 'A1' ) . border = {
top : { style : 'thin' } ,
left : { style : 'thin' } ,
bottom : { style : 'thin' } ,
right : { style : 'thin' }
} ;
// set double thin green border around A3
ws . getCell ( 'A3' ) . border = {
top : { style : 'double' , color : { argb : 'FF00FF00' } } ,
left : { style : 'double' , color : { argb : 'FF00FF00' } } ,
bottom : { style : 'double' , color : { argb : 'FF00FF00' } } ,
right : { style : 'double' , color : { argb : 'FF00FF00' } }
} ;
// set thick red cross in A5
ws . getCell ( 'A5' ) . border = {
diagonal : { up : true , down : true , style : 'thick' , color : { argb : 'FFFF0000' } }
} ;Styles de bordure valides
// fill A1 with red darkVertical stripes
ws . getCell ( 'A1' ) . fill = {
type : 'pattern' ,
pattern : 'darkVertical' ,
fgColor : { argb : 'FFFF0000' }
} ;
// fill A2 with yellow dark trellis and blue behind
ws . getCell ( 'A2' ) . fill = {
type : 'pattern' ,
pattern : 'darkTrellis' ,
fgColor : { argb : 'FFFFFF00' } ,
bgColor : { argb : 'FF0000FF' }
} ;
// fill A3 with solid coral
ws . getCell ( 'A3' ) . fill = {
type : 'pattern' ,
pattern : 'solid' ,
fgColor : { argb : 'F08080' } ,
} ;
// fill A4 with blue-white-blue gradient from left to right
ws . getCell ( 'A4' ) . fill = {
type : 'gradient' ,
gradient : 'angle' ,
degree : 0 ,
stops : [
{ position : 0 , color : { argb : 'FF0000FF' } } ,
{ position : 0.5 , color : { argb : 'FFFFFFFF' } } ,
{ position : 1 , color : { argb : 'FF0000FF' } }
]
} ;
// fill A5 with red-green gradient from center
ws . getCell ( 'A5' ) . fill = {
type : 'gradient' ,
gradient : 'path' ,
center : { left : 0.5 , top : 0.5 } ,
stops : [
{ position : 0 , color : { argb : 'FFFF0000' } } ,
{ position : 1 , color : { argb : 'FF00FF00' } }
]
} ; | Propriété | Requis | Description |
|---|---|---|
| taper | Oui | Valeur : 'modèle' Spécifie que ce remplissage utilise des motifs |
| modèle | Oui | Spécifie le type de modèle (voir Types de modèles valides ci-dessous) |
| fgCouleur | N | Spécifie la couleur de premier plan du motif. La valeur par défaut est noire. |
| bgCouleur | N | Spécifie la couleur d'arrière-plan du motif. La valeur par défaut est blanche. |
Remarque : Si vous souhaitez remplir une cellule à l'aide du motif solid , vous n'avez pas besoin de spécifier bgColor . Voir l'exemple ci-dessus pour la cellule A3 avec un motif solid et un fgColor corail.
Types de modèles valides
| Propriété | Requis | Description |
|---|---|---|
| taper | Oui | Valeur : « dégradé » Spécifie que ce remplissage utilise des dégradés |
| pente | Oui | Spécifie le type de dégradé. L'un des ['angle', 'chemin'] |
| degré | angle | Pour le dégradé « angle », spécifie la direction du dégradé. 0 va de gauche à droite. Les valeurs de 1 à 359 tournent dans le sens des aiguilles d'une montre |
| centre | chemin | Pour le dégradé « chemin ». Spécifie les coordonnées relatives du début du chemin. Les valeurs « gauche » et « haut » vont de 0 à 1 |
| s'arrête | Oui | Spécifie la séquence de couleurs du dégradé. Est un tableau d'objets contenant la position et la couleur commençant par la position 0 et se terminant par la position 1. Les positions intermédiaires peuvent être utilisées pour spécifier d'autres couleurs sur le chemin. |
Mises en garde
En utilisant l'interface ci-dessus, il peut être possible de créer des effets de remplissage dégradé impossibles à utiliser avec le programme d'édition XLSX. Par exemple, Excel ne prend en charge que les dégradés d'angle de 0, 45, 90 et 135. De même, la séquence d'arrêts peut également être limitée par l'interface utilisateur avec les positions [0,1] ou [0,0.5,1] comme seules options. Faites attention à ce remplissage pour vous assurer qu'il est pris en charge par les téléspectateurs XLSX cibles.
Les cellules individuelles prennent désormais en charge le texte enrichi ou le formatage dans la cellule. Les valeurs de texte enrichi peuvent contrôler les propriétés de police de n'importe quel nombre de sous-chaînes au sein de la valeur de texte. Voir Polices pour une liste complète de détails sur les propriétés de police prises en charge.
ws . getCell ( 'A1' ) . value = {
'richText' : [
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 0 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : 'This is ' } ,
{ 'font' : { 'italic' : true , 'size' : 12 , 'color' : { 'theme' : 0 } , 'name' : 'Calibri' , 'scheme' : 'minor' } , 'text' : 'a' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : ' ' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'argb' : 'FFFF6600' } , 'name' : 'Calibri' , 'scheme' : 'minor' } , 'text' : 'colorful' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : ' text ' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'argb' : 'FFCCFFCC' } , 'name' : 'Calibri' , 'scheme' : 'minor' } , 'text' : 'with' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : ' in-cell ' } ,
{ 'font' : { 'bold' : true , 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : 'format' }
]
} ;
expect ( ws . getCell ( 'A1' ) . text ) . to . equal ( 'This is a colorful text with in-cell format' ) ;
expect ( ws . getCell ( 'A1' ) . type ) . to . equal ( Excel . ValueType . RichText ) ;La protection au niveau des cellules peut être modifiée à l’aide de la propriété protection.
ws . getCell ( 'A1' ) . protection = {
locked : false ,
hidden : true ,
} ;Propriétés de protection prises en charge
| Propriété | Défaut | Description |
|---|---|---|
| fermé | vrai | Spécifie si une cellule sera verrouillée si la feuille est protégée. |
| caché | FAUX | Spécifie si la formule d'une cellule sera visible si la feuille est protégée. |
La mise en forme conditionnelle permet à une feuille d'afficher des styles, des icônes, etc. spécifiques en fonction des valeurs de cellule ou de toute formule arbitraire.
Les règles de mise en forme conditionnelle sont ajoutées au niveau de la feuille et couvrent généralement une plage de cellules.
Plusieurs règles peuvent être appliquées à une plage de cellules donnée et chaque règle appliquera son propre style.
Si plusieurs règles affectent une cellule donnée, la valeur de priorité de la règle déterminera quelle règle l'emportera en cas de collision de styles concurrents. La règle avec la valeur de priorité la plus faible gagne. Si les valeurs de priorité ne sont pas spécifiées pour une règle donnée, ExcelJS les attribuera par ordre croissant.
Remarque : à l'heure actuelle, seul un sous-ensemble de règles de formatage conditionnel est pris en charge. Plus précisément, uniquement les règles de formatage qui ne nécessitent pas de rendu XML à l'intérieur d'un élément <extLst>. Cela signifie que les jeux de données et trois jeux d'icônes spécifiques (3Triangles, 3Stars, 5Boxes) ne sont pas pris en charge.
// add a checkerboard pattern to A1:E7 based on row + col being even or odd
worksheet . addConditionalFormatting ( {
ref : 'A1:E7' ,
rules : [
{
type : 'expression' ,
formulae : [ 'MOD(ROW()+COLUMN(),2)=0' ] ,
style : { fill : { type : 'pattern' , pattern : 'solid' , bgColor : { argb : 'FF00FF00' } } } ,
}
]
} )Types de règles de mise en forme conditionnelle pris en charge
| Taper | Description |
|---|---|
| expression | N'importe quelle fonction personnalisée peut être utilisée pour activer la règle. |
| celluleEst | Compare la valeur de la cellule avec la formule fournie à l'aide de l'opérateur spécifié |
| top10 | Applique la mise en forme aux cellules dont les valeurs se trouvent dans les plages supérieures (ou inférieures) |
| au-dessus de la moyenne | Applique le formatage aux cellules dont les valeurs sont supérieures (ou inférieures) à la moyenne |
| Échelle de couleurs | Applique un arrière-plan coloré aux cellules en fonction de l'endroit où leurs valeurs se situent dans la plage |
| jeu d'icônes | Ajoute l'une d'une gamme d'icônes aux cellules en fonction de la valeur |
| contientTexte | Applique une mise en forme selon que la cellule contient un texte spécifique |
| timePériode | Applique le formatage selon que la valeur datetime de la cellule se situe dans une plage spécifiée |
| Champ | Facultatif | Défaut | Description |
|---|---|---|---|
| taper | 'expression' | ||
| priorité | Oui | <auto> | détermine l'ordre de priorité des styles |
| formules | tableau de 1 chaîne de formule qui renvoie une valeur vrai/faux. Pour référencer la valeur de la cellule, utilisez l'adresse de la cellule en haut à gauche | ||
| style | structure de style à appliquer si la formule renvoie vrai |
| Champ | Facultatif | Défaut | Description |
|---|---|---|---|
| taper | 'celluleEst' | ||
| priorité | Oui | <auto> | détermine l'ordre de priorité des styles |
| opérateur | comment comparer la valeur de la cellule avec le résultat de la formule | ||
| formules | tableau de 1 chaîne de formule qui renvoie la valeur à comparer avec chaque cellule | ||
| style | structure de style à appliquer si la comparaison renvoie vrai |
La cellule est des opérateurs
| Opérateur | Description |
|---|---|
| égal | Appliquer le format si la valeur de la cellule est égale à la valeur de la formule |
| supérieur à | Appliquer le format si la valeur de la cellule est supérieure à la valeur de la formule |
| moins que | Appliquer le format si la valeur de la cellule est inférieure à la valeur de la formule |
| entre | Appliquer le format si la valeur de la cellule est comprise entre deux valeurs de formule (incluses) |
| Champ | Facultatif | Défaut | Description |
|---|---|---|---|
| taper | 'top10' | ||
| priorité | Oui | <auto> | détermine l'ordre de priorité des styles |
| rang | Oui | 10 | spécifie combien de valeurs supérieures (ou inférieures) sont incluses dans le formatage |
| pour cent | Oui | FAUX | si c'est vrai, le champ de classement est un pourcentage et non un absolu |
| bas | Oui | FAUX | si c'est vrai, les valeurs inférieures sont incluses au lieu des valeurs supérieures |
| style | structure de style à appliquer si la comparaison renvoie vrai |
| Champ | Facultatif | Défaut | Description |
|---|---|---|---|
| taper | 'au-dessus de la moyenne' | ||
| priorité | Oui | <auto> | détermine l'ordre de priorité des styles |
| au-dessus de la moyenne | Oui | FAUX | si c'est vrai, le champ de classement est un pourcentage et non un absolu |
| style | structure de style à appliquer si la comparaison renvoie vrai |
| Champ | Facultatif | Défaut | Description |
|---|---|---|---|
| taper | 'Échelle de couleurs' | ||
| priorité | Oui | <auto> | détermine l'ordre de priorité des styles |
| cfvo | tableau de 2 à 5 objets de valeur de formatage conditionnel spécifiant des points de cheminement dans la plage de valeurs | ||
| couleur | tableau correspondant de couleurs à utiliser à des points de passage donnés | ||
| style | structure de style à appliquer si la comparaison renvoie vrai |
| Champ | Facultatif | Défaut | Description |
|---|---|---|---|
| taper | 'ensemble d'icônes' | ||
| priorité | Oui | <auto> | détermine l'ordre de priorité des styles |
| jeu d'icônes | Oui | 3Feux de circulation | nom du jeu d'icônes à utiliser |
| afficherValeur | vrai | Spécifie si les cellules de la plage appliquée affichent l'icône et la valeur de la cellule, ou uniquement l'icône. | |
| inverse | FAUX | Spécifie si les icônes du jeu d'icônes spécifié dans iconSet sont affichées dans l'ordre de réserve. Si custom est égal à "true", cette valeur doit être ignorée | |
| coutume | FAUX | Spécifie si un ensemble personnalisé d'icônes est utilisé | |
| cfvo | tableau de 2 à 5 objets de valeur de formatage conditionnel spécifiant des points de cheminement dans la plage de valeurs | ||
| style | structure de style à appliquer si la comparaison renvoie vrai |
| Champ | Facultatif | Défaut | Description |
|---|---|---|---|
| taper | 'barre de données' | ||
| priorité | Oui | <auto> | détermine l'ordre de priorité des styles |
| minLongueur | 0 | Spécifie la longueur de la barre de données la plus courte dans cette plage de mise en forme conditionnelle | |
| longueurmax | 100 | Spécifie la longueur de la barre de données la plus longue dans cette plage de mise en forme conditionnelle | |
| afficherValeur | vrai | Spécifie si les cellules de la plage de mise en forme conditionnelle affichent à la fois la barre de données et la valeur numérique ou la barre de données | |
| pente | vrai | Spécifie si la barre de données a un remplissage dégradé | |
| frontière | vrai | Spécifie si la barre de données a une bordure | |
| négatifBarColorSameAsPositive | vrai | Spécifie si la barre de données a une couleur de barre négative différente de la couleur de barre positive. | |
| négatifBarBorderColorSameAsPositive | vrai | Spécifie si la barre de données a une couleur de bordure négative différente de la couleur de bordure positive | |
| axePosition | 'auto' | Spécifie la position de l'axe pour la barre de données | |
| direction | 'gaucheVersDroite' | Spécifie la direction de la barre de données | |
| cfvo | tableau de 2 à 5 objets de valeur de formatage conditionnel spécifiant des points de cheminement dans la plage de valeurs | ||
| style | structure de style à appliquer si la comparaison renvoie vrai |
| Champ | Facultatif | Défaut | Description |
|---|---|---|---|
| taper | 'contientTexte' | ||
| priorité | Oui | <auto> | détermine l'ordre de priorité des styles |
| opérateur | type de comparaison de texte | ||
| texte | texte à rechercher | ||
| style | structure de style à appliquer si la comparaison renvoie vrai |
Contient des opérateurs de texte
| Opérateur | Description |
|---|---|
| contientTexte | Appliquer le format si la valeur de la cellule contient la valeur spécifiée dans le champ « texte » |
| contient des blancs | Appliquer le format si la valeur de la cellule contient des espaces |
| notContient des blancs | Appliquer le format si la valeur de la cellule ne contient pas d'espaces |
| contient des erreurs | Appliquer le format si la valeur de la cellule contient des erreurs |
| notContainsErrors | Appliquer le format si la valeur de la cellule ne contient pas d'erreurs |
| Champ | Facultatif | Défaut | Description |
|---|---|---|---|
| taper | 'période de temps' | ||
| priorité | Oui | <auto> | détermine l'ordre de priorité des styles |
| timePériode | à quelle période comparer la valeur de la cellule | ||
| style | structure de style à appliquer si la comparaison renvoie vrai |
Périodes de temps
| Période | Description |
|---|---|
| la semaine dernière | Appliquer le format si la valeur de la cellule tombe au cours de la semaine dernière |
| cette semaine | Appliquer le format si la valeur de la cellule tombe cette semaine |
| la semaine prochaine | Appliquer le format si la valeur de la cellule diminue la semaine prochaine |
| hier | Appliquer le format si la valeur de la cellule est égale à hier |
| aujourd'hui | Appliquer le format si la valeur de la cellule est égale à aujourd'hui |
| demain | Appliquer le format si la valeur de la cellule est égale à demain |
| 7derniers jours | Appliquer le format si la valeur de la cellule tombe au cours des 7 derniers jours |
| le mois dernier | Appliquer le format si la valeur de la cellule tombe le mois dernier |
| ce mois-ci | Appliquer le format si la valeur de la cellule tombe ce mois-ci |
| le mois prochain | Appliquer le format si la valeur de la cellule tombe le mois prochain |
Excel prend en charge le plan ; où les lignes ou les colonnes peuvent être développées ou réduites en fonction du niveau de détail que l'utilisateur souhaite afficher.
Les niveaux de plan peuvent être définis dans la configuration des colonnes :
worksheet . columns = [
{ header : 'Id' , key : 'id' , width : 10 } ,
{ header : 'Name' , key : 'name' , width : 32 } ,
{ header : 'D.O.B.' , key : 'DOB' , width : 10 , outlineLevel : 1 }
] ;Ou directement sur la ligne ou la colonne
worksheet . getColumn ( 3 ) . outlineLevel = 1 ;
worksheet . getRow ( 3 ) . outlineLevel = 1 ;Les niveaux de plan de la feuille peuvent être définis sur la feuille de calcul
// set column outline level
worksheet . properties . outlineLevelCol = 1 ;
// set row outline level
worksheet . properties . outlineLevelRow = 1 ;Remarque : l'ajustement des niveaux de plan sur les lignes ou les colonnes ou les niveaux de plan sur la feuille de calcul entraînera un effet secondaire de modification également de la propriété réduite de toutes les lignes ou colonnes affectées par le changement de propriété. Par exemple :
worksheet . properties . outlineLevelCol = 1 ;
worksheet . getColumn ( 3 ) . outlineLevel = 1 ;
expect ( worksheet . getColumn ( 3 ) . collapsed ) . to . be . true ;
worksheet . properties . outlineLevelCol = 2 ;
expect ( worksheet . getColumn ( 3 ) . collapsed ) . to . be . false ;Les propriétés du plan peuvent être définies sur la feuille de calcul
worksheet . properties . outlineProperties = {
summaryBelow : false ,
summaryRight : false ,
} ; L'ajout d'images à une feuille de calcul est un processus en deux étapes. Tout d'abord, l'image est ajoutée au classeur via la fonction addImage() qui renverra également une valeur imageId. Ensuite, à l’aide de l’imageId, l’image peut être ajoutée à la feuille de calcul sous forme d’arrière-plan en mosaïque ou couvrant une plage de cellules.
Remarque : à partir de cette version, l'ajustement ou la transformation de l'image n'est pas pris en charge et les images ne sont pas prises en charge en mode streaming.
La fonction Workbook.addImage prend en charge l'ajout d'images par nom de fichier ou par tampon. A noter que dans les deux cas, l'extension doit être précisée. Les valeurs d'extension valides incluent « jpeg », « png », « gif ».
// add image to workbook by filename
const imageId1 = workbook . addImage ( {
filename : 'path/to/image.jpg' ,
extension : 'jpeg' ,
} ) ;
// add image to workbook by buffer
const imageId2 = workbook . addImage ( {
buffer : fs . readFileSync ( 'path/to.image.png' ) ,
extension : 'png' ,
} ) ;
// add image to workbook by base64
const myBase64Image = "data:image/png;base64,iVBORw0KG..." ;
const imageId2 = workbook . addImage ( {
base64 : myBase64Image ,
extension : 'png' ,
} ) ;À l'aide de l'identifiant de l'image de Workbook.addImage, l'arrière-plan d'une feuille de calcul peut être défini à l'aide de la fonction addBackgroundImage.
// set background
worksheet . addBackgroundImage ( imageId1 ) ;En utilisant l'identifiant d'image de Workbook.addImage, une image peut être intégrée dans la feuille de calcul pour couvrir une plage. Les coordonnées calculées à partir de la plage s'étendront du coin supérieur gauche de la première cellule au coin inférieur droit de la seconde.
// insert an image over B2:D6
worksheet . addImage ( imageId2 , 'B2:D6' ) ;En utilisant une structure au lieu d’une chaîne de plage, il est possible de couvrir partiellement les cellules.
Notez que le système de coordonnées utilisé pour cela est basé sur zéro, donc le coin supérieur gauche de A1 sera { col: 0, row: 0 }. Les fractions de cellules peuvent être spécifiées à l'aide de nombres à virgule flottante, par exemple le milieu de A1 est { col : 0,5, ligne : 0,5 }.
// insert an image over part of B2:D6
worksheet . addImage ( imageId2 , {
tl : { col : 1.5 , row : 1.5 } ,
br : { col : 3.5 , row : 5.5 }
} ) ;La plage de cellules peut également avoir la propriété «Editas» qui contrôlera comment l'image est ancrée aux cellules, il peut avoir l'une des valeurs suivantes:
| Valeur | Description |
|---|---|
| indéfini | Il spécifie que l'image sera déplacée et dimensionnée avec des cellules |
| oncellule | C'est la valeur par défaut. L'image sera déplacée avec des cellules mais pas de taille |
| absolu | L'image ne sera pas déplacée ou dimensionnée avec les cellules |
ws . addImage ( imageId , {
tl : { col : 0.1125 , row : 0.4 } ,
br : { col : 2.101046875 , row : 3.4 } ,
editAs : 'oneCell'
} ) ;Vous pouvez ajouter une image à une cellule, puis définir sa largeur et sa hauteur en pixels à 96 dpi.
worksheet . addImage ( imageId2 , {
tl : { col : 0 , row : 0 } ,
ext : { width : 500 , height : 200 }
} ) ;Vous pouvez ajouter une image avec des hyperliens à une cellule et définir les hyperliens dans la gamme d'images.
worksheet . addImage ( imageId2 , {
tl : { col : 0 , row : 0 } ,
ext : { width : 500 , height : 200 } ,
hyperlinks : {
hyperlink : 'http://www.somewhere.com' ,
tooltip : 'http://www.somewhere.com'
}
} ) ; Les feuilles de travail peuvent être protégées de la modification en ajoutant un mot de passe.
await worksheet . protect ( 'the-password' , options ) ;La protection des feuilles de travail peut également être supprimée:
worksheet . unprotect ( ) ;Voir la protection des cellules pour plus de détails sur la façon de modifier la protection des cellules individuelles.
Remarque: Bien que la fonction Protect () renvoie une promesse indiquant qu'elle est asynchrone, l'implémentation actuelle s'exécute sur le thread principal et utilisera environ 600 ms sur un CPU moyen. Cela peut être ajusté en réglant la médaille, qui peut être utilisée pour rendre le processus plus rapide ou plus résilient.
| Champ | Défaut | Description |
|---|---|---|
| selectLockedCells | vrai | Permet à l'utilisateur de sélectionner les cellules verrouillées |
| selectUnlockedcells | vrai | Permet à l'utilisateur de sélectionner les cellules déverrouillées |
| vitrines | FAUX | Laisse les cellules de format utilisateur |
| format-colonnes | FAUX | Permet aux colonnes de format utilisateur |
| foratrows | FAUX | Permet au format utilisateur des lignes |
| insertrows | FAUX | Permet à l'utilisateur d'insérer des lignes |
| insertcolumns | FAUX | Permet à l'utilisateur d'insérer des colonnes |
| inserthyperlinks | FAUX | Permet à l'utilisateur d'insérer des hyperliens |
| démangeaisons | FAUX | Permet de supprimer les lignes |
| DeleteColumns | FAUX | Permet de supprimer les colonnes de l'utilisateur |
| trier | FAUX | Permet aux données de tri des utilisateurs |
| automatiquement | FAUX | Permet les données de filtre utilisateur dans les tableaux |
| dresseur | FAUX | Permet à l'utilisateur utiliser des tables de pivot |
| méprisation | 100000 | Le nombre d'itérations de hachage effectuées lors de la protection ou de la non-protection |
Options prises en charge lors de la lecture des fichiers xlsx.
| Champ | Requis | Taper | Description |
|---|---|---|---|
| ignorenodes | N | Tableau | Une liste de noms de nœuds à ignorer tout en chargeant le document XLSX. Améliore les performances dans certaines situations. Disponible: sheetPr , dimension , sheetViews , sheetFormatPr , cols , sheetData , autoFilter , mergeCells , rowBreaks , hyperlinks , pageMargins , dataValidations , pageSetup , headerFooter , printOptions , picture , drawing , sheetProtection , tableParts , conditionalFormatting , extLst , |
// read from a file
const workbook = new Excel . Workbook ( ) ;
await workbook . xlsx . readFile ( filename ) ;
// ... use workbook
// read from a stream
const workbook = new Excel . Workbook ( ) ;
await workbook . xlsx . read ( stream ) ;
// ... use workbook
// load from buffer
const workbook = new Excel . Workbook ( ) ;
await workbook . xlsx . load ( data ) ;
// ... use workbook
// using additional options
const workbook = new Excel . Workbook ( ) ;
await workbook . xlsx . load ( data , {
ignoreNodes : [
'dataValidations' // ignores the workbook's Data Validations
] ,
} ) ;
// ... use workbook // write to a file
const workbook = createAndFillWorkbook ( ) ;
await workbook . xlsx . writeFile ( filename ) ;
// write to a stream
await workbook . xlsx . write ( stream ) ;
// write to a new buffer
const buffer = await workbook . xlsx . writeBuffer ( ) ;Options prises en charge lors de la lecture des fichiers CSV.
| Champ | Requis | Taper | Description |
|---|---|---|---|
| dateformates | N | Tableau | Spécifiez le format de codage de date de dayjs. |
| carte | N | Fonction | Fonction de rappel personnalisé array.prototype.map () pour le traitement des données. |
| nom de feuille | N | Chaîne | Spécifiez le nom de la feuille de travail. |
| parserroptions | N | Objet | ParseOptions Options @ Module Fast-CSV / Format pour écrire des données CSV. |
// read from a file
const workbook = new Excel . Workbook ( ) ;
const worksheet = await workbook . csv . readFile ( filename ) ;
// ... use workbook or worksheet
// read from a stream
const workbook = new Excel . Workbook ( ) ;
const worksheet = await workbook . csv . read ( stream ) ;
// ... use workbook or worksheet
// read from a file with European Dates
const workbook = new Excel . Workbook ( ) ;
const options = {
dateFormats : [ 'DD/MM/YYYY' ]
} ;
const worksheet = await workbook . csv . readFile ( filename , options ) ;
// ... use workbook or worksheet
// read from a file with custom value parsing
const workbook = new Excel . Workbook ( ) ;
const options = {
map ( value , index ) {
switch ( index ) {
case 0 :
// column 1 is string
return value ;
case 1 :
// column 2 is a date
return new Date ( value ) ;
case 2 :
// column 3 is JSON of a formula value
return JSON . parse ( value ) ;
default :
// the rest are numbers
return parseFloat ( value ) ;
}
} ,
// https://c2fo.github.io/fast-csv/docs/parsing/options
parserOptions : {
delimiter : 't' ,
quote : false ,
} ,
} ;
const worksheet = await workbook . csv . readFile ( filename , options ) ;
// ... use workbook or worksheetL'analyseur CSV utilise Fast-CSV pour lire le fichier CSV. Les formatrices dans les options transmises à la fonction d'écriture ci-dessus seront transmises au module @ fast-csv / format pour écrire des données CSV. Veuillez vous référer à Fast-CSV Readme.md pour plus de détails.
Les dates sont analysées à l'aide du module NPM DayJS. Si un tableau DateFormates n'est pas fourni, les DateFormates suivantes sont utilisées:
Veuillez vous référer au plugin DayJS CustomParseformat pour plus de détails sur la façon de structurer un DateFormat.
Options prises en charge lors de l'écriture dans un fichier CSV.
| Champ | Requis | Taper | Description |
|---|---|---|---|
| dateformat | N | Chaîne | Spécifiez le format de codage de date de dayjs. |
| dateUtc | N | Booléen | Spécifiez si Exceljs utilise dayjs.utc () pour convertir le fuseau horaire pour les dates d'analyse. |
| codage | N | Chaîne | Spécifiez le format d'encodage du fichier. (S'applique uniquement à .writeFile .) |
| includemptyrows | N | Booléen | Spécifie si les lignes vides peuvent être écrites. |
| carte | N | Fonction | Fonction de rappel Array.protype.map () personnalisé pour le traitement des valeurs de ligne. |
| nom de feuille | N | Chaîne | Spécifiez le nom de la feuille de travail. |
| tople | N | Nombre | Spécifiez l'ID de la feuille de travail. |
| Formatteroptions | N | Objet | Options de formatRoPtions @ module Fast-CSV / Format pour écrire des données CSV. |
// write to a file
const workbook = createAndFillWorkbook ( ) ;
await workbook . csv . writeFile ( filename ) ;
// write to a stream
// Be careful that you need to provide sheetName or
// sheetId for correct import to csv.
await workbook . csv . write ( stream , { sheetName : 'Page name' } ) ;
// write to a file with European Date-Times
const workbook = new Excel . Workbook ( ) ;
const options = {
dateFormat : 'DD/MM/YYYY HH:mm:ss' ,
dateUTC : true , // use utc when rendering dates
} ;
await workbook . csv . writeFile ( filename , options ) ;
// write to a file with custom value formatting
const workbook = new Excel . Workbook ( ) ;
const options = {
map ( value , index ) {
switch ( index ) {
case 0 :
// column 1 is string
return value ;
case 1 :
// column 2 is a date
return dayjs ( value ) . format ( 'YYYY-MM-DD' ) ;
case 2 :
// column 3 is a formula, write just the result
return value . result ;
default :
// the rest are numbers
return value ;
}
} ,
// https://c2fo.github.io/fast-csv/docs/formatting/options
formatterOptions : {
delimiter : 't' ,
quote : false ,
} ,
} ;
await workbook . csv . writeFile ( filename , options ) ;
// write to a new buffer
const buffer = await workbook . csv . writeBuffer ( ) ;L'analyseur CSV utilise Fast-CSV pour écrire le fichier CSV. Les formatrices dans les options transmises à la fonction d'écriture ci-dessus seront transmises au module @ fast-csv / format pour écrire des données CSV. Veuillez vous référer à Fast-CSV Readme.md pour plus de détails.
Les dates sont formatées à l'aide du module NPM DayJS. Si aucun DateFormat n'est fourni, Dayjs.Iso_8601 est utilisé. Lors de la rédaction d'un CSV, vous pouvez fournir le booléen dateUtc comme vrai pour avoir exceljs analyser la date sans convertir automatiquement le fuseau horaire en utilisant dayjs.utc() .
Le fichier E / S documenté ci-dessus nécessite qu'un classeur entier soit construit en mémoire avant que le fichier puisse être écrit. Bien que pratique, il peut limiter la taille du document en raison de la quantité de mémoire requise.
Un écrivain (ou lecteur) en streaming traite les données du classeur ou de la feuille de travail telles qu'elle est générée, la convertissant en formulaire de fichier au fur et à mesure. En règle générale, cela est beaucoup plus efficace sur la mémoire, car l'empreinte de mémoire finale et même les empreintes de mémoire intermédiaire sont beaucoup plus compactes qu'avec la version du document, en particulier si l'on considère que les objets de ligne et de cellule sont éliminés une fois qu'ils sont engagés.
L'interface avec le classeur et la feuille de travail de streaming est presque la même que les versions de document avec quelques différences pratiques mineures:
Notez qu'il est possible de créer l'intégralité du classeur sans commettre de lignes. Lorsque le classeur est engagé, toutes les feuilles de calcul ajoutées (y compris toutes les lignes non engagées) seront automatiquement engagées. Cependant, dans ce cas, peu de choses auront été obtenues sur la version du document.
L'écrivain de classeur XLSX en streaming est disponible dans l'espace de noms ExcelJs.stream.xlsx.
Le constructeur prend un objet d'options facultatifs avec les champs suivants:
| Champ | Description |
|---|---|
| flux | Spécifie un flux écrit pour écrire le classeur XLSX. |
| nom de fichier | Si le flux n'est pas spécifié, ce champ spécifie le chemin d'accès à un fichier pour écrire le classeur XLSX. |
| usesharedstrings | Spécifie s'il faut utiliser des chaînes partagées dans le classeur. La valeur par défaut est false . |
| usyles | Spécifie s'il faut ajouter des informations de style au classeur. Les styles peuvent ajouter des frais généraux de performances. La valeur par défaut est false . |
| fermeture éclair | Les options de zip qui excellent entrent en interne à Archiver. La valeur par défaut n'est undefined . |
Si ni Stream ni Nom de fichier ne sont spécifiés dans les options, le rédacteur de travail créera un objet StreamBuf qui stockera le contenu du classeur XLSX en mémoire. Cet objet StreamBuf, qui peut être accessible via la propriété Workbook.stream, peut être utilisé pour accéder directement aux octets directement par Stream.Read () ou pour tuer le contenu à un autre flux.
// construct a streaming XLSX workbook writer with styles and shared strings
const options = {
filename : './streamed-workbook.xlsx' ,
useStyles : true ,
useSharedStrings : true
} ;
const workbook = new Excel . stream . xlsx . WorkbookWriter ( options ) ;En général, l'interface de l'écrivain XLSX en streaming est le même que le classeur (et les feuilles de travail) décrits ci-dessus, en fait, les objets de ligne, de cellule et de style sont les mêmes.
Cependant, il y a quelques différences ...
Construction
Comme on le voit ci-dessus, le répertoire de travail exigera généralement que le flux de sortie ou le fichier soit spécifié dans le constructeur.
Commettre des données
Lorsqu'une ligne de feuille de travail est prête, elle doit être engagée pour que l'objet et le contenu de la ligne puissent être libérés. En règle générale, cela serait fait lorsque chaque ligne est ajoutée ...
worksheet . addRow ( {
id : i ,
name : theName ,
etc : someOtherDetail
} ) . commit ( ) ;La raison pour laquelle le répertoire des feuilles de travail ne commet pas les lignes car elles sont ajoutées est de permettre à la fusion des cellules entre les lignes:
worksheet . mergeCells ( 'A1:B2' ) ;
worksheet . getCell ( 'A1' ) . value = 'I am merged' ;
worksheet . getCell ( 'C1' ) . value = 'I am not' ;
worksheet . getCell ( 'C2' ) . value = 'Neither am I' ;
worksheet . getRow ( 2 ) . commit ( ) ; // now rows 1 and two are committed.À mesure que chaque feuille de travail est terminée, elle doit également être engagée:
// Finished adding data. Commit the worksheet
worksheet . commit ( ) ;Pour compléter le document XLSX, le classeur doit être engagé. Si une feuille de travail dans un classeur n'est pas engagée, elle sera engagée automatiquement dans le cadre de la validation du classeur.
// Finished the workbook.
await workbook . commit ( ) ;
// ... the stream has been written Le lecteur de classeur XLSX en streaming est disponible dans l'espace de noms Exceljsam.Stream.xlsx.
Le constructeur prend un argument d'entrée requis et un argument d'options facultatifs:
| Argument | Description |
|---|---|
| entrée (requise) | Spécifie le nom du fichier ou le flux lisible à partir duquel lire le classeur XLSX. |
| Options (en option) | Spécifie comment gérer les types d'événements qui se produisent pendant l'analyse de lecture. |
| options. | Spécifie s'il faut émettre des entrées ( 'emit' ) ou non ( 'ignore' ). La valeur par défaut est 'emit' . |
| options.sharedstrings | Spécifie s'il faut mettre en cache des chaînes partagées ( 'cache' ), qui les insère dans les valeurs cellulaires respectives, ou s'il faut les émettre ( 'emit' ) ou les ignorer ( 'ignore' ), dans ce cas, la valeur cellulaire sera une référence à l'index de la chaîne partagée. La valeur par défaut est 'cache' . |
| options.hyperlinks | Spécifie s'il faut cacher les hyperliens ( 'cache' ), qui les insère dans leurs cellules respectives, si elles devraient les émettre ( 'emit' ) ou si elles doivent les ignorer ( 'ignore' ). La valeur par défaut est 'cache' . |
| Options. | Spécifie s'il faut cacher les styles ( 'cache' ), qui les insère dans leurs lignes et cellules respectives, ou s'il faut les ignorer ( 'ignore' ). La valeur par défaut est 'cache' . |
| Options.Worksheets | Spécifie s'il faut émettre des feuilles de travail ( 'emit' ) ou non ( 'ignore' ). La valeur par défaut est 'emit' . |
const workbookReader = new ExcelJS . stream . xlsx . WorkbookReader ( './file.xlsx' ) ;
for await ( const worksheetReader of workbookReader ) {
for await ( const row of worksheetReader ) {
// ...
}
} Veuillez noter que worksheetReader renvoie un tableau de lignes plutôt que chaque ligne individuellement pour des raisons de performance: Nodejs / Node # 31979
Les événements sur le classeur sont «feuille de travail», «cordes partagées» et «hyperliens». Les événements sur la feuille de calcul sont «Row» et «hyperliens».
const options = {
sharedStrings : 'emit' ,
hyperlinks : 'emit' ,
worksheets : 'emit' ,
} ;
const workbook = new ExcelJS . stream . xlsx . WorkbookReader ( './file.xlsx' , options ) ;
for await ( const { eventType , value } of workbook . parse ( ) ) {
switch ( eventType ) {
case 'shared-strings' :
// value is the shared string
case 'worksheet' :
// value is the worksheetReader
case 'hyperlinks' :
// value is the hyperlinksReader
}
} Bien que nous encourageons fortement à utiliser l'itération asynchrone, nous exposons également une interface de streaming pour la compatibilité descendante.
const options = {
sharedStrings : 'emit' ,
hyperlinks : 'emit' ,
worksheets : 'emit' ,
} ;
const workbookReader = new ExcelJS . stream . xlsx . WorkbookReader ( './file.xlsx' , options ) ;
workbookReader . read ( ) ;
workbookReader . on ( 'worksheet' , worksheet => {
worksheet . on ( 'row' , row => {
} ) ;
} ) ;
workbookReader . on ( 'shared-strings' , sharedString => {
// ...
} ) ;
workbookReader . on ( 'hyperlinks' , hyperlinksReader => {
// ...
} ) ;
workbookReader . on ( 'end' , ( ) => {
// ...
} ) ;
workbookReader . on ( 'error' , ( err ) => {
// ...
} ) ;Une partie de cette bibliothèque a été isolée et testée pour une utilisation dans un environnement de navigateur.
En raison de la nature en streaming du lecteur de classeur et rédacteur de travail, ceux-ci n'ont pas été inclus. Seul le classeur basé sur des documents peut être utilisé (voir Créer un classeur pour plus de détails).
Par exemple, le code utilisant Exceljs dans le navigateur jette un œil au dossier Spec / Browser dans le référentiel GitHub.
Les fichiers suivants sont pré-emballés et inclus dans le dossier DIST.
Les types de valeur suivants sont pris en charge.
Enum: excel.valuetype.null
Une valeur nulle indique une absence de valeur et ne sera généralement pas stockée lorsqu'elle est écrite dans le fichier (sauf pour les cellules fusionnées). Il peut être utilisé pour supprimer la valeur d'une cellule.
Par exemple
worksheet . getCell ( 'A1' ) . value = null ; Enum: Excel.valuetype.Merge
Une cellule de fusion est celle qui a sa valeur liée à une autre cellule «maître». L'attribution à une cellule de fusion entraînera la modification de la cellule du maître.
Enum: excel.valuetype.number
Une valeur numérique.
Par exemple
worksheet . getCell ( 'A1' ) . value = 5 ;
worksheet . getCell ( 'A2' ) . value = 3.14159 ; Enum: excel.valuetype.string
Une chaîne de texte simple.
Par exemple
worksheet . getCell ( 'A1' ) . value = 'Hello, World!' ; Enum: excel.valuetype.date
Une valeur de date, représentée par le type de date JavaScript.
Par exemple
worksheet . getCell ( 'A1' ) . value = new Date ( 2017 , 2 , 15 ) ; Enum: excel.valuetype.hyperlink
Une URL avec à la fois le texte et la valeur de liaison.
Par exemple
// link to web
worksheet . getCell ( 'A1' ) . value = {
text : 'www.mylink.com' ,
hyperlink : 'http://www.mylink.com' ,
tooltip : 'www.mylink.com'
} ;
// internal link
worksheet . getCell ( 'A1' ) . value = { text : 'Sheet2' , hyperlink : '#'Sheet2'!A1' } ; Enum: excel.valuetype.formula
Une formule Excel pour calculer les valeurs à la volée. Notez que même si le type de cellule sera une formule, la cellule peut avoir une valeur d'effet de détractions qui sera dérivée de la valeur du résultat.
Notez que ExcelJS ne peut pas traiter la formule pour générer un résultat, il doit être fourni.
Notez que les noms sémantiques de fonction doivent être en anglais et que le séparateur doit être une virgule.
Par exemple
worksheet . getCell ( 'A3' ) . value = { formula : 'A1+A2' , result : 7 } ;
worksheet . getCell ( 'A3' ) . value = { formula : 'SUM(A1,A2)' , result : 7 } ;Les cellules prennent également en charge les getters de commodité pour accéder à la formule et au résultat:
worksheet . getCell ( 'A3' ) . formula === 'A1+A2' ;
worksheet . getCell ( 'A3' ) . result === 7 ;Les formules partagées améliorent la compression du document XLSX en diminuant la répétition du texte dans la feuille de calcul XML. La cellule supérieure gauche dans une gamme est le maître désigné et maintiendra la formule dont toutes les autres cellules de la gamme dériveront. Les autres cellules «esclaves» peuvent ensuite se référer à cette cellule maîtresse au lieu de redéfinir à nouveau toute la formule. Notez que la formule maître sera traduite par les cellules esclaves de la manière habituelle Excel afin que les références à d'autres cellules soient décalées et vers la droite en fonction du décalage de l'esclave au maître. Par exemple: si la cellule maître A2 a une formule faisant référence à A1, alors si la cellule B2 partage la formule d'A2, elle fera référence à B1.
Une formule maître peut être affectée à une cellule avec les cellules esclaves dans sa gamme
worksheet . getCell ( 'A2' ) . value = {
formula : 'A1' ,
result : 10 ,
shareType : 'shared' ,
ref : 'A2:B3'
} ;Une formule partagée peut être affectée à une cellule à l'aide d'un nouveau formulaire de valeur:
worksheet . getCell ( 'B2' ) . value = { sharedFormula : 'A2' , result : 10 } ;Cela spécifie que la cellule B2 est une formule qui sera dérivée de la formule dans A2 et que son résultat est 10.
Le Getter Formula Comocient Traduire la formule dans A2 en ce qu'il devrait être en B2:
expect ( worksheet . getCell ( 'B2' ) . formula ) . to . equal ( 'B1' ) ;Des formules partagées peuvent être attribuées dans une feuille à l'aide de la fonction «FillFormula»:
// set A1 to starting number
worksheet . getCell ( 'A1' ) . value = 1 ;
// fill A2 to A10 with ascending count starting from A1
worksheet . fillFormula ( 'A2:A10' , 'A1+1' , [ 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ] ) ;FillFormula peut également utiliser une fonction de rappel pour calculer la valeur à chaque cellule
// fill A2 to A100 with ascending count starting from A1
worksheet . fillFormula ( 'A2:A100' , 'A1+1' , ( row , col ) => row ) ;Pour faire la distinction entre les cellules de formule réelles et traduites, utilisez le Getter Forulatype:
worksheet . getCell ( 'A3' ) . formulaType === Enums . FormulaType . Master ;
worksheet . getCell ( 'B3' ) . formulaType === Enums . FormulaType . Shared ;Le type de formule a les valeurs suivantes:
| Nom | Valeur |
|---|---|
| Enums.formulatype.none | 0 |
| Enums.formulatype.master | 1 |
| Enums.formulatype.shared | 2 |
Une nouvelle façon d'exprimer des formules partagées dans Excel est la formule du tableau. Dans cette forme, la cellule maître est la seule cellule qui contient des informations relatives à une formule. Il contient le «tableau» de ShareType avec la gamme de cellules auxquelles elle s'applique et la formule qui sera copiée. Les autres cellules sont des cellules régulières avec des valeurs régulières.
Remarque: les formules du tableau ne sont pas traduites de la manière dont les formules partagées sont. Donc, si Master Cell A2 fait référence à A1, la cellule esclave B2 fera également référence à A1.
Par exemple
// assign array formula to A2:B3
worksheet . getCell ( 'A2' ) . value = {
formula : 'A1' ,
result : 10 ,
shareType : 'array' ,
ref : 'A2:B3'
} ;
// it may not be necessary to fill the rest of the values in the sheetLa fonction FillFormula peut également être utilisée pour remplir une formule de tableau
// fill A2:B3 with array formula "A1"
worksheet . fillFormula ( 'A2:B3' , 'A1' , [ 1 , 1 , 1 , 1 ] , 'array' ) ; Enum: excel.valuetype.richText
Texte riche et stylé.
Par exemple
worksheet . getCell ( 'A1' ) . value = {
richText : [
{ text : 'This is ' } ,
{ font : { italic : true } , text : 'italic' } ,
]
} ; Enum: Excel.valuetype.boolean
Par exemple
worksheet . getCell ( 'A1' ) . value = true ;
worksheet . getCell ( 'A2' ) . value = false ; Enum: Excel.valuetype.Error
Par exemple
worksheet . getCell ( 'A1' ) . value = { error : '#N/A' } ;
worksheet . getCell ( 'A2' ) . value = { error : '#VALUE!' } ;Les valeurs de texte d'erreur valides actuelles sont:
| Nom | Valeur |
|---|---|
| Excel.ErrorValue.NotApplicable | #N / A |
| Excel.ErrorValue.ref | #REF! |
| Excel.ErrorValue.name | #NOM? |
| Excel.ErrorValue.Divzero | # Div / 0! |
| Excel.errorvalue.null | #NUL! |
| Excel.ErrorValue.Value | #VALEUR! |
| Excel.errorvalue.num | #Num! |
Tous les efforts sont faits pour faire une bonne interface cohérente qui ne percède pas les versions mais malheureusement, de temps en temps, certaines choses doivent changer pour le plus grand bien.
Les arguments de la fonction de rappel à la feuille de calcul.Eensive ont été échangés et modifiés; C'était une fonction (Rownumber, RowValues), maintenant c'est la fonction (ligne, Rownumber) qui lui donne un look et ressentir davantage la fonction de soulignement (_.each) et priorités l'objet de ligne sur le numéro de ligne.
Cette fonction est passée depuis le renvoi d'un tableau clairsemé de valeurs cellulaires à un renvoi d'un objet de ligne. Cela permet d'accéder aux propriétés des lignes et facilitera la gestion des styles de lignes, etc.
Le tableau clairsemé des valeurs cellulaires est toujours disponible via une feuille de calcul.getrow (Rownumber). Values;
cellule.
Les promesses renvoyées des fonctions sont passées de Bluebird à la promesse du nœud natif qui peut casser le code d'appel s'ils comptent sur les fonctionnalités supplémentaires de Bluebird.
Pour atténuer cela, les deux modifications suivantes ont été ajoutées à 0.3.0:
ExcelJS soutient désormais l'injection de dépendance pour la bibliothèque Promise. Vous pouvez restaurer les promesses de Bluebird en incluant le code suivant dans votre module ...
ExcelJS . config . setValue ( 'promise' , require ( 'bluebird' ) ) ;Veuillez noter: j'ai testé ExcelJS avec Bluebird spécifiquement (car jusqu'à récemment, c'était la bibliothèque qu'il a utilisée). D'après les tests que j'ai effectués, cela ne fonctionnera pas avec Q.
Avant de publier ce module, le code source est transpilé et autrement traité avant d'être placé dans un dossier DIST /. Ce ReadMe identifie deux fichiers - un bundle de navigation et une version minifiée. Aucun autre contenu du dossier DIST / n'est garanti de quelque manière que ce soit autre que le fichier spécifié comme "principal" dans le package.json
La suite de test incluse dans cette LIB comprend un petit script exécuté dans un navigateur sans tête pour valider les packages groupés. Au moment d'écrire ces lignes, il semble que ce test ne joue pas bien dans le sous-système Windows Linux.
Pour cette raison, le test du navigateur peut être désactivé par l'existence d'un fichier nommé.
sudo apt-get install libfontconfigSi une opération d'épissage affecte une cellule fusionnée, le groupe de fusion ne sera pas déplacé correctement
| Version | Changements |
|---|---|
| 0.0.9 |
|
| 0.1.0 |
|
| 0.1.1 |
|
| 0.1.2 |
|
| 0.1.3 |
|
| 0.1,5 |
|
| 0.1.6 |
|
| 0.1.8 |
|
| 0.1.9 |
|
| 0.1.10 |
|
| 0.1.11 |
|
| 0.2.0 |
|
| 0.2.2 |
|
| 0.2.3 |
|
| 0.2.4 |
|
| 0.2.6 |
|
| 0.2.7 |
|
| 0.2.8 |
|
| 0.2.9 |
|
| 0.2.10 |
|
| 0.2.11 |
|
| 0.2.12 |
|
| 0.2.13 |
|
| 0.2.14 |
|
| 0.2.15 |
|
| 0.2.16 |
|
| 0.2.17 |
|
| 0.2.18 |
|
| 0.2.19 |
|
| 0.2.20 |
|
| 0.2.21 |
|
| 0.2.22 |
|
| 0.2.23 |
|
| 0.2.24 |
|
| 0.2.25 |
|
| 0.2.26 |
|
| 0.2.27 |
|
| 0.2.28 |
|
| 0.2.29 |
|
| 0.2.30 |
|
| 0.2.31 |
|
| 0.2.32 |
|
| 0.2.33 |
|
| 0.2.34 |
|
| 0.2.35 |
|
| 0.2.36 |
|
| 0.2.37 |
|
| 0.2.38 |
|
| 0.2.39 |
|
| 0.2.42 |
|
| 0.2.43 |
|
| 0.2.44 |
|
| 0.2.45 |
|
| 0.2.46 |
|
| 0.3.0 |
|
| 0.3.1 |
|
| 0.4.0 |
|
| 0.4.1 |
|
| 0.4.2 |
|
| 0.4.3 |
|
| 0.4.4 |
|
| 0.4.6 |
|
| 0.4.9 |
|
| 0.4.10 |
|
| 0.4.11 |
|
| 0.4.12 |
|
| 0.4.13 |
|
| 0.4.14 |
|
| 0.5.0 |
|
| 0.5.1 |
|
| 0.6.0 |
|
| 0.6.1 |
|
| 0.6.2 |
|
| 0.7.0 |
|
| 0.7.1 |
|
| 0.8.0 |
|
| 0.8.1 |
|
| 0.8.2 |
|
| 0.8.3 |
|
| 0.8.4 |
|
| 0.8.5 |
|
| 0.9.0 |
|
| 0.9.1 |
|
| 1.0.0 |
|
| 1.0.1 |
|
| 1.0.2 |
|
| 1.1.0 |
|
| 1.1.1 |
|
| 1.1.2 |
|
| 1.1.3 |
|
| 1.2.0 |
|
| 1.2.1 |
|
| 1.3.0 |
|
| 1.4.2 |
|
| 1.4.3 |
|
| 1.4.5 |
|
| 1.4.6 |
|
| 1.4.7 |
|
| 1.4.8 |
|
| 1.4.9 |
|
| 1.4.10 |
|
| 1.4.12 |
|
| 1.4.13 |
|
| 1.5.0 |
|
| 1.5.1 |
|
| 1.6.0 |
|
| 1.6.1 |
|
| 1.6.2 |
|
| 1.6.3 |
|
| 1.7.0 |
|
| 1.8.0 |
|
| 1.9.0 |
|
| 1.9.1 |
|
| 1.10.0 |
|
| 1.11.0 |
|
| 1.12.0 |
|
| 1.12.1 |
|
| 1.12.2 |
|
| 1.13.0 |
|
| 1.14.0 |
|
| 1.15.0 |
|
| 2.0.1 | Major Version ChangeIntroducing async/await to ExcelJS! The new async and await features of JavaScript can help a lot to make code more readable and maintainable. To avoid confusion, particularly with returned promises from async functions, we have had to remove the Promise class configuration option and from v2 onwards ExcelJS will use native Promises. Since this is potentially a breaking change we're bumping the major version for this release. Changements
|
| 3.0.0 | Another Major Version ChangeJavascript has changed a lot over the years, and so have the modules and technologies surrounding it. To this end, this major version of ExcelJS changes the structure of the publish artefacts: Main Export is now the Original Javascript SourcePrior to this release, the transpiled ES5 code was exported as the package main. From now on, the package main comes directly from the lib/ folder. This means a number of dependencies have been removed, including the polyfills. ES5 and Browserify are Still IncludedIn order to support those that still require ES5 ready code (eg as dependencies in web apps) the source code will still be transpiled and available in dist/es5. The ES5 code is also browserified and available as dist/exceljs.js or dist/exceljs.min.js See the section Importing for details |
| 3.1.0 |
|
| 3.2.0 |
|
| 3.3.0 |
|
| 3.3.1 |
|
| 3.4.0 |
|
| 3.5.0 |
|
| 3.6.0 |
|
| 3.6.1 |
|
| 3.7.0 |
|
| 3.8.0 |
|
| 3.8.1 |
|
| 3.8.2 |
|
| 3.9.0 |
|
| 3.10.0 |
|
| 4.0.1 |
|
| 4.1.0 |
|
| 4.1.1 |
|
| 4.2.0 |
|
| 4.2.1 |
|
| 4.3.0 |
|
