exceljs
v4.4.0
Lesen, bearbeiten und schreiben Sie Tabellendaten und -stile in XLSX und JSON.
Reverse Engineering aus Excel-Tabellendateien als Projekt.
npm install exceljsBeiträge sind herzlich willkommen! Es hilft mir zu wissen, welche Funktionen gewünscht sind oder welche Fehler die meisten Probleme verursachen.
Ich habe nur eine Bitte; Wenn Sie eine Pull-Anfrage für einen Bugfix einreichen, fügen Sie bitte einen Unit-Test oder Integration-Test (im Spec-Ordner) hinzu, der das Problem erkennt. Sogar ein PR, bei dem nur ein Test fehlschlägt, ist in Ordnung – ich kann analysieren, was der Test macht, und daraus den Code korrigieren.
Hinweis: Bitte vermeiden Sie, die Paketversion in einer PR zu ändern. Versionen werden bei der Veröffentlichung aktualisiert und jede Änderung wird höchstwahrscheinlich zu Zusammenführungskollisionen führen.
Um es klarzustellen: Alle zu dieser Bibliothek hinzugefügten Beiträge sind in der MIT-Lizenz der Bibliothek enthalten.
const ExcelJS = require ( 'exceljs' ) ; Um den transpilierten ES5-Code zu verwenden, beispielsweise für node.js-Versionen älter als 10, verwenden Sie den Pfad dist/es5.
const ExcelJS = require ( 'exceljs/dist/es5' ) ;Hinweis: Der ES5-Build weist eine implizite Abhängigkeit von einer Reihe von Polyfills auf, die von ExcelJS nicht mehr explizit hinzugefügt werden. Sie müssen „core-js“ und „regenerator-runtime“ zu Ihren Abhängigkeiten hinzufügen und die folgenden Anforderungen in Ihren Code aufnehmen, bevor Sie ExcelJS importieren:
// 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' ) ;Für IE 11 benötigen Sie außerdem eine Polyfüllung, um Unicode-Regex-Muster zu unterstützen. Zum Beispiel,
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 veröffentlicht zwei browserbasierte Bundles im Ordner dist/:
Eines mit impliziten Abhängigkeiten von Core-JS-Polyfills ...
< script src =" https://cdnjs.cloudflare.com/ajax/libs/babel-polyfill/6.26.0/polyfill.js " > </ script >
< script src =" exceljs.js " > </ script >Und einer ohne...
< 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 ; Die Arbeitsmappenansichten steuern, wie viele separate Fenster Excel beim Anzeigen der Arbeitsmappe öffnen.
workbook . views = [
{
x : 0 , y : 0 , width : 10000 , height : 20000 ,
firstSheet : 0 , activeTab : 1 , visibility : 'visible'
}
] const sheet = workbook . addWorksheet ( 'My Sheet' ) ;Verwenden Sie den zweiten Parameter der Funktion addWorksheet, um Optionen für das Arbeitsblatt anzugeben.
Zum Beispiel:
// 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' }
} ) ; Verwenden Sie die Arbeitsblatt- id um das Blatt aus der Arbeitsmappe zu entfernen.
Zum Beispiel:
// 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; Es ist wichtig zu wissen, dass workbook.getWorksheet(1) != Workbook.worksheets[0] und workbook.getWorksheet(1) != Workbook.worksheets[1] , da workbook.worksheets[0].id einen beliebigen Wert haben kann.
// make worksheet visible
worksheet . state = 'visible' ;
// make worksheet hidden
worksheet . state = 'hidden' ;
// make worksheet hidden from 'hide/unhide' dialog
worksheet . state = 'veryHidden' ; Arbeitsblätter unterstützen einen Eigenschaften-Bucket, um die Kontrolle über einige Funktionen des Arbeitsblatts zu ermöglichen.
// 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 ;Unterstützte Eigenschaften
| Name | Standard | Beschreibung |
|---|---|---|
| tabColor | undefiniert | Farbe der Registerkarten |
| GliederungLevelCol | 0 | Die Umrissebene der Arbeitsblattspalte |
| GliederungsebeneRow | 0 | Die Gliederungsebene der Arbeitsblattzeile |
| defaultRowHeight | 15 | Standardzeilenhöhe |
| defaultColWidth | (optional) | Standardspaltenbreite |
| dyDescent | 55 | Noch offen |
Dem Arbeitsblatt wurden einige neue Metriken hinzugefügt ...
| Name | Beschreibung |
|---|---|
| rowCount | Die Gesamtzeilengröße des Dokuments. Entspricht der Zeilennummer der letzten Zeile, die Werte enthält. |
| currentRowCount | Eine Zählung der Anzahl der Zeilen, die Werte haben. Wenn eine Zeile in der Mitte des Dokuments leer ist, wird sie nicht in die Zählung einbezogen. |
| ColumnCount | Die Gesamtspaltengröße des Dokuments. Entspricht der maximalen Zellenzahl aus allen Zeilen |
| currentColumnCount | Eine Anzahl der Spalten, die Werte enthalten. |
Alle Eigenschaften, die sich auf das Drucken eines Blatts auswirken können, werden in einem pageSetup-Objekt auf dem Blatt gespeichert.
// 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' ;Unterstützte pageSetup-Einstellungen
| Name | Standard | Beschreibung |
|---|---|---|
| Ränder | Leerzeichen an den Rändern der Seite. Einheiten sind Zoll. | |
| Orientierung | 'Porträt' | Ausrichtung der Seite – also höher (Hochformat) oder breiter (Querformat) |
| horizontalDpi | 4294967295 | Horizontale Punkte pro Zoll. Der Standardwert ist -1 |
| vertikaleDpi | 4294967295 | Vertikale Punkte pro Zoll. Der Standardwert ist -1 |
| fitToPage | Ob fitToWidth und fitToHeight oder Skalierungseinstellungen verwendet werden sollen. Der Standardwert basiert auf dem Vorhandensein dieser Einstellungen im pageSetup-Objekt. Wenn beide vorhanden sind, gewinnt die Skalierung (d. h. der Standardwert ist „false“). | |
| Seitenreihenfolge | 'downThenOver' | In welcher Reihenfolge die Seiten gedruckt werden sollen – eine von ['downThenOver', 'overThenDown'] |
| blackAndWhite | FALSCH | Ohne Farbe drucken |
| Entwurf | FALSCH | Drucken Sie mit geringerer Qualität (und Tinte) |
| cellComments | 'Keiner' | Wo Kommentare platziert werden sollen – einer von ['atEnd', 'asDisplayed', 'None'] |
| Fehler | 'angezeigt' | Wo Fehler angezeigt werden sollen – einer von ['dash', 'blank', 'NA', 'displayed'] |
| Skala | 100 | Prozentwert zum Vergrößern oder Verkleinern des Ausdrucks. Aktiv, wenn fitToPage „false“ ist |
| fitToWidth | 1 | Auf wie viele Seiten breit das Blatt gedruckt werden soll. Aktiv, wenn fitToPage wahr ist |
| fitToHeight | 1 | Auf wie viele Seiten hoch das Blatt gedruckt werden soll. Aktiv, wenn fitToPage wahr ist |
| Papiergröße | Welches Papierformat soll verwendet werden (siehe unten) | |
| showRowColHeaders | FALSCH | Ob die Zeilennummern und Spaltenbuchstaben angezeigt werden sollen |
| showGridLines | FALSCH | Ob Gitterlinien angezeigt werden sollen |
| ersteSeitennummer | Welche Nummer für die erste Seite verwendet werden soll | |
| horizontalZentriert | FALSCH | Ob die Blattdaten horizontal zentriert werden sollen |
| vertikalZentriert | FALSCH | Ob die Blattdaten vertikal zentriert werden sollen |
Beispielpapierformate
| Name | Wert |
|---|---|
| Brief | undefiniert |
| Legal | 5 |
| Exekutive | 7 |
| A3 | 8 |
| A4 | 9 |
| A5 | 11 |
| B5 (JIS) | 13 |
| Umschlag Nr. 10 | 20 |
| Umschlag DL | 27 |
| Umschlag C5 | 28 |
| Umschlag B5 | 34 |
| Umschlag Monarch | 37 |
| Doppelte Japan-Postkarte gedreht | 82 |
| 16K 197x273 mm | 119 |
So fügen Sie Kopf- und Fußzeilen hinzu. Der hinzugefügte Inhalt besteht hauptsächlich aus Text, z. B. Zeit, Einleitung, Dateiinformationen usw., und Sie können den Stil des Texts festlegen. Darüber hinaus können Sie für die erste Seite und die gerade Seite unterschiedliche Texte festlegen.
Hinweis: Bilder werden derzeit nicht unterstützt.
// 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"Unterstützte HeaderFooter-Einstellungen
| Name | Standard | Beschreibung |
|---|---|---|
| andersZuerst | FALSCH | Legen Sie den Wert von differentFirst auf „true“ fest, was angibt, dass sich Kopf-/Fußzeilen für die erste Seite von den anderen Seiten unterscheiden |
| differentOddEven | FALSCH | Legen Sie den Wert von differentOddEven auf true fest, was angibt, dass Kopf-/Fußzeilen für ungerade und gerade Seiten unterschiedlich sind |
| oddHeader | null | Legen Sie die Kopfzeilenzeichenfolge für ungerade (Standard-)Seiten fest. Die Zeichenfolge könnte formatiert werden |
| oddFooter | null | Fußzeilenzeichenfolge für ungerade (Standard-)Seiten festlegen, könnte die Zeichenfolge formatieren |
| evenHeader | null | Legen Sie die Kopfzeilenzeichenfolge für gerade Seiten fest. Die Zeichenfolge könnte formatiert werden |
| evenFooter | null | Fußzeilenzeichenfolge für gerade Seiten festlegen, die Zeichenfolge könnte formatiert werden |
| ersterHeader | null | Legen Sie die Kopfzeilenzeichenfolge für die erste Seite fest. Die Zeichenfolge könnte formatiert werden |
| ersteFußzeile | null | Legen Sie die Fußzeilenzeichenfolge für die erste Seite fest. Die Zeichenfolge könnte formatiert werden |
Skriptbefehle
| Befehle | Beschreibung |
|---|---|
| &L | Position nach links einstellen |
| &C | Position auf die Mitte einstellen |
| &R | Position nach rechts einstellen |
| &P | Die aktuelle Seitenzahl |
| &N | Die Gesamtzahl der Seiten |
| &D | Das aktuelle Datum |
| &T | Die aktuelle Uhrzeit |
| &G | Ein Bild |
| &A | Der Arbeitsblattname |
| &F | Der Dateiname |
| &B | Machen Sie den Text fett |
| &ICH | Text kursiv schreiben |
| &U | Text unterstreichen |
| &"Schriftartname" | Schriftartname, zum Beispiel &"Aril" |
| &Schriftgröße | Schriftgröße, zum Beispiel 12 |
| &KHEXCode | Schriftfarbe, zum Beispiel &KCCCCCC |
Arbeitsblätter unterstützen jetzt eine Liste von Ansichten, die steuern, wie Excel das Blatt darstellt:
Jede Ansicht unterstützt außerdem verschiedene Eigenschaften:
| Name | Standard | Beschreibung |
|---|---|---|
| Zustand | 'Normal' | Steuert den Ansichtsstatus – normal, eingefroren oder geteilt |
| rightToLeft | FALSCH | Legt die Ausrichtung der Arbeitsblattansicht auf rechts nach links fest |
| aktive Zelle | undefiniert | Die aktuell ausgewählte Zelle |
| showRuler | WAHR | Blendet das Lineal im Seitenlayout ein oder aus |
| showRowColHeaders | WAHR | Blendet die Zeilen- und Spaltenüberschriften ein oder aus (z. B. A1, B1 oben und 1,2,3 links). |
| showGridLines | WAHR | Blendet die Gitternetzlinien ein oder aus (wird für Zellen angezeigt, für die keine Ränder definiert wurden). |
| zoomScale | 100 | Prozentualer Zoom, der für die Ansicht verwendet werden soll |
| zoomScaleNormal | 100 | Normaler Zoom für die Ansicht |
| Stil | undefiniert | Präsentationsstil – einer von pageBreakPreview oder pageLayout. Hinweis: pageLayout ist nicht mit eingefrorenen Ansichten kompatibel |
Eingefrorene Ansichten unterstützen die folgenden zusätzlichen Eigenschaften:
| Name | Standard | Beschreibung |
|---|---|---|
| xSplit | 0 | Wie viele Spalten sollen eingefroren werden? Um nur Zeilen einzufrieren, setzen Sie dies auf 0 oder undefiniert |
| ySplit | 0 | Wie viele Zeilen sollen eingefroren werden? Um nur Spalten einzufrieren, setzen Sie dies auf 0 oder undefiniert |
| topLeftCell | besonders | Welche Zelle wird oben links im unteren rechten Bereich angezeigt? Hinweis: Es kann sich nicht um eine eingefrorene Zelle handeln. Standardmäßig wird die erste nicht eingefrorene Zelle verwendet |
worksheet . views = [
{ state : 'frozen' , xSplit : 2 , ySplit : 3 , topLeftCell : 'G10' , activeCell : 'A1' }
] ;Geteilte Ansichten unterstützen die folgenden zusätzlichen Eigenschaften:
| Name | Standard | Beschreibung |
|---|---|---|
| xSplit | 0 | Wie viele Punkte von links muss der Splitter platziert werden? Um vertikal zu teilen, setzen Sie dies auf 0 oder undefiniert |
| ySplit | 0 | Wie viele Punkte von oben muss der Splitter platziert werden? Um horizontal zu teilen, setzen Sie dies auf 0 oder undefiniert |
| topLeftCell | undefiniert | Welche Zelle wird oben links im unteren rechten Bereich angezeigt? |
| activePane | undefiniert | Welcher Bereich wird aktiv sein – einer von „topLeft“, „topRight“, „bottomLeft“ und „bottomRight“. |
worksheet . views = [
{ state : 'split' , xSplit : 2000 , ySplit : 3000 , topLeftCell : 'G10' , activeCell : 'A1' }
] ; Es ist möglich, einen automatischen Filter auf Ihr Arbeitsblatt anzuwenden.
worksheet . autoFilter = 'A1:C1' ;Während die Bereichszeichenfolge die Standardform des AutoFilters ist, unterstützt das Arbeitsblatt auch die folgenden Werte:
// 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' ) ;| Parameter | Beschreibung | Standardwert |
|---|---|---|
| Werte | Die neuen Zeilenwerte | |
| Stil | „i“ für „Von der obigen Zeile erben“, „i+“ für die Einbeziehung leerer Zellen, „n“ für „keine“. | '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' ) ;| Parameter | Beschreibung | Standardwert |
|---|---|---|
| Pos | Geben Sie die Zeilennummer ein, an der Sie einfügen möchten, und schieben Sie von dort aus alle Zeilen nach unten | |
| Werte | Die neuen Zeilenwerte | |
| Stil | „i“ für „Von der obigen Zeile erben“, „i+“ für die Einbeziehung leerer Zellen, „o“ für den ursprünglichen Stil, „o+“ für die Einbeziehung leerer Zellen, „n“ für keine | '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' ) ;| Parameter | Beschreibung | Standardwert |
|---|---|---|
| Start | Ausgangspunkt für die Verbindung | |
| zählen | Anzahl der zu entfernenden Zeilen/Zellen | |
| ...einfügt | Neue Zeilen-/Zellenwerte zum Einfügen |
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 ) ;| Parameter | Beschreibung | Standardwert |
|---|---|---|
| Start | Zeilennummer, die Sie duplizieren möchten (die erste in Excel ist 1) | |
| Menge | Die Zeiten, zu denen Sie die Zeile duplizieren möchten | 1 |
| einfügen | true , wenn Sie neue Zeilen für die Duplikate einfügen möchten, oder false , wenn Sie diese ersetzen möchten | WAHR |
Einzelnen Zellen (oder mehreren Zellgruppen) können Namen zugewiesen werden. Die Namen können in Formeln und zur Datenvalidierung (und wahrscheinlich mehr) verwendet werden.
// 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' ] ) ; Zellen können definieren, welche Werte gültig sind und welche nicht, und dem Benutzer Hinweise zur Orientierung geben.
Validierungstypen können einer der folgenden sein:
| Typ | Beschreibung |
|---|---|
| Liste | Definieren Sie einen diskreten Satz gültiger Werte. Excel bietet diese zur einfachen Eingabe in einem Dropdown-Menü an |
| ganz | Der Wert muss eine ganze Zahl sein |
| dezimal | Der Wert muss eine Dezimalzahl sein |
| textLength | Der Wert kann Text sein, die Länge wird jedoch gesteuert |
| Brauch | Eine benutzerdefinierte Formel steuert die gültigen Werte |
Bei anderen Typen als Liste oder Benutzerdefiniert wirken sich die folgenden Operatoren auf die Validierung aus:
| Operator | Beschreibung |
|---|---|
| zwischen | Die Werte müssen zwischen den Formelergebnissen liegen |
| notBetween | Werte dürfen nicht zwischen Formelergebnissen liegen |
| gleich | Der Wert muss dem Formelergebnis entsprechen |
| notEqual | Der Wert darf nicht dem Formelergebnis entsprechen |
| größer als | Der Wert muss größer als das Formelergebnis sein |
| weniger als | Der Wert muss kleiner als das Formelergebnis sein |
| größer als oder gleich | Der Wert muss größer oder gleich dem Formelergebnis sein |
| LessThanOrEqual | Der Wert muss kleiner oder gleich dem Formelergebnis sein |
// 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 ) ]
} ; Fügen Sie einer Zelle einen Kommentar im alten Stil hinzu
// 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' ,
} ;In der folgenden Tabelle werden die von Zellkommentaren unterstützten Eigenschaften definiert.
| Feld | Erforderlich | Standardwert | Beschreibung |
|---|---|---|---|
| Texte | Y | Der Text des Kommentars | |
| Ränder | N | {} | Bestimmt den Wert der Ränder für automatische oder benutzerdefinierte Zellkommentare |
| Schutz | N | {} | Festlegen des Sperrstatus von Objekten und Objekttexten mithilfe von Schutzattributen |
| editAs | N | 'Absolute' | Verwenden Sie das Attribut „editAs“, um anzugeben, wie die Anmerkung in der Zelle verankert wird |
Bestimmen Sie den Seitenrand-Einstellungsmodus der Zellenanmerkung: automatischer oder benutzerdefinierter Modus.
ws . getCell ( 'B1' ) . note . margins = {
insetmode : 'custom' ,
inset : [ 0.25 , 0.25 , 0.35 , 0.35 ]
}| Eigentum | Erforderlich | Standardwert | Beschreibung |
|---|---|---|---|
| Einfügemodus | N | 'Auto' | Legt fest, ob Kommentarränder automatisch festgelegt werden und der Wert „Auto“ oder „Benutzerdefiniert“ ist. |
| Einsatz | N | [0,13, 0,13, 0,25, 0,25] | Leerzeichen an den Rändern des Kommentars. Einheiten sind Zentimeter. Die Richtung ist links, oben, rechts, unten |
Hinweis: Diese inset Einstellung wird nur wirksam, wenn der Wert von insetmode „custom“ ist.
Festlegen des Sperrstatus von Objekten und Objekttexten mithilfe von Schutzattributen.
ws . getCell ( 'B1' ) . note . protection = {
locked : 'False' ,
lockText : 'False' ,
} ;| Eigentum | Erforderlich | Standardwert | Beschreibung |
|---|---|---|---|
| gesperrt | N | 'WAHR' | Dieses Element gibt an, dass das Objekt gesperrt ist, wenn das Blatt geschützt ist |
| lockText | N | 'WAHR' | Dieses Element gibt an, dass der Text des Objekts gesperrt ist |
Hinweis: Gesperrte Objekte sind nur gültig, wenn das Arbeitsblatt geschützt ist.
Die Zellkommentare können auch über die Eigenschaft „editAs“ verfügen, die steuert, wie die Kommentare in der/den Zelle(n) verankert werden. Es kann einen der folgenden Werte haben:
ws . getCell ( 'B1' ) . note . editAs = 'twoCells' ;| Wert | Beschreibung |
|---|---|
| zweiZellen | Es gibt an, dass die Größe und Position der Notiz je nach Zelle variiert |
| oneCells | Es gibt an, dass die Größe der Notiz fest ist und sich die Position mit der Zelle ändert |
| Absolute | Dies ist die Standardeinstellung. Kommentare werden nicht mit Zellen verschoben oder in ihrer Größe verändert |
Tabellen ermöglichen die blattinterne Bearbeitung von Tabellendaten.
Um eine Tabelle zu einem Arbeitsblatt hinzuzufügen, definieren Sie ein Tabellenmodell und rufen Sie addTable auf:
// 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 ] ,
] ,
} ) ;Hinweis: Durch das Hinzufügen einer Tabelle zu einem Arbeitsblatt wird das Blatt geändert, indem Kopfzeilen und Zeilendaten in das Blatt eingefügt werden. Alle Daten auf dem Blatt, die von der resultierenden Tabelle abgedeckt werden (einschließlich Kopfzeilen und Summen), werden überschrieben.
Die folgende Tabelle definiert die von Tabellen unterstützten Eigenschaften.
| Tabelleneigenschaft | Beschreibung | Erforderlich | Standardwert |
|---|---|---|---|
| Name | Der Name der Tabelle | Y | |
| Anzeigename | Der Anzeigename der Tabelle | N | Name |
| ref | Obere linke Zelle der Tabelle | Y | |
| headerRow | Kopfzeilen oben in der Tabelle anzeigen | N | WAHR |
| totalsRow | Gesamtsummen unten in der Tabelle anzeigen | N | FALSCH |
| Stil | Zusätzliche Stileigenschaften | N | {} |
| Spalten | Spaltendefinitionen | Y | |
| Reihen | Datenzeilen | Y |
Die folgende Tabelle definiert die Eigenschaften, die innerhalb der Tabellenstileigenschaft unterstützt werden.
| Style-Eigenschaft | Beschreibung | Erforderlich | Standardwert |
|---|---|---|---|
| Thema | Das Farbthema des Tisches | N | 'TableStyleMedium2' |
| showFirstColumn | Markieren Sie die erste Spalte (fett) | N | FALSCH |
| showLastColumn | Markieren Sie die letzte Spalte (fett) | N | FALSCH |
| showRowStripes | Alternative Zeilen mit Hintergrundfarbe angezeigt | N | FALSCH |
| showColumnStripes | Alternative Zeilen mit Hintergrundfarbe angezeigt | N | FALSCH |
Die folgende Tabelle definiert die in jeder Tabellenspalte unterstützten Eigenschaften.
| Spalteneigenschaft | Beschreibung | Erforderlich | Standardwert |
|---|---|---|---|
| Name | Der Name der Spalte, der auch in der Kopfzeile verwendet wird | Y | |
| filterButton | Schaltet die Filtersteuerung im Header um | N | FALSCH |
| totalsRowLabel | Beschriftung zur Beschreibung der Summenzeile (erste Spalte) | N | 'Gesamt' |
| totalsRowFunction | Name der Summenfunktion | N | 'keiner' |
| totalsRowFormula | Optionale Formel für benutzerdefinierte Funktionen | N |
In der folgenden Tabelle sind die gültigen Werte für die durch Spalten definierte Eigenschaft „totalsRowFunction“ aufgeführt. Wenn ein anderer Wert als „benutzerdefiniert“ verwendet wird, ist es nicht erforderlich, die zugehörige Formel einzubeziehen, da diese von der Tabelle eingefügt wird.
| Summenfunktionen | Beschreibung |
|---|---|
| keiner | Für diese Spalte gibt es keine Summenfunktion |
| Durchschnitt | Berechnen Sie den Durchschnitt für die Spalte |
| countNums | Zählen Sie die Einträge, die Zahlen sind |
| zählen | Anzahl der Einträge |
| max | Der Maximalwert in dieser Spalte |
| min | Der Mindestwert in dieser Spalte |
| stdDev | Die Standardabweichung für diese Spalte |
| var | Die Varianz für diese Spalte |
| Summe | Die Summe der Einträge für diese Spalte |
| Brauch | Eine benutzerdefinierte Formel. Erfordert einen zugehörigen totalsRowFormula-Wert. |
Gültige Theme-Namen folgen dem folgenden Muster:
Schattierungen, Zahlen können eines von Folgendem sein:
Für kein Thema verwenden Sie den Wert null.
Hinweis: Benutzerdefinierte Tabellenthemen werden von ExcelJS noch nicht unterstützt.
Tabellen unterstützen eine Reihe von Manipulationsfunktionen, mit denen Daten hinzugefügt oder entfernt und einige Eigenschaften geändert werden können. Da viele dieser Vorgänge möglicherweise Auswirkungen auf das Arbeitsblatt haben, müssen die Änderungen nach Abschluss festgeschrieben werden.
Alle Indexwerte in der Tabelle basieren auf Nullen, daher ist die erste Zeilennummer und die erste Spaltennummer 0.
Kopfzeilen und Summen hinzufügen oder entfernen
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 ( ) ;Einen Tisch verschieben
const table = ws . getTable ( 'MyTable' ) ;
// table top-left move to D4
table . ref = 'D4' ;
// commit the table changes into the sheet
table . commit ( ) ;Zeilen hinzufügen und entfernen
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 ( ) ;Spalten hinzufügen und entfernen
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 ( ) ;Spalteneigenschaften ändern
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 ( ) ; Zellen, Zeilen und Spalten unterstützen jeweils eine Vielzahl von Stilen und Formaten, die sich auf die Darstellung der Zellen auswirken.
Stile werden durch Zuweisen der folgenden Eigenschaften festgelegt:
// 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 } ;Wenn ein Stil auf eine Zeile oder Spalte angewendet wird, wird er auf alle derzeit vorhandenen Zellen in dieser Zeile oder Spalte angewendet. Außerdem erbt jede neu erstellte Zelle ihre ursprünglichen Stile von der Zeile und Spalte, zu der sie gehört.
Wenn sowohl die Zeile als auch die Spalte einer Zelle einen bestimmten Stil definieren (z. B. Schriftart), verwendet die Zelle den Zeilenstil gegenüber dem Spaltenstil. Wenn jedoch Zeile und Spalte unterschiedliche Stile definieren (z. B. „column.numFmt“ und „row.font“), erbt die Zelle die Schriftart von der Zeile und „numFmt“ von der Spalte.
Vorsichtsmaßnahme: Alle oben genannten Eigenschaften (mit Ausnahme von numFmt, das ein String ist) sind JS-Objektstrukturen. Wenn dasselbe Stilobjekt mehr als einer Tabellenkalkulationseinheit zugewiesen ist, nutzt jede Entität dasselbe Stilobjekt. Wenn das Stilobjekt später geändert wird, bevor die Tabelle serialisiert wird, werden alle Entitäten, die auf dieses Stilobjekt verweisen, ebenfalls geändert. Dieses Verhalten soll die Leistung priorisieren, indem die Anzahl der erstellten JS-Objekte reduziert wird. Wenn Sie möchten, dass die Stilobjekte unabhängig sind, müssen Sie sie klonen, bevor Sie sie zuweisen. Wenn ein Dokument aus einer Datei (oder einem Stream) gelesen wird und Tabellenkalkulationselemente ähnliche Stile haben, verweisen sie standardmäßig auch auf dasselbe Stilobjekt.
// 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| Schriftarteigenschaft | Beschreibung | Beispielwert(e) |
|---|---|---|
| Name | Schriftartname. | „Arial“, „Calibri“ usw. |
| Familie | Schriftfamilie für Fallback. Ein ganzzahliger Wert. | 1 – Serif, 2 – Sans Serif, 3 – Mono, Andere – unbekannt |
| Schema | Schriftschema. | 'Moll', 'Dur', 'keine' |
| Zeichensatz | Schriftart-Zeichensatz. Ein ganzzahliger Wert. | 1, 2 usw. |
| Größe | Schriftgröße. Ein ganzzahliger Wert. | 9, 10, 12, 16 usw. |
| Farbe | Farbbeschreibung, ein Objekt, das einen ARGB-Wert enthält. | { argb: 'FFFF0000'} |
| deutlich | Schriftstärke | wahr, falsch |
| kursiv | Schriftneigung | wahr, falsch |
| unterstreichen | Unterstreichungsstil der Schriftart | wahr, falsch, „none“, „single“, „double“, „singleAccounting“, „doubleAccounting“ |
| schlagen | Schriftart | wahr, falsch |
| Gliederung | Schriftumriss | wahr, falsch |
| vertAlign | Vertikal ausrichten | 'hochgestellt', 'tiefgestellt' |
// 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' } ;Gültige Ausrichtungseigenschaftswerte
| horizontal | Vertikale | WrapText | ShrinkToFit | Einzug | Leseauftrag | textRotation |
|---|---|---|---|---|---|---|
| links | Spitze | WAHR | WAHR | ganze Zahl | RTL | 0 bis 90 |
| Center | Mitte | FALSCH | FALSCH | ltr | -1 bis -90 | |
| Rechts | unten | Vertikale | ||||
| füllen | verteilt | |||||
| rechtfertigen | rechtfertigen | |||||
| centerContinuous | ||||||
| verteilt |
// 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' } }
} ;Gültige Rahmenstile
// 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' } }
]
} ; | Eigentum | Erforderlich | Beschreibung |
|---|---|---|
| Typ | Y | Wert: 'Muster' Gibt an, dass diese Füllung Muster verwendet |
| Muster | Y | Gibt den Mustertyp an (siehe unten: Gültige Mustertypen). |
| fgColor | N | Gibt die Vordergrundfarbe des Musters an. Die Standardeinstellung ist Schwarz. |
| bgColor | N | Gibt die Hintergrundfarbe des Musters an. Die Standardeinstellung ist Weiß. |
Hinweis: Wenn Sie eine Zelle mit dem solid füllen möchten, müssen Sie bgColor nicht angeben. Siehe Beispiel oben für Zelle A3 mit einem solid Muster und einem korallenroten fgColor .
Gültige Mustertypen
| Eigentum | Erforderlich | Beschreibung |
|---|---|---|
| Typ | Y | Wert: 'Gradient' Gibt an, dass diese Füllung Farbverläufe verwendet |
| Gradient | Y | Gibt den Verlaufstyp an. Einer von ['Winkel', 'Pfad'] |
| Grad | Winkel | Gibt für den Farbverlauf „Winkel“ die Richtung des Farbverlaufs an. 0 ist von links nach rechts. Werte von 1 bis 359 drehen die Richtung im Uhrzeigersinn |
| Center | Weg | Für „Pfad“-Gradient. Gibt die relativen Koordinaten für den Anfang des Pfads an. Die Werte für „links“ und „oben“ liegen zwischen 0 und 1 |
| stoppt | Y | Gibt die Farbverlaufssequenz an. Ist ein Array von Objekten, die Position und Farbe enthalten, beginnend mit Position 0 und endend mit Position 1. Zwischenpositionen können verwendet werden, um andere Farben auf dem Pfad anzugeben. |
Vorbehalte
Mithilfe der oben genannten Schnittstelle können möglicherweise Verlaufsfülleffekte erstellt werden, die mit dem XLSX-Editorprogramm nicht möglich sind. Excel unterstützt beispielsweise nur Winkelgradienten von 0, 45, 90 und 135. Ebenso kann die Reihenfolge der Stopps auch durch die Benutzeroberfläche eingeschränkt werden, wobei die Positionen [0,1] oder [0,0,5,1] die einzigen Optionen sind. Achten Sie bei dieser Füllung darauf, dass sie von den Ziel-XLSX-Viewern unterstützt wird.
Einzelne Zellen unterstützen jetzt Rich-Text oder In-Cell-Formatierung. Rich-Text-Werte können die Schriftarteigenschaften einer beliebigen Anzahl von Teilzeichenfolgen innerhalb des Textwerts steuern. Eine vollständige Liste mit Details zu den unterstützten Schriftarteigenschaften finden Sie unter Schriftarten.
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 ) ;Der Schutz auf Zellenebene kann mithilfe der Schutzeigenschaft geändert werden.
ws . getCell ( 'A1' ) . protection = {
locked : false ,
hidden : true ,
} ;Unterstützte Schutzeigenschaften
| Eigentum | Standard | Beschreibung |
|---|---|---|
| gesperrt | WAHR | Gibt an, ob eine Zelle gesperrt wird, wenn das Blatt geschützt ist. |
| versteckt | FALSCH | Gibt an, ob die Formel einer Zelle sichtbar ist, wenn das Blatt geschützt ist. |
Durch die bedingte Formatierung kann ein Blatt abhängig von Zellwerten oder einer beliebigen Formel bestimmte Stile, Symbole usw. anzeigen.
Regeln für die bedingte Formatierung werden auf Blattebene hinzugefügt und decken normalerweise einen Bereich von Zellen ab.
Auf einen bestimmten Zellbereich können mehrere Regeln angewendet werden, und jede Regel wendet ihren eigenen Stil an.
Wenn sich mehrere Regeln auf eine bestimmte Zelle auswirken, bestimmt der Wert der Regelpriorität, welche Regel gewinnt, wenn konkurrierende Stile kollidieren. Die Regel mit dem niedrigeren Prioritätswert gewinnt. Wenn für eine bestimmte Regel keine Prioritätswerte angegeben sind, weist ExcelJS diese in aufsteigender Reihenfolge zu.
Hinweis: Derzeit wird nur eine Teilmenge der bedingten Formatierungsregeln unterstützt. Insbesondere nur die Formatierungsregeln, die kein XML-Rendering innerhalb eines <extLst>-Elements erfordern. Das bedeutet, dass Datensätze und drei spezifische Symbolsätze (3Triangles, 3Stars, 5Boxes) nicht unterstützt werden.
// 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' } } } ,
}
]
} )Unterstützte Regeltypen für bedingte Formatierung
| Typ | Beschreibung |
|---|---|
| Ausdruck | Zur Aktivierung der Regel kann jede benutzerdefinierte Funktion verwendet werden. |
| cellIs | Vergleicht den Zellwert mit der angegebenen Formel unter Verwendung des angegebenen Operators |
| Top10 | Wendet die Formatierung auf Zellen mit Werten im oberen (oder unteren) Bereich an |
| überdurchschnittlich | Wendet die Formatierung auf Zellen an, deren Werte über (oder unter) dem Durchschnitt liegen |
| Farbskala | Wendet einen farbigen Hintergrund auf Zellen an, je nachdem, wo ihre Werte im Bereich liegen |
| iconSet | Fügt Zellen basierend auf dem Wert eines aus einer Reihe von Symbolen hinzu |
| enthältText | Wendet die Formatierung basierend darauf an, ob die Zelle einen bestimmten Text enthält |
| Zeitperiode | Wendet die Formatierung basierend darauf an, ob der Datums-/Uhrzeitwert der Zelle innerhalb eines angegebenen Bereichs liegt |
| Feld | Optional | Standard | Beschreibung |
|---|---|---|---|
| Typ | 'Ausdruck' | ||
| Priorität | Y | <Auto> | bestimmt die Prioritätsreihenfolge der Stile |
| Formeln | Array aus 1 Formelzeichenfolge, die einen Wahr/Falsch-Wert zurückgibt. Um auf den Zellenwert zu verweisen, verwenden Sie die Zellenadresse oben links | ||
| Stil | Stilstruktur, die angewendet werden soll, wenn die Formel „true“ zurückgibt |
| Feld | Optional | Standard | Beschreibung |
|---|---|---|---|
| Typ | 'cellIs' | ||
| Priorität | Y | <Auto> | bestimmt die Prioritätsreihenfolge der Stile |
| Operator | So vergleichen Sie den Zellenwert mit dem Formelergebnis | ||
| Formeln | Array aus 1 Formelzeichenfolge, das den Wert zurückgibt, der mit jeder Zelle verglichen werden soll | ||
| Stil | Stilstruktur, die angewendet werden soll, wenn der Vergleich „true“ zurückgibt |
Zelle ist Operatoren
| Operator | Beschreibung |
|---|---|
| gleich | Wenden Sie das Format an, wenn der Zellenwert dem Formelwert entspricht |
| größer als | Wenden Sie das Format an, wenn der Zellenwert größer als der Formelwert ist |
| weniger als | Wenden Sie das Format an, wenn der Zellenwert kleiner als der Formelwert ist |
| zwischen | Format anwenden, wenn der Zellenwert zwischen zwei Formelwerten liegt (einschließlich) |
| Feld | Optional | Standard | Beschreibung |
|---|---|---|---|
| Typ | 'Top10' | ||
| Priorität | Y | <Auto> | bestimmt die Prioritätsreihenfolge der Stile |
| Rang | Y | 10 | Gibt an, wie viele obere (oder untere) Werte in die Formatierung einbezogen werden |
| Prozent | Y | FALSCH | Wenn „true“, ist das Rangfeld ein Prozentsatz und kein Absolutwert |
| unten | Y | FALSCH | Wenn „true“, werden die unteren Werte anstelle der oberen einbezogen |
| Stil | Stilstruktur, die angewendet werden soll, wenn der Vergleich „true“ zurückgibt |
| Feld | Optional | Standard | Beschreibung |
|---|---|---|---|
| Typ | 'überdurchschnittlich' | ||
| Priorität | Y | <Auto> | bestimmt die Prioritätsreihenfolge der Stile |
| überdurchschnittlich | Y | FALSCH | Wenn „true“, ist das Rangfeld ein Prozentsatz und kein Absolutwert |
| Stil | Stilstruktur, die angewendet werden soll, wenn der Vergleich „true“ zurückgibt |
| Feld | Optional | Standard | Beschreibung |
|---|---|---|---|
| Typ | 'colorScale' | ||
| Priorität | Y | <Auto> | bestimmt die Prioritätsreihenfolge der Stile |
| cfvo | Array aus 2 bis 5 Wertobjekten mit bedingter Formatierung, die Wegpunkte im Wertebereich angeben | ||
| Farbe | entsprechende Farbpalette, die an bestimmten Wegpunkten verwendet werden soll | ||
| Stil | Stilstruktur, die angewendet werden soll, wenn der Vergleich „true“ zurückgibt |
| Feld | Optional | Standard | Beschreibung |
|---|---|---|---|
| Typ | 'iconSet' | ||
| Priorität | Y | <Auto> | bestimmt die Prioritätsreihenfolge der Stile |
| iconSet | Y | 3Ampeln | Name des zu verwendenden Symbolsatzes |
| showValue | WAHR | Gibt an, ob die Zellen im angewendeten Bereich das Symbol und den Zellenwert oder nur das Symbol anzeigen | |
| umkehren | FALSCH | Gibt an, ob die Symbole im in iconSet angegebenen Symbolsatz in reservierter Reihenfolge angezeigt werden. Wenn „custom“ gleich „true“ ist, muss dieser Wert ignoriert werden | |
| Brauch | FALSCH | Gibt an, ob ein benutzerdefinierter Satz von Symbolen verwendet wird | |
| cfvo | Array aus 2 bis 5 Wertobjekten mit bedingter Formatierung, die Wegpunkte im Wertebereich angeben | ||
| Stil | Stilstruktur, die angewendet werden soll, wenn der Vergleich „true“ zurückgibt |
| Feld | Optional | Standard | Beschreibung |
|---|---|---|---|
| Typ | 'dataBar' | ||
| Priorität | Y | <Auto> | Bestimmt die Prioritätsreihenfolge der Stile |
| minLänge | 0 | Gibt die Länge des kürzesten Datenbalkens in diesem bedingten Formatierungsbereich an | |
| maxLength | 100 | Gibt die Länge des längsten Datenbalkens in diesem bedingten Formatierungsbereich an | |
| showValue | WAHR | Gibt an, ob die Zellen im Bereich der bedingten Formatierung sowohl die Datenleiste als auch den numerischen Wert oder die Datenleiste anzeigen | |
| Gradient | WAHR | Gibt an, ob die Datenleiste eine Farbverlaufsfüllung aufweist | |
| Grenze | WAHR | Gibt an, ob die Datenleiste einen Rahmen hat | |
| negativeBarColorSameAsPositive | WAHR | Gibt an, ob der Datenbalken eine negative Balkenfarbe hat, die sich von der positiven Balkenfarbe unterscheidet | |
| negativeBarBorderColorSameAsPositive | WAHR | Gibt an, ob die Datenleiste eine negative Rahmenfarbe hat, die sich von der positiven Rahmenfarbe unterscheidet | |
| AchsePosition | 'Auto' | Gibt die Achsenposition für die Datenleiste an | |
| Richtung | 'leftToRight' | Gibt die Richtung des Datenbalkens an | |
| cfvo | Array aus 2 bis 5 Wertobjekten mit bedingter Formatierung, die Wegpunkte im Wertebereich angeben | ||
| Stil | Stilstruktur, die angewendet werden soll, wenn der Vergleich „true“ zurückgibt |
| Feld | Optional | Standard | Beschreibung |
|---|---|---|---|
| Typ | 'enthältText' | ||
| Priorität | Y | <Auto> | bestimmt die Prioritätsreihenfolge der Stile |
| Operator | Art des Textvergleichs | ||
| Text | Text, nach dem gesucht werden soll | ||
| Stil | Stilstruktur, die angewendet werden soll, wenn der Vergleich „true“ zurückgibt |
Enthält Textoperatoren
| Operator | Beschreibung |
|---|---|
| enthältText | Wenden Sie das Format an, wenn der Zellenwert den im Feld „Text“ angegebenen Wert enthält |
| enthält Leerzeichen | Wenden Sie das Format an, wenn der Zellenwert Leerzeichen enthält |
| notContainsBlanks | Wenden Sie das Format an, wenn der Zellenwert keine Leerzeichen enthält |
| enthältFehler | Wenden Sie das Format an, wenn der Zellenwert Fehler enthält |
| notContainsErrors | Wenden Sie das Format an, wenn der Zellenwert keine Fehler enthält |
| Feld | Optional | Standard | Beschreibung |
|---|---|---|---|
| Typ | 'timePeriod' | ||
| Priorität | Y | <Auto> | Bestimmt die Prioritätsreihenfolge der Stile |
| Zeitperiode | Mit welchem Zeitraum soll der Zellwert verglichen werden? | ||
| Stil | Stilstruktur, die angewendet werden soll, wenn der Vergleich „true“ zurückgibt |
Zeiträume
| Zeitraum | Beschreibung |
|---|---|
| letzte Woche | Wenden Sie das Format an, wenn der Zellenwert innerhalb der letzten Woche liegt |
| diese Woche | Wenden Sie das Format an, wenn der Zellenwert in diese Woche fällt |
| nächste Woche | Wenden Sie das Format an, wenn der Zellenwert in der nächsten Woche fällt |
| gestern | Wenden Sie das Format an, wenn der Zellenwert dem Wert von gestern entspricht |
| Heute | Wenden Sie das Format an, wenn der Zellenwert dem heutigen Tag entspricht |
| morgen | Wenden Sie das Format an, wenn der Zellenwert dem Wert von morgen entspricht |
| letzte 7 Tage | Wenden Sie das Format an, wenn der Zellenwert innerhalb der letzten 7 Tage liegt |
| letzter Monat | Wenden Sie das Format an, wenn der Zellenwert in den letzten Monat fällt |
| diesen Monat | Wenden Sie das Format an, wenn der Zellenwert in diesen Monat fällt |
| nächster Monat | Wenden Sie das Format an, wenn der Zellenwert im nächsten Monat fällt |
Excel unterstützt die Gliederung; Hier können Zeilen oder Spalten erweitert oder reduziert werden, je nachdem, welchen Detaillierungsgrad der Benutzer anzeigen möchte.
Gliederungsebenen können im Spalten-Setup definiert werden:
worksheet . columns = [
{ header : 'Id' , key : 'id' , width : 10 } ,
{ header : 'Name' , key : 'name' , width : 32 } ,
{ header : 'D.O.B.' , key : 'DOB' , width : 10 , outlineLevel : 1 }
] ;Oder direkt in der Zeile oder Spalte
worksheet . getColumn ( 3 ) . outlineLevel = 1 ;
worksheet . getRow ( 3 ) . outlineLevel = 1 ;Die Blattgliederungsebenen können auf dem Arbeitsblatt festgelegt werden
// set column outline level
worksheet . properties . outlineLevelCol = 1 ;
// set row outline level
worksheet . properties . outlineLevelRow = 1 ;Hinweis: Das Anpassen der Gliederungsebenen in Zeilen oder Spalten oder der Gliederungsebenen im Arbeitsblatt hat den Nebeneffekt, dass auch die reduzierte Eigenschaft aller von der Eigenschaftsänderung betroffenen Zeilen oder Spalten geändert wird. Z.B:
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 ;Die Gliederungseigenschaften können im Arbeitsblatt festgelegt werden
worksheet . properties . outlineProperties = {
summaryBelow : false ,
summaryRight : false ,
} ; Das Hinzufügen von Bildern zu einem Arbeitsblatt erfolgt in zwei Schritten. Zunächst wird das Bild über die Funktion addImage() zur Arbeitsmappe hinzugefügt, die auch einen imageId-Wert zurückgibt. Mithilfe der imageId kann das Bild dann entweder als gekachelter Hintergrund oder über einen Zellbereich zum Arbeitsblatt hinzugefügt werden.
Hinweis: Ab dieser Version wird das Anpassen oder Transformieren des Bildes nicht unterstützt und Bilder werden im Streaming-Modus nicht unterstützt.
Die Funktion Workbook.addImage unterstützt das Hinzufügen von Bildern nach Dateiname oder Puffer. Beachten Sie, dass in beiden Fällen die Erweiterung angegeben werden muss. Zu den gültigen Erweiterungswerten gehören „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' ,
} ) ;Mithilfe der Bild-ID von Workbook.addImage kann der Hintergrund eines Arbeitsblatts mithilfe der Funktion addBackgroundImage festgelegt werden
// set background
worksheet . addBackgroundImage ( imageId1 ) ;Mit der Bild-ID von Workbook.addImage kann ein Bild in das Arbeitsblatt eingebettet werden, um einen Bereich abzudecken. Die aus dem Bereich berechneten Koordinaten erstrecken sich von der oberen linken Ecke der ersten Zelle bis zur unteren rechten Ecke der zweiten Zelle.
// insert an image over B2:D6
worksheet . addImage ( imageId2 , 'B2:D6' ) ;Durch die Verwendung einer Struktur anstelle einer Bereichszeichenfolge ist es möglich, Zellen teilweise abzudecken.
Beachten Sie, dass das hierfür verwendete Koordinatensystem auf Null basiert, sodass die obere linke Seite von A1 {col: 0, row: 0} ist. Bruchteile von Zellen können mithilfe von Gleitkommazahlen angegeben werden, z. B. ist der Mittelpunkt von A1 { Spalte: 0,5, Zeile: 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 }
} ) ;Der Zellbereich kann auch die Eigenschaft 'editas' haben, die steuert, wie das Bild an den Zellen verankert ist, kann es einen der folgenden Werte haben:
| Wert | Beschreibung |
|---|---|
| undefiniert | Es gibt an, dass das Bild bewegt und mit Zellen dimensioniert wird |
| OneCell | Dies ist der Standard. Das Bild wird mit Zellen bewegt, aber nicht dimensioniert |
| Absolute | Das Bild wird nicht mit Zellen bewegt oder dimensioniert |
ws . addImage ( imageId , {
tl : { col : 0.1125 , row : 0.4 } ,
br : { col : 2.101046875 , row : 3.4 } ,
editAs : 'oneCell'
} ) ;Sie können einer Zelle ein Bild hinzufügen und dann seine Breite und Höhe in Pixel bei 96DPI definieren.
worksheet . addImage ( imageId2 , {
tl : { col : 0 , row : 0 } ,
ext : { width : 500 , height : 200 }
} ) ;Sie können einer Zelle ein Bild mit Hyperlinks hinzufügen und die Hyperlinks im Bildbereich definieren.
worksheet . addImage ( imageId2 , {
tl : { col : 0 , row : 0 } ,
ext : { width : 500 , height : 200 } ,
hyperlinks : {
hyperlink : 'http://www.somewhere.com' ,
tooltip : 'http://www.somewhere.com'
}
} ) ; Arbeitsblätter können durch Hinzufügen eines Kennworts vor der Änderung geschützt werden.
await worksheet . protect ( 'the-password' , options ) ;Arbeitsblattschutz kann auch entfernt werden:
worksheet . unprotect ( ) ;Weitere Informationen zum Modifizieren des individuellen Zellschutzes finden Sie in Zellschutz.
HINWEIS: Während die Funktion Protect () ein Versprechen zurückgibt, das angibt, dass es sich um asynchronisiert handelt, wird die aktuelle Implementierung im Hauptfaden ausgeführt und verwendet ca. 600 ms bei einer durchschnittlichen CPU. Dies kann durch Einstellen des Spincount angepasst werden, mit dem der Prozess entweder schneller oder widerstandsfähiger wird.
| Feld | Standard | Beschreibung |
|---|---|---|
| selectLockedcells | WAHR | Lassen Sie den Benutzer gesperrte Zellen auswählen |
| SelectUnLockedcells | WAHR | Lassen Sie den Benutzer entsperrte Zellen auswählen |
| Formatzellen | FALSCH | Lassen Sie den Benutzerzellen Zellen formatieren |
| formatcolumns | FALSCH | Lassen Sie die Spalten der Benutzerformat |
| Formatrows | FALSCH | Lasst das Benutzerformatzreihen |
| Insertrows | FALSCH | Lassen Sie den Benutzer Zeilen einfügen |
| InsertColumns | FALSCH | Lassen Sie den Benutzer Spalten einfügen |
| Inserthyperlinks | FALSCH | Lassen Sie den Benutzer Hyperlinks einfügen |
| Bewerber | FALSCH | Lassen Sie den Benutzer Zeilen löschen |
| DeleteColumns | FALSCH | Lassen Sie den Benutzer Spalten löschen |
| Sortieren | FALSCH | Lassen Sie den Benutzer Daten sortieren |
| Autofilter | FALSCH | Lassen Sie die Benutzerdaten in Tabellen filtern |
| Pivottables | FALSCH | Lassen Sie den Benutzer Pivot -Tabellen verwenden |
| Spincount | 100000 | Die Anzahl der Hash -Iterationen beim Schutz oder der ungeschützten Hash -Iterationen |
Optionen unterstützt beim Lesen von XLSX -Dateien.
| Feld | Erforderlich | Typ | Beschreibung |
|---|---|---|---|
| Ignorenoden | N | Array | Eine Liste von Knotennamen, die beim Laden des XLSX -Dokuments ignoriert werden sollen. Verbessert die Leistung in einigen Situationen. Available: 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 ( ) ;Optionen unterstützt beim Lesen von CSV -Dateien.
| Feld | Erforderlich | Typ | Beschreibung |
|---|---|---|---|
| DateFormats | N | Array | Geben Sie das Datumscodierungsformat von DayJs an. |
| Karte | N | Funktion | Benutzerdefinierte Array.Prototype.map () Rückruffunktion für die Verarbeitung von Daten. |
| Blechname | N | Zeichenfolge | Geben Sie den Arbeitsblattnamen an. |
| Parseroptionen | N | Objekt | Analyseoptionen @Fast-CSV/Format-Modul zum Schreiben von CSV-Daten. |
// 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 worksheetDer CSV-Parser verwendet Fast-CSV, um die CSV-Datei zu lesen. Die FormTeUtEnoptions in den an die obigen Schreibfunktion übergebenen Optionen werden an das @Fast-CSV/Format-Modul übergeben, um CSV-Daten zu schreiben. Weitere Informationen finden Sie im Fast-CSV Readme.md.
Die Daten werden mit dem NPM -Moduldayjs analysiert. Wenn ein DateFormats -Array nicht geliefert wird, werden die folgenden DateFormats verwendet:
Weitere Informationen zum Strukturieren eines DateFormat finden Sie im Plugin "DayJS CustomParseformat".
Optionen unterstützt beim Schreiben in eine CSV -Datei.
| Feld | Erforderlich | Typ | Beschreibung |
|---|---|---|---|
| DateFormat | N | Zeichenfolge | Geben Sie das Datumscodierungsformat von DayJs an. |
| DateUtc | N | Boolescher Wert | Geben Sie an, ob ExcelJS dayjs.utc () verwendet, um die Zeitzone für Parsen -Daten umzuwandeln. |
| Codierung | N | Zeichenfolge | Geben Sie das Dateicodierungsformat an. (Gilt nur für .writeFile .) |
| Einbeziehen von Tempyrows | N | Boolescher Wert | Gibt an, ob leere Zeilen geschrieben werden können. |
| Karte | N | Funktion | Benutzerdefinierte Array.Prototype.map () Rückruffunktion für die Verarbeitung von Zeilenwerten. |
| Blechname | N | Zeichenfolge | Geben Sie den Arbeitsblattnamen an. |
| Blech | N | Nummer | Geben Sie die Arbeitsblatt -ID an. |
| FormTenoTeuteroptionen | N | Objekt | FormTeUtEnoptions-Optionen @Fast-CSV/Format-Modul zum Schreiben von CSV-Daten. |
// 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 ( ) ;Der CSV-Parser verwendet Fast-CSV, um die CSV-Datei zu schreiben. Die FormTeUtEnoptions in den an die obigen Schreibfunktion übergebenen Optionen werden an das @Fast-CSV/Format-Modul übergeben, um CSV-Daten zu schreiben. Weitere Informationen finden Sie im Fast-CSV Readme.md.
Die Daten werden unter Verwendung des NPM -Moduldayjs formatiert. Wenn kein DateFormat geliefert wird, wird Dayjs.iso_8601 verwendet. Beim Schreiben eines CSV können Sie das Boolesche DateUutc als wahr anmelden, damit Exceljs das Datum analysiert, ohne die Zeitzone automatisch mit dayjs.utc() zu konvertieren.
Die oben dokumentierte Datei -E/A erfordert, dass eine gesamte Arbeitsmappe im Speicher erstellt wird, bevor die Datei geschrieben werden kann. Obwohl es bequem ist, kann es die Größe des Dokuments aufgrund der erforderlichen Speichermenge einschränken.
Ein Streaming -Autor (oder Leser) verarbeitet die Arbeitsbuch- oder Arbeitsblattdaten, die so generiert werden, und konvertiert es in das Dateiformular. In der Regel ist dies für den Speicher viel effizienter, da der endgültige Speicherausdruck und sogar die Zwischenspeicher Fußabdrücke viel kompakter sind als mit der Dokumentversion, insbesondere wenn man bedenkt, dass die Zeilen- und Zellobjekte entsorgt werden, sobald sie begangen werden.
Die Schnittstelle zum Streaming -Arbeitsbuch und zum Arbeitsblatt entspricht fast den Dokumentversionen mit einigen geringfügigen praktischen Unterschieden:
Beachten Sie, dass es möglich ist, die gesamte Arbeitsmappe zu erstellen, ohne Zeilen zu begehen. Wenn die Arbeitsmappe verpflichtet ist, werden alle hinzugefügten Arbeitsblätter (einschließlich aller nicht verbindlichen Zeilen) automatisch begangen. In diesem Fall wird jedoch nur wenig über die Dokumentversion gewonnen worden.
Der Streaming XLSX Workbook Writer ist im Namespace exceljs.stream.xlsx verfügbar.
Der Konstruktor nimmt ein optionales Optionsobjekt mit den folgenden Feldern an:
| Feld | Beschreibung |
|---|---|
| Strom | Gibt einen beschreibbaren Stream an, um das XLSX -Arbeitsbuch zu schreiben. |
| Dateiname | Wenn der Stream nicht angegeben ist, gibt dieses Feld den Pfad zu einer Datei an, um die XLSX -Arbeitsmappe zu schreiben. |
| Usesharedstrings | Gibt an, ob Sie gemeinsam genutzte Zeichenfolgen in der Arbeitsmappe verwenden sollen. Standard ist false . |
| Gebrauchswerte | Gibt an, ob Sie der Arbeitsmappe Stilinformationen hinzufügen sollen. Stile können einige Leistungsaufwand hinzufügen. Standard ist false . |
| Reißverschluss | ZIP -Optionen, die sich intern auszeichnen, übergeben an den Archiver. Standardeinstellung ist undefined . |
Wenn in den Optionen weder Stream noch Dateiname angegeben sind, erstellt der Arbeitsbuchautor ein StreamBuf -Objekt, das den Inhalt des XLSX -Arbeitsbuchs im Speicher speichert. Dieses StreamBUF -Objekt, auf das über das Workbook der Eigenschaft zugegriffen werden kann.
// 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 ) ;Im Allgemeinen entspricht die Schnittstelle zum Streaming XLSX -Autor der oben beschriebenen Dokumentarbeitsbuch (und Arbeitsblätter). Tatsächlich sind die Objekte von Zeile, Zellen und Stil die gleichen.
Es gibt jedoch einige Unterschiede ...
Konstruktion
Wie oben erwähnt, muss der Arbeitsbuchwriter in der Regel im Konstruktor angegeben werden.
Daten begehen
Wenn eine Arbeitsblattzeile fertig ist, sollte sie so begangen werden, dass das Zeilenobjekt und das Zeilenobjekt und das Inhalt befreit werden können. Normalerweise würde dies geschehen, da jede Zeile hinzugefügt wird ...
worksheet . addRow ( {
id : i ,
name : theName ,
etc : someOtherDetail
} ) . commit ( ) ;Der Grund, warum der Arbeitsblattwriter keine Zeilen beschränkt, da sie hinzugefügt werden, ist, dass die Zellen über Reihen verschmolzen werden:
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.Da jedes Arbeitsblatt abgeschlossen ist, muss es auch begangen werden:
// Finished adding data. Commit the worksheet
worksheet . commit ( ) ;Um das XLSX -Dokument zu vervollständigen, muss das Arbeitsbuch begangen werden. Wenn ein Arbeitsblatt in einem Arbeitsbuch nicht nicht übereinstimmt, wird sie automatisch im Rahmen des Arbeitsbuchausschusses begangen.
// Finished the workbook.
await workbook . commit ( ) ;
// ... the stream has been written Der Streaming XLSX Workbook Reader ist im Namespace exceljs.stream.xlsx verfügbar.
Der Konstruktor nimmt ein erforderliches Eingabargument und ein optionales Argument für Optionen an:
| Argument | Beschreibung |
|---|---|
| Eingabe (erforderlich) | Gibt den Namen der Datei oder den lesbaren Stream an, aus dem das XLSX -Arbeitsbuch gelesen werden kann. |
| Optionen (optional) | Gibt an, wie Sie mit den Ereignisstypen umgehen, die während der Lesevorrichtung auftreten. |
| Optionen | Gibt an, ob Einträge ( 'emit' ) oder nicht ( 'ignore' ) abgibt. Standard ist 'emit' . |
| options.sharedstrings | Gibt an 'ignore' ob Sie gemeinsam genutzte Zeichenfolgen ( 'emit' 'cache' ) zwischen den jeweils Ein Verweis auf den Index der freigegebenen Zeichenfolge. Standard ist 'cache' . |
| Optionen.Hyperlinks | Gibt an, ob Hyperlinks ( 'cache' ) zwischengespeichert werden soll, was sie in ihre jeweiligen Zellen einfügt, ob sie ausstrahlen ( 'emit' ) oder ob sie ignoriert werden soll ( 'ignore' ). Standard ist 'cache' . |
| Optionen.Styles | Gibt an, ob Sie Stile ( 'cache' ) zwischenspeichern werden sollen, was sie in ihre jeweiligen Zeilen und Zellen einfügt oder ob sie ignoriert werden ( 'ignore' ). Standard ist 'cache' . |
| Optionen.Worksheets | Gibt an, ob Arbeitsblätter ( 'emit' ) oder nicht ( 'ignore' ) abgibt. Standard ist 'emit' . |
const workbookReader = new ExcelJS . stream . xlsx . WorkbookReader ( './file.xlsx' ) ;
for await ( const worksheetReader of workbookReader ) {
for await ( const row of worksheetReader ) {
// ...
}
} Bitte beachten Sie, dass worksheetReader aus Leistungsgründen eher ein Array von Zeilen als jede Zeile einzeln zurückgibt: NodeJS/Knoten#31979
Veranstaltungen in der Arbeitsmappe sind "Arbeitsblatt", "Shared-Strings" und "Hyperlinks". Ereignisse auf dem Arbeitsblatt sind "Row" und "Hyperlinks".
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
}
} Während wir dringend ermutigen, eine asynchronisierende Iteration zu verwenden, enthüllen wir auch eine Streaming -Schnittstelle für die Rückwärtskompatibilität.
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 ) => {
// ...
} ) ;Ein Teil dieser Bibliothek wurde isoliert und für die Verwendung in einer Browserumgebung getestet.
Aufgrund der Streaming -Art des Arbeitsbuchlesers und des Arbeitsbuchautors wurden diese nicht berücksichtigt. Es kann nur das dokumentbasierte Arbeitsbuch verwendet werden (siehe eine Arbeitsmappe für Details).
Beispielsweise sehen Sie den Code mit ExcelJs im Browser den Spezifikations-/Browser -Ordner im GitHub -Repo an.
Die folgenden Dateien sind vorgraben und in den DIST-Ordner enthalten.
Die folgenden Werttypen werden unterstützt.
Enum: excel.valuetype.null
Ein Nullwert zeigt ein Wert an und wird in der Regel nicht gespeichert, wenn sie in die Datei geschrieben wurden (mit Ausnahme von zusammengeführten Zellen). Es kann verwendet werden, um den Wert aus einer Zelle zu entfernen.
Z.B
worksheet . getCell ( 'A1' ) . value = null ; Enum: excel.valuetype.merge
Eine Zusammenführungszelle ist eine, die ihren Wert an eine andere "Master" -Zelle gebunden hat. Durch die Zuweisung einer Zusammenführungszelle wird die Master -Zelle geändert.
Enum: excel.valuetype.number
Ein numerischer Wert.
Z.B
worksheet . getCell ( 'A1' ) . value = 5 ;
worksheet . getCell ( 'A2' ) . value = 3.14159 ; Enum: excel.valuetype.String
Eine einfache Textzeichenfolge.
Z.B
worksheet . getCell ( 'A1' ) . value = 'Hello, World!' ; Enum: excel.valuetype.date
Ein Datumswert, der durch den JavaScript -Datumstyp dargestellt wird.
Z.B
worksheet . getCell ( 'A1' ) . value = new Date ( 2017 , 2 , 15 ) ; Enum: excel.valuetype.hyperlink
Eine URL mit Text- und Linkwert.
Z.B
// 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
Eine Excel -Formel zur Berechnung der Werte im laufenden Fliegen. Beachten Sie, dass die Zelltyp zwar eine Formel ist, die Zelle möglicherweise einen Effektivetypwert hat, der vom Ergebniswert abgeleitet wird.
Beachten Sie, dass ExcelJs die Formel nicht verarbeiten kann, um ein Ergebnis zu erzeugen, sie muss geliefert werden.
Beachten Sie, dass semantische Funktionsnamen in englischer Sprache sein müssen und der Trennzeichen ein Komma sein muss.
Z.B
worksheet . getCell ( 'A3' ) . value = { formula : 'A1+A2' , result : 7 } ;
worksheet . getCell ( 'A3' ) . value = { formula : 'SUM(A1,A2)' , result : 7 } ;Zellen unterstützen auch Convenience Getters, um auf die Formel und das Ergebnis zuzugreifen:
worksheet . getCell ( 'A3' ) . formula === 'A1+A2' ;
worksheet . getCell ( 'A3' ) . result === 7 ;Freigegebene Formeln verbessern die Komprimierung des XLSX -Dokuments, indem die Wiederholung des Textes innerhalb des Arbeitsblatts XML verringert wird. Die obere linke Zelle in einem Bereich ist der ausgewiesene Master und wird die Formel enthalten, aus der alle anderen Zellen im Bereich abgeleitet sind. Die anderen "Sklaven" -Zellen können dann auf diese Master -Zelle verweisen, anstatt die gesamte Formel erneut zu definieren. Beachten Sie, dass die Masterformel in üblicher Excel -Art in die Sklavenzellen übersetzt wird, so dass Verweise auf andere Zellen abhängig vom Sklavenversatz zum Master nach unten und nach rechts verschoben werden. Zum Beispiel: Wenn die Master -Zelle A2 eine Formel hat, die auf A1 verweist, dann wird es bei der Formel von Zelle B2 die A2 -Formel verweist, dann wird sie auf B1 verweisen.
Eine Masterformel kann einer Zelle zusammen mit den Sklavenzellen in ihrem Bereich zugeordnet werden
worksheet . getCell ( 'A2' ) . value = {
formula : 'A1' ,
result : 10 ,
shareType : 'shared' ,
ref : 'A2:B3'
} ;Eine gemeinsame Formel kann einer Zelle mit einem neuen Wertformular zugeordnet werden:
worksheet . getCell ( 'B2' ) . value = { sharedFormula : 'A2' , result : 10 } ;Dies gibt an, dass die Zelle B2 eine Formel ist, die aus der Formel in A2 abgeleitet wird, und ihr Ergebnis ist 10.
Der Formel Convenience Getter übersetzt die Formel in A2 in das, was sie in B2 sein sollte:
expect ( worksheet . getCell ( 'B2' ) . formula ) . to . equal ( 'B1' ) ;Gemeinsame Formeln können unter Verwendung der Funktion "Fillformula" in ein Blatt zugeordnet werden:
// 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 kann auch eine Rückruffunktion verwenden, um den Wert in jeder Zelle zu berechnen
// fill A2 to A100 with ascending count starting from A1
worksheet . fillFormula ( 'A2:A100' , 'A1+1' , ( row , col ) => row ) ;Verwenden Sie den Formulatyp Getter, um zwischen realen und übersetzten Formelzellen zu unterscheiden:
worksheet . getCell ( 'A3' ) . formulaType === Enums . FormulaType . Master ;
worksheet . getCell ( 'B3' ) . formulaType === Enums . FormulaType . Shared ;Der Formeltyp hat die folgenden Werte:
| Name | Wert |
|---|---|
| Enums.formulatype.none | 0 |
| Enums.formulatype.master | 1 |
| Enums.formulatype.shared | 2 |
Eine neue Art, gemeinsame Formeln in Excel auszudrücken, ist die Array -Formel. In dieser Form ist die Master -Zelle die einzige Zelle, die Informationen zu einer Formel enthält. Es enthält das Sharetyp -Array zusammen mit dem Bereich der Zellen, auf die es angewendet wird, und die Formel, die kopiert wird. Der Rest der Zellen sind reguläre Zellen mit regulären Werten.
Hinweis: Array -Formeln werden nicht in der Art und Weise übersetzt, wie gemeinsame Formeln sind. Wenn sich Master Cell A2 auf A1 bezieht, bezieht sich die Sklavenzelle B2 auch auf A1.
Z.B
// 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 sheetDie Fillformula -Funktion kann auch verwendet werden, um eine Array -Formel zu füllen
// fill A2:B3 with array formula "A1"
worksheet . fillFormula ( 'A2:B3' , 'A1' , [ 1 , 1 , 1 , 1 ] , 'array' ) ; Enum: excel.valuetype.richtext
Reicher, gestalteter Text.
Z.B
worksheet . getCell ( 'A1' ) . value = {
richText : [
{ text : 'This is ' } ,
{ font : { italic : true } , text : 'italic' } ,
]
} ; Enum: excel.valuetype.boolean
Z.B
worksheet . getCell ( 'A1' ) . value = true ;
worksheet . getCell ( 'A2' ) . value = false ; Enum: excel.valuetype.Error
Z.B
worksheet . getCell ( 'A1' ) . value = { error : '#N/A' } ;
worksheet . getCell ( 'A2' ) . value = { error : '#VALUE!' } ;Die aktuellen gültigen Fehlertextwerte sind:
| Name | Wert |
|---|---|
| Excel.ErrorValue.notapplicierbar | #N / A |
| Excel.ErrorValue.ref | #REF! |
| Excel.ErrorValue.name | #NAME? |
| Excel.ErrorValue.divzero | #Div/0! |
| Excel.ErrorValue.null | #Null! |
| Excel.ErrorValue.Value | #WERT! |
| Excel.ErrorValue.num | #Num! |
Alle Anstrengungen werden unternommen, um eine gute konsistente Schnittstelle zu machen, die die Versionen nicht durchbricht, aber bedauerlicherweise müssen sich einige Dinge für das Wohl der Allgemeinheit ändern.
Die Argumente in der Rückruffunktion zum Arbeitsblatt. Es war Funktion (Rownumber, Rowvalues), jetzt ist es Funktion (Zeile, Rownumber), die ihm einen Aussehen und das Gefühl der Unterstriche (_..each) und Prioritäten des Zeilenobjekts über die Zeilennummer verleiht.
Diese Funktion hat sich von der Rückgabe eines spärlichen Arrays von Zellwerten in die Rückgabe eines Zeilenobjekts geändert. Dies ermöglicht den Zugriff auf Zeileneigenschaften und erleichtert die Verwaltungsstile usw.
Das spärliche Array der Zellwerte ist weiterhin über Worksheet.getrow (Rownumber) verfügbar;
cell.styles in cell.style umbenannt
Versprechen wurden von Funktionen zurückgegeben, die von Bluebird zu einem nativen Knotenversprechen umgestellt wurden, das den Anrufcode brechen kann, wenn sie sich auf die zusätzlichen Funktionen von Bluebird verlassen.
Um dies zu mildern, wurden die folgenden zwei Änderungen zu 0,3,0 hinzugefügt:
Exceljs unterstützt jetzt die Abhängigkeitsinjektion für die Versprechenbibliothek. Sie können Bluebird -Versprechen wiederherstellen, indem Sie den folgenden Code in Ihr Modul aufnehmen ...
ExcelJS . config . setValue ( 'promise' , require ( 'bluebird' ) ) ;Bitte beachten Sie: Ich habe Exceljs speziell mit Bluebird getestet (seit bis vor kurzem die Bibliothek, die sie verwendet hat). Aus den Tests, die ich gemacht habe, funktioniert es nicht mit Q.
Vor der Veröffentlichung dieses Moduls wird der Quellcode transpiliert und auf andere Weise verarbeitet, bevor er in einem DIST/ Ordner platziert wird. Dieses Readme identifiziert zwei Dateien - ein browseriertes Bundle und eine Minimierungsversion. Kein anderer Inhalt des DIST/ Ordner
Die in dieser LIB enthaltene Testsuite enthält ein kleines Skript, das in einem kopflosen Browser ausgeführt wird, um die gebündelten Pakete zu validieren. Zum Zeitpunkt dieses Schreibens scheint dieser Test im Windows Linux -Subsystem nicht gut zu spielen.
Aus diesem Grund kann der Browser-Test durch das Vorhandensein einer Datei namens.
sudo apt-get install libfontconfigWenn ein Spleißvorgang eine zusammengeführte Zelle beeinflusst, wird die Zusammenführungsgruppe nicht korrekt bewegt
| Version | Änderungen |
|---|---|
| 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. Änderungen
|
| 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 |
|
