- Getting Started
* Installation
* Usage
* The Zen of SheetJS
* JS Ecosystem Demos
- Acquiring and Extracting Data
* Parsing Workbooks
* Processing JSON and JS Data
* Processing HTML Tables
- Processing Data
* Modifying Workbook Structure
* Modifying Cell Values
* Modifying Other Worksheet / Workbook / Cell Properties
- Packaging and Releasing Data
* Writing Workbooks
* Writing Examples
* Streaming Write
* Generating JSON and JS Data
* Generating HTML Tables
* Generating Single-Worksheet Snapshots
- Interface
* Parsing functions
* Writing functions
* Utilities
- Common Spreadsheet Format
* General Structures
* Cell Object
+ Data Types
+ Dates
* Sheet Objects
+ Worksheet Object
+ Chartsheet Object
+ Macrosheet Object
+ Dialogsheet Object
* Workbook Object
+ Workbook File Properties
* Workbook-Level Attributes
+ Defined Names
+ Workbook Views
+ Miscellaneous Workbook Properties
* Document Features
+ Formulae
+ Row and Column Properties
+ Number Formats
+ Hyperlinks
+ Cell Comments
+ Sheet Visibility
+ VBA and Macros
- Parsing Options
* Input Type
* Guessing File Type
- Writing Options
* Supported Output Formats
* Output Type
- Utility Functions
* Array of Arrays Input
* Array of Objects Input
* HTML Table Input
* Formulae Output
* Delimiter-Separated Output
+ UTF-16 Unicode Text
* HTML Output
* JSON
- File Formats
- Testing
* Node
* Browser
* Tested Environments
* Test Files
- Contributing
* OSX/Linux
* Windows
* Tests
- License
- References

| CDN | URL |
|-----------:|:-------------------------------------------|
| unpkg | |
| jsDelivr | |
| CDNjs | |

For example, unpkg makes the latest version available at:

`html

`

The complete single-file version is generated at dist/xlsx.full.min.js

dist/xlsx.core.min.js omits codepage library (no support for XLS encodings)

A slimmer build is generated at dist/xlsx.mini.min.js. Compared to full build:
- codepage library skipped (no support for XLS encodings)
- no support for XLSB / XLS / Lotus 1-2-3 / SpreadsheetML 2003 / Numbers
- node stream utils removed

For broad compatibility with JavaScript engines, the library is written using
ECMAScript 3 language dialect as well as some ES5 features like Array#forEach.
Older browsers require shims to provide missing functions.

To use the shim, add the shim before the script tag that loads xlsx.js:

`html




`

The script also includes IE_LoadFile and IE_SaveFile for loading and saving
files in Internet Explorer versions 6-9. The xlsx.extendscript.js script
bundles the shim in a format suitable for Photoshop and other Adobe products.

`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"
]
}
`

_Filtering for Presidents_

The dataset includes Aaron Burr, a Vice President who was never President!

Array#filter creates a new array with the desired rows. A President served
at least one term with type set to "prez". To test if a particular row has
at least one "prez" term, Array#some is another native JS function. The
complete filter would be:

`js
const prez = raw_data.filter(row => row.terms.some(term => term.type === "prez"));
`

_Lining up the data_

For this example, the name will be the first name combined with the last name
(row.name.first + " " + row.name.last) and the birthday will be the subfield
row.bio.birthday. Using Array#map, the dataset can be massaged in one call:

`js
const rows = prez.map(row => ({
name: row.name.first + " " + row.name.last,
birthday: row.bio.birthday
}));
`

The result is an array of "simple" objects with no nesting:

`js
[
{ name: "George Washington", birthday: "1732-02-22" },
{ name: "John Adams", birthday: "1735-10-19" },
// ... one row per President
]
`

Extract Data

With the cleaned dataset, XLSX.utils.json_to_sheet generates a worksheet:

`js
const worksheet = XLSX.utils.json_to_sheet(rows);
`

XLSX.utils.book_new creates a new workbook and XLSX.utils.book_append_sheet
appends a worksheet to the workbook. The new worksheet will be called "Dates":

`js
const workbook = XLSX.utils.book_new();
XLSX.utils.book_append_sheet(workbook, worksheet, "Dates");
`

Process Data

_Fixing headers_

By default, json_to_sheet creates a worksheet with a header row. In this case,
the headers come from the JS object keys: "name" and "birthday".

The headers are in cells A1 and B1. XLSX.utils.sheet_add_aoa can write text
values to the existing worksheet starting at cell A1:

`js
XLSX.utils.sheet_add_aoa(worksheet, [["Name", "Birthday"]], { origin: "A1" });
`

_Fixing Column Widths_

Some of the names are longer than the default column width. Column widths are
set by setting the "!cols" worksheet property.

The following line sets the width of column A to approximately 10 characters:

`js
worksheet["!cols"] = [ { wch: 10 } ]; // set column A width to 10 characters
`

One Array#reduce call over rows can calculate the maximum width:

`js
const max_width = rows.reduce((w, r) => Math.max(w, r.name.length), 10);
worksheet["!cols"] = [ { wch: max_width } ];
`

