xlsx — Fork do SheetJS xlsx 0.18.5 com correções para CVE-2023-30533 e CVE-2024-22363 | Kitploit

<details>
  <summary><b>Disponibilidade em CDNs</b> (clique para mostrar)</summary>

|    CDN     | URL                                        |
|-----------:|:-------------------------------------------|
|    `unpkg` | <https://unpkg.com/xlsx/>                  |
| `jsDelivr` | <https://jsdelivr.com/package/npm/xlsx>    |
|    `CDNjs` | <https://cdnjs.com/libraries/xlsx>         |

Por exemplo, `unpkg` disponibiliza a versão mais recente em:```html
<script src="https://unpkg.com/xlsx/dist/xlsx.full.min.js"></script>

**Módulos ECMAScript**

O build do Módulo ECMAScript é salvo em `xlsx.mjs` e pode ser adicionado diretamente a uma página com uma tag `script` usando `type=module`:```html
<script type="module">
import { read, writeFileXLSX } from "./xlsx.mjs";

/* load the codepage support library for extended support with older formats  */
import { set_cptable } from "./xlsx.mjs";
import * as cptable from './dist/cpexcel.full.mjs';
set_cptable(cptable);
</script>

**Deno**

`xlsx.mjs` pode ser importado no Deno.  Está disponível em `unpkg`:```ts
// @deno-types="https://unpkg.com/xlsx/types/index.d.ts"
import * as XLSX from 'https://unpkg.com/xlsx/xlsx.mjs';

/* load the codepage support library for extended support with older formats  */
import * as cptable from 'https://unpkg.com/xlsx/dist/cpexcel.full.mjs';
XLSX.set_cptable(cptable);

**Photoshop e InDesign**

`dist/xlsx.extendscript.js` é uma compilação ExtendScript para Photoshop e InDesign que está incluída no pacote `npm`. Pode ser referenciada diretamente com uma diretiva `#include`:```extendscript
#include "xlsx.extendscript.js"

Compatibilidade com Internet Explorer e ECMAScript 3 (clique para mostrar)

Para ampla compatibilidade com mecanismos JavaScript, a biblioteca é escrita usando o dialeto da linguagem ECMAScript 3, bem como alguns recursos do ES5 como Array#forEach. Navegadores mais antigos exigem shims para fornecer funções ausentes.

Para usar o shim, adicione o shim antes da tag script que carrega xlsx.js:```html

O script também inclui `IE_LoadFile` e `IE_SaveFile` para carregar e salvar arquivos nas versões 6-9 do Internet Explorer. O script `xlsx.extendscript.js` agrupa o shim num formato adequado para o Photoshop e outros produtos Adobe.

</details>

### Uso

A maioria dos cenários envolvendo planilhas e dados pode ser dividida em 5 partes:

1) **Adquirir Dados**: Os dados podem ser armazenados em qualquer lugar: arquivos locais ou remotos, bancos de dados, HTML TABLE, ou mesmo gerados programaticamente no navegador.

2) **Extrair Dados**: Para arquivos de planilha, isso envolve a análise dos bytes brutos para ler os dados das células. Para dados JS em geral, isso envolve remodelar os dados.

3) **Processar Dados**: Desde gerar estatísticas resumidas até limpar registros de dados, este passo é o cerne do problema.

4) **Empacotar Dados**: Isso pode envolver criar uma nova planilha ou serializar com `JSON.stringify` ou escrever XML ou simplesmente achatar dados para ferramentas de interface de usuário.

5) **Liberar Dados**: Arquivos de planilha podem ser enviados para um servidor ou escritos localmente. Os dados podem ser apresentados aos usuários numa HTML TABLE ou grade de dados.

Um problema comum envolve gerar uma exportação válida de planilha a partir de dados armazenados numa tabela HTML. Neste exemplo, uma HTML TABLE na página será raspada, uma linha será adicionada ao final com a data do relatório, e um novo arquivo será gerado e baixado localmente. `XLSX.writeFile` cuida de empacotar os dados e tentar um download local:```js
// Acquire Data (reference to the HTML table)
var table_elt = document.getElementById("my-table-id");

// Extract Data (create a workbook object from the table)
var workbook = XLSX.utils.table_to_book(table_elt);

// Process Data (add a new row)
var ws = workbook.Sheets["Sheet1"];
XLSX.utils.sheet_add_aoa(ws, [["Created "+new Date().toISOString()]], {origin:-1});

// Package and Release Data (`writeFile` tries to write and save an XLSB file)
XLSX.writeFile(workbook, "Report.xlsb");

Esta biblioteca tenta simplificar os passos 2 e 4 com funções para extrair dados úteis de arquivos de planilhas (read / readFile) e gerar novos arquivos de planilhas a partir dos dados (write / writeFile). Funções utilitárias adicionais como table_to_book trabalham com outras fontes de dados comuns, como tabelas HTML.

Esta documentação e vários projetos de demonstração cobrem vários cenários e abordagens comuns para os passos 1 e 5.

Funções utilitárias auxiliam no passo 3.

"Adquirindo e Extraindo Dados" descreve soluções para cenários comuns de importação de dados.

"Empacotando e Liberando Dados" descreve soluções para cenários comuns de exportação de dados.

"Processando Dados" descreve soluções para cenários comuns de processamento e manipulação de pastas de trabalho.

"Funções Utilitárias" detalha funções utilitárias para traduzir Arrays JSON e outras estruturas JS comuns em objetos de planilha.

A Filosofia do SheetJS

O processamento de dados deve se encaixar em qualquer fluxo de trabalho

A biblioteca não impõe um ciclo de vida separado. Ela se encaixa perfeitamente em sites e aplicativos construídos com qualquer framework. Os objetos de dados JS simples funcionam bem com Web Workers e APIs futuras.

JavaScript é uma linguagem poderosa para processamento de dados

O "Formato Comum de Planilha" é uma representação simples em objeto dos conceitos centrais de uma pasta de trabalho. As várias funções na biblioteca fornecem ferramentas de baixo nível para trabalhar com o objeto.

Para um processamento JS amigável, existem funções utilitárias para converter partes de uma planilha de/para um Array de Arrays. O exemplo a seguir combina métodos poderosos de Array JS com uma biblioteca de requisição de rede para baixar dados, selecionar as informações que desejamos e criar um arquivo de planilha:

Obter Dados de um Endpoint JSON e Gerar uma Pasta de Trabalho (clique para mostrar)

O objetivo é gerar uma pasta de trabalho XLSB com nomes e datas de nascimento dos presidentes dos EUA.

Adquirir Dados

Dados Brutos

https://theunitedstates.io/congress-legislators/executive.json tem os dados desejados. Por exemplo, John Adams:```js { "id": { /* (data omitted) / }, "name": { "first": "John", // <-- first name "last": "Adams" // <-- last name }, "bio": { "birthday": "1735-10-19", // <-- birthday "gender": "M" }, "terms": [ { "type": "viceprez", / (other fields omitted) / }, { "type": "viceprez", / (other fields omitted) / }, { "type": "prez", / (other fields omitted) */ } // <-- look for "prez" ] }

_Filtragem para Presidentes_

O conjunto de dados inclui Aaron Burr, um Vice-Presidente que nunca foi Presidente!

`Array#filter` cria um novo array com as linhas desejadas. Um Presidente serviu
pelo menos um mandato com `type` definido como `"prez"`. Para testar se uma determinada linha possui
pelo menos um mandato `"prez"`, `Array#some` é outra função JS nativa. O
filtro completo seria:```js
const prez = raw_data.filter(row => row.terms.some(term => term.type === "prez"));

Organizando os dados

Para este exemplo, o nome será o primeiro nome combinado com o sobrenome (row.name.first + " " + row.name.last) e o aniversário será o subcampo row.bio.birthday. Usando Array#map, o conjunto de dados pode ser transformado em uma única chamada:```js const rows = prez.map(row => ({ name: row.name.first + " " + row.name.last, birthday: row.bio.birthday }));

Formatos de arquivo são detalhes de implementação

O analisador cobre uma ampla gama de formatos comuns de arquivos de planilha para garantir que arquivos "HTML-salvos-como-XLS" funcionem tão bem quanto arquivos XLS ou XLSX reais.

O escritor suporta vários formatos de saída comuns para ampla compatibilidade com o ecossistema de dados.

Na maior medida possível, o código de processamento de dados não deve se preocupar com os formatos de arquivo específicos envolvidos.

Demonstrações do Ecossistema JS

O diretório demos inclui projetos de exemplo para:

Frameworks e APIs

Bundlers e Ferramentas

Plataformas e Integrações

Outros exemplos estão incluídos na showcase.

https://sheetjs.com/demos/modify.html mostra um exemplo completo de leitura, modificação e escrita de arquivos.

https://github.com/SheetJS/sheetjs/blob/HEAD/bin/xlsx.njs é a ferramenta de linha de comando incluída nas instalações do Node, lendo arquivos de planilha e exportando o conteúdo em vários formatos.

Adquirindo e Extraindo Dados

Analisando Pastas de Trabalho

API

Extrair dados de bytes de planilha```js var workbook = XLSX.read(data, opts);

O método `read` pode extrair dados de bytes de planilha armazenados em uma string JS, "binary string", buffer NodeJS ou array tipado (`Uint8Array` ou `ArrayBuffer`).

_Ler bytes de planilha de um arquivo local e extrair dados_```js
var workbook = XLSX.readFile(filename, opts);

O método readFile tenta ler um arquivo de planilha no caminho fornecido. Navegadores geralmente não permitem a leitura de arquivos dessa forma (considerado um risco de segurança), e tentativas de ler arquivos dessa maneira lançarão um erro.

O segundo argumento opts é opcional. "Opções de Parsing" aborda as propriedades e comportamentos suportados.

Exemplos

Aqui estão alguns cenários comuns (clique em cada subtítulo para ver o código):

Arquivo local em um servidor NodeJS (clique para mostrar)

readFile usa fs.readFileSync internamente:```js var XLSX = require("xlsx");

var workbook = XLSX.readFile("test.xlsx");

Para Node ESM, o auxiliar `readFile` não está ativado. Em vez disso, `fs.readFileSync` deve ser usado para ler os dados do arquivo como um `Buffer` para uso com `XLSX.read`:```js
import { readFileSync } from "fs";
import { read } from "xlsx/xlsx.mjs";

const buf = readFileSync("test.xlsx");
/* buf is a Buffer */
const workbook = read(buf);

Arquivo local em uma aplicação Deno (clique para mostrar)

readFile usa Deno.readFileSync internamente:```js // @deno-types="https://deno.land/x/sheetjs/types/index.d.ts" import * as XLSX from 'https://deno.land/x/sheetjs/xlsx.mjs'

const workbook = XLSX.readFile("test.xlsx");

Applications reading files must be invoked with the `--allow-read` flag.  The
[`deno` demo](https://github.com/weareu/xlsx/blob/master/demos/deno) has more examples

</details>

<details>
  <summary><b>Arquivo enviado pelo utilizador numa página web ("Arrastar e Soltar")</b> (click to show)</summary>

Para sites modernos que visam o Chrome 76+, `File#arrayBuffer` é recomendado:```js
// XLSX is a global from the standalone script

async function handleDropAsync(e) {
  e.stopPropagation(); e.preventDefault();
  const f = e.dataTransfer.files[0];
  /* f is a File */
  const data = await f.arrayBuffer();
  /* data is an ArrayBuffer */
  const workbook = XLSX.read(data);

  /* DO SOMETHING WITH workbook HERE */
}
drop_dom_element.addEventListener("drop", handleDropAsync, false);

Para máxima compatibilidade, a API FileReader deve ser usada:```js function handleDrop(e) { e.stopPropagation(); e.preventDefault(); var f = e.dataTransfer.files[0]; /* f is a File / var reader = new FileReader(); reader.onload = function(e) { var data = e.target.result; / reader.readAsArrayBuffer(file) -> data will be an ArrayBuffer */ var workbook = XLSX.read(data);

Buscando um arquivo no navegador web ("Ajax") (clique para mostrar)

Para sites modernos que visam Chrome 42+, recomenda-se fetch:```js // XLSX is a global from the standalone script

(async() => { const url = "http://oss.sheetjs.com/test_files/formula_stress_test.xlsx"; const data = await (await fetch(url)).arrayBuffer(); /* data is an ArrayBuffer */ const workbook = XLSX.read(data);

/* DO SOMETHING WITH workbook HERE */ })();

Para um suporte mais amplo, a abordagem `XMLHttpRequest` é recomendada:```js
var url = "http://oss.sheetjs.com/test_files/formula_stress_test.xlsx";

/* set up async GET request */
var req = new XMLHttpRequest();
req.open("GET", url, true);
req.responseType = "arraybuffer";

req.onload = function(e) {
  var workbook = XLSX.read(req.response);

  /* DO SOMETHING WITH workbook HERE */
};

req.send();

A demonstração xhr inclui uma discussão mais longa e mais exemplos.

http://oss.sheetjs.com/sheetjs/ajax.html mostra abordagens alternativas para IE6+.

Arquivo local em um plugin do PhotoShop ou InDesign (clique para mostrar)

readFile encapsula a lógica de File no Photoshop e outros alvos ExtendScript. O caminho especificado deve ser um caminho absoluto:```js #include "xlsx.extendscript.js"

