exceljs
v4.4.0
Lea, manipule y escriba datos y estilos de hojas de cálculo en XLSX y JSON.
Ingeniería inversa a partir de archivos de hojas de cálculo de Excel como proyecto.
npm install exceljs¡Las contribuciones son muy bienvenidas! Me ayuda a saber qué funciones deseo o qué errores están causando más problemas.
Sólo tengo una petición; Si envía una solicitud de extracción para corregir un error, agregue una prueba unitaria o una prueba de integración (en la carpeta de especificaciones) que detecte el problema. Incluso un PR que simplemente tiene una prueba fallida está bien: puedo analizar lo que está haciendo la prueba y corregir el código a partir de eso.
Nota: Intente evitar modificar la versión del paquete en un PR. Las versiones se actualizan en el momento del lanzamiento y cualquier cambio probablemente provocará colisiones de fusión.
Para ser claros, todas las contribuciones agregadas a esta biblioteca se incluirán en la licencia MIT de la biblioteca.
const ExcelJS = require ( 'exceljs' ) ; Para usar el código transpilado de ES5, por ejemplo para versiones de node.js anteriores a 10, use la ruta dist/es5.
const ExcelJS = require ( 'exceljs/dist/es5' ) ;Nota: La compilación de ES5 tiene una dependencia implícita de una serie de polyfills que Exceljs ya no agrega explícitamente. Deberá agregar "core-js" y "regenerator-runtime" a sus dependencias e incluir los siguientes requisitos en su código antes de importar 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 IE 11, también necesitará un polyfill para admitir patrones de expresiones regulares Unicode. Por ejemplo,
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 dos paquetes explorados dentro de la carpeta dist/:
Uno con dependencias implícitas en core-js polyfills...
< script src =" https://cdnjs.cloudflare.com/ajax/libs/babel-polyfill/6.26.0/polyfill.js " > </ script >
< script src =" exceljs.js " > </ script >Y uno sin...
< 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 ; Las vistas del libro controlan cuántas ventanas independientes se abrirá Excel al ver el libro.
workbook . views = [
{
x : 0 , y : 0 , width : 10000 , height : 20000 ,
firstSheet : 0 , activeTab : 1 , visibility : 'visible'
}
] const sheet = workbook . addWorksheet ( 'My Sheet' ) ;Utilice el segundo parámetro de la función addWorksheet para especificar opciones para la hoja de trabajo.
Por ejemplo:
// 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' }
} ) ; Utilice la id la hoja de trabajo para eliminar la hoja del libro de trabajo.
Por ejemplo:
// Create a worksheet
const sheet = workbook . addWorksheet ( 'My Sheet' ) ;
// Remove the worksheet using worksheet id
workbook . removeWorksheet ( sheet . id ) // Iterate over all sheets
// Note: workbook.worksheets.forEach will still work but this is better
workbook . eachSheet ( function ( worksheet , sheetId ) {
// ...
} ) ;
// fetch sheet by name
const worksheet = workbook . getWorksheet ( 'My Sheet' ) ;
// fetch sheet by id
// INFO: Be careful when using it!
// It tries to access to `worksheet.id` field. Sometimes (really very often) workbook has worksheets with id not starting from 1.
// For instance It happens when any worksheet has been deleted.
// It's much more safety when you assume that ids are random. And stop to use this function.
// If you need to access all worksheets in a loop please look to the next example.
const worksheet = workbook . getWorksheet ( 1 ) ;
// access by `worksheets` array:
workbook . worksheets [ 0 ] ; //the first one; Es importante saber que workbook.getWorksheet(1) != Workbook.worksheets[0] y workbook.getWorksheet(1) != Workbook.worksheets[1] , porque workbook.worksheets[0].id puede tener cualquier valor.
// make worksheet visible
worksheet . state = 'visible' ;
// make worksheet hidden
worksheet . state = 'hidden' ;
// make worksheet hidden from 'hide/unhide' dialog
worksheet . state = 'veryHidden' ; Las hojas de trabajo admiten un grupo de propiedades para permitir el control sobre algunas características de la hoja de trabajo.
// 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 ;Propiedades admitidas
| Nombre | Por defecto | Descripción |
|---|---|---|
| pestañaColor | indefinido | Color de las pestañas |
| esquemaNivelCol | 0 | El nivel de esquema de la columna de la hoja de trabajo |
| esquemaNivelFila | 0 | El nivel de esquema de fila de la hoja de trabajo |
| altura de fila predeterminada | 15 | Altura de fila predeterminada |
| defaultColWidth | (opcional) | Ancho de columna predeterminado |
| dyDescenso | 55 | Por determinar |
Se han agregado algunas métricas nuevas a la hoja de trabajo...
| Nombre | Descripción |
|---|---|
| recuento de filas | El tamaño total de fila del documento. Igual al número de fila de la última fila que tiene valores. |
| cuenta de filas real | Un recuento del número de filas que tienen valores. Si una fila de mitad del documento está vacía, no se incluirá en el recuento. |
| columnaContar | El tamaño total de la columna del documento. Igual al recuento máximo de celdas de todas las filas |
| recuento de columnas reales | Un recuento del número de columnas que tienen valores. |
Todas las propiedades que pueden afectar la impresión de una hoja se guardan en un objeto pageSetup de la hoja.
// 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' ;Configuración de configuración de página admitida
| Nombre | Por defecto | Descripción |
|---|---|---|
| márgenes | Espacios en blanco en los bordes de la página. Las unidades son pulgadas. | |
| orientación | 'retrato' | Orientación de la página, es decir, más alta (vertical) o más ancha (paisaje) |
| horizontalDpi | 4294967295 | Puntos horizontales por pulgada. El valor predeterminado es -1 |
| verticalDpi | 4294967295 | Puntos verticales por pulgada. El valor predeterminado es -1 |
| encajar en la página | Ya sea para usar fitToWidth y fitToHeight o configuraciones de escala. El valor predeterminado se basa en la presencia de estas configuraciones en el objeto pageSetup; si ambos están presentes, la escala gana (es decir, el valor predeterminado será falso) | |
| páginaPedido | 'abajo y luego sobre' | En qué orden imprimir las páginas: una de ['downThenOver', 'overThenDown'] |
| negroyblanco | FALSO | Imprimir sin color |
| borrador | FALSO | Imprima con menos calidad (y tinta) |
| celularComentarios | 'Ninguno' | Dónde colocar comentarios: uno de ['atEnd', 'asDisplayed', 'None'] |
| errores | 'desplegado' | Dónde mostrar errores: uno de ['dash', 'blank', 'NA', 'displayed'] |
| escala | 100 | Valor porcentual para aumentar o reducir el tamaño de la impresión. Activo cuando fitToPage es falso |
| ajuste al ancho | 1 | En cuántas páginas de ancho debe imprimirse la hoja. Activo cuando fitToPage es verdadero |
| ajuste a la altura | 1 | En cuántas páginas debe imprimirse la hoja. Activo cuando fitToPage es verdadero |
| Tamaño del papel | Qué tamaño de papel usar (ver más abajo) | |
| mostrarRowColHeaders | FALSO | Si mostrar los números de fila y las letras de las columnas |
| mostrarGridLines | FALSO | Ya sea para mostrar líneas de cuadrícula |
| primer número de página | Qué número usar para la primera página | |
| horizontalCentrado | FALSO | Si se deben centrar los datos de la hoja horizontalmente |
| verticalCentrado | FALSO | Si se deben centrar los datos de la hoja verticalmente |
Tamaños de papel de ejemplo
| Nombre | Valor |
|---|---|
| Carta | indefinido |
| Legal | 5 |
| Ejecutivo | 7 |
| A3 | 8 |
| A4 | 9 |
| A5 | 11 |
| B5 (JIS) | 13 |
| Sobre #10 | 20 |
| Sobre DL | 27 |
| Sobre C5 | 28 |
| Sobre B5 | 34 |
| Monarca del sobre | 37 |
| Postal doble de Japón girada | 82 |
| 16K 197x273mm | 119 |
Aquí se explica cómo agregar encabezados y pies de página. El contenido agregado es principalmente texto, como hora, introducción, información del archivo, etc., y puede configurar el estilo del texto. Además, puede configurar diferentes textos para la primera página e incluso para la página.
Nota: Actualmente no se admiten imágenes.
// 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"Configuraciones de encabezado y pie de página admitidas
| Nombre | Por defecto | Descripción |
|---|---|---|
| diferenteprimero | FALSO | Establezca el valor de DifferentFirst como verdadero, lo que indica que los encabezados y pies de página de la primera página son diferentes de las otras páginas. |
| diferenteImparPar | FALSO | Establezca el valor de DifferentOddEven como verdadero, lo que indica que los encabezados y pies de página de las páginas pares e impares son diferentes. |
| encabezado impar | nulo | Establecer cadena de encabezado para páginas impares (predeterminadas), podría formatear la cadena |
| pie de página impar | nulo | Establecer una cadena de pie de página para páginas impares (predeterminadas), podría formatear la cadena |
| inclusoEncabezado | nulo | Establecer cadena de encabezado para páginas pares, podría formatear la cadena |
| pie de página uniforme | nulo | Establecer cadena de pie de página para páginas pares, podría formatear la cadena |
| primer encabezado | nulo | Establecer cadena de encabezado para la primera página, podría formatear la cadena |
| primer pie de página | nulo | Establecer cadena de pie de página para la primera página, podría formatear la cadena |
Comandos de secuencia de comandos
| Comandos | Descripción |
|---|---|
| &l | Establecer posición a la izquierda |
| &DO | Establecer posición en el centro |
| &R | Establecer posición a la derecha |
| &PAG | El número de página actual |
| &NORTE | El número total de páginas. |
| &D | La fecha actual |
| &T | La hora actual |
| &GRAMO | una imagen |
| &A | El nombre de la hoja de trabajo |
| &F | El nombre del archivo |
| &B | Poner el texto en negrita |
| &I | Poner texto en cursiva |
| &U | Texto subrayado |
| &"nombre de fuente" | nombre de fuente, por ejemplo &"Aril" |
| & tamaño de fuente | tamaño de fuente, por ejemplo 12 |
| &CódigoKHEX | color de fuente, por ejemplo &KCCCCCC |
Las hojas de trabajo ahora admiten una lista de vistas que controlan cómo Excel presenta la hoja:
Cada vista también admite varias propiedades:
| Nombre | Por defecto | Descripción |
|---|---|---|
| estado | 'normal' | Controla el estado de la vista: normal, congelada o dividida. |
| derecha a izquierda | FALSO | Establece la orientación de la vista de la hoja de trabajo de derecha a izquierda |
| celda activa | indefinido | La celda actualmente seleccionada |
| mostrarRegla | verdadero | Muestra u oculta la regla en Diseño de página |
| mostrarRowColHeaders | verdadero | Muestra u oculta los encabezados de filas y columnas (por ejemplo, A1, B1 en la parte superior y 1,2,3 a la izquierda). |
| mostrarGridLines | verdadero | Muestra u oculta las líneas de la cuadrícula (se muestran para celdas donde no se han definido bordes) |
| escala de zoom | 100 | Zoom porcentual a utilizar para la vista |
| zoomEscalaNormal | 100 | Zoom normal para la vista. |
| estilo | indefinido | Estilo de presentación: uno de pageBreakPreview o pageLayout. Nota pageLayout no es compatible con vistas congeladas |
Las vistas congeladas admiten las siguientes propiedades adicionales:
| Nombre | Por defecto | Descripción |
|---|---|---|
| xDividir | 0 | Cuántas columnas congelar. Para congelar filas únicamente, configúrelo en 0 o indefinido |
| yDividir | 0 | Cuántas filas congelar. Para congelar columnas únicamente, configúrelo en 0 o indefinido |
| celda superior izquierda | especial | Qué celda estará en la parte superior izquierda del panel inferior derecho. Nota: no puede ser una celda congelada. El valor predeterminado es la primera celda descongelada |
worksheet . views = [
{ state : 'frozen' , xSplit : 2 , ySplit : 3 , topLeftCell : 'G10' , activeCell : 'A1' }
] ;Las vistas divididas admiten las siguientes propiedades adicionales:
| Nombre | Por defecto | Descripción |
|---|---|---|
| xDividir | 0 | A cuantos puntos desde la izquierda colocar el divisor. Para dividir verticalmente, configúrelo en 0 o indefinido |
| yDividir | 0 | A cuantos puntos desde arriba colocar el divisor. Para dividir horizontalmente, configúrelo en 0 o indefinido |
| celda superior izquierda | indefinido | Qué celda estará en la parte superior izquierda del panel inferior derecho. |
| panel activo | indefinido | Qué panel estará activo: uno de arriba a la izquierda, arriba a la derecha, abajo a la izquierda y abajo a la derecha |
worksheet . views = [
{ state : 'split' , xSplit : 2000 , ySplit : 3000 , topLeftCell : 'G10' , activeCell : 'A1' }
] ; Es posible aplicar un filtro automático a su hoja de trabajo.
worksheet . autoFilter = 'A1:C1' ;Si bien la cadena de rango es la forma estándar del autofiltro, la hoja de trabajo también admitirá los siguientes 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 | Descripción | Valor predeterminado |
|---|---|---|
| valores | Los nuevos valores de fila/s | |
| estilo | 'i' para heredar de la fila anterior, 'i+' para incluir celdas vacías, 'n' para ninguna | 'norte' |
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 | Descripción | Valor predeterminado |
|---|---|---|
| posición | Número de fila donde desea insertar, empujando hacia abajo todas las filas desde allí | |
| valores | Los nuevos valores de fila/s | |
| estilo | 'i' para heredar de la fila anterior, 'i+' para incluir celdas vacías, 'o' para el estilo original, 'o+' para incluir celdas vacías, 'n' para ninguno | 'norte' |
// 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 | Descripción | Valor predeterminado |
|---|---|---|
| comenzar | Punto de partida desde el que empalmar | |
| contar | Número de filas/celdas a eliminar | |
| ...inserciones | Nuevos valores de fila/celda para insertar |
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 | Descripción | Valor predeterminado |
|---|---|---|
| comenzar | Número de fila que desea duplicar (el primero en Excel es 1) | |
| cantidad | Las veces que quieres duplicar la fila. | 1 |
| insertar | verdadero si desea insertar nuevas filas para los duplicados, o falso si desea reemplazarlos | verdadero |
Las celdas individuales (o varios grupos de celdas) pueden tener nombres asignados. Los nombres se pueden usar en fórmulas y validación de datos (y probablemente más).
// 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' ] ) ; Las celdas pueden definir qué valores son válidos o no y proporcionar indicaciones al usuario para guiarlo.
Los tipos de validación pueden ser uno de los siguientes:
| Tipo | Descripción |
|---|---|
| lista | Defina un conjunto discreto de valores válidos. Excel los ofrecerá en un menú desplegable para facilitar la entrada. |
| entero | El valor debe ser un número entero. |
| decimal | El valor debe ser un número decimal. |
| longitud del texto | El valor puede ser texto pero la longitud está controlada. |
| costumbre | Una fórmula personalizada controla los valores válidos. |
Para tipos distintos de lista o personalizado, los siguientes operadores afectan la validación:
| Operador | Descripción |
|---|---|
| entre | Los valores deben estar entre los resultados de la fórmula. |
| no entre | Los valores no deben estar entre los resultados de la fórmula. |
| igual | El valor debe ser igual al resultado de la fórmula. |
| no igual | El valor no debe ser igual al resultado de la fórmula |
| mayor que | El valor debe ser mayor que el resultado de la fórmula. |
| menos que | El valor debe ser menor que el resultado de la fórmula. |
| mayor que o igual | El valor debe ser mayor o igual que el resultado de la fórmula. |
| menor que o igual | El valor debe ser menor o igual que el resultado de la 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 ) ]
} ; Agregar comentario de estilo antiguo a una celda
// 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' ,
} ;La siguiente tabla define las propiedades admitidas por los comentarios de celda.
| Campo | Requerido | Valor predeterminado | Descripción |
|---|---|---|---|
| textos | Y | El texto del comentario. | |
| márgenes | norte | {} | Determina el valor de los márgenes para comentarios de celda automáticos o personalizados. |
| protección | norte | {} | Especificación del estado de bloqueo de objetos y texto de objeto mediante atributos de protección |
| editar como | norte | 'absoluto' | Utilice el atributo 'editAs' para especificar cómo se ancla la anotación a la celda |
Determine el modo de configuración del margen de página de la anotación de celda, modo automático o personalizado.
ws . getCell ( 'B1' ) . note . margins = {
insetmode : 'custom' ,
inset : [ 0.25 , 0.25 , 0.35 , 0.35 ]
}| Propiedad | Requerido | Valor predeterminado | Descripción |
|---|---|---|---|
| modo de inserción | norte | 'auto' | Determina si los márgenes de los comentarios se configuran automáticamente y el valor es "automático" o "personalizado". |
| recuadro | norte | [0,13, 0,13, 0,25, 0,25] | Espacios en blanco en los bordes del comentario. Las unidades son centímetros. La dirección es izquierda, arriba, derecha, abajo. |
Nota: Esta configuración inset tiene efecto solo cuando el valor de insetmode es "personalizado".
Especificación del estado de bloqueo de objetos y texto de objetos mediante atributos de protección.
ws . getCell ( 'B1' ) . note . protection = {
locked : 'False' ,
lockText : 'False' ,
} ;| Propiedad | Requerido | Valor predeterminado | Descripción |
|---|---|---|---|
| bloqueado | norte | 'Verdadero' | Este elemento especifica que el objeto está bloqueado cuando la hoja está protegida. |
| bloquearTexto | norte | 'Verdadero' | Este elemento especifica que el texto del objeto está bloqueado. |
Nota: Los objetos bloqueados son válidos sólo cuando la hoja de trabajo está protegida.
Los comentarios de las celdas también pueden tener la propiedad 'editAs' que controlará cómo se anclan los comentarios a las celdas. Puede tener uno de los siguientes valores:
ws . getCell ( 'B1' ) . note . editAs = 'twoCells' ;| Valor | Descripción |
|---|---|
| dos celdas | Especifica que el tamaño y la posición de la nota varían según las celdas. |
| una celda | Especifica que el tamaño de la nota es fijo y la posición cambia con la celda. |
| absoluto | Este es el valor predeterminado. Los comentarios no se moverán ni se dimensionarán con celdas. |
Las tablas permiten la manipulación de datos tabulares dentro de la hoja.
Para agregar una tabla a una hoja de trabajo, defina un modelo de tabla y llame a 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: Agregar una tabla a una hoja de trabajo modificará la hoja al colocar encabezados y datos de filas en la hoja. Se sobrescribirán todos los datos de la hoja cubierta por la tabla resultante (incluidos encabezados y totales).
La siguiente tabla define las propiedades admitidas por las tablas.
| Propiedad de tabla | Descripción | Requerido | Valor predeterminado |
|---|---|---|---|
| nombre | El nombre de la mesa | Y | |
| nombre para mostrar | El nombre para mostrar de la tabla. | norte | nombre |
| árbitro | Celda superior izquierda de la tabla | Y | |
| encabezadoFila | Mostrar encabezados en la parte superior de la tabla | norte | verdadero |
| totalesfila | Mostrar totales al final de la tabla | norte | FALSO |
| estilo | Propiedades de estilo adicionales | norte | {} |
| columnas | Definiciones de columnas | Y | |
| filas | Filas de datos | Y |
La siguiente tabla define las propiedades admitidas dentro de la propiedad de estilo de tabla.
| Propiedad de estilo | Descripción | Requerido | Valor predeterminado |
|---|---|---|---|
| tema | El tema del color de la mesa. | norte | 'TableStyleMedium2' |
| mostrarPrimeraColumna | Resalte la primera columna (negrita) | norte | FALSO |
| mostrarÚltimaColumna | Resalte la última columna (negrita) | norte | FALSO |
| mostrarFilaRayas | Filas alternativas mostradas con color de fondo | norte | FALSO |
| mostrarColumnaRayas | Filas alternativas mostradas con color de fondo | norte | FALSO |
La siguiente tabla define las propiedades admitidas dentro de cada columna de la tabla.
| Propiedad de columna | Descripción | Requerido | Valor predeterminado |
|---|---|---|---|
| nombre | El nombre de la columna, también utilizado en el encabezado. | Y | |
| botón de filtro | Cambia el control del filtro en el encabezado. | norte | FALSO |
| totalesRowLabel | Etiqueta para describir la fila de totales (primera columna) | norte | 'Total' |
| totalesFilaFunción | Nombre de la función de totales | norte | 'ninguno' |
| totalesFilaFórmula | Fórmula opcional para funciones personalizadas | norte |
La siguiente tabla enumera los valores válidos para la propiedad totalsRowFunction definida por columnas. Si se utiliza cualquier valor que no sea 'personalizado', no es necesario incluir la fórmula asociada ya que será insertada por la tabla.
| Funciones de totales | Descripción |
|---|---|
| ninguno | No hay función de totales para esta columna |
| promedio | Calcular el promedio de la columna. |
| contar números | Cuente las entradas que son números. |
| contar | Recuento de entradas |
| máximo | El valor máximo en esta columna. |
| mín. | El valor mínimo en esta columna. |
| stdDev | La desviación estándar de esta columna |
| var | La variación de esta columna. |
| suma | La suma de las entradas de esta columna. |
| costumbre | Una fórmula personalizada. Requiere un valor totalsRowFormula asociado. |
Los nombres de temas válidos siguen el siguiente patrón:
Las sombras, los números pueden ser uno de:
Para ningún tema, utilice el valor nulo.
Nota: Exceljs aún no admite temas de tablas personalizados.
Las tablas admiten un conjunto de funciones de manipulación que permiten agregar o eliminar datos y cambiar algunas propiedades. Dado que muchas de estas operaciones pueden tener efectos en la hoja, los cambios deben confirmarse una vez completados.
Todos los valores de índice de la tabla están basados en cero, por lo que el número de la primera fila y el número de la primera columna es 0.
Agregar o eliminar encabezados y totales
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 ( ) ;Reubicar una mesa
const table = ws . getTable ( 'MyTable' ) ;
// table top-left move to D4
table . ref = 'D4' ;
// commit the table changes into the sheet
table . commit ( ) ;Agregar y eliminar filas
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 ( ) ;Agregar y eliminar columnas
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 ( ) ;Cambiar propiedades de columna
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 ( ) ; Las celdas, filas y columnas admiten cada una un amplio conjunto de estilos y formatos que afectan la forma en que se muestran las celdas.
Los estilos se establecen asignando las siguientes propiedades:
// 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 } ;Cuando se aplica un estilo a una fila o columna, se aplicará a todas las celdas existentes actualmente en esa fila o columna. Además, cualquier celda nueva que se cree heredará sus estilos iniciales de la fila y columna a la que pertenece.
Si la fila y la columna de una celda definen un estilo específico (por ejemplo, fuente), la celda usará el estilo de fila sobre el estilo de columna. Sin embargo, si la fila y la columna definen estilos diferentes (por ejemplo, columna.numFmt y fila.font), la celda heredará la fuente de la fila y el numFmt de la columna.
Advertencia: todas las propiedades anteriores (con la excepción de numFmt, que es una cadena) son estructuras de objetos JS. Si el mismo objeto de estilo se asigna a más de una entidad de hoja de cálculo, cada entidad compartirá el mismo objeto de estilo. Si el objeto de estilo se modifica posteriormente antes de serializar la hoja de cálculo, todas las entidades que hacen referencia a ese objeto de estilo también se modificarán. Este comportamiento tiene como objetivo priorizar el rendimiento reduciendo la cantidad de objetos JS creados. Si desea que los objetos de estilo sean independientes, deberá clonarlos antes de asignarlos. Además, de forma predeterminada, cuando se lee un documento desde un archivo (o secuencia), si las entidades de la hoja de cálculo comparten estilos similares, también harán referencia al mismo 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| Propiedad de fuente | Descripción | Valor(es) de ejemplo |
|---|---|---|
| nombre | Nombre de la fuente. | 'Arial', 'Calibri', etc. |
| familia | Familia de fuentes para respaldo. Un valor entero. | 1 - Serif, 2 - Sans Serif, 3 - Mono, Otros - desconocido |
| esquema | Esquema de fuentes. | 'menor', 'mayor', 'ninguno' |
| juego de caracteres | Juego de caracteres de fuente. Un valor entero. | 1, 2, etc |
| tamaño | Tamaño de fuente. Un valor entero. | 9, 10, 12, 16, etc. |
| color | Descripción del color, un objeto que contiene un valor ARGB. | { argb: 'FFFF0000'} |
| atrevido | Peso de fuente | verdadero, falso |
| itálico | Pendiente de fuente | verdadero, falso |
| subrayar | Estilo de subrayado de fuente | verdadero, falso, 'ninguno', 'único', 'doble', 'contabilidad única', 'contabilidad doble' |
| huelga | | verdadero, falso |
| describir | Esquema de fuente | verdadero, falso |
| alineación vertical | alineación vertical | 'superíndice', 'subíndice' |
// 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 propiedad de alineación válidos
| horizontal | vertical | envolverTexto | reducirParaAjustar | sangrar | lecturaOrden | rotación de texto |
|---|---|---|---|---|---|---|
| izquierda | arriba | verdadero | verdadero | entero | rtl | 0 a 90 |
| centro | medio | FALSO | FALSO | litros | -1 a -90 | |
| bien | abajo | vertical | ||||
| llenar | repartido | |||||
| justificar | justificar | |||||
| centroContinuo | ||||||
| repartido |
// 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 borde 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' } }
]
} ; | Propiedad | Requerido | Descripción |
|---|---|---|
| tipo | Y | Valor: 'patrón' Especifica que este relleno utiliza patrones. |
| patrón | Y | Especifica el tipo de patrón (consulte Tipos de patrones válidos a continuación) |
| fgColor | norte | Especifica el color de primer plano del patrón. El valor predeterminado es negro. |
| bgColor | norte | Especifica el color de fondo del patrón. El valor predeterminado es blanco. |
Nota: Si desea llenar una celda usando el patrón solid , no necesita especificar bgColor . Vea el ejemplo anterior para la celda A3 con un patrón solid y un fgColor coral.
Tipos de patrones válidos
| Propiedad | Requerido | Descripción |
|---|---|---|
| tipo | Y | Valor: 'gradiente' Especifica que este relleno utiliza degradados. |
| gradiente | Y | Especifica el tipo de degradado. Uno de ['ángulo', 'camino'] |
| grado | ángulo | Para degradado de 'ángulo', especifica la dirección del degradado. 0 es de izquierda a derecha. Los valores del 1 al 359 giran en el sentido de las agujas del reloj. |
| centro | camino | Para gradiente de 'ruta'. Especifica las coordenadas relativas para el inicio de la ruta. Los valores 'izquierdo' y 'superior' oscilan entre 0 y 1 |
| se detiene | Y | Especifica la secuencia de colores del degradado. Es una matriz de objetos que contiene posición y color que comienza con la posición 0 y termina con la posición 1. Se pueden usar posiciones intermedias para especificar otros colores en la ruta. |
Advertencias
Usando la interfaz anterior, es posible crear efectos de relleno degradado que no son posibles usando el programa de edición XLSX. Por ejemplo, Excel solo admite gradientes de ángulo de 0, 45, 90 y 135. De manera similar, la secuencia de paradas también puede estar limitada por la interfaz de usuario con las posiciones [0,1] o [0,0.5,1] como únicas opciones. Tenga cuidado con este relleno para asegurarse de que sea compatible con los espectadores XLSX de destino.
Las celdas individuales ahora admiten texto enriquecido o formato dentro de la celda. Los valores de texto enriquecido pueden controlar las propiedades de fuente de cualquier número de subcadenas dentro del valor de texto. Consulte Fuentes para obtener una lista completa de detalles sobre las propiedades de fuentes compatibles.
ws . getCell ( 'A1' ) . value = {
'richText' : [
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 0 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : 'This is ' } ,
{ 'font' : { 'italic' : true , 'size' : 12 , 'color' : { 'theme' : 0 } , 'name' : 'Calibri' , 'scheme' : 'minor' } , 'text' : 'a' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : ' ' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'argb' : 'FFFF6600' } , 'name' : 'Calibri' , 'scheme' : 'minor' } , 'text' : 'colorful' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : ' text ' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'argb' : 'FFCCFFCC' } , 'name' : 'Calibri' , 'scheme' : 'minor' } , 'text' : 'with' } ,
{ 'font' : { 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : ' in-cell ' } ,
{ 'font' : { 'bold' : true , 'size' : 12 , 'color' : { 'theme' : 1 } , 'name' : 'Calibri' , 'family' : 2 , 'scheme' : 'minor' } , 'text' : 'format' }
]
} ;
expect ( ws . getCell ( 'A1' ) . text ) . to . equal ( 'This is a colorful text with in-cell format' ) ;
expect ( ws . getCell ( 'A1' ) . type ) . to . equal ( Excel . ValueType . RichText ) ;La protección a nivel de celda se puede modificar utilizando la propiedad de protección.
ws . getCell ( 'A1' ) . protection = {
locked : false ,
hidden : true ,
} ;Propiedades de protección admitidas
| Propiedad | Por defecto | Descripción |
|---|---|---|
| bloqueado | verdadero | Especifica si una celda se bloqueará si la hoja está protegida. |
| oculto | FALSO | Especifica si la fórmula de una celda será visible si la hoja está protegida. |
El formato condicional permite que una hoja muestre estilos, íconos, etc. específicos según los valores de celda o cualquier fórmula arbitraria.
Las reglas de formato condicional se agregan a nivel de hoja y normalmente cubrirán un rango de celdas.
Se pueden aplicar varias reglas a un rango de celdas determinado y cada regla aplicará su propio estilo.
Si varias reglas afectan una celda determinada, el valor de prioridad de la regla determinará qué regla ganará si los estilos en competencia chocan. Gana la regla con el valor de prioridad más bajo. Si no se especifican valores de prioridad para una regla determinada, ExcelJS los asignará en orden ascendente.
Nota: actualmente, solo se admite un subconjunto de reglas de formato condicional. Específicamente, solo las reglas de formato que no requieren representación XML dentro de un elemento <extLst>. Esto significa que no se admiten conjuntos de datos ni tres conjuntos de iconos específicos (3Triangles, 3Stars, 5Boxes).
// 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 reglas de formato condicional admitidos
| Tipo | Descripción |
|---|---|
| expresión | Se puede utilizar cualquier función personalizada para activar la regla. |
| celular es | Compara el valor de la celda con la fórmula proporcionada utilizando el operador especificado |
| top10 | Aplica formato a celdas con valores en los rangos superiores (o inferiores) |
| arribaPromedio | Aplica formato a celdas con valores superiores (o inferiores) al promedio |
| escala de colores | Aplica un fondo de color a las celdas según dónde se encuentran sus valores en el rango |
| conjunto de iconos | Agrega uno de una variedad de íconos a las celdas según el valor |
| contiene texto | Aplica formato según si la celda es un texto específico |
| período de tiempo | Aplica formato en función de si el valor de fecha y hora de la celda se encuentra dentro de un rango específico |
| Campo | Opcional | Por defecto | Descripción |
|---|---|---|---|
| tipo | 'expresión' | ||
| prioridad | Y | <automático> | determina el orden de prioridad de los estilos |
| fórmulas | matriz de 1 cadena de fórmula que devuelve un valor verdadero/falso. Para hacer referencia al valor de la celda, use la dirección de la celda superior izquierda | ||
| estilo | estructura de estilo a aplicar si la fórmula devuelve verdadero |
| Campo | Opcional | Por defecto | Descripción |
|---|---|---|---|
| tipo | 'celdaEs' | ||
| prioridad | Y | <automático> | determina el orden de prioridad de los estilos |
| operador | cómo comparar el valor de la celda con el resultado de la fórmula | ||
| fórmulas | matriz de 1 cadena de fórmula que devuelve el valor para comparar con cada celda | ||
| estilo | estructura de estilo a aplicar si la comparación devuelve verdadero |
Operadores de celdas
| Operador | Descripción |
|---|---|
| igual | Aplicar formato si el valor de la celda es igual al valor de la fórmula |
| mayor que | Aplicar formato si el valor de la celda es mayor que el valor de la fórmula |
| menos que | Aplicar formato si el valor de la celda es menor que el valor de la fórmula |
| entre | Aplicar formato si el valor de la celda está entre dos valores de fórmula (inclusive) |
| Campo | Opcional | Por defecto | Descripción |
|---|---|---|---|
| tipo | 'top10' | ||
| prioridad | Y | <automático> | determina el orden de prioridad de los estilos |
| rango | Y | 10 | especifica cuántos valores superiores (o inferiores) se incluyen en el formato |
| por ciento | Y | FALSO | Si es verdadero, el campo de clasificación es un porcentaje, no un valor absoluto. |
| abajo | Y | FALSO | Si es verdadero, se incluyen los valores inferiores en lugar de los superiores. |
| estilo | estructura de estilo a aplicar si la comparación devuelve verdadero |
| Campo | Opcional | Por defecto | Descripción |
|---|---|---|---|
| tipo | 'por encima del promedio' | ||
| prioridad | Y | <automático> | determina el orden de prioridad de los estilos |
| arribaPromedio | Y | FALSO | Si es verdadero, el campo de clasificación es un porcentaje, no un valor absoluto. |
| estilo | estructura de estilo a aplicar si la comparación devuelve verdadero |
| Campo | Opcional | Por defecto | Descripción |
|---|---|---|---|
| tipo | 'escala de colores' | ||
| prioridad | Y | <automático> | determina el orden de prioridad de los estilos |
| cfvo | matriz de 2 a 5 objetos de valor de formato condicional que especifican puntos de ruta en el rango de valores | ||
| color | correspondiente conjunto de colores para usar en puntos de ruta determinados | ||
| estilo | estructura de estilo a aplicar si la comparación devuelve verdadero |
| Campo | Opcional | Por defecto | Descripción |
|---|---|---|---|
| tipo | 'conjunto de iconos' | ||
| prioridad | Y | <automático> | determina el orden de prioridad de los estilos |
| conjunto de iconos | Y | 3Semáforos | nombre del icono configurado para usar |
| mostrar valor | verdadero | Especifica si las celdas en el rango aplicado muestran el icono y el valor de la celda, o solo el icono | |
| contrarrestar | FALSO | Especifica si los iconos del conjunto de iconos especificado en iconSet se muestran en orden de reserva. Si personalizado es igual a "verdadero", este valor debe ignorarse | |
| costumbre | FALSO | Especifica si se utiliza un conjunto personalizado de iconos. | |
| cfvo | matriz de 2 a 5 objetos de valor de formato condicional que especifican puntos de ruta en el rango de valores | ||
| estilo | estructura de estilo a aplicar si la comparación devuelve verdadero |
| Campo | Opcional | Por defecto | Descripción |
|---|---|---|---|
| tipo | 'barra de datos' | ||
| prioridad | Y | <automático> | determina el orden de prioridad de los estilos |
| minLongitud | 0 | Especifica la longitud de la barra de datos más corta en este rango de formato condicional. | |
| longitud máxima | 100 | Especifica la longitud de la barra de datos más larga en este rango de formato condicional. | |
| mostrar valor | verdadero | Especifica si las celdas en el rango de formato condicional muestran tanto la barra de datos como el valor numérico o la barra de datos. | |
| gradiente | verdadero | Especifica si la barra de datos tiene un relleno degradado. | |
| borde | verdadero | Especifica si la barra de datos tiene un borde. | |
| Color de barra negativoIgual que positivo | verdadero | Especifica si la barra de datos tiene un color de barra negativo que es diferente del color de la barra positiva | |
| negativoBarBordeColorIgual quePositivo | verdadero | Especifica si la barra de datos tiene un color de borde negativo diferente del color del borde positivo. | |
| ejePosición | 'auto' | Especifica la posición del eje para la barra de datos. | |
| dirección | 'de izquierda a derecha' | Especifica la dirección de la barra de datos. | |
| cfvo | matriz de 2 a 5 objetos de valor de formato condicional que especifican puntos de ruta en el rango de valores | ||
| estilo | estructura de estilo a aplicar si la comparación devuelve verdadero |
| Campo | Opcional | Por defecto | Descripción |
|---|---|---|---|
| tipo | 'contieneTexto' | ||
| prioridad | Y | <automático> | determina el orden de prioridad de los estilos |
| operador | tipo de comparación de texto | ||
| texto | texto a buscar | ||
| estilo | estructura de estilo a aplicar si la comparación devuelve verdadero |
Contiene operadores de texto
| Operador | Descripción |
|---|---|
| contiene texto | Aplicar formato si el valor de la celda contiene el valor especificado en el campo 'texto' |
| contiene espacios en blanco | Aplicar formato si el valor de la celda contiene espacios en blanco |
| no contiene espacios en blanco | Aplicar formato si el valor de la celda no contiene espacios en blanco |
| contieneErrores | Aplicar formato si el valor de la celda contiene errores |
| no contiene errores | Aplicar formato si el valor de la celda no contiene errores |
| Campo | Opcional | Por defecto | Descripción |
|---|---|---|---|
| tipo | 'período de tiempo' | ||
| prioridad | Y | <automático> | determina el orden de prioridad de los estilos |
| período de tiempo | con qué período de tiempo comparar el valor de la celda | ||
| estilo | estructura de estilo a aplicar si la comparación devuelve verdadero |
Periodos de tiempo
| Período de tiempo | Descripción |
|---|---|
| la semana pasada | Aplicar formato si el valor de la celda se encuentra dentro de la última semana |
| esta semana | Aplicar formato si el valor de la celda cae esta semana |
| la próxima semana | Aplicar formato si el valor de la celda cae en la próxima semana |
| ayer | Aplicar formato si el valor de la celda es igual a ayer |
| hoy | Aplicar formato si el valor de la celda es igual a hoy |
| mañana | Aplicar formato si el valor de la celda es igual a mañana |
| últimos 7 días | Aplicar formato si el valor de la celda se encuentra dentro de los últimos 7 días |
| último mes | Aplicar formato si el valor de la celda cae en el último mes |
| este mes | Aplicar formato si el valor de la celda cae en este mes |
| siguientemes | Aplicar formato si el valor de la celda cae el próximo mes |
Excel admite esquemas; donde las filas o columnas se pueden expandir o contraer según el nivel de detalle que el usuario desee ver.
Los niveles de esquema se pueden definir en la configuración de columnas:
worksheet . columns = [
{ header : 'Id' , key : 'id' , width : 10 } ,
{ header : 'Name' , key : 'name' , width : 32 } ,
{ header : 'D.O.B.' , key : 'DOB' , width : 10 , outlineLevel : 1 }
] ;O directamente en la fila o columna
worksheet . getColumn ( 3 ) . outlineLevel = 1 ;
worksheet . getRow ( 3 ) . outlineLevel = 1 ;Los niveles de esquema de la hoja se pueden configurar en la hoja de trabajo.
// set column outline level
worksheet . properties . outlineLevelCol = 1 ;
// set row outline level
worksheet . properties . outlineLevelRow = 1 ;Nota: ajustar los niveles de esquema en filas o columnas o los niveles de esquema en la hoja de trabajo generará el efecto secundario de modificar también la propiedad contraída de todas las filas o columnas afectadas por el cambio de propiedad. P.ej:
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 ;Las propiedades del esquema se pueden configurar en la hoja de trabajo.
worksheet . properties . outlineProperties = {
summaryBelow : false ,
summaryRight : false ,
} ; Agregar imágenes a una hoja de trabajo es un proceso de dos pasos. Primero, la imagen se agrega al libro de trabajo mediante la función addImage() que también devolverá un valor de imageId. Luego, usando imageId, la imagen se puede agregar a la hoja de trabajo como fondo en mosaico o cubriendo un rango de celdas.
Nota: A partir de esta versión, no se admite ajustar o transformar la imagen y las imágenes no se admiten en modo de transmisión.
La función Workbook.addImage admite agregar imágenes por nombre de archivo o por búfer. Tenga en cuenta que en ambos casos se debe especificar la extensión. Los valores de extensión válidos incluyen '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 la identificación de la imagen de Workbook.addImage, el fondo de una hoja de trabajo se puede configurar usando la función addBackgroundImage
// set background
worksheet . addBackgroundImage ( imageId1 ) ;Usando la identificación de la imagen de Workbook.addImage, se puede incrustar una imagen dentro de la hoja de trabajo para cubrir un rango. Las coordenadas calculadas a partir del rango cubrirán desde la parte superior izquierda de la primera celda hasta la parte inferior derecha de la segunda.
// insert an image over B2:D6
worksheet . addImage ( imageId2 , 'B2:D6' ) ;Usando una estructura en lugar de una cadena de rango, es posible cubrir celdas parcialmente.
Tenga en cuenta que el sistema de coordenadas utilizado para esto está basado en cero, por lo que la parte superior izquierda de A1 será {col: 0, fila: 0}. Las fracciones de celdas se pueden especificar utilizando números de punto flotante, por ejemplo, el punto medio de A1 es {col: 0,5, fila: 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 }
} ) ;El rango de celdas también puede tener la propiedad 'editAs' que controlará cómo se ancla la imagen a las celdas. Puede tener uno de los siguientes valores:
| Valor | Descripción |
|---|---|
| indefinido | Especifica que la imagen se moverá y cambiará de tamaño con celdas. |
| una celda | Este es el valor predeterminado. La imagen se moverá con celdas pero sin tamaño |
| absoluto | La imagen no se moverá ni se cambiará su tamaño con celdas. |
ws . addImage ( imageId , {
tl : { col : 0.1125 , row : 0.4 } ,
br : { col : 2.101046875 , row : 3.4 } ,
editAs : 'oneCell'
} ) ;Puede agregar una imagen a una celda y luego definir su ancho y altura en píxeles a 96 ppi.
worksheet . addImage ( imageId2 , {
tl : { col : 0 , row : 0 } ,
ext : { width : 500 , height : 200 }
} ) ;Puede agregar una imagen con hipervínculos a una celda y define los hipervínculos en el rango de imágenes.
worksheet . addImage ( imageId2 , {
tl : { col : 0 , row : 0 } ,
ext : { width : 500 , height : 200 } ,
hyperlinks : {
hyperlink : 'http://www.somewhere.com' ,
tooltip : 'http://www.somewhere.com'
}
} ) ; Las hojas de trabajo pueden protegerse de la modificación agregando una contraseña.
await worksheet . protect ( 'the-password' , options ) ;La protección de la hoja de trabajo también se puede eliminar:
worksheet . unprotect ( ) ;Consulte la protección de la celda para obtener detalles sobre cómo modificar la protección de la celda individual.
Nota: Si bien la función Protect () devuelve una promesa que indica que es async, la implementación actual se ejecuta en el hilo principal y usará aproximadamente 600 ms en una CPU promedio. Esto se puede ajustar configurando el spincount, que se puede usar para hacer que el proceso sea más rápido o más resistente.
| Campo | Por defecto | Descripción |
|---|---|---|
| SelectLockedCells | verdadero | Permite que el usuario seleccione celdas bloqueadas |
| selectUnlockedCells | verdadero | Permite que el usuario seleccione celdas desbloqueadas |
| formatelas | FALSO | Permite que las celdas de formato de usuario |
| formatcolumns | FALSO | Permite que las columnas de formato de usuario |
| formato | FALSO | Permite que las filas de formato de usuario |
| insertrows | FALSO | Permite que el usuario inserte filas |
| insertcolumns | FALSO | Permite que el usuario inserte columnas |
| inserthyperlinks | FALSO | Permite que el usuario inserte hipervínculos |
| deletero | FALSO | Permite que el usuario elimine las filas |
| deletecolumna | FALSO | Permite que el usuario elimine columnas |
| clasificar | FALSO | Permite que el usuario ordene los datos |
| autofiltro | FALSO | Permite que el usuario filtrara los datos en las tablas |
| tiroteo | FALSO | Permite que el usuario use tablas de pivote |
| spindount | 100000 | El número de hash iteraciones realizadas al proteger o desprote. |
Opciones admitidas al leer archivos XLSX.
| Campo | Requerido | Tipo | Descripción |
|---|---|---|---|
| ignorenodes | norte | Formación | Una lista de nombres de nodos para ignorar al cargar el documento XLSX. Mejora el rendimiento en algunas situaciones. 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 ( ) ;Opciones admitidas al leer archivos CSV.
| Campo | Requerido | Tipo | Descripción |
|---|---|---|---|
| formats de dátiles | norte | Formación | Especifique el formato de codificación de fecha de DayJs. |
| mapa | norte | Función | Array.prototype Custom.map () Función de devolución de llamada para procesar datos. |
| nombre de nombre | norte | Cadena | Especifique el nombre de la hoja de trabajo. |
| parseroptaciones | norte | Objeto | opciones de parseoptions @módulo Fast-CSV/Format para escribir datos 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 worksheetEl analizador CSV usa Fast-CSV para leer el archivo CSV. Las formatomaciones en las opciones pasadas a la función de escritura anterior se pasarán al módulo @Fast-CSV/Format para escribir datos CSV. Consulte el readme.md de Fast-CSV para obtener más detalles.
Las fechas se analizan utilizando el módulo NPM DayJs. Si no se suministra una matriz de información de fecha, se utilizan los siguientes formatos de fecha:
Consulte el complemento DayJS CustomParseFormat para obtener detalles sobre cómo estructurar un DateFormat.
Opciones admitidas al escribir en un archivo CSV.
| Campo | Requerido | Tipo | Descripción |
|---|---|---|---|
| dateFormat | norte | Cadena | Especifique el formato de codificación de fecha de DayJs. |
| dateutc | norte | Booleano | Especifique si Exceljs usa dayjs.utc () para convertir la zona horaria para las fechas de análisis. |
| codificación | norte | Cadena | Especificar formato de codificación de archivo. (Solo se aplica a .writeFile .) |
| incluir EXMPREWYROWS | norte | Booleano | Especifica si se pueden escribir filas vacías. |
| mapa | norte | Función | Array.prototype Custom.map () Función de devolución de llamada para procesar valores de fila. |
| nombre de nombre | norte | Cadena | Especifique el nombre de la hoja de trabajo. |
| sillón | norte | Número | Especificar ID de hoja de trabajo. |
| formateras | norte | Objeto | Opciones de FormatterOptions @Fast-CSV/Format Module para escribir datos 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 ( ) ;El analizador CSV usa Fast-CSV para escribir el archivo CSV. Las formatomaciones en las opciones pasadas a la función de escritura anterior se pasarán al módulo @Fast-CSV/Format para escribir datos CSV. Consulte el readme.md de Fast-CSV para obtener más detalles.
Las fechas se formatean utilizando el módulo NPM DayJs. Si no se suministra dateFormat, se usa DayJS.ISO_8601. Al escribir un CSV, puede proporcionar el boolean DateUtc como cierto para que Exceljs analice la fecha sin convertir automáticamente la zona horaria usando dayjs.utc() .
La E/S del archivo documentada anteriormente requiere que un libro de trabajo completo se construya en la memoria antes de que se pueda escribir el archivo. Si bien es conveniente, puede limitar el tamaño del documento debido a la cantidad de memoria requerida.
Un escritor de transmisión (o lector) procesa el libro de trabajo o los datos de la hoja de trabajo tal como se genera, convirtiéndolo en el formulario de archivo a medida que avanza. Por lo general, esto es mucho más eficiente en la memoria, ya que la huella de memoria final e incluso las huellas de memoria intermedia son mucho más compactas que con la versión del documento, especialmente cuando considera que los objetos de la fila y la celda están dispuestas una vez que se comprometen.
La interfaz para el libro de trabajo de transmisión y la hoja de trabajo es casi la misma que las versiones de documentos con algunas diferencias prácticas menores:
Tenga en cuenta que es posible construir todo el libro de trabajo sin cometer filas. Cuando se compromete el libro de trabajo, todas las hojas de trabajo agregadas (incluidas todas las filas no comprometidas) se comprometerán automáticamente. Sin embargo, en este caso, se habrá ganado poco sobre la versión del documento.
El escritor de libros de trabajo de transmisión XLSX está disponible en el espacio de nombres Exceljs.stream.xlsx.
El constructor toma un objeto de opciones opcionales con los siguientes campos:
| Campo | Descripción |
|---|---|
| arroyo | Especifica un flujo de escritura para escribir el libro de trabajo XLSX. |
| Nombre del archivo | Si no se especifica la transmisión, este campo especifica la ruta a un archivo para escribir el libro de trabajo XLSX. |
| Estringas de USSHared | Especifica si usar cadenas compartidas en el libro de trabajo. El valor predeterminado es false . |
| Usestyles | Especifica si agregar información de estilo al libro de trabajo. Los estilos pueden agregar algo de sobrecarga de rendimiento. El valor predeterminado es false . |
| cremallera | Opciones zip que sobresalen pasan internamente al archiver. El valor predeterminado está undefined . |
Si no se especifica la transmisión ni el nombre de archivo en las opciones, el escritor de libros creará un objeto StreamBuf que almacenará el contenido del libro de trabajo XLSX en la memoria. Este objeto StreamBuf, al que se puede acceder a través del libro de propiedades de propiedad.
// construct a streaming XLSX workbook writer with styles and shared strings
const options = {
filename : './streamed-workbook.xlsx' ,
useStyles : true ,
useSharedStrings : true
} ;
const workbook = new Excel . stream . xlsx . WorkbookWriter ( options ) ;En general, la interfaz para el escritor de transmisión XLSX es la misma que el libro de trabajo de documentos (y las hojas de trabajo) descrita anteriormente, de hecho, los objetos de fila, celda y estilo son los mismos.
Sin embargo, hay algunas diferencias ...
Construcción
Como se vio anteriormente, el WorkbookWriter generalmente requerirá que la secuencia o archivo de salida se especifique en el constructor.
Cometer datos
Cuando una fila de hoja de trabajo está lista, debe comprometerse para que se pueda liberar el objeto de fila y el contenido. Por lo general, esto se haría a medida que se agrega cada fila ...
worksheet . addRow ( {
id : i ,
name : theName ,
etc : someOtherDetail
} ) . commit ( ) ;La razón por la que la hoja de trabajo no comete filas, ya que se agregan es permitir que las celdas se fusionen entre filas:
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.A medida que se completa cada hoja de trabajo, también debe comprometerse:
// Finished adding data. Commit the worksheet
worksheet . commit ( ) ;Para completar el documento XLSX, el libro de trabajo debe comprometerse. Si alguna hoja de trabajo en un libro de trabajo no está comprometida, se comprometerán automáticamente como parte de la confirmación del libro de trabajo.
// Finished the workbook.
await workbook . commit ( ) ;
// ... the stream has been written El lector de libros de trabajo de transmisión XLSX está disponible en el espacio de nombres Exceljs.stream.xlsx.
El constructor toma un argumento de entrada requerido y un argumento de opciones opcional:
| Argumento | Descripción |
|---|---|
| entrada (requerido) | Especifica el nombre del archivo o la transmisión legible desde la cual leer el libro de trabajo XLSX. |
| Opciones (opcional) | Especifica cómo manejar los tipos de eventos que ocurren durante el análisis de lectura. |
| opciones.entries | Especifica si emitir entradas ( 'emit' ) o no ( 'ignore' ). El valor predeterminado es 'emit' . |
| opciones.sharedstrings | Especifica si almacenar en caché las cadenas compartidas ( 'cache' ), que las inserta en los valores de las celdas respectivas, o si emitirlas ( 'emit' ) o ignorarlas ( 'ignore' ), en ambos casos el valor de la celda será Una referencia al índice de la cadena compartida. El valor predeterminado es 'cache' . |
| opciones.hyperlinks | Especifica si cachear hipervínculos ( 'cache' ), que los inserta en sus respectivas celdas, si emitirlos ( 'emit' ) o si ignorarlos ( 'ignore' ). El valor predeterminado es 'cache' . |
| opciones. Estilos | Especifica si almacenar estilos de almacenamiento en caché ( 'cache' ), que los inserta en sus respectivas filas y celdas, o si los ignorar ( 'ignore' ). El valor predeterminado es 'cache' . |
| Opciones. Hojas de trabajo | Especifica si emitir hojas de trabajo ( 'emit' ) o no ( 'ignore' ). El valor predeterminado es 'emit' . |
const workbookReader = new ExcelJS . stream . xlsx . WorkbookReader ( './file.xlsx' ) ;
for await ( const worksheetReader of workbookReader ) {
for await ( const row of worksheetReader ) {
// ...
}
} Tenga en cuenta que worksheetReader devuelve una matriz de filas en lugar de cada fila individualmente por razones de rendimiento: nodejs/nodo#31979
Los eventos en el libro de trabajo son 'hoja de trabajo', 'cuerdas compartidas' y 'hipervínculos'. Los eventos en la hoja de trabajo son 'fila' y 'hipervínculos'.
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
}
} Si bien alentamos encarecidamente a usar la iteración de asíncrono, también exponemos una interfaz de transmisión para la compatibilidad hacia atrás.
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 ) => {
// ...
} ) ;Una parte de esta biblioteca ha sido aislada y probada para su uso dentro de un entorno de navegador.
Debido a la naturaleza de transmisión del lector de libros y escritor de libros de trabajo, no se han incluido. Solo se puede utilizar el libro de trabajo basado en el documento (consulte Crear un libro de trabajo para más detalles).
Por ejemplo, el código que usa Exceljs en el navegador eche un vistazo a la carpeta Spec/Browser en el repositorio de GitHub.
Los siguientes archivos están previos e incluidos dentro de la carpeta DIST.
Se admiten los siguientes tipos de valor.
Enum: Excel.ValueType.null
Un valor nulo indica una ausencia de valor y generalmente no se almacenará cuando se escriba en el archivo (excepto las celdas fusionadas). Se puede usar para eliminar el valor de una celda.
P.ej
worksheet . getCell ( 'A1' ) . value = null ; Enum: Excel.ValueType.Merge
Una celda de fusión es aquella que tiene su valor vinculado a otra celda 'maestra'. Asignar a una celda de fusión hará que la celda del maestro se modifique.
Enum: Excel.ValueType.number
Un valor numérico.
P.ej
worksheet . getCell ( 'A1' ) . value = 5 ;
worksheet . getCell ( 'A2' ) . value = 3.14159 ; Enum: Excel.ValueType.String
Una simple cadena de texto.
P.ej
worksheet . getCell ( 'A1' ) . value = 'Hello, World!' ; Enum: Excel.ValueType.Date
Un valor de fecha, representado por el tipo de fecha JavaScript.
P.ej
worksheet . getCell ( 'A1' ) . value = new Date ( 2017 , 2 , 15 ) ; Enum: Excel.ValueType.hyperlink
Una URL con valor de texto y enlace.
P.ej
// 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
Una fórmula de Excel para calcular valores sobre la mosca. Tenga en cuenta que si bien el tipo de celda será fórmula, la celda puede tener un valor de efectivo que se derivará del valor de resultado.
Tenga en cuenta que Exceljs no puede procesar la fórmula para generar un resultado, debe suministrarse.
Tenga en cuenta que los nombres semánticos de la función deben estar en inglés y el separador debe ser una coma.
P.ej
worksheet . getCell ( 'A3' ) . value = { formula : 'A1+A2' , result : 7 } ;
worksheet . getCell ( 'A3' ) . value = { formula : 'SUM(A1,A2)' , result : 7 } ;Las celdas también admiten compradores de conveniencia para acceder a la fórmula y al resultado:
worksheet . getCell ( 'A3' ) . formula === 'A1+A2' ;
worksheet . getCell ( 'A3' ) . result === 7 ;Las fórmulas compartidas mejoran la compresión del documento XLSX al disminuir la repetición del texto dentro de la hoja de trabajo XML. La célula superior izquierda en un rango es el maestro designado y sostendrá la fórmula de la que se derivarán todas las demás células en el rango. Las otras células 'esclavas' pueden referirse a esta célula maestra en lugar de redefinir toda la fórmula nuevamente. Tenga en cuenta que la fórmula maestra se traducirá a las celdas de esclavos de la manera habitual de Excel para que las referencias a otras celdas se desplazarán hacia abajo y hacia la derecha dependiendo del desplazamiento del esclavo al maestro. Por ejemplo: si la celda maestra A2 tiene una fórmula que hace referencia a A1, entonces si la celda B2 comparte la fórmula de A2, se referirá a B1.
Se puede asignar una fórmula maestra a una celda junto con las celdas de esclavos en su rango
worksheet . getCell ( 'A2' ) . value = {
formula : 'A1' ,
result : 10 ,
shareType : 'shared' ,
ref : 'A2:B3'
} ;Se puede asignar una fórmula compartida a una celda utilizando un nuevo formulario de valor:
worksheet . getCell ( 'B2' ) . value = { sharedFormula : 'A2' , result : 10 } ;Esto especifica que la celda B2 es una fórmula que se derivará de la fórmula en A2 y su resultado es 10.
El Getter de conveniencia de la fórmula traducirá la fórmula en A2 a lo que debería ser en B2:
expect ( worksheet . getCell ( 'B2' ) . formula ) . to . equal ( 'B1' ) ;Las fórmulas compartidas se pueden asignar en una hoja utilizando la función '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 también puede usar una función de devolución de llamada para calcular el valor en cada celda
// 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 reales y traducidas, use el getter de formulatipo:
worksheet . getCell ( 'A3' ) . formulaType === Enums . FormulaType . Master ;
worksheet . getCell ( 'B3' ) . formulaType === Enums . FormulaType . Shared ;El tipo de fórmula tiene los siguientes valores:
| Nombre | Valor |
|---|---|
| Enums.formulatype.none | 0 |
| Enums.formulatype.master | 1 |
| Enums.formulatype.shared | 2 |
Una nueva forma de expresar fórmulas compartidas en Excel es la fórmula de matriz. En esta forma, la célula maestra es la única célula que contiene cualquier información relacionada con una fórmula. Contiene la 'matriz' de ShareType junto con el rango de celdas a las que se aplica y la fórmula que se copiará. El resto de las células son celdas regulares con valores regulares.
Nota: Las fórmulas de matriz no se traducen de la manera en que lo son las fórmulas compartidas. Entonces, si la celda maestra A2 se refiere a A1, entonces la celda de esclavos B2 también se referirá a A1.
P.ej
// assign array formula to A2:B3
worksheet . getCell ( 'A2' ) . value = {
formula : 'A1' ,
result : 10 ,
shareType : 'array' ,
ref : 'A2:B3'
} ;
// it may not be necessary to fill the rest of the values in the sheetLa función FillFormula también se puede usar para llenar una 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 y con estilo.
P.ej
worksheet . getCell ( 'A1' ) . value = {
richText : [
{ text : 'This is ' } ,
{ font : { italic : true } , text : 'italic' } ,
]
} ; Enum: Excel.ValueType.Boolean
P.ej
worksheet . getCell ( 'A1' ) . value = true ;
worksheet . getCell ( 'A2' ) . value = false ; Enum: Excel.ValueType.Error
P.ej
worksheet . getCell ( 'A1' ) . value = { error : '#N/A' } ;
worksheet . getCell ( 'A2' ) . value = { error : '#VALUE!' } ;Los valores de texto de error válidos actuales son:
| Nombre | Valor |
|---|---|
| Excel.ErrorValue.notaplicable | #N / A |
| Excel.errorValue.Ref | #¡ÁRBITRO! |
| Excel.errorValue.name | #¿NOMBRE? |
| Excel.errorValue.divzero | #DIV/0! |
| Excel.errorValue.null | #¡NULO! |
| Excel.errorValue.value | #¡VALOR! |
| Excel.errorValue.num | #Num! |
Se hace todo lo posible para hacer una buena interfaz consistente que no rompa las versiones, pero lamentablemente, de vez en cuando algunas cosas tienen que cambiar para el bien mayor.
Los argumentos en la función de devolución de llamada a la hoja de trabajo. De cada uno se han cambiado y cambiado; Era la función (número de tope, los valores de remos), ahora es la función (fila, número de tope) lo que le da una apariencia más parecida a la función y las prioridades del subrayamiento del objeto de fila sobre el número de fila.
Esta función ha cambiado de devolver una matriz escasa de los valores de la celda a devolver un objeto de fila. Esto permite acceder a las propiedades de la fila y facilitará la gestión de estilos de fila, etc.
La matriz escasa de los valores de las celdas todavía está disponible a través de la hoja de trabajo.
Cell.styles renombrado a Cell.style
Las promesas regresaron de las funciones cambiadas de Bluebird a Native Node Promise, que puede romper el código de llamadas si dependen de las características adicionales de Bluebird.
Para mitigar esto, se agregaron los siguientes dos cambios a 0.3.0:
Exceljs ahora admite la inyección de dependencia para la biblioteca Promise. Puede restaurar las promesas Bluebird incluyendo el siguiente código en su módulo ...
ExcelJS . config . setValue ( 'promise' , require ( 'bluebird' ) ) ;Tenga en cuenta: he probado los Exceljs con Bluebird específicamente (desde hace poco, esta era la biblioteca que usaba). A partir de las pruebas que he hecho, no funcionará con Q.
Antes de publicar este módulo, el código fuente se transpila y se procesa de otra manera antes de colocarse en una carpeta DIST. Este readMe identifica dos archivos: un paquete navegador y una versión minificada. Ningún otro contenido de la carpeta Dist/ se garantiza de ninguna otra manera que no sea el archivo especificado como "principal" en el paquete.json
El suite de prueba incluido en este LIB incluye un pequeño script ejecutado en un navegador sin cabeza para validar los paquetes agrupados. En el momento de este escrito, parece que esta prueba no juega bien en el subsistema de Windows Linux.
Por esta razón, la prueba del navegador puede deshabilitarse por la existencia de un archivo llamado .disable-test-navegador
sudo apt-get install libfontconfigSi alguna operación de empalme afecta una celda fusionada, el grupo de fusión no se moverá correctamente
| Versión | Cambios |
|---|---|
| 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. Cambios
|
| 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 |
|