Note: If the starting point was a file or HTML table, XLSX.utils.sheet_to_json
will generate an array of JS objects.

Package and Release Data

XLSX.writeFile creates a spreadsheet file and tries to write it to the system.
In the browser, it will try to prompt the user to download the file. In NodeJS,
it will write to the local directory.

`js
XLSX.writeFile(workbook, "Presidents.xlsx");
`

Complete Example

`js
// Uncomment the next line for use in NodeJS:
// const XLSX = require("xlsx"), axios = require("axios");

(async() => {
/ fetch JSON data and parse /
const url = "https://theunitedstates.io/congress-legislators/executive.json";
const raw_data = (await axios(url, {responseType: "json"})).data;

/ filter for the Presidents /
const prez = raw_data.filter(row => row.terms.some(term => term.type === "prez"));

/ flatten objects /
const rows = prez.map(row => ({
name: row.name.first + " " + row.name.last,
birthday: row.bio.birthday
}));

/ generate worksheet and workbook /
const worksheet = XLSX.utils.json_to_sheet(rows);
const workbook = XLSX.utils.book_new();
XLSX.utils.book_append_sheet(workbook, worksheet, "Dates");

/ fix headers /
XLSX.utils.sheet_add_aoa(worksheet, [["Name", "Birthday"]], { origin: "A1" });

/ calculate column width /
const max_width = rows.reduce((w, r) => Math.max(w, r.name.length), 10);
worksheet["!cols"] = [ { wch: max_width } ];

/ create an XLSX file and try to save to Presidents.xlsx /
XLSX.writeFile(workbook, "Presidents.xlsx");
})();
`

For use in the web browser, assuming the snippet is saved to snippet.js,
script tags should be used to include the axios and xlsx standalone builds:

`html



`

readFile uses fs.readFileSync under the hood:

`js
var XLSX = require("xlsx");

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

For Node ESM, the readFile helper is not enabled. Instead, fs.readFileSync
should be used to read the file data as a Buffer for use with 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);
`

readFile uses Deno.readFileSync under the hood:

`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 has more examples

For modern websites targeting Chrome 76+, File#arrayBuffer is recommended:

`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);
`

For maximal compatibility, the FileReader API should be used:

`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);

/ DO SOMETHING WITH workbook HERE /
};
reader.readAsArrayBuffer(f);
}
drop_dom_element.addEventListener("drop", handleDrop, false);
`

demonstrates the FileReader technique.

Starting with an HTML INPUT element with type="file":

`html

`

For modern websites targeting Chrome 76+, Blob#arrayBuffer is recommended:

`js
// XLSX is a global from the standalone script

async function handleFileAsync(e) {
const file = e.target.files[0];
const data = await file.arrayBuffer();
/ data is an ArrayBuffer /
const workbook = XLSX.read(data);

/ DO SOMETHING WITH workbook HERE /
}
input_dom_element.addEventListener("change", handleFileAsync, false);
`

For broader support (including IE10+), the FileReader approach is recommended:

`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);
`

The oldie demo shows an IE-compatible fallback scenario.

For modern websites targeting Chrome 42+, fetch is recommended:

`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 /
})();
`

For broader support, the XMLHttpRequest approach is recommended:

`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();
`

The xhr demo includes a longer discussion and more examples.

shows fallback approaches for IE6+.

readFile wraps the File logic in Photoshop and other ExtendScript targets.
The specified path should be an absolute path:

`js
#include "xlsx.extendscript.js"

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

The extendscript demo includes a more complex example.

readFile can be used in the renderer process:

`js
/ From the renderer process /
var XLSX = require("xlsx");

var workbook = XLSX.readFile(path);
`

Electron APIs have changed over time. The electron demo
shows a complete example and details the required version-specific settings.

The react demo includes a sample React Native app.

Since React Native does not provide a way to read files from the filesystem, a
third-party library must be used. The following libraries have been tested:

- react-native-file-access

The base64 encoding returns strings compatible with the base64 type:

`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

The ascii encoding returns binary strings compatible with the binary type:

`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"});
`

read can accept a NodeJS buffer. readFile can read files generated by a
HTTP POST request body parser like 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);
`

The server demo has more advanced examples.

`js
const XLSX = require("xlsx");

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

For broader compatibility, third-party modules are recommended.

request requires a null encoding to yield Buffers:

`js
var XLSX = require("xlsx");
var request = require("request");

request({url: url, encoding: null}, function(err, resp, body) {
var workbook = XLSX.read(body);

/ DO SOMETHING WITH workbook HERE /
});
`

axios works the same way in browser and in 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 /
})();
`

The net module in the main process can make HTTP/HTTPS requests to external
resources. Responses should be manually concatenated using 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();
`

`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);
});
}
`

When dealing with ReadableStream, the easiest approach is to buffer the stream
and process the whole thing at the end:

`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);
`

The database demo includes examples of working with
databases and query results.

@tensorflow/tfjs and other libraries expect data in simple
arrays, well-suited for worksheets where each column is a data vector. That is
the transpose of how most people use spreadsheets, where each row is a vector.

When recovering data from tfjs, the returned data points are stored in a typed
array. An array of arrays can be constructed with loops. Array#unshift can
prepend a title row before the conversion:

`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);
`

The array demo shows a complete example.

`html






