exceljs
v4.4.0
Leia, manipule e grave dados e estilos de planilhas em XLSX e JSON.
Engenharia reversa a partir de arquivos de planilha do Excel como um projeto.
npm install exceljsContribuições são muito bem-vindas! Isso me ajuda a saber quais recursos são desejados ou quais bugs estão causando mais problemas.
Tenho apenas um pedido; Se você enviar uma solicitação pull para uma correção de bug, adicione um teste de unidade ou teste de integração (na pasta de especificações) que detecte o problema. Mesmo um PR que tenha apenas um teste com falha está bem - posso analisar o que o teste está fazendo e corrigir o código a partir disso.
Nota: Tente evitar modificar a versão do pacote em um PR. As versões são atualizadas no lançamento e qualquer alteração provavelmente resultará em colisões de mesclagem.
Para ser claro, todas as contribuições adicionadas a esta biblioteca serão incluídas na licença MIT da biblioteca.
const ExcelJS = require ( 'exceljs' ) ; Para usar o código transpilado ES5, por exemplo, para versões node.js anteriores a 10, use o caminho dist/es5.
const ExcelJS = require ( 'exceljs/dist/es5' ) ;Nota: A compilação ES5 tem uma dependência implícita de vários polyfills que não são mais adicionados explicitamente pelo Exceljs. Você precisará adicionar "core-js" e "regenerator-runtime" às suas dependências e incluir os seguintes requisitos em seu código antes da importação do Exceljs:
// polyfills required by exceljs
require ( 'core-js/modules/es.promise' ) ;
require ( 'core-js/modules/es.string.includes' ) ;
require ( 'core-js/modules/es.object.assign' ) ;
require ( 'core-js/modules/es.object.keys' ) ;
require ( 'core-js/modules/es.symbol' ) ;
require ( 'core-js/modules/es.symbol.async-iterator' ) ;
require ( 'regenerator-runtime/runtime' ) ;
const ExcelJS = require ( 'exceljs/dist/es5' ) ;Para o IE 11, você também precisará de um polyfill para suportar padrões regex unicode. Por exemplo,
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 publica dois pacotes navegadorizados dentro da pasta dist/:
Um com dependências implícitas em polyfills core-js...
< script src =" https://cdnjs.cloudflare.com/ajax/libs/babel-polyfill/6.26.0/polyfill.js " > </ script >
< script src =" exceljs.js " > </ script >E um sem...
< 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 ; As visualizações da pasta de trabalho controlam quantas janelas separadas o Excel abrirá ao visualizar a pasta de trabalho.
workbook . views = [
{
x : 0 , y : 0 , width : 10000 , height : 20000 ,
firstSheet : 0 , activeTab : 1 , visibility : 'visible'
}
] const sheet = workbook . addWorksheet ( 'My Sheet' ) ;Use o segundo parâmetro da função addWorksheet para especificar opções para a planilha.
Por exemplo:
// 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' }
} ) ; Use o id da planilha para remover a planilha da pasta de trabalho.
Por exemplo:
// 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; É importante saber que workbook.getWorksheet(1) != Workbook.worksheets[0] e workbook.getWorksheet(1) != Workbook.worksheets[1] , porque workbook.worksheets[0].id pode ter qualquer valor.
// make worksheet visible
worksheet . state = 'visible' ;
// make worksheet hidden
worksheet . state = 'hidden' ;
// make worksheet hidden from 'hide/unhide' dialog
worksheet . state = 'veryHidden' ; As planilhas oferecem suporte a um intervalo de propriedades para permitir o controle sobre alguns recursos da planilha.
// 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 ;Propriedades suportadas
| Nome | Padrão | Descrição |
|---|---|---|
| abaCor | indefinido | Cor das abas |
| contornoLevelCol | 0 | O nível de estrutura de tópicos da coluna da planilha |
| contornoLevelRow | 0 | O nível de estrutura de tópicos da linha da planilha |
| padrãoRowHeight | 15 | Altura da linha padrão |
| larguraCol padrão | (opcional) | Largura da coluna padrão |
| dyDescent | 55 | A definir |
Algumas novas métricas foram adicionadas à planilha...
| Nome | Descrição |
|---|---|
| contagem de linhas | O tamanho total da linha do documento. Igual ao número da última linha que contém valores. |
| realRowCount | Uma contagem do número de linhas que possuem valores. Se uma linha intermediária do documento estiver vazia, ela não será incluída na contagem. |
| colunaCount | O tamanho total da coluna do documento. Igual à contagem máxima de células de todas as linhas |
| actualColumnCount | Uma contagem do número de colunas que possuem valores. |
Todas as propriedades que podem afetar a impressão de uma planilha são mantidas em um objeto pageSetup na planilha.
// 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' ;Configurações de configuração de página suportadas
| Nome | Padrão | Descrição |
|---|---|---|
| margens | Espaço em branco nas bordas da página. As unidades são polegadas. | |
| orientação | 'retrato' | Orientação da página – ou seja, mais alta (retrato) ou mais larga (paisagem) |
| horizontalDpi | 4294967295 | Pontos horizontais por polegada. O valor padrão é -1 |
| verticalDpi | 4294967295 | Pontos verticais por polegada. O valor padrão é -1 |
| fitToPage | Seja para usar fitToWidth e fitToHeight ou configurações de escala. O padrão é baseado na presença dessas configurações no objeto pageSetup - se ambos estiverem presentes, a escala vence (ou seja, o padrão será falso) | |
| pedido de página | 'downThenOver' | Qual ordem de impressão das páginas - uma de ['downThenOver', 'overThenDown'] |
| preto e branco | falso | Imprimir sem cor |
| rascunho | falso | Imprima com menos qualidade (e tinta) |
| cellComments | 'Nenhum' | Onde colocar comentários - um de ['atEnd', 'asDisplayed', 'None'] |
| erros | 'exibido' | Onde mostrar erros - um de ['traço', 'em branco', 'NA', 'exibido'] |
| escala | 100 | Valor percentual para aumentar ou reduzir o tamanho da impressão. Ativo quando fitToPage é falso |
| fitToWidth | 1 | Em quantas páginas de largura a folha deve ser impressa. Ativo quando fitToPage é verdadeiro |
| fitToHeight | 1 | Em quantas páginas a folha deve ser impressa. Ativo quando fitToPage é verdadeiro |
| tamanho do papel | Qual tamanho de papel usar (veja abaixo) | |
| showRowColHeaders | falso | Se deve mostrar os números das linhas e letras das colunas |
| mostrarGridLines | falso | Se deve mostrar linhas de grade |
| primeiroPageNumber | Qual número usar para a primeira página | |
| horizontalCentralizado | falso | Se deve centralizar os dados da planilha horizontalmente |
| verticalCentralizado | falso | Se deve centralizar os dados da planilha verticalmente |
Exemplos de tamanhos de papel
| Nome | Valor |
|---|---|
| Carta | indefinido |
| Jurídico | 5 |
| Executivo | 7 |
| A3 | 8 |
| A4 | 9 |
| A5 | 11 |
| B5 (JIS) | 13 |
| Envelope #10 | 20 |
| Envelope DL | 27 |
| Envelope C5 | 28 |
| Envelope B5 | 34 |
| Monarca do Envelope | 37 |
| Cartão postal duplo do Japão girado | 82 |
| 16K 197x273mm | 119 |
Veja como adicionar cabeçalhos e rodapés. O conteúdo adicionado é principalmente texto, como hora, introdução, informações do arquivo, etc., e você pode definir o estilo do texto. Além disso, você pode definir textos diferentes para a primeira página e até para a página.
Nota: Imagens não são suportadas atualmente.
// 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"Configurações de headerFooter suportadas
| Nome | Padrão | Descrição |
|---|---|---|
| diferentePrimeiro | falso | Defina o valor de DifferentFirst como verdadeiro, o que indica que os cabeçalhos/rodapés da primeira página são diferentes das outras páginas |
| diferenteÍmparPar | falso | Defina o valor de DifferentOddEven como verdadeiro, o que indica que os cabeçalhos/rodapés das páginas pares e ímpares são diferentes |
| cabeçalho estranho | nulo | Definir string de cabeçalho para páginas ímpares (padrão), pode formatar a string |
| rodapé estranho | nulo | Definir string de rodapé para páginas ímpares (padrão), pode formatar a string |
| EvenHeader | nulo | Definir string de cabeçalho para páginas pares, pode formatar a string |
| rodapé uniforme | nulo | Definir sequência de rodapé para páginas pares, pode formatar a sequência |
| primeiroCabeçalho | nulo | Definir string de cabeçalho para a primeira página, poderia formatar a string |
| primeiro rodapé | nulo | Definir string de rodapé para a primeira página, poderia formatar a string |
Comandos de script
| Comandos | Descrição |
|---|---|
| &L | Definir posição para a esquerda |
| &C | Definir posição para o centro |
| &R | Definir posição para a direita |
| &P | O número da página atual |
| &N | O número total de páginas |
| &D | A data atual |
| &T | A hora atual |
| &G | Uma foto |
| &UM | O nome da planilha |
| &F | O nome do arquivo |
| &B | Deixe o texto em negrito |
| &EU | Texto em itálico |
| &você | Sublinhar texto |
| &"nome da fonte" | nome da fonte, por exemplo &"Aril" |
| &tamanho da fonte | tamanho da fonte, por exemplo 12 |
| &KHEXCódigo | cor da fonte, por exemplo &KCCCCCC |
As planilhas agora oferecem suporte a uma lista de visualizações que controlam como o Excel apresenta a planilha:
Cada visualização também oferece suporte a várias propriedades:
| Nome | Padrão | Descrição |
|---|---|---|
| estado | 'normal' | Controla o estado de visualização - normal, congelado ou dividido |
| direita para esquerda | falso | Define a orientação da visualização da planilha da direita para a esquerda |
| célula ativa | indefinido | A célula atualmente selecionada |
| showRuler | verdadeiro | Mostra ou oculta a régua no Layout de Página |
| showRowColHeaders | verdadeiro | Mostra ou esconde os cabeçalhos das linhas e colunas (por exemplo A1, B1 no topo e 1,2,3 à esquerda |
| mostrarGridLines | verdadeiro | Mostra ou oculta as linhas de grade (mostradas para células onde as bordas não foram definidas) |
| escala de zoom | 100 | Zoom percentual a ser usado para a visualização |
| zoomScaleNormal | 100 | Zoom normal para a visualização |
| estilo | indefinido | Estilo de apresentação - pageBreakPreview ou pageLayout. Nota pageLayout não é compatível com visualizações congeladas |
As visualizações congeladas suportam as seguintes propriedades extras:
| Nome | Padrão | Descrição |
|---|---|---|
| xSplit | 0 | Quantas colunas congelar. Para congelar apenas linhas, defina como 0 ou indefinido |
| yDividir | 0 | Quantas linhas congelar. Para congelar apenas colunas, defina como 0 ou indefinido |
| topLeftCell | especial | Qual célula ficará no canto superior esquerdo no painel inferior direito. Nota: não pode ser uma célula congelada. O padrão é a primeira célula descongelada |
worksheet . views = [
{ state : 'frozen' , xSplit : 2 , ySplit : 3 , topLeftCell : 'G10' , activeCell : 'A1' }
] ;As visualizações divididas suportam as seguintes propriedades extras:
| Nome | Padrão | Descrição |
|---|---|---|
| xSplit | 0 | Quantos pontos da esquerda para colocar o divisor. Para dividir verticalmente, defina como 0 ou indefinido |
| yDividir | 0 | Quantos pontos a partir do topo para colocar o divisor. Para dividir horizontalmente, defina como 0 ou indefinido |
| topLeftCell | indefinido | Qual célula ficará no canto superior esquerdo no painel inferior direito. |
| painel ativo | indefinido | Qual painel estará ativo - um entre topLeft, topRight, bottomLeft e bottomRight |
worksheet . views = [
{ state : 'split' , xSplit : 2000 , ySplit : 3000 , topLeftCell : 'G10' , activeCell : 'A1' }
] ; É possível aplicar um filtro automático à sua planilha.
worksheet . autoFilter = 'A1:C1' ;Embora a string de intervalo seja o formato padrão do autoFiltro, a planilha também oferecerá suporte aos seguintes valores:
// 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' ) ;| Parâmetro | Descrição | Valor padrão |
|---|---|---|
| valor/s | Os novos valores de linha/s | |
| estilo | 'i' para herdar da linha acima, 'i+' para incluir células vazias, 'n' para nenhuma | 'e' |
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' ) ;| Parâmetro | Descrição | Valor padrão |
|---|---|---|
| posição | Número da linha onde você deseja inserir, empurrando para baixo todas as linhas a partir daí | |
| valor/s | Os novos valores de linha/s | |
| estilo | 'i' para herdar da linha acima, 'i+' para incluir células vazias, 'o' para estilo original, 'o+' para incluir células vazias, 'n' para nenhuma | 'e' |
// 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' ) ;| Parâmetro | Descrição | Valor padrão |
|---|---|---|
| começar | Ponto inicial para emendar de | |
| contar | Número de linhas/células a serem removidas | |
| ...inserções | Novos valores de linha/célula para inserir |
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 ) ;| Parâmetro | Descrição | Valor padrão |
|---|---|---|
| começar | Número da linha que você deseja duplicar (o primeiro no Excel é 1) | |
| quantia | Os horários em que você deseja duplicar a linha | 1 |
| inserir | verdadeiro se desejar inserir novas linhas para as duplicatas ou falso se desejar substituí-las | verdadeiro |
Células individuais (ou vários grupos de células) podem ter nomes atribuídos a elas. Os nomes podem ser usados em fórmulas e validação de dados (e provavelmente mais).
// 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' ] ) ; As células podem definir quais valores são válidos ou não e fornecer avisos ao usuário para ajudar a orientá-los.
Os tipos de validação podem ser um dos seguintes:
| Tipo | Descrição |
|---|---|
| lista | Defina um conjunto discreto de valores válidos. O Excel os oferecerá em um menu suspenso para facilitar a entrada |
| todo | O valor deve ser um número inteiro |
| decimal | O valor deve ser um número decimal |
| comprimento do texto | O valor pode ser texto, mas o comprimento é controlado |
| personalizado | Uma fórmula personalizada controla os valores válidos |
Para tipos diferentes de lista ou personalizado, os seguintes operadores afetam a validação:
| Operador | Descrição |
|---|---|
| entre | Os valores devem estar entre os resultados da fórmula |
| não entre | Os valores não devem ficar entre os resultados da fórmula |
| igual | O valor deve ser igual ao resultado da fórmula |
| não igual | O valor não deve ser igual ao resultado da fórmula |
| maior que | O valor deve ser maior que o resultado da fórmula |
| menor que | O valor precisa ser menor que o resultado da fórmula |
| maior que ou igual | O valor deve ser maior ou igual ao resultado da fórmula |
| menos que ou igual | O valor precisa ser menor ou igual ao resultado da fórmula |
// 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 ) ]
} ; Adicionar comentário de estilo antigo a uma célula
// 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' ,
} ;A tabela a seguir define as propriedades suportadas pelos comentários das células.
| Campo | Obrigatório | Valor padrão | Descrição |
|---|---|---|---|
| textos | S | O texto do comentário | |
| margens | N | {} | Determina o valor das margens para comentários de células automáticos ou personalizados |
| proteção | N | {} | Especificando o status de bloqueio de objetos e texto de objeto usando atributos de proteção |
| editarAs | N | 'absoluto' | Use o atributo 'editAs' para especificar como a anotação é ancorada na célula |
Determine o modo de configuração da margem da página da anotação da célula, modo automático ou personalizado.
ws . getCell ( 'B1' ) . note . margins = {
insetmode : 'custom' ,
inset : [ 0.25 , 0.25 , 0.35 , 0.35 ]
}| Propriedade | Obrigatório | Valor padrão | Descrição |
|---|---|---|---|
| modo de inserção | N | 'auto' | Determina se as margens dos comentários são definidas automaticamente e o valor é 'automático' ou 'personalizado' |
| inserir | N | [0,13, 0,13, 0,25, 0,25] | Espaço em branco nas bordas do comentário. As unidades são centímetros. A direção é esquerda, superior, direita, inferior |
Nota: Esta configuração inset entra em vigor somente quando o valor de insetmode é 'custom'.
Especificar o status de bloqueio de objetos e texto de objeto usando atributos de proteção.
ws . getCell ( 'B1' ) . note . protection = {
locked : 'False' ,
lockText : 'False' ,
} ;| Propriedade | Obrigatório | Valor padrão | Descrição |
|---|---|---|---|
| bloqueado | N | 'Verdadeiro' | Este elemento especifica que o objeto está bloqueado quando a planilha está protegida |
| lockText | N | 'Verdadeiro' | Este elemento especifica que o texto do objeto está bloqueado |
Nota: Os objetos bloqueados são válidos somente quando a planilha está protegida.
Os comentários das células também podem ter a propriedade 'editAs' que controlará como os comentários são ancorados na(s) célula(s). Pode ter um dos seguintes valores:
ws . getCell ( 'B1' ) . note . editAs = 'twoCells' ;| Valor | Descrição |
|---|---|
| duas células | Especifica que o tamanho e a posição da nota variam de acordo com as células |
| oneCells | Especifica que o tamanho da nota é fixo e a posição muda com a célula |
| absoluto | Este é o padrão. Os comentários não serão movidos ou dimensionados com células |
As tabelas permitem a manipulação de dados tabulares na planilha.
Para adicionar uma tabela a uma planilha, defina um modelo de tabela e chame addTable:
// add a table to a sheet
ws . addTable ( {
name : 'MyTable' ,
ref : 'A1' ,
headerRow : true ,
totalsRow : true ,
style : {
theme : 'TableStyleDark3' ,
showRowStripes : true ,
} ,
columns : [
{ name : 'Date' , totalsRowLabel : 'Totals:' , filterButton : true } ,
{ name : 'Amount' , totalsRowFunction : 'sum' , filterButton : false } ,
] ,
rows : [
[ new Date ( '2019-07-20' ) , 70.10 ] ,
[ new Date ( '2019-07-21' ) , 70.60 ] ,
[ new Date ( '2019-07-22' ) , 70.10 ] ,
] ,
} ) ;Nota: Adicionar uma tabela a uma planilha modificará a planilha, colocando cabeçalhos e dados de linha na planilha. Quaisquer dados na planilha coberta pela tabela resultante (incluindo cabeçalhos e totais) serão substituídos.
A tabela a seguir define as propriedades suportadas pelas tabelas.
| Propriedade da tabela | Descrição | Obrigatório | Valor padrão |
|---|---|---|---|
| nome | O nome da tabela | S | |
| nome de exibição | O nome de exibição da tabela | N | nome |
| referência | Célula superior esquerda da tabela | S | |
| linha de cabeçalho | Mostrar cabeçalhos no topo da tabela | N | verdadeiro |
| linha total | Mostrar totais na parte inferior da tabela | N | falso |
| estilo | Propriedades extras de estilo | N | {} |
| colunas | Definições de coluna | S | |
| linhas | Linhas de dados | S |
A tabela a seguir define as propriedades suportadas na propriedade de estilo de tabela.
| Propriedade de estilo | Descrição | Obrigatório | Valor padrão |
|---|---|---|---|
| tema | O tema de cores da mesa | N | 'TableStyleMedium2' |
| mostrarPrimeiraColuna | Destaque a primeira coluna (negrito) | N | falso |
| mostrarÚltimaColuna | Destaque a última coluna (negrito) | N | falso |
| showRowStripes | Linhas alternativas mostradas com cor de fundo | N | falso |
| showColumnStripes | Linhas alternativas mostradas com cor de fundo | N | falso |
A tabela a seguir define as propriedades suportadas em cada coluna da tabela.
| Propriedade da coluna | Descrição | Obrigatório | Valor padrão |
|---|---|---|---|
| nome | O nome da coluna, também usado no cabeçalho | S | |
| filtroButton | Alterna o controle de filtro no cabeçalho | N | falso |
| totaisRowLabel | Rótulo para descrever a linha de totais (primeira coluna) | N | 'Total' |
| totalsRowFunction | Nome da função de totais | N | 'nenhum' |
| totalsRowFormula | Fórmula opcional para funções personalizadas | N |
A tabela a seguir lista os valores válidos para a propriedade totalsRowFunction definida por colunas. Caso seja utilizado qualquer valor diferente de ‘custom’, não é necessário incluir a fórmula associada, pois esta será inserida pela tabela.
| Funções totais | Descrição |
|---|---|
| nenhum | Nenhuma função de totais para esta coluna |
| média | Calcular a média da coluna |
| contagemNúmeros | Conte as entradas que são números |
| contar | Contagem de entradas |
| máx. | O valor máximo nesta coluna |
| min | O valor mínimo nesta coluna |
| stdDesv | O desvio padrão para esta coluna |
| var | A variação para esta coluna |
| soma | A soma das entradas desta coluna |
| personalizado | Uma fórmula personalizada. Requer um valor totalsRowFormula associado. |
Os nomes de temas válidos seguem o seguinte padrão:
Tons e números podem ser um dos seguintes:
Para nenhum tema, use o valor nulo.
Nota: temas de tabelas personalizadas ainda não são suportados pelo Exceljs.
As tabelas suportam um conjunto de funções de manipulação que permitem adicionar ou remover dados e alterar algumas propriedades. Como muitas dessas operações podem ter efeitos na planilha, as alterações devem ser confirmadas depois de concluídas.
Todos os valores de índice na tabela são baseados em zero, portanto, o número da primeira linha e o número da primeira coluna são 0.
Adicionando ou removendo cabeçalhos e totais
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 ( ) ;Realocando uma mesa
const table = ws . getTable ( 'MyTable' ) ;
// table top-left move to D4
table . ref = 'D4' ;
// commit the table changes into the sheet
table . commit ( ) ;Adicionando e removendo linhas
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 ( ) ;Adicionando e removendo colunas
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 ( ) ;Alterar propriedades da coluna
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 ( ) ; Cada célula, linha e coluna oferece suporte a um rico conjunto de estilos e formatos que afetam o modo como as células são exibidas.
Os estilos são definidos atribuindo as seguintes propriedades:
// 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 } ;Quando um estilo é aplicado a uma linha ou coluna, ele será aplicado a todas as células existentes naquela linha ou coluna. Além disso, qualquer nova célula criada herdará seus estilos iniciais da linha e coluna à qual pertence.
Se a linha e a coluna de uma célula definirem um estilo específico (por exemplo, fonte), a célula usará o estilo da linha em vez do estilo da coluna. Porém se a linha e a coluna definirem estilos diferentes (por exemplo, column.numFmt e row.font), a célula herdará a fonte da linha e o numFmt da coluna.
Advertência: todas as propriedades acima (com exceção de numFmt, que é uma string), são estruturas de objetos JS. Se o mesmo objeto de estilo for atribuído a mais de uma entidade de planilha, cada entidade compartilhará o mesmo objeto de estilo. Se o objeto de estilo for modificado posteriormente antes da planilha ser serializada, todas as entidades que fazem referência a esse objeto de estilo também serão modificadas. Este comportamento tem como objetivo priorizar o desempenho, reduzindo o número de objetos JS criados. Se quiser que os objetos de estilo sejam independentes, você precisará cloná-los antes de atribuí-los. Além disso, por padrão, quando um documento é lido de um arquivo (ou fluxo), se as entidades da planilha compartilharem estilos semelhantes, elas também farão referência ao mesmo objeto de estilo.
// 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| Propriedade da fonte | Descrição | Valores de exemplo |
|---|---|---|
| nome | Nome da fonte. | 'Arial', 'Calibri', etc. |
| família | Família de fontes para substituto. Um valor inteiro. | 1 - Serif, 2 - Sans Serif, 3 - Mono, Outros - desconhecido |
| esquema | Esquema de fontes. | 'menor', 'maior', 'nenhum' |
| conjunto de caracteres | Conjunto de caracteres de fonte. Um valor inteiro. | 1, 2, etc |
| tamanho | Tamanho da fonte. Um valor inteiro. | 9, 10, 12, 16, etc. |
| cor | Descrição da cor, um objeto contendo um valor ARGB. | { argb: 'FFFF0000'} |
| audacioso | Peso da fonte | verdadeiro, falso |
| itálico | Inclinação da fonte | verdadeiro, falso |
| sublinhado | Estilo de sublinhado da fonte | verdadeiro, falso, 'nenhum', 'single', 'double', 'singleAccounting', 'doubleAccounting' |
| batida | | verdadeiro, falso |
| contorno | Contorno da fonte | verdadeiro, falso |
| vertAlign | Alinhamento vertical | 'sobrescrito', 'subscrito' |
// 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' } ;Valores de propriedade de alinhamento válidos
| horizontal | vertical | wrapText | encolher para caber | recuar | ordem de leitura | rotação de texto |
|---|---|---|---|---|---|---|
| esquerda | principal | verdadeiro | verdadeiro | inteiro | RTL | 0 a 90 |
| centro | meio | falso | falso | litro | -1 a -90 | |
| certo | fundo | vertical | ||||
| preencher | distribuído | |||||
| justificar | justificar | |||||
| centroContínuo | ||||||
| distribuído |
// 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' } }
} ;Estilos de borda válidos
// 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' } }
]
} ; | Propriedade | Obrigatório | Descrição |
|---|---|---|
| tipo | S | Valor: 'padrão' Especifica que este preenchimento usa padrões |
| padrão | S | Especifica o tipo de padrão (veja Tipos de padrões válidos abaixo) |
| fgCor | N | Especifica a cor de primeiro plano do padrão. O padrão é preto. |
| bgColor | N | Especifica a cor de fundo do padrão. O padrão é branco. |
Nota: Se quiser preencher uma célula usando o padrão solid , não será necessário especificar bgColor . Veja o exemplo acima para a célula A3 com um padrão solid e um coral fgColor .
Tipos de padrões válidos
| Propriedade | Obrigatório | Descrição |
|---|---|---|
| tipo | S | Valor: 'gradiente' Especifica que este preenchimento usa gradientes |
| gradiente | S | Especifica o tipo de gradiente. Um de ['ângulo', 'caminho'] |
| grau | ângulo | Para gradiente de 'ângulo', especifica a direção do gradiente. 0 é da esquerda para a direita. Valores de 1 a 359 gira no sentido horário |
| centro | caminho | Para gradiente de 'caminho'. Especifica as coordenadas relativas para o início do caminho. Os valores 'esquerdo' e 'superior' variam de 0 a 1 |
| para | S | Especifica a sequência de cores do gradiente. É uma matriz de objetos contendo posição e cor começando na posição 0 e terminando na posição 1. Posições intermediárias podem ser usadas para especificar outras cores no caminho. |
Advertências
Usando a interface acima, pode ser possível criar efeitos de preenchimento gradiente que não são possíveis usando o programa editor XLSX. Por exemplo, o Excel suporta apenas gradientes de ângulo de 0, 45, 90 e 135. Da mesma forma, a sequência de paradas também pode ser limitada pela IU com posições [0,1] ou [0,0.5,1] como as únicas opções. Tome cuidado com esse preenchimento para ter certeza de que ele é compatível com os visualizadores XLSX de destino.
Células individuais agora suportam rich text ou formatação na célula. Os valores de rich text podem controlar as propriedades de fonte de qualquer número de substrings dentro do valor do texto. Consulte Fontes para obter uma lista completa de detalhes sobre quais propriedades de fonte são suportadas.
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 ) ;A proteção em nível de célula pode ser modificada usando a propriedade de proteção.
ws . getCell ( 'A1' ) . protection = {
locked : false ,
hidden : true ,
} ;Propriedades de proteção suportadas
| Propriedade | Padrão | Descrição |
|---|---|---|
| bloqueado | verdadeiro | Especifica se uma célula será bloqueada se a planilha estiver protegida. |
| escondido | falso | Especifica se a fórmula de uma célula ficará visível se a planilha estiver protegida. |
A formatação condicional permite que uma planilha mostre estilos, ícones, etc. específicos, dependendo dos valores das células ou de qualquer fórmula arbitrária.
As regras de formatação condicional são adicionadas no nível da planilha e normalmente abrangem um intervalo de células.
Várias regras podem ser aplicadas a um determinado intervalo de células e cada regra aplicará seu próprio estilo.
Se várias regras afetarem uma determinada célula, o valor de prioridade da regra determinará qual regra vencerá se os estilos concorrentes colidirem. A regra com o valor de prioridade mais baixo vence. Se os valores de prioridade não forem especificados para uma determinada regra, o ExcelJS os atribuirá em ordem crescente.
Nota: atualmente, apenas um subconjunto de regras de formatação condicional é suportado. Especificamente, apenas as regras de formatação que não exigem renderização XML dentro de um elemento <extLst>. Isso significa que conjuntos de dados e três conjuntos de ícones específicos (3Triangles, 3Stars, 5Boxes) não são suportados.
// 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' } } } ,
}
]
} )Tipos de regras de formatação condicional compatíveis
| Tipo | Descrição |
|---|---|
| expressão | Qualquer função personalizada pode ser usada para ativar a regra. |
| célula é | Compara o valor da célula com a fórmula fornecida usando o operador especificado |
| 10 principais | Aplica formatação a células com valores nos intervalos superiores (ou inferiores) |
| acima da média | Aplica formatação a células com valores acima (ou abaixo) da média |
| escala de cores | Aplica um fundo colorido às células com base na localização dos seus valores no intervalo |
| conjunto de ícones | Adiciona um dentre vários ícones às células com base no valor |
| contémTexto | Aplica formatação com base no fato de a célula ser um texto específico |
| período de tempo | Aplica a formatação com base no fato de o valor de data e hora da célula estar dentro de um intervalo especificado |
| Campo | Opcional | Padrão | Descrição |
|---|---|---|---|
| tipo | 'expressão' | ||
| prioridade | S | <automático> | determina a ordem de prioridade dos estilos |
| fórmulas | matriz de 1 string de fórmula que retorna um valor verdadeiro/falso. Para fazer referência ao valor da célula, use o endereço da célula no canto superior esquerdo | ||
| estilo | estrutura de estilo a ser aplicada se a fórmula retornar verdadeiro |
| Campo | Opcional | Padrão | Descrição |
|---|---|---|---|
| tipo | 'célula é' | ||
| prioridade | S | <automático> | determina a ordem de prioridade dos estilos |
| operador | como comparar o valor da célula com o resultado da fórmula | ||
| fórmulas | matriz de 1 string de fórmula que retorna o valor a ser comparado com cada célula | ||
| estilo | estrutura de estilo a ser aplicada se a comparação retornar verdadeiro |
Célula é Operadora
| Operador | Descrição |
|---|---|
| igual | Aplicar formato se o valor da célula for igual ao valor da fórmula |
| maior que | Aplicar formato se o valor da célula for maior que o valor da fórmula |
| menor que | Aplicar formato se o valor da célula for menor que o valor da fórmula |
| entre | Aplicar formato se o valor da célula estiver entre dois valores de fórmula (inclusive) |
| Campo | Opcional | Padrão | Descrição |
|---|---|---|---|
| tipo | 'top10' | ||
| prioridade | S | <automático> | determina a ordem de prioridade dos estilos |
| classificação | S | 10 | especifica quantos valores superiores (ou inferiores) estão incluídos na formatação |
| por cento | S | falso | se for verdade, o campo de classificação é uma porcentagem, não um valor absoluto |
| fundo | S | falso | se for verdade, os valores inferiores serão incluídos em vez dos valores superiores |
| estilo | estrutura de estilo a ser aplicada se a comparação retornar verdadeiro |
| Campo | Opcional | Padrão | Descrição |
|---|---|---|---|
| tipo | 'acima da média' | ||
| prioridade | S | <automático> | determina a ordem de prioridade dos estilos |
| acima da média | S | falso | se for verdade, o campo de classificação é uma porcentagem, não um valor absoluto |
| estilo | estrutura de estilo a ser aplicada se a comparação retornar verdadeiro |
| Campo | Opcional | Padrão | Descrição |
|---|---|---|---|
| tipo | 'escala de cores' | ||
| prioridade | S | <automático> | determina a ordem de prioridade dos estilos |
| CFVO | matriz de 2 a 5 objetos de valor de formatação condicional especificando pontos de referência no intervalo de valores | ||
| cor | matriz correspondente de cores para usar em determinados pontos de passagem | ||
| estilo | estrutura de estilo a ser aplicada se a comparação retornar verdadeiro |
| Campo | Opcional | Padrão | Descrição |
|---|---|---|---|
| tipo | 'conjunto de ícones' | ||
| prioridade | S | <automático> | determina a ordem de prioridade dos estilos |
| conjunto de ícones | S | 3Semáforos | nome do ícone definido para usar |
| mostrarValor | verdadeiro | Especifica se as células no intervalo aplicado exibem o ícone e o valor da célula ou apenas o ícone | |
| reverter | falso | Especifica se os ícones no conjunto de ícones especificado em iconSet são mostrados em ordem de reserva. Se custom for igual a "true", este valor deverá ser ignorado | |
| personalizado | falso | Especifica se um conjunto personalizado de ícones é usado | |
| CFVO | matriz de 2 a 5 objetos de valor de formatação condicional especificando pontos de referência no intervalo de valores | ||
| estilo | estrutura de estilo a ser aplicada se a comparação retornar verdadeiro |
| Campo | Opcional | Padrão | Descrição |
|---|---|---|---|
| tipo | 'barra de dados' | ||
| prioridade | S | <automático> | determina a ordem de prioridade dos estilos |
| comprimento mínimo | 0 | Especifica o comprimento da barra de dados mais curta neste intervalo de formatação condicional | |
| comprimento máximo | 100 | Especifica o comprimento da barra de dados mais longa neste intervalo de formatação condicional | |
| mostrarValor | verdadeiro | Especifica se as células no intervalo de formatação condicional exibem a barra de dados e o valor numérico ou a barra de dados | |
| gradiente | verdadeiro | Especifica se a barra de dados possui preenchimento gradiente | |
| fronteira | verdadeiro | Especifica se a barra de dados possui uma borda | |
| negativoBarColorSameAsPositive | verdadeiro | Especifica se a barra de dados tem uma cor de barra negativa diferente da cor de barra positiva | |
| negativoBarBorderColorSameAsPositive | verdadeiro | Especifica se a barra de dados tem uma cor de borda negativa diferente da cor de borda positiva | |
| posição do eixo | 'auto' | Especifica a posição do eixo da barra de dados | |
| direção | 'esquerda para direita' | Especifica a direção da barra de dados | |
| CFVO | matriz de 2 a 5 objetos de valor de formatação condicional especificando pontos de referência no intervalo de valores | ||
| estilo | estrutura de estilo a ser aplicada se a comparação retornar verdadeiro |
| Campo | Opcional | Padrão | Descrição |
|---|---|---|---|
| tipo | 'contémTexto' | ||
| prioridade | S | <automático> | determina a ordem de prioridade dos estilos |
| operador | tipo de comparação de texto | ||
| texto | texto para pesquisar | ||
| estilo | estrutura de estilo a ser aplicada se a comparação retornar verdadeiro |
Contém operadores de texto
| Operador | Descrição |
|---|---|
| contémTexto | Aplicar formato se o valor da célula contiver o valor especificado no campo 'texto' |
| contém espaços em branco | Aplicar formato se o valor da célula contiver espaços em branco |
| notContainsBlanks | Aplicar formato se o valor da célula não contiver espaços em branco |
| contémErros | Aplicar formato se o valor da célula contiver erros |
| notContainsErrors | Aplicar formato se o valor da célula não contiver erros |
| Campo | Opcional | Padrão | Descrição |
|---|---|---|---|
| tipo | 'período de tempo' | ||
| prioridade | S | <automático> | determina a ordem de prioridade dos estilos |
| período de tempo | a que período de tempo comparar o valor da célula | ||
| estilo | estrutura de estilo a ser aplicada se a comparação retornar verdadeiro |
Períodos de tempo
| Período de tempo | Descrição |
|---|---|
| semana passada | Aplicar formato se o valor da célula estiver na última semana |
| essa semana | Aplicar formato se o valor da célula cair nesta semana |
| próxima semana | Aplicar formato se o valor da célula cair na próxima semana |
| ontem | Aplicar formato se o valor da célula for igual a ontem |
| hoje | Aplicar formato se o valor da célula for igual a hoje |
| amanhã | Aplicar formato se o valor da célula for igual a amanhã |
| últimos 7 dias | Aplicar formato se o valor da célula estiver nos últimos 7 dias |
| último mês | Aplicar formato se o valor da célula cair no mês passado |
| este mês | Aplicar formato se o valor da célula cair neste mês |
| próximo mês | Aplicar formato se o valor da célula cair no próximo mês |
Excel suporta delineamento; onde linhas ou colunas podem ser expandidas ou recolhidas dependendo do nível de detalhe que o usuário deseja visualizar.
Os níveis de estrutura de tópicos podem ser definidos na configuração da coluna:
worksheet . columns = [
{ header : 'Id' , key : 'id' , width : 10 } ,
{ header : 'Name' , key : 'name' , width : 32 } ,
{ header : 'D.O.B.' , key : 'DOB' , width : 10 , outlineLevel : 1 }
] ;Ou diretamente na linha ou coluna
worksheet . getColumn ( 3 ) . outlineLevel = 1 ;
worksheet . getRow ( 3 ) . outlineLevel = 1 ;Os níveis de contorno da planilha podem ser definidos na planilha
// set column outline level
worksheet . properties . outlineLevelCol = 1 ;
// set row outline level
worksheet . properties . outlineLevelRow = 1 ;Nota: ajustar os níveis de estrutura de tópicos em linhas ou colunas ou os níveis de estrutura de tópicos na planilha incorrerá no efeito colateral de também modificar a propriedade recolhida de todas as linhas ou colunas afetadas pela alteração de propriedade. Por exemplo:
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 ;As propriedades do contorno podem ser definidas na planilha
worksheet . properties . outlineProperties = {
summaryBelow : false ,
summaryRight : false ,
} ; Adicionar imagens a uma planilha é um processo de duas etapas. Primeiro, a imagem é adicionada à pasta de trabalho por meio da função addImage() que também retornará um valor imageId. Em seguida, usando o imageId, a imagem pode ser adicionada à planilha como um plano de fundo lado a lado ou cobrindo um intervalo de células.
Nota: A partir desta versão, o ajuste ou transformação da imagem não é suportado e as imagens não são suportadas no modo streaming.
A função Workbook.addImage suporta a adição de imagens por nome de arquivo ou por Buffer. Observe que em ambos os casos a extensão deve ser especificada. Os valores de extensão válidos incluem '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' ,
} ) ;Usando o ID da imagem de Workbook.addImage, o plano de fundo de uma planilha pode ser definido usando a função addBackgroundImage
// set background
worksheet . addBackgroundImage ( imageId1 ) ;Usando o ID da imagem de Workbook.addImage, uma imagem pode ser incorporada na planilha para cobrir um intervalo. As coordenadas calculadas a partir do intervalo cobrirão desde o canto superior esquerdo da primeira célula até o canto inferior direito da segunda.
// insert an image over B2:D6
worksheet . addImage ( imageId2 , 'B2:D6' ) ;Usando uma estrutura em vez de uma string de intervalo, é possível cobrir parcialmente as células.
Observe que o sistema de coordenadas usado para isso é baseado em zero, então o canto superior esquerdo de A1 será {col: 0, row: 0}. Frações de células podem ser especificadas usando números de ponto flutuante, por exemplo, o ponto médio de A1 é { col: 0,5, row: 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 }
} ) ;A faixa celular também pode ter a propriedade 'Editas', que controlará como a imagem está ancorada nas células, ela pode ter um dos seguintes valores:
| Valor | Descrição |
|---|---|
| indefinido | Especifica que a imagem será movida e dimensionada com células |
| OneCell | Este é o padrão. A imagem será movida com células, mas não tamanho |
| absoluto | A imagem não será movida ou dimensionada com células |
ws . addImage ( imageId , {
tl : { col : 0.1125 , row : 0.4 } ,
br : { col : 2.101046875 , row : 3.4 } ,
editAs : 'oneCell'
} ) ;Você pode adicionar uma imagem a uma célula e definir sua largura e altura em pixels a 96dpi.
worksheet . addImage ( imageId2 , {
tl : { col : 0 , row : 0 } ,
ext : { width : 500 , height : 200 }
} ) ;Você pode adicionar uma imagem com hiperlinks a uma célula e define os hiperlinks no intervalo de imagens.
worksheet . addImage ( imageId2 , {
tl : { col : 0 , row : 0 } ,
ext : { width : 500 , height : 200 } ,
hyperlinks : {
hyperlink : 'http://www.somewhere.com' ,
tooltip : 'http://www.somewhere.com'
}
} ) ; As planilhas podem ser protegidas da modificação adicionando uma senha.
await worksheet . protect ( 'the-password' , options ) ;A proteção da planilha também pode ser removida:
worksheet . unprotect ( ) ;Consulte a proteção celular para obter detalhes sobre como modificar a proteção individual das células.
Nota: Enquanto a função Protect () retorna uma promessa indicando que é assíncrona, a implementação atual é executada no encadeamento principal e usará aproximadamente 600ms em uma CPU média. Isso pode ser ajustado definindo o Spincount, que pode ser usado para tornar o processo mais rápido ou mais resiliente.
| Campo | Padrão | Descrição |
|---|---|---|
| SelectLockedCells | verdadeiro | Permite o usuário selecionar células bloqueadas |
| SelectUnlockedCells | verdadeiro | Permite o usuário selecionar células desbloqueadas |
| FormatCells | falso | Permite que o usuário formate as células |
| formatColumns | falso | Permite as colunas do formato do usuário |
| Formatrows | falso | Deixe o usuário formatar linhas |
| insertrows | falso | Permite o usuário inserir linhas |
| insertColumns | falso | Permite que o usuário insira colunas |
| inserthyperlinks | falso | Permite que o usuário insira hiperlinks |
| Deleterows | falso | Permite o usuário excluir linhas |
| DeleteColumns | falso | Permite que o usuário exclua colunas |
| organizar | falso | Permite que o usuário classifique dados |
| Autofilter | falso | Permite os dados do filtro do usuário em tabelas |
| Pivottables | falso | Permite que o usuário use tabelas dinâmicas |
| Espincount | 100.000 | O número de iterações de hash realizadas ao proteger ou desprotegir |
Opções suportadas ao ler arquivos XLSX.
| Campo | Obrigatório | Tipo | Descrição |
|---|---|---|---|
| ignorenodos | N | Variedade | Uma lista de nomes de nó para ignorar enquanto carrega o documento XLSX. Melhora o desempenho em algumas situações. 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 ( ) ;Opções suportadas ao ler arquivos CSV.
| Campo | Obrigatório | Tipo | Descrição |
|---|---|---|---|
| DateFormats | N | Variedade | Especifique o formato de codificação da data de DayJs. |
| mapa | N | Função | Função de retorno de chamada Array.prototype.map () Custom Array.prototype.map () para processamento de dados. |
| SheetName | N | Corda | Especifique o nome da planilha. |
| parseroptions | N | Objeto | Opções de parseoptões @módulo Fast-CSV/Formato para gravar dados de CSV. |
// read from a file
const workbook = new Excel . Workbook ( ) ;
const worksheet = await workbook . csv . readFile ( filename ) ;
// ... use workbook or worksheet
// read from a stream
const workbook = new Excel . Workbook ( ) ;
const worksheet = await workbook . csv . read ( stream ) ;
// ... use workbook or worksheet
// read from a file with European Dates
const workbook = new Excel . Workbook ( ) ;
const options = {
dateFormats : [ 'DD/MM/YYYY' ]
} ;
const worksheet = await workbook . csv . readFile ( filename , options ) ;
// ... use workbook or worksheet
// read from a file with custom value parsing
const workbook = new Excel . Workbook ( ) ;
const options = {
map ( value , index ) {
switch ( index ) {
case 0 :
// column 1 is string
return value ;
case 1 :
// column 2 is a date
return new Date ( value ) ;
case 2 :
// column 3 is JSON of a formula value
return JSON . parse ( value ) ;
default :
// the rest are numbers
return parseFloat ( value ) ;
}
} ,
// https://c2fo.github.io/fast-csv/docs/parsing/options
parserOptions : {
delimiter : 't' ,
quote : false ,
} ,
} ;
const worksheet = await workbook . csv . readFile ( filename , options ) ;
// ... use workbook or worksheetO analisador CSV usa o Fast-CSV para ler o arquivo CSV. As formaturas nas opções passadas para a função de gravação acima serão passadas para o módulo @fast-csv/formato para gravar dados de CSV. Consulte o Fast-CSV Readme.md para obter detalhes.
As datas são analisadas usando o módulo NPM DayJs. Se uma matriz DateFormats não for fornecida, os seguintes formatos de data serão usados:
Consulte o plugin Dayjs CustomParseFormat para obter detalhes sobre como estruturar um DateFormat.
Opções suportadas ao gravar em um arquivo CSV.
| Campo | Obrigatório | Tipo | Descrição |
|---|---|---|---|
| DateFormat | N | Corda | Especifique o formato de codificação da data de DayJs. |
| DateUtc | N | Booleano | Especifique se o ExcelJS usa dayjs.utc () para converter o fuso horário para analisar as datas. |
| codificação | N | Corda | Especifique o formato de codificação de arquivo. (Aplica -se apenas ao .writeFile .) |
| incluirmEmptyrows | N | Booleano | Especifica se linhas vazias podem ser escritas. |
| mapa | N | Função | Função de retorno de chamada Array.prototype.map () Custom Array.Prototype.Map () para processamento de valores de linha. |
| SheetName | N | Corda | Especifique o nome da planilha. |
| Sheetid | N | Número | Especifique o ID da planilha. |
| Formatternations | N | Objeto | Opções de formatRatroptions @módulo Fast-CSV/Formato para gravar dados de CSV. |
// write to a file
const workbook = createAndFillWorkbook ( ) ;
await workbook . csv . writeFile ( filename ) ;
// write to a stream
// Be careful that you need to provide sheetName or
// sheetId for correct import to csv.
await workbook . csv . write ( stream , { sheetName : 'Page name' } ) ;
// write to a file with European Date-Times
const workbook = new Excel . Workbook ( ) ;
const options = {
dateFormat : 'DD/MM/YYYY HH:mm:ss' ,
dateUTC : true , // use utc when rendering dates
} ;
await workbook . csv . writeFile ( filename , options ) ;
// write to a file with custom value formatting
const workbook = new Excel . Workbook ( ) ;
const options = {
map ( value , index ) {
switch ( index ) {
case 0 :
// column 1 is string
return value ;
case 1 :
// column 2 is a date
return dayjs ( value ) . format ( 'YYYY-MM-DD' ) ;
case 2 :
// column 3 is a formula, write just the result
return value . result ;
default :
// the rest are numbers
return value ;
}
} ,
// https://c2fo.github.io/fast-csv/docs/formatting/options
formatterOptions : {
delimiter : 't' ,
quote : false ,
} ,
} ;
await workbook . csv . writeFile ( filename , options ) ;
// write to a new buffer
const buffer = await workbook . csv . writeBuffer ( ) ;O analisador CSV usa o Fast-CSV para gravar o arquivo CSV. As formaturas nas opções passadas para a função de gravação acima serão passadas para o módulo @fast-csv/formato para gravar dados de CSV. Consulte o Fast-CSV Readme.md para obter detalhes.
As datas são formatadas usando o módulo NPM DayJs. Se nenhum DateFormat for fornecido, o DayJs.iso_8601 será usado. Ao escrever um CSV, você pode fornecer o DateUTC booleano como fiel ao Exceljs analisar a data sem converter automaticamente o fuso horário usando dayjs.utc() .
A E/S do arquivo documentada acima exige que uma pasta de trabalho inteira seja construída na memória antes que o arquivo possa ser gravado. Embora conveniente, ele pode limitar o tamanho do documento devido à quantidade de memória necessária.
Um escritor de streaming (ou leitor) processa os dados da pasta de trabalho ou da planilha à medida que são gerados, convertendo -os em formulário de arquivo. Normalmente, isso é muito mais eficiente na memória, pois a pegada final da memória e até as pegadas de memória intermediária são muito mais compactas do que com a versão do documento, especialmente quando você considera que os objetos de linha e célula são descartados quando são cometidos.
A interface para a pasta de trabalho e a planilha de streaming é quase a mesma das versões do documento com algumas pequenas diferenças práticas:
Observe que é possível construir toda a pasta de trabalho sem cometer linhas. Quando a pasta de trabalho estiver comprometida, todas as planilhas adicionadas (incluindo todas as linhas não comprometidas) serão automaticamente comprometidas. No entanto, neste caso, pouco terá sido obtido sobre a versão do documento.
O escritor da pasta de trabalho XLSX de streaming está disponível no espaço para nome do Exceljs.stream.xlsx.
O construtor pega um objeto de opções opcionais com os seguintes campos:
| Campo | Descrição |
|---|---|
| fluxo | Especifica um fluxo gravável para escrever a pasta de trabalho do XLSX. |
| nome do arquivo | Se o fluxo não for especificado, este campo especifica o caminho para um arquivo para gravar a pasta de trabalho do XLSX. |
| UsoSharedStrings | Especifica se o uso de strings compartilhados na pasta de trabalho. O padrão é false . |
| estilos de uso | Especifica se deve adicionar informações de estilo à pasta de trabalho. Os estilos podem adicionar algumas despesas gerais de desempenho. O padrão é false . |
| zip | Opções ZIP que se destacam internamente passam para o Archiver. O padrão é undefined . |
Se nem o fluxo nem o nome do arquivo forem especificados nas opções, o redator da pasta de trabalho criará um objeto Streambuf que armazenará o conteúdo da pasta de trabalho XLSX na memória. Este objeto Streambuf, que pode ser acessado através da pasta de trabalho de propriedades.stream, pode ser usado para acessar os bytes diretamente por stream.read () ou para tubar o conteúdo em outro fluxo.
// 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 ) ;Em geral, a interface do streaming XLSX Writer é a mesma da pasta de trabalho de documentos (e planilhas) descrita acima, na verdade, os objetos de linha, célula e estilo são os mesmos.
No entanto, existem algumas diferenças ...
Construção
Como visto acima, o WorkBookWriter normalmente exige que o fluxo ou arquivo de saída seja especificado no construtor.
Cometer dados
Quando uma linha de planilha estiver pronta, ela deve ser cometida para que o objeto e o conteúdo da linha possam ser libertados. Normalmente, isso seria feito à medida que cada linha é adicionada ...
worksheet . addRow ( {
id : i ,
name : theName ,
etc : someOtherDetail
} ) . commit ( ) ;A razão pela qual o worksheetwriter não comete linhas como é adicionado é permitir que as células sejam mescladas entre linhas:
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.À medida que cada planilha é concluída, também deve ser cometida:
// Finished adding data. Commit the worksheet
worksheet . commit ( ) ;Para concluir o documento XLSX, a pasta de trabalho deve ser comprometida. Se alguma planilha em uma pasta de trabalho não for confirmada, eles serão comprometidos automaticamente como parte da pasta de trabalho.
// Finished the workbook.
await workbook . commit ( ) ;
// ... the stream has been written O leitor da pasta de trabalho XLSX de streaming está disponível no espaço para nome do Exceljs.stream.xlsx.
O construtor pega um argumento de entrada necessário e um argumento de opções opcionais:
| Argumento | Descrição |
|---|---|
| entrada (necessária) | Especifica o nome do arquivo ou o fluxo legível para ler a pasta de trabalho do XLSX. |
| Opções (opcional) | Especifica como lidar com os tipos de eventos que ocorrem durante a análise de leitura. |
| options.entries | Especifica se deve emitir entradas ( 'emit' ) ou não ( 'ignore' ). O padrão é 'emit' . |
| options.sharedStrings | Especifica se deve cache as cordas compartilhadas ( 'cache' ), que as insere nos respectivos valores celulares, ou se devem emitê -los ( 'emit' ) ou ignorá -los ( 'ignore' ), nesse caso, o valor da célula será uma referência ao índice da string compartilhada. O padrão é 'cache' . |
| options.hyperlinks | Especifica se deve cache os hiperlinks ( 'cache' ), que os insere em suas respectivas células, seja para emitê -las ( 'emit' ) ou se deve ignorá -las ( 'ignore' ). O padrão é 'cache' . |
| options.styles | Especifica se os estilos de cache ( 'cache' ), que os inserem em suas respectivas linhas e células ou se devem ignorá -las ( 'ignore' ). O padrão é 'cache' . |
| options.worksheets | Especifica se deve emitir planilhas ( 'emit' ) ou não ( 'ignore' ). O padrão é 'emit' . |
const workbookReader = new ExcelJS . stream . xlsx . WorkbookReader ( './file.xlsx' ) ;
for await ( const worksheetReader of workbookReader ) {
for await ( const row of worksheetReader ) {
// ...
}
} Observe que worksheetReader retorna uma variedade de linhas em vez de cada linha individualmente por razões de desempenho: Nodejs/nó#31979
Os eventos na pasta de trabalho são 'planilha', 'strings compartilhados' e 'hiperlinks'. Os eventos na planilha são 'Row' e '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
}
} Embora incentivemos fortemente o uso da iteração assíncrona, também expomos uma interface de streaming para compatibilidade com versões anteriores.
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 ) => {
// ...
} ) ;Uma parte desta biblioteca foi isolada e testada para uso em um ambiente de navegador.
Devido à natureza de streaming do leitor da pasta de trabalho e do escritor da pasta de trabalho, eles não foram incluídos. Somente a pasta de trabalho baseada em documentos pode ser usada (consulte Crie uma pasta de trabalho para obter detalhes).
Por exemplo, o código usando o ExcelJs no navegador dê uma olhada na pasta Spec/navegador no repo Github.
Os arquivos a seguir são pré-conceituados e incluídos dentro da pasta Dist.
Os seguintes tipos de valor são suportados.
Enum: excel.valuetype.null
Um valor nulo indica uma ausência de valor e normalmente não será armazenado quando gravado no arquivo (exceto para células mescladas). Pode ser usado para remover o valor de uma célula.
Por exemplo
worksheet . getCell ( 'A1' ) . value = null ; Enum: excel.valuetype.merge
Uma célula de mesclagem é aquela que tem seu valor ligado a outra célula 'mestre'. A atribuição a uma célula de mesclagem fará com que a célula do mestre seja modificada.
Enum: excel.valuetype.number
Um valor numérico.
Por exemplo
worksheet . getCell ( 'A1' ) . value = 5 ;
worksheet . getCell ( 'A2' ) . value = 3.14159 ; Enum: excel.valuetype.string
Uma string de texto simples.
Por exemplo
worksheet . getCell ( 'A1' ) . value = 'Hello, World!' ; Enum: excel.valuetype.date
Um valor de data, representado pelo tipo de data do JavaScript.
Por exemplo
worksheet . getCell ( 'A1' ) . value = new Date ( 2017 , 2 , 15 ) ; Enum: excel.valuetype.hyperlink
Um URL com o valor de texto e link.
Por exemplo
// 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
Uma fórmula do Excel para calcular valores em tempo real. Observe que, embora o tipo de célula seja fórmula, a célula pode ter um valor de efetividade que será derivado do valor do resultado.
Observe que o ExcelJs não pode processar a fórmula para gerar um resultado, ele deve ser fornecido.
Observe que os nomes semânticos da função devem estar em inglês e o separador deve ser uma vírgula.
Por exemplo
worksheet . getCell ( 'A3' ) . value = { formula : 'A1+A2' , result : 7 } ;
worksheet . getCell ( 'A3' ) . value = { formula : 'SUM(A1,A2)' , result : 7 } ;As células também suportam getters de conveniência para acessar a fórmula e o resultado:
worksheet . getCell ( 'A3' ) . formula === 'A1+A2' ;
worksheet . getCell ( 'A3' ) . result === 7 ;As fórmulas compartilhadas aprimoram a compactação do documento XLSX, diminuindo a repetição do texto na planilha XML. A célula superior esquerda em um intervalo é o mestre designado e manterá a fórmula de que todas as outras células do intervalo serão derivadas. As outras células 'escravos' podem se referir a esta célula mestre em vez de redefinir toda a fórmula novamente. Observe que a fórmula mestre será traduzida para as células escravas da maneira usual do Excel, para que as referências a outras células sejam deslocadas para baixo e para a direita, dependendo do deslocamento do escravo para o mestre. Por exemplo: se a célula mestre A2 tiver uma fórmula referente a A1, se a célula B2 compartilhar a fórmula do A2, ela fará referência a B1.
Uma fórmula mestre pode ser atribuída a uma célula junto com as células escravas em sua faixa
worksheet . getCell ( 'A2' ) . value = {
formula : 'A1' ,
result : 10 ,
shareType : 'shared' ,
ref : 'A2:B3'
} ;Uma fórmula compartilhada pode ser atribuída a uma célula usando um novo formulário de valor:
worksheet . getCell ( 'B2' ) . value = { sharedFormula : 'A2' , result : 10 } ;Isso especifica que a célula B2 é uma fórmula que será derivada da fórmula em A2 e seu resultado é 10.
A fórmula Conveniência Getter traduzirá a fórmula em A2 para o que deveria ser em B2:
expect ( worksheet . getCell ( 'B2' ) . formula ) . to . equal ( 'B1' ) ;As fórmulas compartilhadas podem ser atribuídas a uma folha usando a função 'FillFormula':
// set A1 to starting number
worksheet . getCell ( 'A1' ) . value = 1 ;
// fill A2 to A10 with ascending count starting from A1
worksheet . fillFormula ( 'A2:A10' , 'A1+1' , [ 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ] ) ;FillFormula também pode usar uma função de retorno de chamada para calcular o valor em cada célula
// fill A2 to A100 with ascending count starting from A1
worksheet . fillFormula ( 'A2:A100' , 'A1+1' , ( row , col ) => row ) ;Para distinguir entre células de fórmula reais e traduzidas, use o Formulatype Getter:
worksheet . getCell ( 'A3' ) . formulaType === Enums . FormulaType . Master ;
worksheet . getCell ( 'B3' ) . formulaType === Enums . FormulaType . Shared ;Tipo de fórmula tem os seguintes valores:
| Nome | Valor |
|---|---|
| Enums.formulatype.none | 0 |
| Enums.formulatype.master | 1 |
| Enums.formulatype.shared | 2 |
Uma nova maneira de expressar fórmulas compartilhadas no Excel é a fórmula da matriz. Nesta forma, a célula mestre é a única célula que contém qualquer informação relacionada a uma fórmula. Ele contém o Sharetype 'Array' junto com a faixa de células a que se aplica e a fórmula que será copiada. O restante das células são células regulares com valores regulares.
Nota: As fórmulas de matriz não são traduzidas da maneira que são fórmulas compartilhadas. Portanto, se a célula mestre A2 se referir a A1, a célula escrava B2 também se referirá a A1.
Por exemplo
// 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 sheetA função FillFformula também pode ser usada para preencher uma fórmula de matriz
// fill A2:B3 with array formula "A1"
worksheet . fillFormula ( 'A2:B3' , 'A1' , [ 1 , 1 , 1 , 1 ] , 'array' ) ; Enum: Excel.Valuetype.RichText
Texto rico e estilizado.
Por exemplo
worksheet . getCell ( 'A1' ) . value = {
richText : [
{ text : 'This is ' } ,
{ font : { italic : true } , text : 'italic' } ,
]
} ; Enum: Excel.Valuetype.Boolean
Por exemplo
worksheet . getCell ( 'A1' ) . value = true ;
worksheet . getCell ( 'A2' ) . value = false ; Enum: Excel.Valuetype.error
Por exemplo
worksheet . getCell ( 'A1' ) . value = { error : '#N/A' } ;
worksheet . getCell ( 'A2' ) . value = { error : '#VALUE!' } ;Os valores atuais de texto de erro válido são:
| Nome | Valor |
|---|---|
| Excel.errorValue.NotaPplicable | #N / D |
| Excel.errorValue.ref | #Ref! |
| Excel.errorValue.name | #NOME? |
| Excel.errorValue.divzero | #DIV/0! |
| Excel.errorValue.null | #NULO! |
| Excel.errorValue.value | #VALOR! |
| Excel.errorValue.num | #NUM! |
Todo esforço é feito para criar uma boa interface consistente que não rompe as versões, mas lamentavelmente, de vez em quando, algumas coisas precisam mudar para o bem maior.
Os argumentos na função de retorno de chamada para a planilha.Eachrow foram trocados e alterados; Era a função (ROWNUMER, ROWVALUES), agora é a função (linha, réplica), que dá uma olhada e se sente mais com a função sublinheira (_.each) e prioridades do objeto da linha sobre o número da linha.
Esta função mudou ao retornar uma matriz esparsa de valores celulares para retornar um objeto de linha. Isso permite acessar propriedades da linha e facilitará o gerenciamento de estilos de linha e assim por diante.
A variedade esparsa dos valores celulares ainda está disponível via worksheet.getRow (rownumber) .Values;
Cell.styles renomeado para Cell.style
As promessas retornadas das funções foram transferidas do Bluebird para o nó nativo promessa, que pode quebrar o código de chamada se eles confiarem nos recursos extras do Bluebird.
Para mitigar isso, as duas alterações a seguir foram adicionadas a 0.3.0:
O ExcelJS agora suporta injeção de dependência para a Biblioteca de Promessa. Você pode restaurar as promessas do Bluebird, incluindo o seguinte código em seu módulo ...
ExcelJS . config . setValue ( 'promise' , require ( 'bluebird' ) ) ;Observação: eu testei o ExcelJS com o Bluebird especificamente (desde recentemente, essa era a biblioteca usada). A partir dos testes que fiz, não funcionará com Q.
Antes de publicar este módulo, o código -fonte é transpilado e processado de outra forma antes de ser colocado em uma pasta dist/. Este ReadMe identifica dois arquivos - um pacote navegalizado e uma versão minificada. Nenhum outro conteúdo da Dist/ Pasta é garantido de outra maneira que não seja o arquivo especificado como "Main" no package.json
O conjunto de testes incluído neste LIB inclui um pequeno script executado em um navegador sem cabeça para validar os pacotes agrupados. No momento da redação deste artigo, parece que esse teste não é bom no subsistema do Windows Linux.
Por esse motivo, o teste do navegador pode ser desativado pela existência de um arquivo chamado.
sudo apt-get install libfontconfigSe alguma operação em emenda afetar uma célula mesclada, o grupo de mesclagem não será movido corretamente
| Versão | Mudanças |
|---|---|
| 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. Mudanças
|
| 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 |
|