/* Read test.xlsx from the Documents folder */ var workbook = XLSX.readFile(Folder.myDocuments + "/test.xlsx");

A [`extendscript` demo](https://github.com/weareu/xlsx/blob/master/demos/extendscript) inclui um exemplo mais complexo.

</details>

<details>
  <summary><b>Arquivo local em um aplicativo Electron</b> (clique para exibir)</summary>

`readFile` pode ser usado no processo renderizador:```js
/* From the renderer process */
var XLSX = require("xlsx");

var workbook = XLSX.readFile(path);

As APIs do Electron mudaram ao longo do tempo. O demo electron mostra um exemplo completo e detalha as configurações específicas de versão necessárias.

Arquivo local em um aplicativo móvel com React Native (clique para mostrar)

O demo react inclui um aplicativo React Native de exemplo.

Como o React Native não fornece uma maneira de ler arquivos do sistema de arquivos, uma biblioteca de terceiros deve ser usada. As seguintes bibliotecas foram testadas:

react-native-file-access

A codificação base64 retorna strings compatíveis com o tipo base64:```js import XLSX from "xlsx"; import { FileSystem } from "react-native-file-access";

const b64 = await FileSystem.readFile(path, "base64"); /* b64 is a base64 string */ const workbook = XLSX.read(b64, {type: "base64"});

- [`react-native-fs`](https://npm.im/react-native-fs)

A codificação `ascii` retorna cadeias binárias compatíveis com o tipo `binary`:```js
import XLSX from "xlsx";
import { readFile } from "react-native-fs";

const bstr = await readFile(path, "ascii");
/* bstr is a binary string */
const workbook = XLSX.read(bstr, {type: "binary"});

Uploads de Arquivos do Servidor NodeJS (clique para mostrar)

read pode aceitar um buffer NodeJS. readFile pode ler arquivos gerados por um parser de corpo de requisição HTTP POST como formidable:```js const XLSX = require("xlsx"); const http = require("http"); const formidable = require("formidable");

const server = http.createServer((req, res) => { const form = new formidable.IncomingForm(); form.parse(req, (err, fields, files) => { /* grab the first file */ const f = Object.entries(files)[0][1]; const path = f.filepath; const workbook = XLSX.readFile(path);

/* DO SOMETHING WITH workbook HERE */

}); }).listen(process.env.PORT || 7262);

O [`server` demo](https://github.com/weareu/xlsx/blob/master/demos/server) contém exemplos mais avançados.

</details>

<details>
  <summary><b>Baixar ficheiros num processo NodeJS</b> (clique para mostrar)</summary>

O Node 17.5 e 18.0 têm suporte nativo para fetch:```js
const XLSX = require("xlsx");

const data = await (await fetch(url)).arrayBuffer();
/* data is an ArrayBuffer */
const workbook = XLSX.read(data);

Para maior compatibilidade, recomenda-se módulos de terceiros.

request requer uma codificação null para produzir Buffers:```js var XLSX = require("xlsx"); var request = require("request");

Baixar arquivos em um aplicativo Electron (clique para mostrar)

O módulo net no processo principal pode fazer requisições HTTP/HTTPS para recursos externos. As respostas devem ser concatenadas manualmente usando Buffer.concat:```js const XLSX = require("xlsx"); const { net } = require("electron");

const req = net.request(url); req.on("response", (res) => { const bufs = []; // this array will collect all of the buffers res.on("data", (chunk) => { bufs.push(chunk); }); res.on("end", () => { const workbook = XLSX.read(Buffer.concat(bufs));

/* DO SOMETHING WITH workbook HERE */

}); }); req.end();

</details>

<details>
  <summary><b>Fluxos de Leitura em NodeJS</b> (clique para exibir)</summary>

Ao lidar com fluxos de leitura, a abordagem mais fácil é armazenar em buffer o fluxo
e processar tudo no final:```js
var fs = require("fs");
var XLSX = require("xlsx");

function process_RS(stream, cb) {
  var buffers = [];
  stream.on("data", function(data) { buffers.push(data); });
  stream.on("end", function() {
    var buffer = Buffer.concat(buffers);
    var workbook = XLSX.read(buffer, {type:"buffer"});

    /* DO SOMETHING WITH workbook IN THE CALLBACK */
    cb(workbook);
  });
}

ReadableStream no navegador (clique para mostrar)

Ao lidar com ReadableStream, a abordagem mais fácil é armazenar o fluxo em buffer e processar tudo no final:```js // XLSX is a global from the standalone script

async function process_RS(stream) { /* collect data */ const buffers = []; const reader = stream.getReader(); for(;;) { const res = await reader.read(); if(res.value) buffers.push(res.value); if(res.done) break; }

/* concat */ const out = new Uint8Array(buffers.reduce((acc, v) => acc + v.length, 0));

let off = 0; for(const u8 of arr) { out.set(u8, off); off += u8.length; }

return out; }

const data = await process_RS(stream); /* data is Uint8Array */ const workbook = XLSX.read(data);

</details>

Exemplos mais detalhados são abordados nas [demonstrações incluídas](https://github.com/weareu/xlsx/blob/master/demos)

### Processando Dados JSON e JS

Dados JSON e JS tendem a representar planilhas únicas. Esta seção usará algumas funções utilitárias para gerar pastas de trabalho.

_Criar uma nova Pasta de Trabalho_```js
var workbook = XLSX.utils.book_new();

A função utilitária book_new cria uma pasta de trabalho vazia sem planilhas.

Softwares de planilha geralmente exigem pelo menos uma planilha e impõem esse requisito na interface do usuário. Esta biblioteca impõe o requisito no momento da gravação, gerando erros se uma pasta de trabalho vazia for passada para funções de gravação.

API

Crie uma planilha a partir de um array de arrays de valores JS```js var worksheet = XLSX.utils.aoa_to_sheet(aoa, opts);

A função utilitária `aoa_to_sheet` percorre um "array de arrays" em ordem principal de linha, gerando um objeto de planilha. O trecho a seguir gera uma planilha com a célula `A1` definida como a string `A1`, a célula `B1` definida como `B1`, etc:```js
var worksheet = XLSX.utils.aoa_to_sheet([
  ["A1", "B1", "C1"],
  ["A2", "B2", "C2"],
  ["A3", "B3", "C3"]
]);

Processamento de Tabelas HTML

API

Criar uma planilha extraindo uma TABELA HTML da página```js var worksheet = XLSX.utils.table_to_sheet(dom_element, opts);

A função utilitária `table_to_sheet` recebe um elemento DOM TABLE e itera pelas linhas para gerar uma planilha. O argumento `opts` é opcional.
["HTML Table Input"](#html-table-input) descreve a função em mais detalhes.



_Crie uma pasta de trabalho raspando uma TABLE HTML na página_```js
var workbook = XLSX.utils.table_to_book(dom_element, opts);

A função utilitária table_to_book segue a mesma lógica que table_to_sheet. Após gerar uma planilha, ela cria uma pasta de trabalho em branco e anexa a planilha.

O argumento de opções suporta as mesmas opções que table_to_sheet, com a adição de uma propriedade sheet para controlar o nome da planilha. Se a propriedade estiver ausente ou nenhuma opção for especificada, o nome padrão Sheet1 é usado.

Exemplos

Aqui estão alguns cenários comuns (clique em cada subtítulo para ver o código):

Elemento HTML TABLE em uma página web (clique para mostrar)

```html

Sheet	JS
12345	67

Várias tabelas em uma página web podem ser convertidas em planilhas individuais:```js
/* create new workbook */
var workbook = XLSX.utils.book_new();

/* convert table "table1" to worksheet named "Sheet1" */
var sheet1 = XLSX.utils.table_to_sheet(document.getElementById("table1"));
XLSX.utils.book_append_sheet(workbook, sheet1, "Sheet1");

/* convert table "table2" to worksheet named "Sheet2" */
var sheet2 = XLSX.utils.table_to_sheet(document.getElementById("table2"));
XLSX.utils.book_append_sheet(workbook, sheet2, "Sheet2");

/* workbook now has 2 worksheets */

Alternativamente, o código HTML pode ser extraído e analisado:```js var htmlstr = document.getElementById("tableau").outerHTML; var workbook = XLSX.read(htmlstr, {type:"string"});

</details>

<details>
  <summary><b>Extensão do Chrome/Chromium</b> (clique para mostrar)</summary>

A [`chrome` demo](https://github.com/weareu/xlsx/blob/master/demos/chrome) mostra um exemplo completo e detalha as permissões necessárias e outras configurações.

Em uma extensão, é recomendado gerar o workbook em um script de conteúdo e passar o objeto de volta para a extensão:```js
/* in the worker script */
chrome.runtime.onMessage.addListener(function(msg, sender, cb) {
  /* pass a message like { sheetjs: true } from the extension to scrape */
  if(!msg || !msg.sheetjs) return;
  /* create a new workbook */
  var workbook = XLSX.utils.book_new();
  /* loop through each table element */
  var tables = document.getElementsByTagName("table")
  for(var i = 0; i < tables.length; ++i) {
    var worksheet = XLSX.utils.table_to_sheet(tables[i]);
    XLSX.utils.book_append_sheet(workbook, worksheet, "Table" + i);
  }
  /* pass back to the extension */
  return cb(workbook);
});

Tabelas HTML no Lado do Servidor com Headless Chrome (clique para mostrar)

A demonstração headless inclui uma demonstração completa para converter arquivos HTML em pastas de trabalho XLSB. A ideia central é adicionar o script à página, analisar a tabela no contexto da página, gerar uma pasta de trabalho em base64 e enviá-la de volta para processamento adicional:```js const XLSX = require("xlsx"); const { readFileSync } = require("fs"), puppeteer = require("puppeteer");

const url = https://sheetjs.com/demos/table;

/* get the standalone build source (node_modules/xlsx/dist/xlsx.full.min.js) */ const lib = readFileSync(require.resolve("xlsx/dist/xlsx.full.min.js"), "utf8");

(async() => { /* start browser and go to web page */ const browser = await puppeteer.launch(); const page = await browser.newPage(); await page.goto(url, {waitUntil: "networkidle2"});

/* inject library */ await page.addScriptTag({content: lib});

/* this function s5s will be called by the script below, receiving the Base64-encoded file */ await page.exposeFunction("s5s", async(b64) => { const workbook = XLSX.read(b64, {type: "base64" });

/* DO SOMETHING WITH workbook HERE */

});

/* generate XLSB file in webpage context and send back result / await page.addScriptTag({content: ` / call table_to_book on first table */ var workbook = XLSX.utils.table_to_book(document.querySelector("TABLE"));

/* generate XLSX file */
var b64 = XLSX.write(workbook, {type: "base64", bookType: "xlsb"});

/* call "s5s" hook exposed from the node process */
window.s5s(b64);

Tabelas HTML do NodeJS sem navegador (clique para mostrar)

O NodeJS não inclui uma implementação DOM e o Puppeteer requer uma compilação pesada do Chromium. jsdom é uma alternativa leve:```js const XLSX = require("xlsx"); const { readFileSync } = require("fs"); const { JSDOM } = require("jsdom");

/* obtain HTML string. This example reads from test.html / const html_str = fs.readFileSync("test.html", "utf8"); / get first TABLE element / const doc = new JSDOM(html_str).window.document.querySelector("table"); / generate workbook */ const workbook = XLSX.utils.table_to_book(doc);

</details>

## Processamento de Dados

O ["Formato Comum de Planilha"](#common-spreadsheet-format) é uma representação simples de objeto dos conceitos centrais de uma pasta de trabalho.  As funções utilitárias trabalham com a representação do objeto e destinam-se a lidar com casos de uso comuns.

### Modificando a Estrutura da Pasta de Trabalho

**API**

_Anexar uma Planilha a uma Pasta de Trabalho_```js
XLSX.utils.book_append_sheet(workbook, worksheet, sheet_name);

A função utilitária book_append_sheet adiciona uma folha de cálculo ao livro de trabalho. O terceiro argumento especifica o nome desejado da folha de cálculo. Várias folhas de cálculo podem ser adicionadas a um livro de trabalho chamando a função várias vezes. Se o nome da folha de cálculo já estiver em uso no livro de trabalho, será lançado um erro.

Anexar uma Folha de Cálculo a um Livro de Trabalho e encontrar um nome único```js var new_name = XLSX.utils.book_append_sheet(workbook, worksheet, name, true);

Se o quarto argumento for `true`, a função começará com o nome da planilha especificado. Se o nome da planilha existir na pasta de trabalho, um novo nome de planilha será escolhido encontrando a raiz do nome e incrementando o contador:```js
XLSX.utils.book_append_sheet(workbook, sheetA, "Sheet2", true); // Sheet2
XLSX.utils.book_append_sheet(workbook, sheetB, "Sheet2", true); // Sheet3
XLSX.utils.book_append_sheet(workbook, sheetC, "Sheet2", true); // Sheet4
XLSX.utils.book_append_sheet(workbook, sheetD, "Sheet2", true); // Sheet5

O resultado é uma matriz de objetos "simples" sem aninhamento:```js
[
  { name: "George Washington", birthday: "1732-02-22" },
  { name: "John Adams", birthday: "1735-10-19" },
  // ... one row per President
]

`XLSX.utils.book_new` cria uma nova pasta de trabalho e `XLSX.utils.book_append_sheet` anexa uma planilha à pasta de trabalho. A nova planilha será chamada de "Dates":```js
const workbook = XLSX.utils.book_new();
XLSX.utils.book_append_sheet(workbook, worksheet, "Dates");

_Corrigindo Larguras de Colunas_

Alguns dos nomes são mais longos que a largura padrão da coluna.  As larguras das colunas são
definidas por [definir a propriedade `"!cols"` da planilha](#row-and-column-properties).

A linha a seguir define a largura da coluna A para aproximadamente 10 caracteres:```js
worksheet["!cols"] = [ { wch: 10 } ]; // set column A width to 10 characters

Nota: Se o ponto de partida foi um arquivo ou tabela HTML, `XLSX.utils.sheet_to_json` gerará um array de objetos JS.

**Dados do Pacote e da Versão**

`XLSX.writeFile` cria um arquivo de planilha e tenta escrevê-lo no sistema.  No navegador, tentará solicitar que o usuário faça o download do arquivo.  No NodeJS, ele escreverá no diretório local.```js
XLSX.writeFile(workbook, "Presidents.xlsx");

Para uso no navegador web, assumindo que o snippet está salvo como `snippet.js`, tags de script devem ser usadas para incluir as builds standalone do `axios` e do `xlsx`:```html
<script src="https://unpkg.com/xlsx/dist/xlsx.full.min.js"></script>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script src="snippet.js"></script>

typed arrays and math

<https://oss.sheetjs.com/sheetjs/> demonstra a técnica FileReader.

</details>

<details>
  <summary><b>Arquivo enviado pelo usuário com um elemento HTML INPUT</b> (clique para mostrar)</summary>

Começando com um elemento HTML INPUT com `type="file"`:```html
<input type="file" id="input_dom_element">

Para suporte mais amplo (incluindo IE10+), a abordagem `FileReader` é recomendada:```js
function handleFile(e) {
  var file = e.target.files[0];
  var reader = new FileReader();
  reader.onload = function(e) {
    var data = e.target.result;
    /* reader.readAsArrayBuffer(file) -> data will be an ArrayBuffer */
    var workbook = XLSX.read(e.target.result);

    /* DO SOMETHING WITH workbook HERE */
  };
  reader.readAsArrayBuffer(file);
}
input_dom_element.addEventListener("change", handleFile, false);

[`axios`](https://npm.im/axios) funciona da mesma forma no navegador e no NodeJS:```js
const XLSX = require("xlsx");
const axios = require("axios");

(async() => {
  const res = await axios.get(url, {responseType: "arraybuffer"});
  /* res.data is a Buffer */
  const workbook = XLSX.read(res.data);

  /* DO SOMETHING WITH workbook HERE */
})();

A função utilitária `json_to_sheet` percorre uma matriz de objetos JS em ordem, gerando um objeto de planilha. Por padrão, ela gerará uma linha de cabeçalho e uma linha por objeto na matriz. O argumento opcional `opts` tem configurações para controlar a ordem das colunas e a saída do cabeçalho.

["Entrada de Matriz de Objetos"](#array-of-arrays-input) descreve a função e o argumento opcional `opts` em mais detalhes.

**Exemplos**

["Zen do SheetJS"](#the-zen-of-sheetjs) contém um exemplo detalhado "Obter Dados de um Endpoint JSON e Gerar uma Pasta de Trabalho"


[`x-spreadsheet`](https://github.com/myliang/x-spreadsheet) é uma grade de dados interativa para pré-visualizar e modificar dados estruturados no navegador web. A [demonstração do `xspreadsheet`](https://github.com/weareu/xlsx/blob/master/demos/xspreadsheet) inclui um script de exemplo com a função `xtos` para converter de objeto de dados do x-spreadsheet para uma pasta de trabalho. <https://oss.sheetjs.com/sheetjs/x-spreadsheet> é uma demonstração ao vivo.

<details>
  <summary><b>Registros de uma consulta de banco de dados (SQL ou no-SQL)</b> (clique para mostrar)</summary>

A [demonstração do `database`](https://github.com/weareu/xlsx/blob/master/demos/database) inclui exemplos de trabalho com bancos de dados e resultados de consultas.

</details>


<details>
  <summary><b>Computações Numéricas com TensorFlow.js</b> (clique para mostrar)</summary>

[`@tensorflow/tfjs`](https://github.com/weareu/xlsx/blob/master/%40tensorflow/tfjs) e outras bibliotecas esperam dados em arrays simples, bem adequados para planilhas onde cada coluna é um vetor de dados. Isso é a transposição de como a maioria das pessoas usa planilhas, onde cada linha é um vetor.

Ao recuperar dados do `tfjs`, os pontos de dados retornados são armazenados em um array tipado. Um array de arrays pode ser construído com loops. `Array#unshift` pode antepor uma linha de título antes da conversão:```js
const XLSX = require("xlsx");
const tf = require('@tensorflow/tfjs');

/* suppose xs and ys are vectors (1D tensors) -> tfarr will be a typed array */
const tfdata = tf.stack([xs, ys]).transpose();
const shape = tfdata.shape;
const tfarr = tfdata.dataSync();

/* construct the array of arrays */
const aoa = [];
for(let j = 0; j < shape[0]; ++j) {
  aoa[j] = [];
  for(let i = 0; i < shape[1]; ++i) aoa[j][i] = tfarr[j * shape[1] + i];
}
/* add headers to the top */
aoa.unshift(["x", "y"]);

/* generate worksheet */
const worksheet = XLSX.utils.aoa_to_sheet(aoa);

</details>

<details>
  <summary><b>Tabelas HTML no Lado do Servidor com WebKit Headless</b> (clique para mostrar)</summary>

A [`headless` demo](https://github.com/weareu/xlsx/blob/master/demos/headless) inclui uma demonstração completa para converter arquivos HTML em pastas de trabalho XLSB usando [PhantomJS](https://phantomjs.org/). A ideia central é adicionar o script à página, analisar a tabela no contexto da página, gerar uma pasta de trabalho `binary` e enviá-la de volta para processamento adicional:```js
var XLSX = require('xlsx');
var page = require('webpage').create();

/* this code will be run in the page */
var code = [ "function(){",
  /* call table_to_book on first table */
  "var wb = XLSX.utils.table_to_book(document.body.getElementsByTagName('table')[0]);",

  /* generate XLSB file and return binary string */
  "return XLSX.write(wb, {type: 'binary', bookType: 'xlsb'});",
"}" ].join("");

page.open('https://sheetjs.com/demos/table', function() {
  /* Load the browser script from the UNPKG CDN */
  page.includeJs("https://unpkg.com/xlsx/dist/xlsx.full.min.js", function() {
    /* The code will return an XLSB file encoded as binary string */
    var bin = page.evaluateJavaScript(code);

    var workbook = XLSX.read(bin, {type: "binary"});
    /* DO SOMETHING WITH workbook HERE */

    phantom.exit();
  });
});

A propriedade `SheetNames` do objeto workbook é uma lista dos nomes das planilhas na "ordem das guias". As funções da API consultarão este array.

_Substituir uma Planilha no lugar_```js
workbook.Sheets[sheet_name] = new_worksheet;

Adicionar uma nova planilha a um workbook (clique para exibir)

Este exemplo usa XLSX.utils.aoa_to_sheet.```js var ws_name = "SheetJS";

/* Create worksheet */ var ws_data = [ [ "S", "h", "e", "e", "t", "J", "S" ], [ 1 , 2 , 3 , 4 , 5 ] ]; var ws = XLSX.utils.aoa_to_sheet(ws_data);

/* Add the worksheet to the workbook */ XLSX.utils.book_append_sheet(wb, ws, ws_name);

</details>

### Modificando Valores de Células

**API**

_Modificar o valor de uma única célula em uma planilha_```js
XLSX.utils.sheet_add_aoa(worksheet, [[new_value]], { origin: address });

Modificar vários valores de células em uma planilha```js XLSX.utils.sheet_add_aoa(worksheet, aoa, opts);

A função utilitária `sheet_add_aoa` modifica os valores das células numa folha de cálculo. O primeiro argumento é o objeto da folha de cálculo. O segundo argumento é um array de arrays de valores. A chave `origin` do terceiro argumento controla onde as células serão escritas. O seguinte trecho define `B3=1` e `E5="abc"`:```js
XLSX.utils.sheet_add_aoa(worksheet, [
  [1],                             // <-- Write 1 to cell B3
  ,                                // <-- Do nothing in row 4
  [/*B5*/, /*C5*/, /*D5*/, "abc"]  // <-- Write "abc" to cell E5
], { origin: "B3" });

"Entrada de Array de Arrays" descreve a função e o argumento opcional opts em mais detalhes.

Exemplos

Adicionando linhas a uma planilha (clique para mostrar)

O valor de origem especial -1 instrui sheet_add_aoa a começar na coluna A da linha após a última linha no intervalo, anexando os dados:```js XLSX.utils.sheet_add_aoa(worksheet, [ ["first row after data", 1], ["second row after data", 2] ], { origin: -1 });

</details>


### Modificando Outras Propriedades de Planilha / Pasta de Trabalho / Célula

A seção ["Formato Comum de Planilha"](#common-spreadsheet-format) descreve as estruturas de objetos em maiores detalhes.

## Empacotando e Liberando Dados

### Escrevendo Pastas de Trabalho

**API**

_Gerar bytes de planilha (arquivo) a partir dos dados_```js
var data = XLSX.write(workbook, opts);

O método write tenta empacotar dados da pasta de trabalho em um arquivo na memória. Por padrão, arquivos XLSX são gerados, mas isso pode ser controlado com a propriedade bookType do argumento opts. Com base na opção type, os dados podem ser armazenados como uma "binary string", string JS, Uint8Array ou Buffer.

O segundo argumento opts é obrigatório. cobre as propriedades e comportamentos suportados.

Propriedades de Linhas e Colunas

Suporte de Formato (clique para mostrar)

Propriedades de Linhas: XLSX/M, XLSB, BIFF8 XLS, XLML, SYLK, DOM, ODS

Propriedades de Colunas: XLSX/M, XLSB, BIFF8 XLS, XLML, SYLK, DOM

As propriedades de linhas e colunas não são extraídas por padrão ao ler de um arquivo e não são persistidas por padrão ao escrever em um arquivo. A opção cellStyles: true deve ser passada para a função de leitura ou escrita relevante.

Propriedades de Colunas

O array !cols em cada planilha, se presente, é uma coleção de objetos ColInfo que possuem as seguintes propriedades:```typescript type ColInfo = { /* visibility */ hidden?: boolean; // if true, the column is hidden

/* column width is specified in one of the following ways: / wpx?: number; // width in screen pixels width?: number; // width in Excel's "Max Digit Width", width256 is integral wch?: number; // width in characters

/* other fields for preserving features from files */ level?: number; // 0-indexed outline / group level MDW?: number; // Excel's "Max Digit Width" unit, always integral };

_Row Properties_

O array `!rows` em cada planilha, se presente, é uma coleção de objetos `RowInfo` que possuem as seguintes propriedades:```typescript
type RowInfo = {
  /* visibility */
  hidden?: boolean; // if true, the row is hidden

  /* row height is specified in one of the following ways: */
  hpx?:    number;  // height in screen pixels
  hpt?:    number;  // height in points

  level?:  number;  // 0-indexed outline / group level
};

Outline / Group Levels Convention

A interface do Excel exibe o nível de estrutura base como 1 e o nível máximo como 8. Seguindo as convenções do JS, o SheetJS usa níveis de estrutura indexados a partir de 0, onde o nível de estrutura base é 0 e o nível máximo é 7.

Por que existem três tipos de largura? (clique para mostrar)

Existem três tipos diferentes de largura correspondentes às três maneiras diferentes de armazenar larguras de colunas em planilhas:

Formatos de texto simples como SYLK usam contagem bruta de caracteres. Ferramentas contemporâneas como Visicalc e Multiplan eram baseadas em caracteres. Como os caracteres tinham a mesma largura, bastava armazenar uma contagem. Esta tradição foi continuada nos formatos BIFF.

O SpreadsheetML (2003) tentou alinhar-se com o HTML padronizando a contagem de pixels na tela em todo o arquivo. Larguras de colunas, alturas de linhas e outras medidas usam pixels. Quando as contagens de pixels e caracteres não se alinham, o Excel arredonda os valores.

O XLSX armazena internamente as larguras de colunas em uma forma nebulosa de "Largura Máxima do Dígito" (Max Digit Width). A Largura Máxima do Dígito é a largura do maior dígito quando renderizado (geralmente o caractere "0" é o mais largo). A largura interna deve ser um múltiplo inteiro da a largura dividida por 256. O ECMA-376 descreve uma fórmula para converter entre pixels e a largura interna. Isso representa uma abordagem híbrida.

Funções de leitura tentam preencher todas as três propriedades. Funções de escrita tentarão ciclar os valores especificados para o tipo desejado. Para evitar possíveis conflitos, a manipulação deve primeiro excluir as outras propriedades. Por exemplo, ao alterar a largura em pixels, exclua as propriedades wch e width.

Detalhes de implementação (clique para mostrar)

Alturas de Linhas

O Excel armazena internamente as alturas de linhas em pontos. A resolução padrão é 72 DPI ou 96 PPI, então o pixel e o tamanho do ponto devem concordar. Para diferentes resoluções, eles podem não concordar, então a biblioteca separa os conceitos.

Mesmo que toda a informação esteja disponível, espera-se que os escritores sigam a ordem de prioridade:

usar hpx altura em pixels se disponível
usar hpt altura em pontos se disponível

Larguras de Colunas

Dadas as restrições, é possível determinar o MDW sem realmente inspecionar a fonte! Os analisadores adivinham a largura em pixels convertendo de largura para pixels e vice-versa, repetindo para todos os MDW possíveis e selecionando o MDW que minimiza o erro. O XLML na verdade armazena a largura em pixels, então o palpite funciona na direção oposta.

Mesmo que toda a informação esteja disponível, espera-se que os escritores sigam a ordem de prioridade:

usar o campo width se disponível
usar wpx largura em pixels se disponível
usar wch contagem de caracteres se disponível

Formatos de Número

O texto formatado cell.w para cada célula é produzido a partir do formato cell.v e cell.z. Se o formato não for especificado, o formato General do Excel é usado. O formato pode ser especificado como uma string ou como um índice na tabela de formatos. Espera-se que os analisadores preencham workbook.SSF com a tabela de formatos de número. Espera-se que os escritores serializem a tabela.

Ferramentas personalizadas devem garantir que a tabela local tenha cada string de formato usada em algum lugar na tabela. A convenção do Excel determina que os formatos personalizados comecem no índice 164. O exemplo a seguir cria um formato personalizado do zero:

Nova planilha com formato personalizado (clique para mostrar)

```js var wb = { SheetNames: ["Sheet1"], Sheets: { Sheet1: { "!ref":"A1:C1", A1: { t:"n", v:10000 }, // <-- General format B1: { t:"n", v:10000, z: "0%" }, // <-- Builtin format C1: { t:"n", v:10000, z: "\"T\"\ #0.00" } // <-- Custom format } } } ```

As regras são ligeiramente diferentes de como o Excel exibe formatos de número personalizados. Em particular, caracteres literais devem ser envolvidos em aspas duplas ou precedidos por uma barra invertida. Para mais informações, consulte o artigo da documentação do Excel Create or delete a custom number format ou ECMA-376 18.8.31 (Number Formats)

Formatos de Número Padrão (clique para mostrar)

Os formatos padrão estão listados na ECMA-376 18.8.30:

O formato 14 (m/d/yy) é localizado pelo Excel: mesmo que o arquivo especifique esse formato de número, ele será desenhado de forma diferente com base nas configurações do sistema. Isso faz sentido quando o produtor e o consumidor dos arquivos estão na mesma localidade, mas isso nem sempre é o caso na Internet. Para contornar essa ambiguidade, as funções de leitura aceitam a opção dateNF para substituir a interpretação dessa string de formato específica.

Hiperlinks

Suporte de Formato (clique para mostrar)

Hiperlinks de Célula: XLSX/M, XLSB, BIFF8 XLS, XLML, ODS

Dicas de Ferramenta: XLSX/M, XLSB, BIFF8 XLS, XLML

Hiperlinks são armazenados na chave l dos objetos de célula. O campo Target do objeto de hiperlink é o destino do link, incluindo o fragmento da URI. As dicas de ferramenta são armazenadas no campo Tooltip e são exibidas quando você move o mouse sobre o texto.

Por exemplo, o trecho a seguir cria um link da célula A3 para https://sheetjs.com com a dica "Encontre-nos no SheetJS.com!":```js ws['A1'].l = { Target:"https://sheetjs.com", Tooltip:"Find us @ SheetJS.com!" };

Observe que o Excel não estiliza automaticamente hiperlinks -- eles geralmente serão exibidos como texto normal.

_Links Remotos_

Links HTTP / HTTPS podem ser usados diretamente:```js
ws['A2'].l = { Target:"https://docs.sheetjs.com/#hyperlinks" };
ws['A3'].l = { Target:"http://localhost:7262/yes_localhost_works" };

O Excel também suporta links de e-mail mailto com linha de assunto:```js ws['A4'].l = { Target:"mailto:[email protected]" }; ws['A5'].l = { Target:"mailto:[email protected]?subject=Test Subject" };

_Links Locais_

Links para caminhos absolutos devem usar o esquema de URI `file://`:```js
ws['B1'].l = { Target:"file:///SheetJS/t.xlsx" }; /* Link to /SheetJS/t.xlsx */
ws['B2'].l = { Target:"file:///c:/SheetJS.xlsx" }; /* Link to c:\SheetJS.xlsx */

Links para caminhos relativos podem ser especificados sem um esquema:```js ws['B3'].l = { Target:"SheetJS.xlsb" }; /* Link to SheetJS.xlsb / ws['B4'].l = { Target:"../SheetJS.xlsm" }; / Link to ../SheetJS.xlsm */

Caminhos Relativos têm comportamento indefinido no formato SpreadsheetML 2003.  Excel
2019 tratará uma marca pai `..\` como dois níveis acima.

_Links Internos_

Links onde o destino é uma célula, intervalo ou nome definido na mesma pasta de trabalho
("Links Internos") são marcados com um caractere hash inicial:```js
ws['C1'].l = { Target:"#E2" }; /* Link to cell E2 */
ws['C2'].l = { Target:"#Sheet2!E2" }; /* Link to cell E2 in sheet Sheet2 */
ws['C3'].l = { Target:"#SomeDefinedName" }; /* Link to Defined Name */

Comentários de Célula

Os comentários de célula são objetos armazenados no array c de objetos de célula. O conteúdo real do comentário é dividido em blocos com base no autor do comentário. O campo a de cada objeto de comentário é o autor do comentário e o campo t é a representação em texto simples.

Por exemplo, o seguinte trecho adiciona um comentário de célula na célula A1:```js if(!ws.A1.c) ws.A1.c = []; ws.A1.c.push({a:"SheetJS", t:"I'm a little comment, short and stout!"});

Nota: O XLSB impõe um limite de 54 caracteres para o nome do Autor. Nomes com mais de 54 caracteres podem causar problemas com outros formatos.

Para marcar um comentário como normalmente oculto, defina a propriedade `hidden`:```js
if(!ws.A1.c) ws.A1.c = [];
ws.A1.c.push({a:"SheetJS", t:"This comment is visible"});

if(!ws.A2.c) ws.A2.c = [];
ws.A2.c.hidden = true;
ws.A2.c.push({a:"SheetJS", t:"This comment will be hidden"});

Threaded Comments

Introduced in Excel 365, threaded comments are plain text comment snippets with author metadata and parent references. They are supported in XLSX and XLSB.

To mark a comment as threaded, each comment part must have a true T property:```js if(!ws.A1.c) ws.A1.c = []; ws.A1.c.push({a:"SheetJS", t:"This is not threaded"});

if(!ws.A2.c) ws.A2.c = []; ws.A2.c.hidden = true; ws.A2.c.push({a:"SheetJS", t:"This is threaded", T: true}); ws.A2.c.push({a:"JSSheet", t:"This is also threaded", T: true});

Não há metadados do Active Directory ou do Office 365 associados a autores em uma thread.

#### Visibilidade da Planilha

O Excel permite ocultar planilhas na barra de guias inferior.  Os dados da planilha são armazenados no
arquivo, mas a interface do usuário não os disponibiliza facilmente.  Planilhas ocultas padrão
são reveladas no menu "Reexibir".  O Excel também possui planilhas "muito ocultas" que
não podem ser reveladas no menu.  Só é acessível no Editor VB!

A configuração de visibilidade é armazenada na propriedade `Hidden` do array de propriedades da planilha.

<details>
  <summary><b>Mais detalhes</b> (clique para mostrar)</summary>

| Valor | Definição  |
|:-----:|:------------|
|   0   | Visível     |
|   1   | Oculta      |
|   2   | Muito Oculta |

Com <https://rawgit.com/SheetJS/test_files/HEAD/sheet_visibility.xlsx>:```js
> wb.Workbook.Sheets.map(function(x) { return [x.name, x.Hidden] })
[ [ 'Visible', 0 ], [ 'Hidden', 1 ], [ 'VeryHidden', 2 ] ]

Formatos não Excel não suportam o estado Very Hidden. A melhor forma de testar se uma planilha está visível é verificar se a propriedade Hidden é verdade lógica:```js

wb.Workbook.Sheets.map(function(x) { return [x.name, !x.Hidden] }) [ [ 'Visible', true ], [ 'Hidden', false ], [ 'VeryHidden', false ] ]

</details>

#### VBA e Macros

As Macros VBA são armazenadas em um blob de dados especial que é exposto na propriedade `vbaraw` do objeto da pasta de trabalho quando a opção `bookVBA` é `true`. Elas são suportadas nos formatos `XLSM`, `XLSB` e `BIFF8 XLS`. Os escritores de formato suportados inserem automaticamente os blobs de dados se eles estiverem presentes na pasta de trabalho e associam com os nomes das planilhas.

<details>
	<summary><b>Nomes de Código Personalizados</b> (clique para mostrar)</summary>

O nome de código da pasta de trabalho é armazenado em `wb.Workbook.WBProps.CodeName`. Por padrão, o Excel escreverá `ThisWorkbook` ou uma frase traduzida como `DieseArbeitsmappe`. Os nomes de código das planilhas e gráficos estão no objeto de propriedades da planilha em `wb.Workbook.Sheets[i].CodeName`. Macrosheets e Dialogsheets são ignorados.

Os leitores e escritores preservam os nomes de código, mas eles precisam ser definidos manualmente ao adicionar um blob VBA a uma pasta de trabalho diferente.

</details>

<details>
	<summary><b>Macrosheets</b> (clique para mostrar)</summary>

Versões mais antigas do Excel também suportavam um tipo de planilha "macrosheet" não-VBA que armazenava comandos de automação. Elas são expostas em objetos com a propriedade `!type` definida como `"macro"`.

</details>

<details>
	<summary><b>Detectando macros em pastas de trabalho</b> (clique para mostrar)</summary>

O campo `vbaraw` só será definido se houver macros presentes, então o teste é simples:```js
function wb_has_macro(wb/*:workbook*/)/*:boolean*/ {
	if(!!wb.vbaraw) return true;
	const sheets = wb.SheetNames.map((n) => wb.Sheets[n]);
	return sheets.some((ws) => !!ws && ws['!type']=='macro');
}

Nome da Opção	Padrão	Descrição
`type`		Codificação dos dados de entrada (ver Tipo de Entrada abaixo)
`raw`	false	Se true, a análise de texto simples não interpretará valores **
`codepage`		Se especificado, usa a página de código quando apropriado **
`cellFormula`	true	Salva fórmulas no campo .f
`cellHTML`	true	Interpreta rich text e salva HTML no campo `.h`
`cellNF`	false	Salva string de formato numérico no campo `.z`
`cellStyles`	false	Salva informações de estilo/tema no campo `.s`
`cellText`	true	Gera texto formatado no campo `.w`
`cellDates`	false	Armazena datas como tipo `d` (padrão é `n`)
`dateNF`		Se especificado, usa a string para o código de data 14 **
`sheetStubs`	false	Cria objetos de célula do tipo `z` para células stub
`sheetRows`	0	Se >0, lê as primeiras `sheetRows` linhas **
`bookDeps`	false	Se true, analisa cadeias de cálculo

Mesmo se cellNF for false, o texto formatado será gerado e salvo em .w
Em alguns casos, as folhas podem ser analisadas mesmo que bookSheets seja false.
O Excel tenta agressivamente interpretar valores de CSV e outros textos simples. Isso leva a um comportamento surpreendente! A opção raw suprime a interpretação de valores.
bookSheets e bookProps combinam para fornecer ambos os conjuntos de informações.
Deps será um objeto vazio se bookDeps for false.
O comportamento de bookFiles depende do tipo de arquivo:
- array keys (caminhos no ZIP) para formatos baseados em ZIP
- hash files (mapeando caminhos para objetos representando os arquivos) para ZIP
- objeto cfb para formatos que usam contêineres CFB
sheetRows-1 linhas serão geradas ao observar a saída do objeto JSON (pois a linha de cabeçalho é contada como uma linha ao analisar os dados)
Por padrão, todas as planilhas são analisadas. sheets restringe com base no tipo de entrada:
- número: índice baseado em zero da planilha a ser analisada (0 é a primeira planilha)
- string: nome da planilha a ser analisada (não diferencia maiúsculas/minúsculas)
- array de números e strings para selecionar múltiplas planilhas.
bookVBA meramente expõe o objeto VBA CFB bruto. Ele não analisa os dados. XLSM e XLSB armazenam o objeto VBA CFB em xl/vbaProject.bin. BIFF8 XLS mistura as entradas VBA junto com a entrada principal da Pasta de Trabalho, então a biblioteca gera um novo blob compatível com XLSB a partir do contêiner XLS CFB.
codepage é aplicado a arquivos BIFF2 - BIFF5 sem registros CodePage e a arquivos CSV sem BOM no modo type:"binary". BIFF8 XLS sempre usa 1200 por padrão.
PRN afeta a análise de arquivos de texto sem um caractere delimitador comum.
Atualmente apenas criptografia XOR é suportada. Um erro de não suportado será lançado para arquivos que empregam outros métodos de criptografia.
Funções mais recentes do Excel são serializadas com o prefixo _xlfn., oculto do usuário. O SheetJS remove _xlfn. normalmente. A opção xlfn os preserva.
WTF é principalmente para desenvolvimento. Por padrão, o analisador suprimirá erros de leitura em planilhas individuais, permitindo que você leia as planilhas que são analisadas corretamente. Definir WTF:true força esses erros a serem lançados.

`type`	entrada esperada
`"base64"`	string: codificação Base64 do arquivo
`"binary"`	string: string binária (byte `n` é `data.charCodeAt(n)`)
`"string"`	string: string JS (caracteres interpretados como UTF8)
`"buffer"`	Buffer do Node.js
`"array"`	array: array de inteiros de 8 bits sem sinal (byte `n` é `data[n]`)
`"file"`	string: caminho do arquivo que será lido (apenas Node.js)

Detalhes de Implementação (clique para mostrar)

O Excel e outras ferramentas de planilha leem os primeiros bytes e aplicam outras heurísticas para determinar um tipo de arquivo. Isso permite a troca de tipos de arquivo: renomear arquivos com a extensão .xls dirá ao seu computador para usar o Excel para abrir o arquivo, mas o Excel saberá como tratá-lo. Esta biblioteca aplica lógica similar:

Byte 0	Tipo de Arquivo Bruto	Tipos de Planilha
`0xD0`	Contêiner CFB	BIFF 5/8 ou XLSX/XLSB protegido ou WQ3/QPW ou XLR
`0x09`	Fluxo BIFF	BIFF 2/3/4/5
`0x3C`	XML/HTML	SpreadsheetML / Flat ODS / UOS1 / HTML / texto simples
`0x50`	Arquivo ZIP	XLSB ou XLSX/M ou ODS ou UOS2 ou NUMBERS ou texto
`0x49`	Texto Simples	SYLK ou texto simples
`0x54`	Texto Simples	DIF ou texto simples
`0xEF`	Codificado UTF8	SpreadsheetML / Flat ODS / UOS1 / HTML / texto simples
`0xFF`	Codificado UTF16	SpreadsheetML / Flat ODS / UOS1 / HTML / texto simples
`0x00`	Fluxo de Registro	Lotus WK* ou Quattro Pro ou texto simples
`0x7B`	Texto simples	RTF ou texto simples
`0x0A`	Texto simples	SpreadsheetML / Flat ODS / UOS1 / HTML / texto simples
`0x0D`	Texto simples	SpreadsheetML / Flat ODS / UOS1 / HTML / texto simples
`0x20`	Texto simples	SpreadsheetML / Flat ODS / UOS1 / HTML / texto simples

Arquivos DBF são detectados com base no primeiro byte, bem como no terceiro e quarto bytes (correspondentes ao mês e dia da data do arquivo)

Arquivos do Works para Windows são detectados com base no registro BOF com tipo 0xFF

A adivinhação de formato de texto simples segue a ordem de prioridade:

Tags HTML incluem: html, table, head, meta, script, style, div

Por que arquivos de texto aleatórios são válidos? (clique para mostrar)

O Excel é extremamente agressivo na leitura de arquivos. Adicionar uma extensão XLS a qualquer arquivo de texto de exibição (onde os únicos caracteres são caracteres de exibição ANSI) engana o Excel fazendo-o pensar que o arquivo é potencialmente um arquivo CSV ou TSV, mesmo que seja apenas uma coluna! Esta biblioteca tenta replicar esse comportamento.

A melhor abordagem é validar a planilha desejada e garantir que ela tenha o número esperado de linhas ou colunas. Extrair o intervalo é extremamente simples:```js var range = XLSX.utils.decode_range(worksheet['!ref']); var ncols = range.e.c - range.s.c + 1, nrows = range.e.r - range.s.r + 1;

</details>

## Opções de Escrita

As funções exportadas `write` e `writeFile` aceitam um argumento de opções:

| Nome da Opção |  Padrão | Descrição                                         |
| :---------- | -------: | :-------------------------------------------------- |
|`type`       |          | Codificação dos dados de saída (veja Tipo de Saída abaixo)        |
|`cellDates`  |  `false` | Armazenar datas como tipo `d` (padrão é `n`)            |
|`bookSST`    |  `false` | Gerar Tabela de Strings Compartilhada **                     |
|`bookType`   | `"xlsx"` | Tipo de Pasta de Trabalho (veja abaixo os formatos suportados)  |
|`sheet`      |     `""` | Nome da Planilha para formatos de folha única **       |
|`compression`|  `false` | Usar compressão ZIP para formatos baseados em ZIP **        |
|`Props`      |          | Sobrescrever propriedades da pasta de trabalho ao escrever **        |
|`themeXLSX`  |          | Sobrescrever XML de tema ao escrever XLSX/XLSB/XLSM **   |
|`ignoreEC`   |   `true` | Suprimir erros de "número como texto" **                 |
|`numbers`    |          | Payload para exportação NUMBERS **                       |

- `bookSST` é mais lento e consome mais memória, mas tem melhor compatibilidade com versões antigas do iOS Numbers
- Os dados brutos são a única coisa garantida a serem salvos.  Recursos não descritos neste README podem não ser serializados.
- `cellDates` se aplica apenas à saída XLSX e não é garantido que funcione com leitores de terceiros.  O próprio Excel normalmente não escreve células com tipo `d`, então ferramentas não Excel podem ignorar os dados ou apresentar erro na presença de datas.
- `Props` é um objeto que espelha o campo `Props` da pasta de trabalho.  Veja a tabela da seção [Propriedades do Arquivo da Pasta de Trabalho](#workbook-file-properties).
- se especificado, a string de `themeXLSX` será salva como o tema principal para arquivos XLSX/XLSB/XLSM (para `xl/theme/theme1.xml` no ZIP)
- Devido a um bug no programa, alguns recursos como "Texto para Colunas" farão o Excel travar em planilhas onde condições de erro são ignoradas.  O escritor marcará os arquivos para ignorar o erro por padrão.  Defina `ignoreEC` como `false` para suprimir.
- Devido ao tamanho dos dados, os dados NUMBERS não estão incluídos por padrão. Os scripts incluídos `xlsx.zahl.js` e `xlsx.zahl.mjs` contêm os dados.

### Formatos de Saída Suportados

Para ampla compatibilidade com ferramentas de terceiros, esta biblioteca suporta muitos formatos de saída.  O tipo de arquivo específico é controlado com a opção `bookType`:

| `bookType` | extensão de arquivo | contêiner | folhas | Descrição                     |
| :--------- | -------: | :-------: | :----- |:------------------------------- |
| `xlsx`     | `.xlsx`  |    ZIP    | multi  | Formato XML Excel 2007+          |
| `xlsm`     | `.xlsm`  |    ZIP    | multi  | Formato XML de Macro Excel 2007+    |
| `xlsb`     | `.xlsb`  |    ZIP    | multi  | Formato Binário Excel 2007+       |
| `biff8`    | `.xls`   |    CFB    | multi  | Formato de Pasta de Trabalho Excel 97-2004   |
| `biff5`    | `.xls`   |    CFB    | multi  | Formato de Pasta de Trabalho Excel 5.0/95    |
| `biff4`    | `.xls`   |   none    | single | Formato de Planilha Excel 4.0      |
| `biff3`    | `.xls`   |   none    | single | Formato de Planilha Excel 3.0      |
| `biff2`    | `.xls`   |   none    | single | Formato de Planilha Excel 2.0      |
| `xlml`     | `.xls`   |   none    | multi  | Excel 2003-2004 (SpreadsheetML) |
| `numbers`  |`.numbers`|    ZIP    | single | Planilha Numbers 3.0+        |
| `ods`      | `.ods`   |    ZIP    | multi  | Planilha OpenDocument        |
| `fods`     | `.fods`  |   none    | multi  | Planilha OpenDocument Plana   |
| `wk3`      | `.wk3`   |   none    | multi  | Pasta de Trabalho Lotus (WK3)            |
| `csv`      | `.csv`   |   none    | single | Valores Separados por Vírgula          |
| `txt`      | `.txt`   |   none    | single | Texto Unicode UTF-16 (TXT)       |
| `sylk`     | `.sylk`  |   none    | single | Link Simbólico (SYLK)            |
| `html`     | `.html`  |   none    | single | Documento HTML                   |
| `dif`      | `.dif`   |   none    | single | Formato de Intercâmbio de Dados (DIF)   |
| `dbf`      | `.dbf`   |   none    | single | dBASE II + Extensões VFP (DBF) |
| `wk1`      | `.wk1`   |   none    | single | Planilha Lotus (WK1)           |
| `rtf`      | `.rtf`   |   none    | single | Formato Rich Text (RTF)          |
| `prn`      | `.prn`   |   none    | single | Texto Formatado Lotus            |
| `eth`      | `.eth`   |   none    | single | Formato de Registro Ethercalc (ETH)   |

- `compression` se aplica apenas a formatos com contêineres ZIP.
- Formatos que suportam apenas uma folha exigem a opção `sheet` especificando a planilha.  Se a string estiver vazia, a primeira planilha é usada.
- `writeFile` adivinhará automaticamente o formato do arquivo de saída com base na extensão do arquivo se `bookType` não for especificado.  Ele escolherá o primeiro formato na tabela mencionada que corresponda à extensão.

### Tipo de Saída

O argumento `type` para `write` reflete o argumento `type` para `read`:

| `type`     | saída                                                          |
|------------|-----------------------------------------------------------------|
| `"base64"` | string: codificação Base64 do arquivo                             |
| `"binary"` | string: string binária (byte `n` é `data.charCodeAt(n)`)        |
| `"string"` | string: string JS (caracteres interpretados como UTF8)              |
| `"buffer"` | nodejs Buffer                                                   |
| `"array"`  | ArrayBuffer, array de fallback de inteiros sem sinal de 8 bits               |
| `"file"`   | string: caminho do arquivo que será criado (apenas nodejs)         |

- Para compatibilidade com Excel, a saída `csv` sempre incluirá a marca de ordem de byte UTF-8.

## Funções Utilitárias

As funções `sheet_to_*` aceitam uma planilha e um objeto de opções opcional.

As funções `*_to_sheet` aceitam um objeto de dados e um objeto de opções opcional.

Os exemplos são baseados na seguinte planilha:```
XXX| A | B | C | D | E | F | G |
---+---+---+---+---+---+---+---+
 1 | S | h | e | e | t | J | S |
 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
 3 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |

Entrada de Array de Arrays

XLSX.utils.aoa_to_sheet recebe um array de arrays de valores JS e retorna uma planilha semelhante aos dados de entrada. Números, Booleanos e Strings são armazenados com os estilos correspondentes. Datas são armazenadas como data ou números. Lacunas no array e valores undefined explícitos são ignorados. Valores null podem ser preenchidos com stubs. Todos os outros valores são armazenados como strings. A função aceita um argumento de opções:

Exemplos (clique para mostrar)

Para gerar a planilha de exemplo:```js var ws = XLSX.utils.aoa_to_sheet([ "SheetJS".split(""), [1,2,3,4,5,6,7], [2,3,4,5,6,7,8] ]);

</details>

`XLSX.utils.sheet_add_aoa` recebe um array de arrays de valores JS e atualiza um
objeto de planilha existente. Segue o mesmo processo de `aoa_to_sheet` e
aceita um argumento de opções:

| Nome da Opção | Padrão  | Descrição                                          |
| :------------ | :-----: | :------------------------------------------------- |
|`dateNF`       |  FMT 14 | Usar formato de data especificado na saída de string|
|`cellDates`    |  false  | Armazenar datas como tipo `d` (padrão é `n`)      |
|`sheetStubs`   |  false  | Criar objetos de célula do tipo `z` para valores `null`|
|`nullError`    |  false  | Se verdadeiro, emitir células de erro `#NULL!` para valores `null`|
|`origin`       |         | Usar célula especificada como ponto de partida (ver abaixo)|

`origin` deve ser um dos seguintes:

| `origin`         | Descrição                                               |
| :--------------- | :------------------------------------------------------ |
| (cell object)    | Usar célula especificada (objeto de célula)            |
| (string)         | Usar célula especificada (célula estilo A1)            |
| (number >= 0)    | Começar da primeira coluna na linha especificada (0-indexado)|
| -1               | Anexar ao final da planilha começando na primeira coluna|
| (default)        | Começar da célula A1                                    |

<details>
  <summary><b>Exemplos</b> (clique para mostrar)</summary>

Considere a planilha:```
XXX| A | B | C | D | E | F | G |
---+---+---+---+---+---+---+---+
 1 | S | h | e | e | t | J | S |

---

[Read more](https://github.com/weareu/xlsx)

O método `writeFile` empacota os dados e tenta salvar o novo arquivo.  O
formato do arquivo de exportação é determinado pela extensão de `filename` (`SheetJS.xlsx`
sinaliza exportação XLSX, `SheetJS.xlsb` sinaliza exportação XLSB, etc).

O método `writeFile` usa APIs específicas da plataforma para iniciar o salvamento do arquivo. No
NodeJS, `fs.readFileSync` pode criar um arquivo.  No navegador web, é tentado um
download usando o atributo `download` do HTML5, com fallbacks para IE.

_Gerar e tentar salvar um arquivo XLSX_```js
XLSX.writeFileXLSX(workbook, filename, opts);

Arquivo local em um servidor NodeJS (clique para mostrar)

writeFile usa fs.writeFileSync em ambientes de servidor:```js var XLSX = require("xlsx");

/* output format determined by filename */ XLSX.writeFile(workbook, "out.xlsb");

Para Node ESM, o auxiliar `writeFile` não está habilitado. Em vez disso, `fs.writeFileSync` deve ser usado para escrever os dados do arquivo em um `Buffer` para uso com `XLSX.write`:```js
import { writeFileSync } from "fs";
import { write } from "xlsx/xlsx.mjs";

const buf = write(workbook, {type: "buffer", bookType: "xlsb"});
/* buf is a Buffer */
const workbook = writeFileSync("out.xlsb", buf);

Arquivo local em uma aplicação Deno (clique para mostrar)

writeFile usa Deno.writeFileSync internamente:```js // @deno-types="https://deno.land/x/sheetjs/types/index.d.ts" import * as XLSX from 'https://deno.land/x/sheetjs/xlsx.mjs'

XLSX.writeFile(workbook, "test.xlsx");

Aplicações que escrevem arquivos devem ser invocadas com a flag `--allow-write`.  A [demonstração do `deno`](https://github.com/weareu/xlsx/blob/master/demos/deno) tem mais exemplos

</details>

<details>
  <summary><b>Arquivo local em um plugin do PhotoShop ou InDesign</b> (clique para mostrar)</summary>

`writeFile` encapsula a lógica do `File` no Photoshop e outros alvos do ExtendScript.
O caminho especificado deve ser um caminho absoluto:```js
#include "xlsx.extendscript.js"

/* output format determined by filename */
XLSX.writeFile(workbook, "out.xlsx");
/* at this point, out.xlsx is a file that you can distribute */

O demonstrativo extendscript inclui um exemplo mais complexo.

Baixar um arquivo no navegador para a máquina do usuário (clique para mostrar)

XLSX.writeFile encapsula algumas técnicas para acionar o salvamento de um arquivo:

A API URL do navegador cria uma URL de objeto para o arquivo, que a biblioteca utiliza criando um link e forçando um clique. É suportada em navegadores modernos.
msSaveBlob é uma API do IE10+ para acionar o salvamento de um arquivo.
IE_FileSave usa VBScript e ActiveX para escrever um arquivo no IE6+ para Windows XP e Windows 7. O shim deve ser incluído na página HTML que o contém.

Não há uma maneira padrão de determinar se o arquivo real foi baixado.```js /* output format determined by filename / XLSX.writeFile(workbook, "out.xlsb"); / at this point, out.xlsb will have been downloaded */

</details>

<details>
  <summary><b>Baixar um arquivo em navegadores legados</b> (clique para mostrar)</summary>

`XLSX.writeFile` técnicas funcionam para a maioria dos navegadores modernos, bem como para IE antigo.
Para navegadores muito mais antigos, existem soluções alternativas implementadas por bibliotecas wrapper.

[`FileSaver.js`](https://github.com/eligrey/FileSaver.js/) implementa `saveAs`.
Nota: `XLSX.writeFile` chamará automaticamente `saveAs` se disponível.```js
/* bookType can be any supported output type */
var wopts = { bookType:"xlsx", bookSST:false, type:"array" };

var wbout = XLSX.write(workbook,wopts);

/* the saveAs call downloads a file on the local machine */
saveAs(new Blob([wbout],{type:"application/octet-stream"}), "test.xlsx");

Downloadify usa um botão Flash SWF para gerar arquivos locais, adequado para ambientes onde o ActiveX não está disponível:```js Downloadify.create(id,{ /* other options are required! read the downloadify docs for more info */ filename: "test.xlsx", data: function() { return XLSX.write(wb, {bookType:"xlsx", type:"base64"}); }, append: false, dataType: "base64" });

O [demo `oldie`](https://github.com/weareu/xlsx/blob/master/demos/oldie) mostra um cenário de fallback compatível com IE.

</details>

<details>
  <summary><b>Upload de arquivo pelo navegador (ajax)</b> (clique para mostrar)</summary>

Um exemplo completo usando XHR está [incluído no demo XHR](https://github.com/weareu/xlsx/blob/master/demos/xhr), juntamente
com exemplos para fetch e bibliotecas wrapper.  Este exemplo assume que o servidor
pode lidar com arquivos codificados em Base64 (veja o demo para um servidor nodejs básico):```js
/* in this example, send a base64 string to the server */
var wopts = { bookType:"xlsx", bookSST:false, type:"base64" };

var wbout = XLSX.write(workbook,wopts);

var req = new XMLHttpRequest();
req.open("POST", "/upload", true);
var formdata = new FormData();
formdata.append("file", "test.xlsx"); // <-- server expects `file` to hold name
formdata.append("data", wbout); // <-- `data` holds the base64-encoded data
req.send(formdata);

Geração de Arquivos com PhantomJS (Headless Webkit) (click to show)

A demonstração headless inclui uma demonstração completa para converter arquivos HTML em pastas de trabalho XLSB usando PhantomJS. O PhantomJS fs.write suporta a escrita de arquivos a partir do processo principal, mas possui uma interface diferente do módulo fs do NodeJS:```js var XLSX = require('xlsx'); var fs = require('fs');

/* generate a binary string / var bin = XLSX.write(workbook, { type:"binary", bookType: "xlsx" }); / write to file */ fs.write("test.xlsx", bin, "wb");

Note: A seção ["Processamento de Tabelas HTML"](#processing-html-tables) mostra como
gerar uma pasta de trabalho a partir de tabelas HTML em uma página no "Headless WebKit".

</details>



Os [demos incluídos](https://github.com/weareu/xlsx/blob/master/demos) cobrem aplicativos móveis e outras implantações especiais.

### Exemplos de Escrita

- <http://sheetjs.com/demos/table.html> exportando uma tabela HTML
- <http://sheetjs.com/demos/writexlsx.html> gera um arquivo simples

### Escrita em Streaming

As funções de escrita em streaming estão disponíveis no objeto `XLSX.stream`. Elas
recebem os mesmos argumentos que as funções normais de escrita, mas retornam um
Stream Legível do NodeJS.

- `XLSX.stream.to_csv` é a versão em streaming de `XLSX.utils.sheet_to_csv`.
- `XLSX.stream.to_html` é a versão em streaming de `XLSX.utils.sheet_to_html`.
- `XLSX.stream.to_json` é a versão em streaming de `XLSX.utils.sheet_to_json`.

<details>
  <summary><b>converter nodejs para CSV e escrever arquivo</b> (clique para mostrar)</summary>```js
var output_file_name = "out.csv";
var stream = XLSX.stream.to_csv(worksheet);
stream.pipe(fs.createWriteStream(output_file_name));

nodejs escrever fluxo JSON para a tela (clique para mostrar)

```js /* to_json returns an object-mode stream */ var stream = XLSX.stream.to_json(worksheet, {raw:true});

/* the following stream converts JS objects to text via JSON.stringify */ var conv = new Transform({writableObjectMode:true}); conv._transform = function(obj, e, cb){ cb(null, JSON.stringify(obj) + "\n"); };

stream.pipe(conv); conv.pipe(process.stdout);

</details>

<details>
  <summary><b>Exportando arquivos NUMBERS</b> (clique para mostrar)</summary>

O escritor NUMBERS requer uma base bastante grande.  Os scripts suplementares `xlsx.zahl`
fornecem suporte.  `xlsx.zahl.js` é projetado para uso standalone e NodeJS
uso, enquanto `xlsx.zahl.mjs` é adequado para ESM.

_Navegador_```html
<meta charset="utf8">
<script src="xlsx.full.min.js"></script>
<script src="xlsx.zahl.js"></script>
<script>
var wb = XLSX.utils.book_new(); var ws = XLSX.utils.aoa_to_sheet([
  ["SheetJS", "<3","விரிதாள்"],
  [72,,"Arbeitsblätter"],
  [,62,"数据"],
  [true,false,],
]); XLSX.utils.book_append_sheet(wb, ws, "Sheet1");
XLSX.writeFile(wb, "textport.numbers", {numbers: XLSX_ZAHL, compression: true});
</script>

Nó```js var XLSX = require("./xlsx.flow"); var XLSX_ZAHL = require("./dist/xlsx.zahl"); var wb = XLSX.utils.book_new(); var ws = XLSX.utils.aoa_to_sheet([ ["SheetJS", "<3","விரிதாள்"], [72,,"Arbeitsblätter"], [,62,"数据"], [true,false,], ]); XLSX.utils.book_append_sheet(wb, ws, "Sheet1"); XLSX.writeFile(wb, "textport.numbers", {numbers: XLSX_ZAHL, compression: true});

_Deno_```ts
import * as XLSX from './xlsx.mjs';
import XLSX_ZAHL from './dist/xlsx.zahl.mjs';

var wb = XLSX.utils.book_new(); var ws = XLSX.utils.aoa_to_sheet([
  ["SheetJS", "<3","விரிதாள்"],
  [72,,"Arbeitsblätter"],
  [,62,"数据"],
  [true,false,],
]); XLSX.utils.book_append_sheet(wb, ws, "Sheet1");
XLSX.writeFile(wb, "textports.numbers", {numbers: XLSX_ZAHL, compression: true});

Pré-visualizando dados em uma grade de dados React (clique para mostrar)

react-data-grid é uma grade de dados adaptada para o React. Ela espera duas propriedades: rows de objetos de dados e columns que descrevem as colunas. Para fins de ajustar os dados à API da grade de dados React, é mais fácil começar com uma matriz de matrizes.

Esta demonstração começa buscando um arquivo remoto e usando XLSX.read para extrair:```js import { useEffect, useState } from "react"; import DataGrid from "react-data-grid"; import { read, utils } from "xlsx";

const url = "https://oss.sheetjs.com/test_files/RkNumber.xls";

export default function App() { const [columns, setColumns] = useState([]); const [rows, setRows] = useState([]); useEffect(() => {(async () => { const wb = read(await (await fetch(url)).arrayBuffer(), { WTF: 1 });

/* use sheet_to_json with header: 1 to generate an array of arrays */
const data = utils.sheet_to_json(wb.Sheets[wb.SheetNames[0]], { header: 1 });

/* see react-data-grid docs to understand the shape of the expected data */
setColumns(data[0].map((r) => ({ key: r, name: r })));
setRows(data.slice(1).map((r) => r.reduce((acc, x, i) => {
  acc[data[0][i]] = x;
  return acc;
}, {})));

})(); });

return ; }

</details>

<details>
  <summary><b>Visualizando dados em uma grade de dados VueJS</b> (clique para mostrar)</summary>

[`vue3-table-lite`](https://github.com/linmasahiro/vue3-table-lite) é uma tabela
de dados simples do VueJS 3. Ela é apresentada [no demo VueJS](https://github.com/weareu/xlsx/blob/master/demos/vue/modify).

</details>

<details>
  <summary><b>Preenchendo um banco de dados (SQL ou no-SQL)</b> (clique para mostrar)</summary>

O [`database` demo](https://github.com/weareu/xlsx/blob/master/demos/database) inclui exemplos de trabalho com bancos de
dados e resultados de consultas.

</details>

<details>
  <summary><b>Computações Numéricas com TensorFlow.js</b> (clique para mostrar)</summary>

[`@tensorflow/tfjs`](https://github.com/weareu/xlsx/blob/master/%40tensorflow/tfjs) e outras bibliotecas esperam dados em
arrays simples, bem adequados para planilhas onde cada coluna é um vetor de
dados. Essa é a transposição de como a maioria das pessoas usa planilhas, onde
cada linha é um vetor.

Um único `Array#map` pode extrair linhas nomeadas individuais da exportação
`sheet_to_json`:```js
const XLSX = require("xlsx");
const tf = require('@tensorflow/tfjs');

const key = "age"; // this is the field we want to pull
const ages = XLSX.utils.sheet_to_json(worksheet).map(r => r[key]);
const tf_data = tf.tensor1d(ages);

Todos os campos podem ser processados de uma vez usando uma transposição do tensor 2D gerado com a exportação sheet_to_json com header: 1. A primeira linha, se contiver rótulos de cabeçalho, deve ser removida com um slice:```js const XLSX = require("xlsx"); const tf = require('@tensorflow/tfjs');

/* array of arrays of the data starting on the second row / const aoa = XLSX.utils.sheet_to_json(worksheet, {header: 1}).slice(1); / dataset in the "correct orientation" / const tf_dataset = tf.tensor2d(aoa).transpose(); / pull out each dataset with a slice */ const tf_field0 = tf_dataset.slice([0,0], [1,tensor.shape[1]]).flatten(); const tf_field1 = tf_dataset.slice([1,0], [1,tensor.shape[1]]).flatten();

O [`array` demo](https://github.com/weareu/xlsx/blob/master/demos/array) mostra um exemplo completo.

</details>

### Gerando Tabelas HTML

**API**

_Gerar Tabela HTML a partir da Planilha_```js
var html = XLSX.utils.sheet_to_html(worksheet);

A função utilitária sheet_to_html gera código HTML com base nos dados da planilha. Cada célula da planilha é mapeada para um elemento <TD>. Células mescladas na planilha são serializadas definindo os atributos colspan e rowspan.

Exemplos

A função utilitária sheet_to_html gera código HTML que pode ser adicionado a qualquer elemento DOM definindo o innerHTML:```js var container = document.getElementById("tavolo"); container.innerHTML = XLSX.utils.sheet_to_html(worksheet);

Combinando com `fetch`, construir um site a partir de um workbook é direto:

<details>
  <summary><b>Vanilla JS + HTML fetch workbook and generate table previews</b> (clique para mostrar)</summary>```html
<body>
  <style>TABLE { border-collapse: collapse; } TD { border: 1px solid; }</style>
  <div id="tavolo"></div>
  <script src="https://unpkg.com/xlsx/dist/xlsx.full.min.js"></script>
  <script type="text/javascript">
(async() => {
  /* fetch and parse workbook -- see the fetch example for details */
  const workbook = XLSX.read(await (await fetch("sheetjs.xlsx")).arrayBuffer());

  let output = [];
  /* loop through the worksheet names in order */
  workbook.SheetNames.forEach(name => {

    /* generate HTML from the corresponding worksheets */
    const worksheet = workbook.Sheets[name];
    const html = XLSX.utils.sheet_to_html(worksheet);

    /* add a header with the title name followed by the table */
    output.push(`<H3>${name}</H3>${html}`);
  });
  /* write to the DOM at the end */
  tavolo.innerHTML = output.join("\n");
})();
  </script>
</body>

Buscar workbook com React e gerar visualizações de tabela HTML (clique para mostrar)

Geralmente, é recomendado usar um fluxo de trabalho amigável ao React, mas é possível gerar HTML e usá-lo no React com dangerouslySetInnerHTML:```jsx function Tabeller(props) { /* the workbook object is the state */ const [workbook, setWorkbook] = React.useState(XLSX.utils.book_new());

/* fetch and update the workbook with an effect / React.useEffect(() => { (async() => { / fetch and parse workbook -- see the fetch example for details */ const wb = XLSX.read(await (await fetch("sheetjs.xlsx")).arrayBuffer()); setWorkbook(wb); })(); });

return workbook.SheetNames.map(name => (<>

name

<div dangerouslySetInnerHTML={{ /* this __html mantra is needed to set the inner HTML */ __html: XLSX.utils.sheet_to_html(workbook.Sheets[name]) }} /> </>)); }

The [`react` demo](https://github.com/weareu/xlsx/blob/master/demos/react) inclui mais exemplos de React.

</details>

<details>
  <summary><b>VueJS buscar workbook e gerar prévias de tabela HTML</b> (clique para mostrar)</summary>

É geralmente recomendado usar um workflow amigável ao VueJS, mas é possível
gerar HTML e utilizá-lo no VueJS com a diretiva `v-html`:```jsx
import { read, utils } from 'xlsx';
import { reactive } from 'vue';

const S5SComponent = {
  mounted() { (async() => {
    /* fetch and parse workbook -- see the fetch example for details */
    const workbook = read(await (await fetch("sheetjs.xlsx")).arrayBuffer());
    /* loop through the worksheet names in order */
    workbook.SheetNames.forEach(name => {
      /* generate HTML from the corresponding worksheets */
      const html = utils.sheet_to_html(workbook.Sheets[name]);
      /* add to state */
      this.wb.wb.push({ name, html });
    });
  })(); },
  /* this state mantra is required for array updates to work */
  setup() { return { wb: reactive({ wb: [] }) }; },
  template: `
  <div v-for="ws in wb.wb" :key="ws.name">
    <h3>{{ ws.name }}</h3>
    <div v-html="ws.html"></div>
  </div>`
};

O demos vuejs inclui mais exemplos de React.

Esta captura instantânea foi projetada para replicar o tipo de saída "CSV UTF8 (`.csv`)".
["Saída Separada por Delimitador"](#delimiter-separated-output) descreve a
função e o argumento opcional `opts` em mais detalhes.

_Gerar "Texto" a partir de uma única planilha_```js
var txt = XLSX.utils.sheet_to_txt(worksheet, opts);

Este instantâneo gera um array de entradas representando as fórmulas incorporadas. As fórmulas de matriz são renderizadas na forma `range=formula` enquanto células comuns são renderizadas na forma `cell=formula or value`.  Literais de string são prefixados com um apóstrofo `'`, consistente com a exibição da barra de fórmulas do Excel.

["Saída de Fórmulas"](#formulae-output) descreve a função em mais detalhes.

## Interface

`XLSX` é a variável exposta no navegador e a variável exportada do Node

`XLSX.version` é a versão da biblioteca (adicionada pelo script de compilação).

`XLSX.SSF` é uma versão embutida da [biblioteca de formato](https://git.io/ssf).

### Funções de análise

`XLSX.read(data, read_opts)` tenta analisar `data`.

`XLSX.readFile(filename, read_opts)` tenta ler `filename` e analisar.

As opções de análise são descritas na seção [Opções de Análise](#parsing-options).

### Funções de escrita

`XLSX.write(wb, write_opts)` tenta escrever a pasta de trabalho `wb`

`XLSX.writeFile(wb, filename, write_opts)` tenta escrever `wb` em `filename`. Em ambientes baseados em navegador, tentará forçar um download no lado do cliente.

`XLSX.writeFileAsync(wb, filename, o, cb)` tenta escrever `wb` em `filename`. Se `o` for omitido, o escritor usará o terceiro argumento como callback.

`XLSX.stream` contém um conjunto de funções de escrita em fluxo.

As opções de escrita são descritas na seção [Opções de Escrita](#writing-options).

### Utilitários

Utilitários estão disponíveis no objeto `XLSX.utils` e são descritos na seção [Funções Utilitárias](#utility-functions):

**Construção:**

- `book_new` cria uma pasta de trabalho vazia
- `book_append_sheet` adiciona uma planilha a uma pasta de trabalho

**Importação:**

- `aoa_to_sheet` converte um array de arrays de dados JS em uma planilha.
- `json_to_sheet` converte um array de objetos JS em uma planilha.
- `table_to_sheet` converte um elemento DOM TABLE em uma planilha.
- `sheet_add_aoa` adiciona um array de arrays de dados JS a uma planilha existente.
- `sheet_add_json` adiciona um array de objetos JS a uma planilha existente.

**Exportação:**

- `sheet_to_json` converte um objeto de planilha em um array de objetos JSON.
- `sheet_to_csv` gera saída de valores separados por delimitador.
- `sheet_to_txt` gera texto formatado em UTF16.
- `sheet_to_html` gera saída HTML.
- `sheet_to_formulae` gera uma lista das fórmulas (com fallbacks de valor).

**Manipulação de células e endereços de células:**

- `format_cell` gera o valor de texto para uma célula (usando formatos de número).
- `encode_row / decode_row` converte entre linhas indexadas em 0 e linhas indexadas em 1.
- `encode_col / decode_col` converte entre colunas indexadas em 0 e nomes de colunas.
- `encode_cell / decode_cell` converte endereços de células.
- `encode_range / decode_range` converte intervalos de células.

## Formato Comum de Planilha

SheetJS está em conformidade com o Formato Comum de Planilha (CSF):

### Estruturas Gerais

Os objetos de endereço de célula são armazenados como `{c:C, r:R}` onde `C` e `R` são números de coluna e linha indexados em 0, respectivamente.  Por exemplo, o endereço de célula `B5` é representado pelo objeto `{c:1, r:4}`.

Os objetos de intervalo de células são armazenados como `{s:S, e:E}` onde `S` é a primeira célula e `E` é a última célula no intervalo.  Os intervalos são inclusivos.  Por exemplo, o intervalo `A3:B7` é representado pelo objeto `{s:{c:0, r:2}, e:{c:1, r:6}}`.
As funções utilitárias realizam uma travessia em ordem principal de linha de um intervalo de planilha:```js
for(var R = range.s.r; R <= range.e.r; ++R) {
  for(var C = range.s.c; C <= range.e.c; ++C) {
    var cell_address = {c:C, r:R};
    /* if an A1-style address is needed, encode the address */
    var cell_ref = XLSX.utils.encode_cell(cell_address);
  }
}

Key	Description
`v`	raw value (see Data Types section for more info)
`w`	formatted text (if applicable)
`t`	type: `b` Boolean, `e` Error, `n` Number, `d` Date, `s` Text, `z` Stub
`f`	cell formula encoded as an A1-style string (if applicable)
`F`	range of enclosing array if formula is array formula (if applicable)
`D`	if true, array formula is dynamic (if applicable)
`r`	rich text encoding (if applicable)
`h`	HTML rendering of the rich text (if applicable)
`c`	comments associated with the cell
`z`	number format string associated with the cell (if requested)
`l`	cell hyperlink object (`.Target` holds link, `.Tooltip` is tooltip)
`s`	the style/theme of the cell (if applicable)

Type	Description
`b`	Boolean: value interpreted as JS `boolean`
`e`	Error: value is a numeric code and `w` property stores common name **
`n`	Number: value is a JS `number` **
`d`	Date: value is a JS `Date` object or string to be parsed as Date **
`s`	Text: value interpreted as JS `string` and written as text **
`z`	Stub: blank stub cell that is ignored by data processing utilities **

Valores de erro e interpretação (clique para mostrar)

Value	Error Meaning
`0x00`	`#NULL!`
`0x07`	`#DIV/0!`
`0x0F`	`#VALUE!`
`0x17`	`#REF!`
`0x1D`	`#NAME?`
`0x24`	`#NUM!`
`0x2A`	`#N/A`
`0x2B`	`#GETTING_DATA`

Épocas: 1900 e 1904 (clique para mostrar)

O Excel suporta duas épocas (1 de Janeiro de 1900 e 1 de Janeiro de 1904). A época da pasta de trabalho pode ser determinada examinando a propriedade wb.Workbook.WBProps.date1904 da pasta de trabalho:```js !!(((wb.Workbook||{}).WBProps||{}).date1904)

</details>

### Objetos de Planilha

Cada chave que não começa com `!` mapeia para uma célula (usando a notação `A-1`)

`sheet[address]` retorna o objeto de célula para o endereço especificado.

**Chaves especiais de planilha (acessíveis como `sheet[key]`, cada uma iniciando com `!`):**

- `sheet['!ref']`: intervalo baseado em A-1 representando o intervalo da planilha. Funções que trabalham com planilhas devem usar este parâmetro para determinar o intervalo. Células atribuídas fora do intervalo não são processadas. Em particular, ao escrever uma planilha manualmente, células fora do intervalo não são incluídas.

  Funções que manipulam planilhas devem verificar a presença do campo `!ref`. Se `!ref` for omitido ou não for um intervalo válido, as funções podem tratar a planilha como vazia ou tentar adivinhar o intervalo. As utilidades padrão que acompanham esta biblioteca tratam planilhas como vazias (por exemplo, a saída CSV é uma string vazia).

  Ao ler uma planilha com a propriedade `sheetRows` definida, o parâmetro ref usará o intervalo restrito. O intervalo original é definido em `ws['!fullref']`.

- `sheet['!margins']`: Objeto representando as margens da página. Os valores padrão seguem o predefinido "normal" do Excel. O Excel também tem predefinições "wide" e "narrow", mas são armazenadas como medidas brutas. As principais propriedades estão listadas abaixo:

<details>
  <summary><b>Detalhes das margens da página</b> (clique para mostrar)</summary>

| key      | description                     | "normal" | "wide" | "narrow" |
|----------|---------------------------------|:---------|:-------|:-------- |
| `left`   | margem esquerda (polegadas)     | `0.7`    | `1.0`  | `0.25`   |
| `right`  | margem direita (polegadas)      | `0.7`    | `1.0`  | `0.25`   |
| `top`    | margem superior (polegadas)     | `0.75`   | `1.0`  | `0.75`   |
| `bottom` | margem inferior (polegadas)     | `0.75`   | `1.0`  | `0.75`   |
| `header` | margem do cabeçalho (polegadas) | `0.3`    | `0.5`  | `0.3`    |
| `footer` | margem do rodapé (polegadas)    | `0.3`    | `0.5`  | `0.3`    |```js
/* Set worksheet sheet to "normal" */
ws["!margins"]={left:0.7, right:0.7, top:0.75,bottom:0.75,header:0.3,footer:0.3}
/* Set worksheet sheet to "wide" */
ws["!margins"]={left:1.0, right:1.0, top:1.0, bottom:1.0, header:0.5,footer:0.5}
/* Set worksheet sheet to "narrow" */
ws["!margins"]={left:0.25,right:0.25,top:0.75,bottom:0.75,header:0.3,footer:0.3}

Detalhes da Proteção da Planilha (clique para mostrar)

chave	recurso (true=desabilitado / false=habilitado)	padrão
`selectLockedCells`	Selecionar células bloqueadas	habilitado
`selectUnlockedCells`	Selecionar células desbloqueadas	habilitado
`formatCells`	Formatar células	desabilitado
`formatColumns`	Formatar colunas	desabilitado
`formatRows`	Formatar linhas	desabilitado
`insertColumns`	Inserir colunas	desabilitado
`insertRows`	Inserir linhas	desabilitado
`insertHyperlinks`	Inserir hiperlinks	desabilitado
`deleteColumns`	Excluir colunas	desabilitado
`deleteRows`	Excluir linhas	desabilitado
`sort`	Classificar	desabilitado
`autoFilter`	Filtrar	desabilitado
`pivotTables`	Usar relatórios de Tabela Dinâmica	desabilitado
`objects`	Editar objetos	habilitado
`scenarios`	Editar cenários	habilitado

#### Chartsheet Object

Os Chartsheets são representados como planilhas padrão. Eles são distinguidos pela propriedade `!type` definida como `"chart"`.

Os dados subjacentes e `!ref` referem-se aos dados em cache na chartsheet. A primeira linha da chartsheet é o cabeçalho subjacente.

#### Macrosheet Object

Os Macrosheets são representados como planilhas padrão. Eles são distinguidos pela propriedade `!type` definida como `"macro"`.

#### Dialogsheet Object

Os Dialogsheets são representados como planilhas padrão. Eles são distinguidos pela propriedade `!type` definida como `"dialog"`.

### Workbook Object

`workbook.SheetNames` é uma lista ordenada das planilhas no workbook

`wb.Sheets[sheetname]` retorna um objeto que representa a planilha.

`wb.Props` é um objeto que armazena as propriedades padrão. `wb.Custprops` armazena propriedades personalizadas. Como as propriedades padrão do XLS desviam do padrão XLSX, a análise do XLS armazena as propriedades principais em ambos os lugares.

`wb.Workbook` armazena [atributos de nível de workbook](#workbook-level-attributes).

#### Workbook File Properties

Os vários formatos de arquivo usam nomes internos diferentes para propriedades de arquivo. O objeto `Props` do workbook normaliza os nomes:

<details>
  <summary><b>Propriedades do Arquivo</b> (clique para mostrar)</summary>

| JS Name       | Excel Description              |
|:--------------|:-------------------------------|
| `Title`       | Aba Resumo "Título"            |
| `Subject`     | Aba Resumo "Assunto"          |
| `Author`      | Aba Resumo "Autor"           |
| `Manager`     | Aba Resumo "Gerente"          |
| `Company`     | Aba Resumo "Empresa"          |
| `Category`    | Aba Resumo "Categoria"         |
| `Keywords`    | Aba Resumo "Palavras-chave"         |
| `Comments`    | Aba Resumo "Comentários"         |
| `LastAuthor`  | Aba Estatísticas "Último Salvamento por" |
| `CreatedDate` | Aba Estatísticas "Criada"       |

</details>

Por exemplo, para definir a propriedade de título do workbook:```js
if(!wb.Props) wb.Props = {};
wb.Props.Title = "Insert Title Here";

Propriedades dos Nomes Definidos (clique para mostrar)

Key	Descrição
`Sheet`	Escopo do nome. Índice da Planilha (0 = primeira planilha) ou `null` (Pasta de trabalho)
`Name`	Nome sensível a maiúsculas/minúsculas. Regras padrão se aplicam **
`Ref`	Referência no estilo A1 (`"Sheet1!$A$1:$D$20"`)
`Comment`	Comentário (aplicável apenas para XLS/XLSX/XLSB)

Key	Descrição
`CodeName`	Nome do Código da Pasta de Trabalho do Projeto VBA
`date1904`	época: 0/falso para sistema 1900, 1/verdadeiro para 1904
`filterPrivacy`	Avisar ou remover informações de identificação pessoal ao salvar

Suporte a Formatos de Arquivo de Fórmulas (clique para mostrar)

Representação de Armazenamento	Formatos	Leitura	Escrita
Strings no estilo A1	XLSX	✔	✔
Strings no estilo RC	XLML e texto simples	✔	✔
Fórmulas analisadas BIFF	XLSB e todos os formatos XLS	✔
Fórmulas OpenFormula	ODS/FODS/UOS	✔	✔
Fórmulas analisadas Lotus	Todos os formatos Lotus WK_	✔

Como o Excel proíbe que células nomeadas colidam com nomes de referências de células no estilo A1 ou RC, uma conversão de regex (não tão simples) é possível. As fórmulas analisadas BIFF e as fórmulas analisadas Lotus precisam ser explicitamente desenroladas. As fórmulas OpenFormula podem ser convertidas com expressões regulares.

As fórmulas compartilhadas são descomprimidas e cada célula tem a fórmula correspondente à sua célula. Os escritores geralmente não tentam gerar fórmulas compartilhadas.

Utilitários como `aoa_to_sheet` aceitarão objetos de célula em vez de valores:```js
var worksheet = XLSX.utils.aoa_to_sheet([
  [ 1 ], // A1
  [ 2 ], // A2
  [ {t: "n", v: 3, f: "A1+A2"} ] // A3
]);

Se os resultados reais forem necessários em JS, o [SheetJS Pro](https://sheetjs.com/pro) oferece um componente de calculadora de fórmulas para avaliar expressões, atualizar valores e células dependentes e atualizar pastas de trabalho inteiras.

**Fórmulas de Matriz**

_Atribuir uma fórmula de matriz_```js
XLSX.utils.sheet_set_array_formula(worksheet, range, formula);

Para uma fórmula de matriz de várias células, cada célula tem o mesmo intervalo de matriz, mas apenas a primeira célula especifica a fórmula. Considere `D1:D3=A1:A3*B1:B3`:```js
// API function
XLSX.utils.sheet_set_array_formula(worksheet, "D1:D3", "A1:A3*B1:B3");

// ... OR raw operations
worksheet['D1'] = { t:'n', F:"D1:D3", f:"A1:A3*B1:B3" };
worksheet['D2'] = { t:'n', F:"D1:D3" };
worksheet['D3'] = { t:'n', F:"D1:D3" };

Lançadas em 2020, as Fórmulas de Matriz Dinâmica são suportadas nos formatos de arquivo XLSX/XLSM e XLSB. Elas são representadas como fórmulas de matriz normais, mas possuem metadados especiais de célula indicando que a fórmula deve poder ajustar o intervalo.

Uma fórmula de matriz pode ser marcada como dinâmica definindo a propriedade `D` da célula como true. O intervalo `F` é esperado, mas pode ser definido como a célula atual:```js
// API function
XLSX.utils.sheet_set_array_formula(worksheet, "C1", "_xlfn.UNIQUE(A1:A3)", 1);

// ... OR raw operations
worksheet['C1'] = { t: "s", f: "_xlfn.UNIQUE(A1:A3)", F:"C1", D: 1 }; // dynamic

When reading a file, the `xlfn` option preserves the prefixes.

<details>
  <summary><b> Funções que exigem o prefixo `_xlfn.`</b> (clique para mostrar)</summary>

Esta lista está a crescer a cada lançamento do Excel.```
ACOT
ACOTH
AGGREGATE
ARABIC
BASE
BETA.DIST
BETA.INV
BINOM.DIST
BINOM.DIST.RANGE
BINOM.INV
BITAND
BITLSHIFT
BITOR
BITRSHIFT
BITXOR
BYCOL
BYROW
CEILING.MATH
CEILING.PRECISE
CHISQ.DIST
CHISQ.DIST.RT
CHISQ.INV
CHISQ.INV.RT
CHISQ.TEST
COMBINA
CONFIDENCE.NORM
CONFIDENCE.T
COT
COTH
COVARIANCE.P
COVARIANCE.S
CSC
CSCH
DAYS
DECIMAL
ERF.PRECISE
ERFC.PRECISE
EXPON.DIST
F.DIST
F.DIST.RT
F.INV
F.INV.RT
F.TEST
FIELDVALUE
FILTERXML
FLOOR.MATH
FLOOR.PRECISE
FORMULATEXT
GAMMA
GAMMA.DIST
GAMMA.INV
GAMMALN.PRECISE
GAUSS
HYPGEOM.DIST
IFNA
IMCOSH
IMCOT
IMCSC
IMCSCH
IMSEC
IMSECH
IMSINH
IMTAN
ISFORMULA
ISOMITTED
ISOWEEKNUM
LAMBDA
LET
LOGNORM.DIST
LOGNORM.INV
MAKEARRAY
MAP
MODE.MULT
MODE.SNGL
MUNIT
NEGBINOM.DIST
NORM.DIST
NORM.INV
NORM.S.DIST
NORM.S.INV
NUMBERVALUE
PDURATION
PERCENTILE.EXC
PERCENTILE.INC
PERCENTRANK.EXC
PERCENTRANK.INC
PERMUTATIONA
PHI
POISSON.DIST
QUARTILE.EXC
QUARTILE.INC
QUERYSTRING
RANDARRAY
RANK.AVG
RANK.EQ
REDUCE
RRI
SCAN
SEC
SECH
SEQUENCE
SHEET
SHEETS
SKEW.P
SORTBY
STDEV.P
STDEV.S
T.DIST
T.DIST.2T
T.DIST.RT
T.INV
T.INV.2T
T.TEST
UNICHAR
UNICODE
UNIQUE
VAR.P
VAR.S
WEBSERVICE
WEIBULL.DIST
XLOOKUP
XOR
Z.TEST

chave	Recurso do Excel	padrão
`above`	Desmarcar "Linhas de resumo abaixo dos detalhes"	`false`
`left`	Desmarcar "Linhas de resumo à direita dos detalhes"	`false`

0	`General`
1	`0`
2	`0.00`
3	`#,##0`
4	`#,##0.00`
9	`0%`
10	`0.00%`
11	`0.00E+00`
12	`# ?/?`
13	`# ??/??`
14	`m/d/yy` (veja abaixo)
15	`d-mmm-yy`
16	`d-mmm`
17	`mmm-yy`
18	`h:mm AM/PM`
19	`h:mm:ss AM/PM`
20	`h:mm`
21	`h:mm:ss`
22	`m/d/yy h:mm`
37	`#,##0 ;(#,##0)`
38	`#,##0 ;[Red](#,##0)`
39	`#,##0.00;(#,##0.00)`
40	`#,##0.00;[Red](#,##0.00)`
45	`mm:ss`
46	`[h]:mm:ss`
47	`mmss.0`
48	`##0.0E+0`
49	`@`

XML	`<?xml` aparece nos primeiros 1024 caracteres
HTML	começa com `<` e tags HTML aparecem nos primeiros 1024 caracteres *
XML	começa com `<` e a primeira tag é válida
RTF	começa com `{\rt`
DSV	começa com `/sep=.$/`, o separador é o caractere especificado
DSV	mais caracteres `
DSV	mais caracteres `;` não citados do que `\t` ou `,` nos primeiros 1024
TSV	mais caracteres `\t` não citados do que `,` nos primeiros 1024
CSV	um dos primeiros 1024 caracteres é uma vírgula `","`
ETH	começa com `socialcalc:version:`
PRN	a opção `PRN` está definida como true
CSV	(fallback)

xlsx

Mais Populares

Índice

Primeiros Passos

Instalação

A Filosofia do SheetJS

Demonstrações do Ecossistema JS

Adquirindo e Extraindo Dados

Analisando Pastas de Trabalho

Processamento de Tabelas HTML

Propriedades de Linhas e Colunas

Formatos de Número

Hiperlinks

Comentários de Célula

Opções de Parsing

Tipo de Entrada

Adivinhando o Tipo de Arquivo

Entrada de Array de Arrays

Gerando dados JSON e JS

name

Gerando Snapshots de Uma Única Planilha

Objeto Cell

Tipos de Dados

Datas

Objeto Worksheet

Atributos no Nível da Pasta de Trabalho

Nomes Definidos

Visualizações da Pasta de Trabalho

Propriedades Diversas da Pasta de Trabalho

Recursos do Documento

Fórmulas

`dateNF`	FMT 14	Usar formato de data especificado na saída de string
`cellDates`	false	Armazenar datas como tipo `d` (padrão é `n`)
`sheetStubs`	false	Criar objetos de célula do tipo `z` para valores `null`
`nullError`	false	Se verdadeiro, emitir células de erro `#NULL!` para valores `null`