`

Multiple tables on a web page can be converted to individual worksheets:

`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 /
`

Alternatively, the HTML code can be extracted and parsed:

`js
var htmlstr = document.getElementById("tableau").outerHTML;
var workbook = XLSX.read(htmlstr, {type:"string"});
`

The chrome demo shows a complete example and details the
required permissions and other settings.

In an extension, it is recommended to generate the workbook in a content script
and pass the object back to the extension:

`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);
});
`

The headless demo includes a complete demo to convert HTML
files to XLSB workbooks. The core idea is to add the script to the page, parse
the table in the page context, generate a base64 workbook and send it back
for further processing:

`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);
});

/ cleanup /
await browser.close();
})();
`

The headless demo includes a complete demo to convert HTML
files to XLSB workbooks using PhantomJS. The core idea
is to add the script to the page, parse the table in the page context, generate
a binary workbook and send it back for further processing:

`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();
});
});
`

NodeJS does not include a DOM implementation and Puppeteer requires a hefty
Chromium build. jsdom is a lightweight alternative:

`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);
`

This example uses 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);
`

The special origin value -1 instructs sheet_add_aoa to start in column A of
the row after the last row in the range, appending the data:

`js
XLSX.utils.sheet_add_aoa(worksheet, [
["first row after data", 1],
["second row after data", 2]
], { origin: -1 });
`

writeFile uses fs.writeFileSync in server environments:

`js
var XLSX = require("xlsx");

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

For Node ESM, the writeFile helper is not enabled. Instead, fs.writeFileSync
should be used to write the file data to a Buffer for use with 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);
`

writeFile uses Deno.writeFileSync under the hood:

`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");
`

Applications writing files must be invoked with the --allow-write flag. The
deno demo has more examples

writeFile wraps the File logic in Photoshop and other ExtendScript targets.
The specified path should be an absolute path:

`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 /
`

The extendscript demo includes a more complex example.

XLSX.writeFile wraps a few techniques for triggering a file save:

- URL browser API creates an object URL for the file, which the library uses
by creating a link and forcing a click. It is supported in modern browsers.
- msSaveBlob is an IE10+ API for triggering a file save.
- IE_FileSave uses VBScript and ActiveX to write a file in IE6+ for Windows
XP and Windows 7. The shim must be included in the containing HTML page.

There is no standard way to determine if the actual file has been downloaded.

`js
/ output format determined by filename /
XLSX.writeFile(workbook, "out.xlsb");
/ at this point, out.xlsb will have been downloaded /
`

XLSX.writeFile techniques work for most modern browsers as well as older IE.
For much older browsers, there are workarounds implemented by wrapper libraries.

FileSaver.js implements saveAs.
Note: XLSX.writeFile will automatically call saveAs if available.

`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 uses a Flash SWF button
to generate local files, suitable for environments where ActiveX is unavailable:

`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"
});
`

The oldie demo shows an IE-compatible fallback scenario.

`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);
`

The headless demo includes a complete demo to convert HTML
files to XLSB workbooks using PhantomJS. PhantomJS
fs.write supports writing files from the main process but has a different
interface from the NodeJS fs module:

`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: The section "Processing HTML Tables" shows how
to generate a workbook from HTML tables in a page in "Headless WebKit".

`js
var output_file_name = "out.csv";
var stream = XLSX.stream.to_csv(worksheet);
stream.pipe(fs.createWriteStream(output_file_name));
`

`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);
`

The NUMBERS writer requires a fairly large base. The supplementary xlsx.zahl
scripts provide support. xlsx.zahl.js is designed for standalone and NodeJS
use, while xlsx.zahl.mjs is suitable for ESM.

_Browser_

`html




`

_Node_

`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});
`

react-data-grid is a data grid tailored for
react. It expects two properties: rows of data objects and columns which
describe the columns. For the purposes of massaging the data to fit the react
data grid API it is easiest to start from an array of arrays.

This demo starts by fetching a remote file and using XLSX.read to extract:

`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 ;
}
`

vue3-table-lite is a simple
VueJS 3 data table. It is featured in the VueJS demo.

The database demo includes examples of working with
databases and query results.

@tensorflow/tfjs and other libraries expect data in simple
arrays, well-suited for worksheets where each column is a data vector. That is
the transpose of how most people use spreadsheets, where each row is a vector.

A single Array#map can pull individual named rows from sheet_to_json export:

`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);
`

All fields can be processed at once using a transpose of the 2D tensor generated
with the sheet_to_json export with header: 1. The first row, if it contains
header labels, should be removed with a 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();
`

The array demo shows a complete example.

`html




It is generally recommended to use a React-friendly workflow, but it is possible
to generate HTML and use it in React with 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

It is generally recommended to use a VueJS-friendly workflow, but it is possible
to generate HTML and use it in VueJS with the v-html directive:

`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:

The vuejs demo includes more React examples.