Das Ziel ist es, eine XLSB-Arbeitsmappe mit den Namen und Geburtstagen der US-Präsidenten zu erzeugen.

Daten beschaffen

Rohdaten

https://theunitedstates.io/congress-legislators/executive.json enthält die gewünschten Daten. Zum Beispiel 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" ] }

_Filtern nach Präsidenten_

Der Datensatz enthält Aaron Burr, einen Vizepräsidenten, der nie Präsident war!

`Array#filter` erstellt ein neues Array mit den gewünschten Zeilen.  Ein Präsident amtierte
mindestens eine Amtszeit mit `type` gesetzt auf `"prez"`.  Um zu testen, ob eine bestimmte Zeile
mindestens eine `"prez"`-Amtszeit enthält, ist `Array#some` eine weitere native JS-Funktion.  Der
vollständige Filter wäre:```js
const prez = raw_data.filter(row => row.terms.some(term => term.type === "prez"));

Daten ausrichten

Für dieses Beispiel wird der Name aus Vorname und Nachname zusammengesetzt (row.name.first + " " + row.name.last) und das Geburtsdatum ist das Unterfeld row.bio.birthday. Mit Array#map kann der Datensatz in einem einzigen Aufruf umgeformt werden:```js const rows = prez.map(row => ({ name: row.name.first + " " + row.name.last, birthday: row.bio.birthday }));

Das Ergebnis ist ein Array aus "einfachen" Objekten ohne Verschachtelung:```js
[
  { name: "George Washington", birthday: "1732-02-22" },
  { name: "John Adams", birthday: "1735-10-19" },
  // ... one row per President
]

Daten extrahieren

Mit dem bereinigten Datensatz erzeugt XLSX.utils.json_to_sheet ein Arbeitsblatt:```js const worksheet = XLSX.utils.json_to_sheet(rows);

`XLSX.utils.book_new` erstellt eine neue Arbeitsmappe und `XLSX.utils.book_append_sheet` fügt ein Arbeitsblatt zur Arbeitsmappe hinzu. Das neue Arbeitsblatt wird "Dates" genannt:```js
const workbook = XLSX.utils.book_new();
XLSX.utils.book_append_sheet(workbook, worksheet, "Dates");

Daten verarbeiten

Kopfzeilen korrigieren

Standardmäßig erstellt json_to_sheet ein Arbeitsblatt mit einer Kopfzeile. In diesem Fall, stammen die Kopfzeilen aus den JavaScript-Objekt-Schlüsseln: "name" und "birthday".

Die Kopfzeilen befinden sich in den Zellen A1 und B1. XLSX.utils.sheet_add_aoa kann Textwerte in das vorhandene Arbeitsblatt ab Zelle A1 schreiben:```js XLSX.utils.sheet_add_aoa(worksheet, [["Name", "Birthday"]], { origin: "A1" });

_Fixing Column Widths_

Einige der Namen sind länger als die Standardspaltenbreite.  Spaltenbreiten werden
durch [Festlegen der `"!cols"`-Arbeitsblatteigenschaft](#row-and-column-properties) gesetzt.

Die folgende Zeile setzt die Breite von Spalte A auf ungefähr 10 Zeichen:```js
worksheet["!cols"] = [ { wch: 10 } ]; // set column A width to 10 characters

Ein Array#reduce-Aufruf über rows kann die maximale Breite berechnen:```js const max_width = rows.reduce((w, r) => Math.max(w, r.name.length), 10); worksheet["!cols"] = [ { wch: max_width } ];

Hinweis: Wenn der Ausgangspunkt eine Datei oder eine HTML-Tabelle war, erzeugt `XLSX.utils.sheet_to_json` ein Array von JavaScript-Objekten.

**Paket- und Versionsdaten**

`XLSX.writeFile` erstellt eine Tabellenkalkulationsdatei und versucht, sie auf dem System zu speichern. Im Browser wird versucht, den Benutzer zum Herunterladen der Datei aufzufordern.  In NodeJS wird in das lokale Verzeichnis geschrieben.```js
XLSX.writeFile(workbook, "Presidents.xlsx");

Vollständiges Beispiel```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"); })();

Für die Verwendung im Webbrowser, vorausgesetzt das Snippet ist in `snippet.js` gespeichert,
sollten `script`-Tags verwendet werden, um die eigenständigen Builds von `axios` und `xlsx` einzubinden:```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>

readFile verwendet im Hintergrund fs.readFileSync:```js var XLSX = require("xlsx");

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

Für Node ESM ist der `readFile`-Helfer nicht aktiviert. Stattdessen sollte `fs.readFileSync`
verwendet werden, um die Dateidaten als `Buffer` für die Verwendung mit `XLSX.read` zu lesen:```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 verwendet intern Deno.readFileSync:```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");

Anwendungen, die Dateien lesen, müssen mit dem Flag `--allow-read` aufgerufen werden.  Das
[`deno` Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/deno/) enthält weitere Beispiele

</details>

<details>
  <summary><b>Vom Benutzer übermittelte Datei in einer Webseite („Drag-and-Drop")</b> (zum Anzeigen klicken)</summary>

Für moderne Websites, die auf Chrome 76+ abzielen, wird `File#arrayBuffer` empfohlen:```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);

Für maximale Kompatibilität sollte die FileReader-API verwendet werden:```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);

<https://oss.sheetjs.com/sheetjs/> demonstriert die FileReader-Technik.

</details>

<details>
  <summary><b>Vom Benutzer übermittelte Datei mit einem HTML-INPUT-Element</b> (zum Anzeigen klicken)</summary>

Beginnend mit einem HTML-INPUT-Element mit `type="file"`:```html
<input type="file" id="input_dom_element">

Für moderne Websites, die Chrome 76+ anvisieren, wird Blob#arrayBuffer empfohlen:```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);

Für eine breitere Unterstützung (einschließlich IE10+) wird der `FileReader`-Ansatz empfohlen:```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);

Die oldie Demo zeigt ein IE-kompatibles Fallback-Szenario.

Für moderne Websites, die auf Chrome 42+ abzielen, wird fetch empfohlen:```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 */ })();

Für eine breitere Unterstützung wird der `XMLHttpRequest`-Ansatz empfohlen:```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();

Die xhr-Demo enthält eine längere Diskussion und weitere Beispiele.

http://oss.sheetjs.com/sheetjs/ajax.html zeigt Fallback-Ansätze für IE6+.

readFile kapselt die File-Logik in Photoshop und anderen ExtendScript-Zielen. Der angegebene Pfad sollte ein absoluter Pfad sein:```js #include "xlsx.extendscript.js"

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

Das [`extendscript`-Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/extendscript/) enthält ein komplexeres Beispiel.

</details>

<details>
  <summary><b>Lokale Datei in einer Electron-App</b> (zum Anzeigen klicken)</summary>

`readFile` kann im Renderer-Prozess verwendet werden:```js
/* From the renderer process */
var XLSX = require("xlsx");

var workbook = XLSX.readFile(path);

Die Electron-APIs haben sich im Laufe der Zeit geändert. Die electron-Demo zeigt ein vollständiges Beispiel und beschreibt die erforderlichen versionsspezifischen Einstellungen.

Die react-Demo enthält eine Beispiel-App für React Native.

Da React Native keine Möglichkeit bietet, Dateien aus dem Dateisystem zu lesen, muss eine Drittanbieter-Bibliothek verwendet werden. Die folgenden Bibliotheken wurden getestet:

• react-native-file-access

Die base64-Kodierung gibt Zeichenketten zurück, die mit dem Typ base64 kompatibel sind:```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)

Die `ascii`-Kodierung gibt Binärstrings zurück, die mit dem Typ `binary` kompatibel sind:```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 kann einen NodeJS-Puffer akzeptieren. readFile kann Dateien lesen, die von einem Body-Parser für HTTP-POST-Anfragen wie formidable erzeugt wurden:```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);

Die [`server`-Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/server) enthält fortgeschrittenere Beispiele.

</details>

<details>
  <summary><b>Dateien in einem NodeJS-Prozess herunterladen</b> (klicken zum Anzeigen)</summary>

Node 17.5 und 18.0 haben native Unterstützung für fetch:```js
const XLSX = require("xlsx");

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

Für eine breitere Kompatibilität werden Module von Drittanbietern empfohlen.

request erfordert eine null-Kodierung, um Buffers zu erzeugen:```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`](https://npm.im/axios) funktioniert im Browser und in NodeJS auf die gleiche Weise:```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 */
})();

Das net-Modul im Hauptprozess kann HTTP/HTTPS-Anfragen an externe Ressourcen senden. Antworten sollten manuell mit Buffer.concat verkettet werden:```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>Readable Streams in NodeJS</b> (klicken zum Anzeigen)</summary>

Bei der Arbeit mit Readable Streams ist der einfachste Ansatz, den Stream zu puffern
und das Ganze am Ende zu verarbeiten:```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);
  });
}

Beim Umgang mit ReadableStream ist es am einfachsten, den Stream zu puffern und das Ganze am Ende zu verarbeiten:```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>

Ausführlichere Beispiele werden in den [enthaltenen Demos](https://github.com/weareu/xlsx/blob/HEAD/demos/) behandelt.

### Verarbeiten von JSON- und JS-Daten

JSON- und JS-Daten stellen in der Regel einzelne Arbeitsblätter dar. In diesem Abschnitt werden einige Hilfsfunktionen verwendet, um Arbeitsmappen zu erzeugen.

_Neue Arbeitsmappe erstellen_```js
var workbook = XLSX.utils.book_new();

Die book_new-Hilfsfunktion erstellt eine leere Arbeitsmappe ohne Arbeitsblätter.

Tabellenkalkulationssoftware erfordert in der Regel mindestens ein Arbeitsblatt und setzt diese Anforderung in der Benutzeroberfläche durch. Diese Bibliothek setzt die Anforderung beim Schreiben durch und wirft Fehler, wenn eine leere Arbeitsmappe an Schreibfunktionen übergeben wird.

API

Erstellen Sie ein Arbeitsblatt aus einem Array von Arrays von JS-Werten```js var worksheet = XLSX.utils.aoa_to_sheet(aoa, opts);

Die Hilfsfunktion `aoa_to_sheet` durchläuft ein „Array von Arrays“ in zeilenweiser
Reihenfolge und erzeugt ein Arbeitsblatt-Objekt.  Das folgende Snippet erzeugt ein Blatt,
wobei Zelle `A1` auf den String `A1`, Zelle `B1` auf `B1` usw. gesetzt wird:```js
var worksheet = XLSX.utils.aoa_to_sheet([
  ["A1", "B1", "C1"],
  ["A2", "B2", "C2"],
  ["A3", "B3", "C3"]
]);

"Array-von-Arrays-Eingabe" beschreibt die Funktion und das optionale opts-Argument ausführlicher.

Erstellen Sie ein Arbeitsblatt aus einem Array von JS-Objekten```js var worksheet = XLSX.utils.json_to_sheet(jsa, opts);

Die Hilfsfunktion `json_to_sheet` durchläuft ein Array von JS-Objekten in der
Reihenfolge und erzeugt ein Arbeitsblattobjekt. Standardmäßig wird eine Kopfzeile
und eine Zeile pro Objekt im Array erzeugt. Das optionale `opts`-Argument enthält
Einstellungen zur Steuerung der Spaltenreihenfolge und der Kopfzeilenausgabe.

["Array von Objekten als Eingabe"](#array-of-arrays-input) beschreibt die Funktion
und das optionale `opts`-Argument ausführlicher.

**Beispiele**

["Das Zen von SheetJS"](#the-zen-of-sheetjs) enthält ein ausführliches Beispiel: "Daten
von einem JSON-Endpunkt abrufen und eine Arbeitsmappe erzeugen"

[`x-spreadsheet`](https://github.com/myliang/x-spreadsheet) ist ein interaktives
Datenraster zum Vorschauen und Bearbeiten strukturierter Daten im Webbrowser. Die
[`xspreadsheet`-Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/xspreadsheet) enthält ein Beispielskript mit der
`xtos`-Funktion zum Konvertieren von einem x-spreadsheet-Datenobjekt in eine Arbeitsmappe.
<https://oss.sheetjs.com/sheetjs/x-spreadsheet> ist eine Live-Demo.

<details>
  <summary><b>Datensätze aus einer Datenbankabfrage (SQL oder No-SQL)</b> (klicken zum Anzeigen)</summary>

Die [`database`-Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/database/) enthält Beispiele für die Arbeit mit
Datenbanken und Abfrageergebnissen.

</details>


<details>
  <summary><b>Numerische Berechnungen mit TensorFlow.js</b> (klicken zum Anzeigen)</summary>

[`@tensorflow/tfjs`](https://github.com/weareu/xlsx/blob/HEAD/@tensorflow/tfjs) und andere Bibliotheken erwarten Daten in einfachen
Arrays – gut geeignet für Arbeitsblätter, bei denen jede Spalte einen Datenvektor darstellt. Das ist
die Transponierte der üblichen Verwendung von Tabellenkalkulationen, bei der jede Zeile ein Vektor ist.

Beim Abrufen von Daten aus `tfjs` werden die zurückgegebenen Datenpunkte in einem typisierten
Array gespeichert. Ein Array aus Arrays kann mit Schleifen erstellt werden. Mit `Array#unshift` kann
vor der Konvertierung eine Titelzeile vorangestellt werden:```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);

Das array Demo zeigt ein vollständiges Beispiel.

Mehrere Tabellen auf einer Webseite können in einzelne Arbeitsblätter konvertiert werden:```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 */

Alternativ kann der HTML-Code extrahiert und geparst werden:```js var htmlstr = document.getElementById("tableau").outerHTML; var workbook = XLSX.read(htmlstr, {type:"string"});

</details>

<details>
  <summary><b>Chrome/Chromium-Erweiterung</b> (klicken, um anzuzeigen)</summary>

Die [`chrome`-Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/chrome/) zeigt ein vollständiges Beispiel und erläutert
die erforderlichen Berechtigungen und weitere Einstellungen.

In einer Erweiterung wird empfohlen, die Arbeitsmappe in einem Content-Skript zu erstellen
und das Objekt an die Erweiterung zurückzugeben:```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);
});

Die headless Demo enthält eine vollständige Demo zum Konvertieren von HTML Dateien in XLSB-Arbeitsmappen. Die Kernidee besteht darin, das Skript zur Seite hinzuzufügen, die Tabelle im Seitenkontext zu parsen, eine base64-Arbeitsmappe zu generieren und sie zur weiteren Verarbeitung zurückzusenden:```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(); })();

</details>

<details>
  <summary><b>Serverseitige HTML-Tabellen mit Headless WebKit</b> (click to show)</summary>

Die [`headless` Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/headless/) enthält eine vollständige Demo zum Konvertieren von HTML-Dateien in XLSB-Arbeitsmappen mithilfe von [PhantomJS](https://phantomjs.org/). Die Kernidee besteht darin, das Skript zur Seite hinzuzufügen, die Tabelle im Seitenkontext zu parsen, eine `binary`-Arbeitsmappe zu erzeugen und sie zur weiteren Verarbeitung zurückzusenden:```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 enthält keine DOM-Implementierung und Puppeteer erfordert einen umfangreichen Chromium-Build. jsdom ist eine leichtgewichtige 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);

</details>

## Datenverarbeitung

Das ["Common Spreadsheet Format"](#common-spreadsheet-format) ist eine einfache Objektdarstellung
der Kernkonzepte einer Arbeitsmappe.  Die Hilfsfunktionen arbeiten
mit der Objektdarstellung und sind dafür gedacht, häufige Anwendungsfälle abzudecken.

### Ändern der Arbeitsmappenstruktur

**API**

_Ein Arbeitsblatt an eine Arbeitsmappe anhängen_```js
XLSX.utils.book_append_sheet(workbook, worksheet, sheet_name);

Die Hilfsfunktion book_append_sheet fügt einer Arbeitsmappe ein Arbeitsblatt hinzu. Das dritte Argument gibt den gewünschten Namen des Arbeitsblatts an. Durch mehrmaliges Aufrufen der Funktion können einer Arbeitsmappe mehrere Arbeitsblätter hinzugefügt werden. Wenn der Name des Arbeitsblatts in der Arbeitsmappe bereits verwendet wird, wird ein Fehler ausgelöst.

Ein Arbeitsblatt an eine Arbeitsmappe anhängen und einen eindeutigen Namen finden```js var new_name = XLSX.utils.book_append_sheet(workbook, worksheet, name, true);

Wenn das vierte Argument `true` ist, beginnt die Funktion mit dem angegebenen Arbeitsblattnamen. Wenn der Blattname in der Arbeitsmappe vorhanden ist, wird ein neuer Arbeitsblattname gewählt, indem der Namensstamm ermittelt und der Zähler erhöht wird:```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

Liste der Arbeitsblattnamen in Tab-Reihenfolge```js var wsnames = workbook.SheetNames;

Die `SheetNames`-Eigenschaft des Workbook-Objekts ist eine Liste der Arbeitsblattnamen
in „Tab-Reihenfolge".  API-Funktionen werden sich dieses Array ansehen.

_Ein Arbeitsblatt direkt ersetzen_```js
workbook.Sheets[sheet_name] = new_worksheet;

Die Sheets-Eigenschaft des Workbook-Objekts ist ein Objekt, dessen Schlüssel Namen sind und dessen Werte Worksheet-Objekte sind. Durch Neuzuweisung an eine Eigenschaft des Sheets-Objekts kann das Worksheet-Objekt geändert werden, ohne die übrige Worksheet-Struktur zu stören.

Beispiele

</details>

### Ändern von Zellwerten

**API**

_Einen einzelnen Zellwert in einem Arbeitsblatt ändern_```js
XLSX.utils.sheet_add_aoa(worksheet, [[new_value]], { origin: address });

Die Hilfsfunktion `sheet_add_aoa` ändert Zellwerte in einem Arbeitsblatt.  Das
erste Argument ist das Arbeitsblattobjekt.  Das zweite Argument ist ein Array von
Arrays von Werten.  Der `origin`-Schlüssel des dritten Arguments steuert, wohin Zellen
geschrieben werden.  Das folgende Snippet setzt `B3=1` und `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" });

Parsing-Optionen

Die exportierten Funktionen read und readFile akzeptieren ein Optionsargument:

• Auch wenn cellNF false ist, wird formatierter Text erzeugt und in .w gespeichert.
• In manchen Fällen werden Sheets auch dann geparst, wenn bookSheets false ist.
• Excel versucht aggressiv, Werte aus CSV und anderem Klartext zu interpretieren. Das führt zu überraschendem Verhalten! Die Option raw unterdrückt die Wertanalyse.
• bookSheets und bookProps kombiniert ergeben beide Informationsmengen.
• Deps ist ein leeres Objekt, wenn bookDeps false ist.
• Das Verhalten von bookFiles hängt vom Dateityp ab:
  • keys-Array (Pfade im ZIP) für ZIP-basierte Formate
  • files-Hash (Zuordnung von Pfaden zu Objekten, die die Dateien repräsentieren) für ZIP
  • cfb-Objekt für Formate, die CFB-Container verwenden

Eingabetyp

Zeichenfolgen können auf verschiedene Weise interpretiert werden. Der Parameter type für read teilt der Bibliothek mit, wie das Datenargument zu parsen ist:

Dateityp erraten

</details>

## Schreiboptionen

Die exportierten Funktionen `write` und `writeFile` akzeptieren ein Optionsargument:

| Option Name |  Standard | Beschreibung                                         |
| :---------- | -------: | :-------------------------------------------------- |
|`type`       |          | Ausgabe-Datenkodierung (siehe Ausgabetyp unten)      |
|`cellDates`  |  `false` | Datumsangaben als Typ `d` speichern (Standard ist `n`) |
|`bookSST`    |  `false` | Shared String Table erzeugen **                      |
|`bookType`   | `"xlsx"` | Typ der Arbeitsmappe (siehe unten für unterstützte Formate) |
|`sheet`      |     `""` | Name des Arbeitsblatts für Formate mit einem einzelnen Blatt ** |
|`compression`|  `false` | ZIP-Komprimierung für ZIP-basierte Formate verwenden ** |
|`Props`      |          | Arbeitsmappen-Eigenschaften beim Schreiben überschreiben ** |
|`themeXLSX`  |          | Theme-XML beim Schreiben von XLSX/XLSB/XLSM überschreiben ** |
|`ignoreEC`   |   `true` | „Zahl als Text“-Fehler unterdrücken **               |
|`numbers`    |          | Nutzdaten für NUMBERS-Export **                      |

- `bookSST` ist langsamer und speicherintensiver, bietet aber eine bessere Kompatibilität mit älteren Versionen von iOS Numbers.
- Die Rohdaten sind das Einzige, dessen Speicherung garantiert ist. Funktionen, die in dieser README nicht beschrieben sind, werden möglicherweise nicht serialisiert.
- `cellDates` gilt nur für die XLSX-Ausgabe und funktioniert nicht garantiert mit Drittanbieter-Readern. Excel selbst schreibt normalerweise keine Zellen vom Typ `d`, daher ignorieren Nicht-Excel-Tools die Daten möglicherweise oder melden bei Datumsangaben einen Fehler.
- `Props` ist ein Objekt, das das `Props`-Feld der Arbeitsmappe abbildet. Siehe die Tabelle im Abschnitt [Workbook File Properties](#workbook-file-properties).
- Falls angegeben, wird die Zeichenkette aus `themeXLSX` als primäres Theme für XLSX/XLSB/XLSM-Dateien gespeichert (in `xl/theme/theme1.xml` in der ZIP).
- Aufgrund eines Fehlers im Programm können einige Funktionen wie „Text in Spalten“ Excel auf Arbeitsblättern zum Absturz bringen, auf denen Fehlerbedingungen ignoriert werden. Der Writer markiert Dateien standardmäßig so, dass der Fehler ignoriert wird. Setzen Sie `ignoreEC` auf `false`, um dies zu unterdrücken.
- Aufgrund der Datengröße sind die NUMBERS-Daten standardmäßig nicht enthalten. Die enthaltenen Skripte `xlsx.zahl.js` und `xlsx.zahl.mjs` enthalten die Daten.

### Unterstützte Ausgabeformate

Für eine breite Kompatibilität mit Drittanbieter-Tools unterstützt diese Bibliothek viele Ausgabeformate. Der konkrete Dateityp wird über die Option `bookType` gesteuert:

| `bookType` | Dateiendung | Container | Blätter | Beschreibung                     |
| :--------- | -------: | :-------: | :----- |:------------------------------- |
| `xlsx`     | `.xlsx`  |    ZIP    | mehrere | Excel 2007+ XML-Format          |
| `xlsm`     | `.xlsm`  |    ZIP    | mehrere | Excel 2007+ Makro-XML-Format    |
| `xlsb`     | `.xlsb`  |    ZIP    | mehrere | Excel 2007+ Binärformat         |
| `biff8`    | `.xls`   |    CFB    | mehrere | Excel 97-2004-Arbeitsmappenformat |
| `biff5`    | `.xls`   |    CFB    | mehrere | Excel 5.0/95-Arbeitsmappenformat |
| `biff4`    | `.xls`   |   none    | einzeln | Excel 4.0-Arbeitsblattformat    |
| `biff3`    | `.xls`   |   none    | einzeln | Excel 3.0-Arbeitsblattformat    |
| `biff2`    | `.xls`   |   none    | einzeln | Excel 2.0-Arbeitsblattformat    |
| `xlml`     | `.xls`   |   none    | mehrere | Excel 2003-2004 (SpreadsheetML) |
| `numbers`  |`.numbers`|    ZIP    | einzeln | Numbers 3.0+ Tabellenkalkulation |
| `ods`      | `.ods`   |    ZIP    | mehrere | OpenDocument-Tabellenkalkulation |
| `fods`     | `.fods`  |   none    | mehrere | Flat OpenDocument Spreadsheet   |
| `wk3`      | `.wk3`   |   none    | mehrere | Lotus-Arbeitsmappe (WK3)        |
| `csv`      | `.csv`   |   none    | einzeln | Kommagetrennte Werte            |
| `txt`      | `.txt`   |   none    | einzeln | UTF-16-Unicode-Text (TXT)       |
| `sylk`     | `.sylk`  |   none    | einzeln | Symbolic Link (SYLK)            |
| `html`     | `.html`  |   none    | einzeln | HTML-Dokument                   |
| `dif`      | `.dif`   |   none    | einzeln | Datenaustauschformat (DIF)      |
| `dbf`      | `.dbf`   |   none    | einzeln | dBASE II + VFP-Erweiterungen (DBF) |
| `wk1`      | `.wk1`   |   none    | einzeln | Lotus-Arbeitsblatt (WK1)        |
| `rtf`      | `.rtf`   |   none    | einzeln | Rich Text Format (RTF)          |
| `prn`      | `.prn`   |   none    | einzeln | Lotus-formatierter Text         |
| `eth`      | `.eth`   |   none    | einzeln | Ethercalc-Datensatzformat (ETH) |

- `compression` gilt nur für Formate mit ZIP-Containern.
- Formate, die nur ein einzelnes Blatt unterstützen, erfordern eine `sheet`-Option, die das Arbeitsblatt angibt. Wenn die Zeichenkette leer ist, wird das erste Arbeitsblatt verwendet.
- `writeFile` errät das Ausgabedateiformat automatisch anhand der Dateiendung, wenn `bookType` nicht angegeben ist. Es wählt das erste Format in der obigen Tabelle, das mit der Endung übereinstimmt.

### Ausgabetyp

Das `type`-Argument für `write` entspricht dem `type`-Argument für `read`:

| `type`     | Ausgabe                                                          |
|------------|-----------------------------------------------------------------|
| `"base64"` | Zeichenkette: Base64-Kodierung der Datei                        |
| `"binary"` | Zeichenkette: Binärzeichenkette (Byte `n` ist `data.charCodeAt(n)`) |
| `"string"` | Zeichenkette: JS-Zeichenkette (Zeichen werden als UTF8 interpretiert) |
| `"buffer"` | nodejs Buffer                                                  |
| `"array"`  | ArrayBuffer, Fallback-Array aus vorzeichenlosen 8-Bit-Ganzzahlen |
| `"file"`   | Zeichenkette: Pfad der Datei, die erstellt wird (nur nodejs)    |

- Aus Kompatibilitätsgründen mit Excel enthält die `csv`-Ausgabe immer das UTF-8-Byte-Order-Mark.

## Hilfsfunktionen

---

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

Der spezielle Ursprungswert -1 weist sheet_add_aoa an, in Spalte A der Zeile nach der letzten Zeile im Bereich zu beginnen und die Daten anzuhängen:```js XLSX.utils.sheet_add_aoa(worksheet, [ ["first row after data", 1], ["second row after data", 2] ], { origin: -1 });

</details>


### Ändern weiterer Arbeitsblatt- / Arbeitsmappen- / Zelleigenschaften

Der Abschnitt ["Common Spreadsheet Format"](#common-spreadsheet-format) beschreibt
die Objektstrukturen ausführlicher.

## Verpacken und Veröffentlichen von Daten

### Arbeitsmappen schreiben

**API**

_Tabellenkalkulationsbytes (Datei) aus Daten erzeugen_```js
var data = XLSX.write(workbook, opts);

Die write-Methode versucht, Daten aus der Arbeitsmappe in eine Datei im Speicher zu verpacken. Standardmäßig werden XLSX-Dateien erzeugt, dies kann jedoch über die Eigenschaft bookType des Arguments opts gesteuert werden. Abhängig von der Option type können die Daten als "Binärstring", JS-String, Uint8Array oder Buffer gespeichert werden.

Das zweite Argument opts ist erforderlich. "Schreiboptionen" behandelt die unterstützten Eigenschaften und Verhaltensweisen.

Datei erzeugen und versuchen zu speichern```js XLSX.writeFile(workbook, filename, opts);

Die `writeFile`-Methode verpackt die Daten und versucht, die neue Datei zu speichern. Das Exportdateiformat wird durch die Erweiterung von `filename` bestimmt (`SheetJS.xlsx` signalisiert XLSX-Export, `SheetJS.xlsb` signalisiert XLSB-Export usw.).

Die `writeFile`-Methode verwendet plattformspezifische APIs, um das Speichern der Datei auszulösen. In NodeJS kann `fs.readFileSync` eine Datei erstellen. Im Webbrowser wird ein Download mithilfe des HTML5-`download`-Attributs versucht, mit Fallbacks für IE.

_Eine XLSX-Datei erzeugen und versuchen, sie zu speichern_```js
XLSX.writeFileXLSX(workbook, filename, opts);

Die Methode writeFile bündelt eine Reihe verschiedener Exportfunktionen. Das ist gut für die Entwicklererfahrung, aber nicht geeignet für Tree Shaking mit den aktuellen Entwicklungswerkzeugen. Wenn nur XLSX-Exporte benötigt werden, vermeidet diese Methode das Referenzieren der anderen Exportfunktionen.

Das zweite opts-Argument ist optional. "Schreiboptionen" behandelt die unterstützten Eigenschaften und Verhaltensweisen.

Beispiele

Für Node ESM ist der `writeFile`-Helfer nicht aktiviert. Stattdessen sollte `fs.writeFileSync` verwendet werden, um die Dateidaten in einen `Buffer` zu schreiben, der mit `XLSX.write` verwendet wird:```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);

Anwendungen, die Dateien schreiben, müssen mit dem `--allow-write`-Flag aufgerufen werden.  Das
[`deno`-Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/deno/) enthält weitere Beispiele

</details>

<details>
  <summary><b>Lokale Datei in einem PhotoShop- oder InDesign-Plugin</b> (zum Anzeigen klicken)</summary>

`writeFile` kapselt die `File`-Logik in Photoshop und anderen ExtendScript-Zielumgebungen.
Der angegebene Pfad sollte ein absoluter Pfad sein:```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 */

</details>

<details>
  <summary><b>Eine Datei in älteren Browsern herunterladen</b> (klicken zum Anzeigen)</summary>

`XLSX.writeFile`-Techniken funktionieren in den meisten modernen Browsern sowie in älteren IE-Versionen.
Für wesentlich ältere Browser gibt es Workarounds, die von Wrapper-Bibliotheken implementiert werden.

[`FileSaver.js`](https://github.com/eligrey/FileSaver.js/) implementiert `saveAs`.
Hinweis: `XLSX.writeFile` ruft `saveAs` automatisch auf, sofern verfügbar.```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");

Hinweis: Der Abschnitt ["Processing HTML Tables"](#processing-html-tables) zeigt, wie
eine Arbeitsmappe aus HTML-Tabellen auf einer Seite in "Headless WebKit" erzeugt wird.

</details>



Die [enthaltenen Demos](https://github.com/weareu/xlsx/blob/HEAD/demos/) decken mobile Apps und andere spezielle Bereitstellungen ab.

### Schreibbeispiele

- <http://sheetjs.com/demos/table.html> exportiert eine HTML-Tabelle
- <http://sheetjs.com/demos/writexlsx.html> erzeugt eine einfache Datei

### Streaming-Schreiben

Die Streaming-Schreibfunktionen sind im Objekt `XLSX.stream` verfügbar.  Sie
übernehmen dieselben Argumente wie die normalen Schreibfunktionen, geben aber einen NodeJS Readable Stream zurück.

- `XLSX.stream.to_csv` ist die Streaming-Version von `XLSX.utils.sheet_to_csv`.
- `XLSX.stream.to_html` ist die Streaming-Version von `XLSX.utils.sheet_to_html`.
- `XLSX.stream.to_json` ist die Streaming-Version von `XLSX.utils.sheet_to_json`.

<details>
  <summary><b>nodejs in CSV konvertieren und Datei schreiben</b> (klicken zum Anzeigen)</summary>```js
var output_file_name = "out.csv";
var stream = XLSX.stream.to_csv(worksheet);
stream.pipe(fs.createWriteStream(output_file_name));

</details>

<details>
  <summary><b>Exportieren von NUMBERS-Dateien</b> (klicken zum Anzeigen)</summary>

Der NUMBERS-Writer benötigt eine ziemlich große Basis. Die ergänzenden Skripte `xlsx.zahl`
bieten Unterstützung. `xlsx.zahl.js` ist für den eigenständigen Einsatz und die Nutzung mit NodeJS
konzipiert, während `xlsx.zahl.mjs` für ESM geeignet ist.

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

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

https://github.com/sheetjs/sheetaki leitet Schreibströme an die nodejs-Antwort weiter.

Generieren von JSON- und JS-Daten

JSON- und JS-Daten repräsentieren in der Regel einzelne Arbeitsblätter. Die Hilfsfunktionen in diesem Abschnitt arbeiten mit einzelnen Arbeitsblättern.

Der Abschnitt „Common Spreadsheet Format“ beschreibt die Objektstruktur genauer. workbook.SheetNames ist eine geordnete Liste der Arbeitsblattnamen. workbook.Sheets ist ein Objekt, dessen Schlüssel die Arbeitsblattnamen und dessen Werte die Arbeitsblattobjekte sind.

Das „erste Arbeitsblatt“ ist unter workbook.Sheets[workbook.SheetNames[0]] gespeichert.

API

Ein Array von JS-Objekten aus einem Arbeitsblatt erstellen```js var jsa = XLSX.utils.sheet_to_json(worksheet, opts);

_Erstellen Sie ein Array von Arrays mit JS-Werten aus einem Arbeitsblatt_```js
var aoa = XLSX.utils.sheet_to_json(worksheet, {...opts, header: 1});

Die Hilfsfunktion sheet_to_json durchläuft eine Arbeitsmappe in zeilenweiser Reihenfolge und erzeugt ein Array von Objekten. Das zweite Argument opts steuert eine Reihe von Exportentscheidungen, einschließlich der Art der Werte (JS-Werte oder formatierter Text). Der Abschnitt "JSON" beschreibt das Argument genauer.

Standardmäßig scannt sheet_to_json die erste Zeile und verwendet die Werte als Kopfzeilen. Mit der Option header: 1 exportiert die Funktion ein Array von Arrays von Werten.

Beispiele

x-spreadsheet ist ein interaktives Datenraster zum Vorschauen und Bearbeiten strukturierter Daten im Webbrowser. Die xspreadsheet-Demo enthält ein Beispielskript mit der Funktion stox zum Konvertieren einer Arbeitsmappe in ein x-spreadsheet-Datenobjekt. https://oss.sheetjs.com/sheetjs/x-spreadsheet ist eine Live-Demo.

/* 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;
}, {})));

</details>

<details>
  <summary><b>Vorschau von Daten in einem VueJS-Datenraster</b> (zum Anzeigen klicken)</summary>

[`vue3-table-lite`](https://github.com/linmasahiro/vue3-table-lite) ist eine einfache
VueJS-3-Datentabelle. Es wird [in der VueJS-Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/vue/modify/) vorgestellt.

</details>

<details>
  <summary><b>Befüllen einer Datenbank (SQL oder no-SQL)</b> (zum Anzeigen klicken)</summary>

Die [`database`-Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/database/) enthält Beispiele für die Arbeit mit
Datenbanken und Abfrageergebnissen.

</details>

<details>
  <summary><b>Numerische Berechnungen mit TensorFlow.js</b> (zum Anzeigen klicken)</summary>

[`@tensorflow/tfjs`](https://github.com/weareu/xlsx/blob/HEAD/@tensorflow/tfjs) und andere Bibliotheken erwarten Daten in einfachen
Arrays, die sich gut für Arbeitsblätter eignen, bei denen jede Spalte ein Datenvektor ist. Das ist
die transponierte Form der üblichen Verwendung von Tabellenkalkulationen, bei denen jede Zeile ein Vektor ist.

Ein einziges `Array#map` kann einzelne benannte Zeilen aus dem `sheet_to_json`-Export extrahieren:```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);

Die [`react`-Demo](https://github.com/weareu/xlsx/blob/HEAD/demos/react) enthält weitere React-Beispiele.

</details>

<details>
  <summary><b>VueJS-Arbeitsmappe abrufen und HTML-Tabellenvorschauen erzeugen</b> (klicken zum Anzeigen)</summary>

Es wird allgemein empfohlen, einen VueJS-freundlichen Workflow zu verwenden, aber es ist möglich
HTML zu erzeugen und es in VueJS mit der `v-html`-Direktive zu verwenden:```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>`
};

Erzeugen von Snapshots für einzelne Arbeitsblätter

Die sheet_to_*-Funktionen akzeptieren ein Arbeitsblatt-Objekt.

API

CSV aus einem einzelnen Arbeitsblatt generieren```js var csv = XLSX.utils.sheet_to_csv(worksheet, opts);

Dieser Snapshot ist dafür ausgelegt, den Ausgabetyp "CSV UTF8 (`.csv`)" nachzubilden.
["Trennzeichengetrennte Ausgabe"](#delimiter-separated-output) beschreibt die
Funktion und das optionale `opts`-Argument genauer.

_Generieren von "Text" aus einem einzelnen Arbeitsblatt_```js
var txt = XLSX.utils.sheet_to_txt(worksheet, opts);

Dieser Schnappschuss ist dafür vorgesehen, den Ausgabetyp "UTF16 Text (.txt)" zu replizieren. "Durch Trennzeichen getrennter Output" beschreibt die Funktion und das optionale opts-Argument ausführlicher.

Generieren Sie eine Liste von Formeln aus einem einzelnen Arbeitsblatt```js var fmla = XLSX.utils.sheet_to_formulae(worksheet);

Dieser Schnappschuss erzeugt ein Array von Einträgen, die die eingebetteten Formeln darstellen.
Arrayformeln werden in der Form `range=formula` dargestellt, während normale Zellen
in der Form `cell=formula or value` dargestellt werden. Zeichenfolgenliterale werden mit
einem Apostroph `'` präfixiert, konsistent mit der Darstellung in der Excel-Formelleiste.

["Formulae Output"](#formulae-output) beschreibt die Funktion genauer.

## Schnittstelle

`XLSX` ist die im Browser bereitgestellte Variable und die exportierte Node-Variable

`XLSX.version` ist die Version der Bibliothek (vom Build-Skript hinzugefügt).

`XLSX.SSF` ist eine eingebettete Version der [Format-Bibliothek](https://git.io/ssf).

### Parse-Funktionen

`XLSX.read(data, read_opts)` versucht, `data` zu parsen.

`XLSX.readFile(filename, read_opts)` versucht, `filename` zu lesen und zu parsen.

Parse-Optionen werden im Abschnitt [Parsing-Optionen](#parsing-options) beschrieben.

### Schreibfunktionen

`XLSX.write(wb, write_opts)` versucht, die Arbeitsmappe `wb` zu schreiben

`XLSX.writeFile(wb, filename, write_opts)` versucht, `wb` in `filename` zu schreiben.
In browserbasierten Umgebungen wird versucht, einen clientseitigen Download zu erzwingen.

`XLSX.writeFileAsync(wb, filename, o, cb)` versucht, `wb` in `filename` zu schreiben.
Wenn `o` weggelassen wird, verwendet der Writer das dritte Argument als Rückruffunktion.

`XLSX.stream` enthält eine Reihe von Streaming-Schreibfunktionen.

Schreiboptionen werden im Abschnitt [Schreiboptionen](#writing-options) beschrieben.

### Hilfsfunktionen

Hilfsfunktionen sind im Objekt `XLSX.utils` verfügbar und werden im
Abschnitt [Hilfsfunktionen](#utility-functions) beschrieben:

**Erstellen:**

- `book_new` erstellt eine leere Arbeitsmappe
- `book_append_sheet` fügt einer Arbeitsmappe ein Arbeitsblatt hinzu

**Importieren:**

- `aoa_to_sheet` wandelt ein Array von Arrays mit JS-Daten in ein Arbeitsblatt um.
- `json_to_sheet` wandelt ein Array von JS-Objekten in ein Arbeitsblatt um.
- `table_to_sheet` wandelt ein DOM-TABLE-Element in ein Arbeitsblatt um.
- `sheet_add_aoa` fügt einem vorhandenen Arbeitsblatt ein Array von Arrays mit JS-Daten hinzu.
- `sheet_add_json` fügt einem vorhandenen Arbeitsblatt ein Array von JS-Objekten hinzu.


**Exportieren:**

- `sheet_to_json` wandelt ein Arbeitsblattobjekt in ein Array von JSON-Objekten um.
- `sheet_to_csv` erzeugt eine Ausgabe mit durch Trennzeichen getrennten Werten.
- `sheet_to_txt` erzeugt UTF16-formatierten Text.
- `sheet_to_html` erzeugt HTML-Ausgabe.
- `sheet_to_formulae` erzeugt eine Liste der Formeln (mit Wert-Fallbacks).


**Zell- und Zelladress-Manipulation:**

- `format_cell` erzeugt den Textwert für eine Zelle (unter Verwendung von Zahlenformaten).
- `encode_row / decode_row` konvertiert zwischen 0-indizierten und 1-indizierten Zeilen.
- `encode_col / decode_col` konvertiert zwischen 0-indizierten Spalten und Spaltennamen.
- `encode_cell / decode_cell` konvertiert Zelladressen.
- `encode_range / decode_range` konvertiert Zellbereiche.

## Common Spreadsheet Format

SheetJS entspricht dem Common Spreadsheet Format (CSF):

### Allgemeine Strukturen

Zelladressobjekte werden als `{c:C, r:R}` gespeichert, wobei `C` und `R` die 0-indizierten
Spalten- bzw. Zeilennummern sind. Beispielsweise wird die Zelladresse `B5` durch das
Objekt `{c:1, r:4}` dargestellt.

Zellbereichsobjekte werden als `{s:S, e:E}` gespeichert, wobei `S` die erste Zelle und
`E` die letzte Zelle im Bereich ist. Die Bereiche sind inklusiv. Beispielsweise wird der
Bereich `A3:B7` durch das Objekt `{s:{c:0, r:2}, e:{c:1, r:6}}` dargestellt.
Hilfsfunktionen führen einen Durchlauf in zeilenweiser Reihenfolge durch einen Tabellenbereich aus:```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);
  }
}

Zellobjekt

Zellobjekte sind einfache JS-Objekte, deren Schlüssel und Werte der folgenden Konvention folgen:

Integrierte Export-Dienstprogramme (wie der CSV-Exporteur) verwenden den w-Text, falls verfügbar. Um einen Wert zu ändern, löschen Sie cell.w (oder setzen Sie es auf undefined), bevor Sie einen Export versuchen. Die Dienstprogramme regenerieren den w-Text aus dem Zahlenformat (cell.z) und dem Rohwert, falls möglich.

Die tatsächliche Arrayformel wird im f-Feld der ersten Zelle im Array-Bereich gespeichert. Andere Zellen im Bereich lassen das f-Feld weg.

Datentypen

Der Rohwert wird in der v-Werteigenschaft gespeichert und basierend auf der t-Typeigenschaft interpretiert. Diese Trennung ermöglicht die Darstellung von Zahlen sowie numerischem Text. Es gibt 6 gültige Zelltypen:

Typ n ist der Number-Typ. Dies umfasst alle Formen von Daten, die Excel als Zahlen speichert, wie Datum/Uhrzeit und Boolesche Felder. Excel verwendet ausschließlich Daten, die in eine IEEE754-Gleitkommazahl passen, genau wie JS Number, daher enthält das v-Feld die rohe Zahl. Das w-Feld enthält formatierten Text. Datumsangaben werden standardmäßig als Zahlen gespeichert und mit XLSX.SSF.parse_date_code konvertiert.

Typ d ist der Date-Typ, der nur erzeugt wird, wenn die Option cellDates übergeben wird. Da JSON keinen nativen Date-Typ hat, wird von Parser generell erwartet, ISO-8601-Datumszeichenfolgen zu speichern, wie man sie von date.toISOString() erhalten würde. Andererseits sollten Writer und Exporteure in der Lage sein, Datumszeichenfolgen und JS-Date-Objekte zu verarbeiten. Beachten Sie, dass Excel Zeitzonenmodifikatoren ignoriert und alle Datumsangaben in der lokalen Zeitzone behandelt. Die Bibliothek korrigiert diesen Fehler nicht.

Typ s ist der String-Typ. Werte werden explizit als Text gespeichert. Excel interpretiert diese Zellen als „als Text gespeicherte Zahl“. Generierte Excel-Dateien unterdrücken diese Fehlerklasse automatisch, aber andere Formate können Fehler hervorrufen.

Typ z stellt leere Stub-Zellen dar. Sie werden in Fällen erzeugt, in denen Zellen keinen zugewiesenen Wert haben, aber Kommentare oder andere Metadaten enthalten. Sie werden von den Datenverarbeitungs-Dienstprogrammfunktionen der Kernbibliothek ignoriert. Standardmäßig werden diese Zellen nicht erzeugt; die Parser-Option sheetStubs muss auf true gesetzt werden.

Datumsangaben

</details>

### Sheet-Objekte

Jeder Schlüssel, der nicht mit `!` beginnt, entspricht einer Zelle (unter Verwendung der A-1-Notation)

`sheet[address]` gibt das Zellobjekt für die angegebene Adresse zurück.

**Besondere Sheet-Schlüssel (zugänglich als `sheet[key]`, jeder beginnt mit `!`):**

- `sheet['!ref']`: A-1-basierter Bereich, der den Sheet-Bereich darstellt. Funktionen, die
  mit Sheets arbeiten, sollten diesen Parameter verwenden, um den Bereich zu bestimmen.  Zellen, die
  außerhalb des Bereichs zugewiesen werden, werden nicht verarbeitet.  Insbesondere werden beim
  manuellen Schreiben eines Sheets Zellen außerhalb des Bereichs nicht einbezogen

  Funktionen, die Sheets verarbeiten, sollten das Vorhandensein des Felds `!ref` prüfen.
  Wenn `!ref` weggelassen wird oder kein gültiger Bereich ist, können Funktionen das
  Sheet als leer behandeln oder versuchen, den Bereich zu erraten.  Die Standard-Dienstprogramme, die
  mit dieser Bibliothek geliefert werden, behandeln Sheets als leer (zum Beispiel ist die CSV-Ausgabe
  eine leere Zeichenkette).

  Beim Lesen eines Arbeitsblatts mit gesetzter `sheetRows`-Eigenschaft verwendet der ref-Parameter
  den eingeschränkten Bereich.  Der ursprüngliche Bereich ist unter `ws['!fullref']` festgelegt.

- `sheet['!margins']`: Objekt, das die Seitenränder darstellt.  Die Standardwerte
  folgen der Excel-Voreinstellung "normal".  Excel hat auch eine "wide"- und eine "narrow"-Voreinstellung,
  die jedoch als rohe Maße gespeichert sind. Die wichtigsten Eigenschaften sind unten aufgelistet:

<details>
  <summary><b>Details zu Seitenrändern</b> (zum Anzeigen klicken)</summary>

| key       | Beschreibung          | "normal" | "wide" | "narrow" |
|----------|------------------------|:---------|:-------|:-------- |
| `left`    | linker Rand (Zoll)    | `0.7`    | `1.0`  | `0.25`   |
| `right`   | rechter Rand (Zoll)   | `0.7`    | `1.0`  | `0.25`   |
| `top`     | oberer Rand (Zoll)    | `0.75`   | `1.0`  | `0.75`   |
| `bottom`  | unterer Rand (Zoll)   | `0.75`   | `1.0`  | `0.75`   |
| `header`  | Kopfzeilenrand (Zoll) | `0.3`    | `0.5`  | `0.3`    |
| `footer`  | Fußzeilenrand (Zoll)  | `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}

Arbeitsblatt-Objekt

Zusätzlich zu den Basis-Schlüsseln des Blatts fügen Arbeitsblätter außerdem hinzu:

• ws['!cols']: Array von Spalteneigenschaftenobjekten. Spaltenbreiten werden in Dateien tatsächlich in einer normalisierten Form gespeichert, gemessen anhand der "Maximum Digit Width" (der größten Breite der gerenderten Ziffern 0–9 in Pixel). Beim Parsen speichern die Spaltenobjekte die Pixelbreite im Feld wpx, die Zeichenbreite im Feld wch und die maximale Ziffernbreite im Feld MDW.

• ws['!rows']: Array von Zeileneigenschaftenobjekten, wie später in der Dokumentation erläutert. Jedes Zeilenobjekt codiert Eigenschaften einschließlich Zeilenhöhe und Sichtbarkeit.

• ws['!merges']: Array von Bereichsobjekten, die den verbundenen Zellen im Arbeitsblatt entsprechen. Reine Textformate unterstützen keine verbundenen Zellen. Der CSV-Export schreibt alle Zellen im Bereich der verbundenen Zellen, falls sie vorhanden sind. Stellen Sie daher sicher, dass nur die erste Zelle (oben links) im Bereich gesetzt ist.

• ws['!outline']: Konfiguriert das Verhalten von Gliederungen. Die Optionen entsprechen standardmäßig den Standardeinstellungen in Excel 2019:

• ws['!protect']: Objekt mit Schreibschutzeigenschaften für Arbeitsblätter. Der Schlüssel password gibt das Passwort für Formate an, die passwortgeschützte Arbeitsblätter unterstützen (XLSX/XLSB/XLS). Der Writer verwendet die XOR-Verschleierungsmethode. Die folgenden Schlüssel steuern den Arbeitsblattschutz – setzen Sie false, um eine Funktion zu aktivieren, wenn das Arbeitsblatt gesperrt ist, oder setzen Sie true, um eine Funktion zu deaktivieren:

• ws['!autofilter']: AutoFilter-Objekt gemäß dem folgenden Schema:```typescript type AutoFilter = { ref:string; // A-1 based range representing the AutoFilter table range }

#### Chartsheet-Objekt

Chartsheets werden als Standard-Tabellenblätter dargestellt. Sie werden durch die
`!type`-Eigenschaft mit dem Wert `"chart"` unterschieden.

Die zugrunde liegenden Daten und `!ref` beziehen sich auf die zwischengespeicherten Daten im Chartsheet. Die
erste Zeile des Chartsheets ist der zugrunde liegende Kopfbereich.

#### Macrosheet-Objekt

Macrosheets werden als Standard-Tabellenblätter dargestellt. Sie werden durch die
`!type`-Eigenschaft mit dem Wert `"macro"` unterschieden.

#### Dialogsheet-Objekt

Dialogsheets werden als Standard-Tabellenblätter dargestellt. Sie werden durch die
`!type`-Eigenschaft mit dem Wert `"dialog"` unterschieden.

### Workbook-Objekt

`workbook.SheetNames` ist eine geordnete Liste der Tabellenblätter im Workbook.

`wb.Sheets[sheetname]` gibt ein Objekt zurück, das das Arbeitsblatt darstellt.

`wb.Props` ist ein Objekt, das die Standardeigenschaften speichert. `wb.Custprops` speichert
benutzerdefinierte Eigenschaften. Da die XLS-Standardeigenschaften von den XLSX-
Standards abweichen, speichert die XLS-Analyse die Kerneigenschaften an beiden Stellen.

`wb.Workbook` speichert [Attribute auf Workbook-Ebene](#workbook-level-attributes).

#### Dateieigenschaften des Workbooks

Die verschiedenen Dateiformate verwenden unterschiedliche interne Namen für Dateieigenschaften. Das
`Props`-Objekt des Workbooks normalisiert die Namen:

<details>
  <summary><b>Dateieigenschaften</b> (zum Anzeigen klicken)</summary>

| JS-Name       | Excel-Beschreibung            |
|:--------------|:------------------------------|
| `Title`       | Registerkarte "Zusammenfassung", "Titel" |
| `Subject`     | Registerkarte "Zusammenfassung", "Betreff" |
| `Author`      | Registerkarte "Zusammenfassung", "Autor" |
| `Manager`     | Registerkarte "Zusammenfassung", "Manager" |
| `Company`     | Registerkarte "Zusammenfassung", "Firma" |
| `Category`    | Registerkarte "Zusammenfassung", "Kategorie" |
| `Keywords`    | Registerkarte "Zusammenfassung", "Schlüsselwörter" |
| `Comments`    | Registerkarte "Zusammenfassung", "Kommentare" |
| `LastAuthor`  | Registerkarte "Statistik", "Zuletzt gespeichert von" |
| `CreatedDate` | Registerkarte "Statistik", "Erstellt" |

</details>

Um beispielsweise die Titel-Eigenschaft des Workbooks festzulegen:```js
if(!wb.Props) wb.Props = {};
wb.Props.Title = "Insert Title Here";

Benutzerdefinierte Eigenschaften werden im Arbeitsmappen-Objekt Custprops hinzugefügt:```js if(!wb.Custprops) wb.Custprops = {}; wb.Custprops["Custom Property"] = "Custom Value";

Autoren werden den `Props`-Schlüssel des Optionsobjekts verarbeiten:```js
/* force the Author to be "SheetJS" */
XLSX.write(wb, {Props:{Author:"SheetJS"}});

Attribute auf Arbeitsmappenebene

wb.Workbook speichert Attribute auf Arbeitsmappenebene.

Definierte Namen

wb.Workbook.Names ist ein Array von definierten Namensobjekten mit den folgenden Schlüsseln:

Excel erlaubt es, dass zwei blattbezogene definierte Namen denselben Namen tragen. Ein blattbezogener Name kann jedoch nicht mit einem Namen im Arbeitsmappenbereich kollidieren. Writer von Arbeitsmappen erzwingen diese Einschränkung möglicherweise nicht.

Arbeitsmappenansichten

wb.Workbook.Views ist ein Array von Arbeitsmappenansichtsobjekten mit den folgenden Schlüsseln:

Verschiedene Arbeitsmappeneigenschaften

wb.Workbook.WBProps enthält weitere Arbeitsmappeneigenschaften:

Dokumentfunktionen

Selbst bei grundlegenden Funktionen wie der Datumsspeicherung speichern die offiziellen Excel-Formate denselben Inhalt auf unterschiedliche Weise. Von den Parsern wird erwartet, dass sie von der Darstellung des zugrunde liegenden Dateiformats in das Common Spreadsheet Format konvertieren. Von den Writern wird erwartet, dass sie vom CSF zurück in das zugrunde liegende Dateiformat konvertieren.

Formeln

Die Formelzeichenfolge im A1-Stil wird im Feld f gespeichert. Obwohl verschiedene Dateiformate die Formeln auf unterschiedliche Weise speichern, werden die Formate übersetzt. Obwohl einige Formate Formeln mit einem vorangestellten Gleichheitszeichen speichern, beginnen CSF-Formeln nicht mit =.

Formeln für einzelne Zellen

Bei einfachen Formeln kann der f-Schlüssel der gewünschten Zelle auf den tatsächlichen Formeltext gesetzt werden. Dieses Arbeitsblatt stellt A1=1, A2=2 und A3=A1+A2 dar:```js var worksheet = { "!ref": "A1:A3", A1: { t:'n', v:1 }, A2: { t:'n', v:2 }, A3: { t:'n', v:3, f:'A1+A2' } };

Hilfsfunktionen wie `aoa_to_sheet` akzeptieren Zellobjekte anstelle von Werten:```js
var worksheet = XLSX.utils.aoa_to_sheet([
  [ 1 ], // A1
  [ 2 ], // A2
  [ {t: "n", v: 3, f: "A1+A2"} ] // A3
]);

Zellen mit Formeleinträgen, aber ohne Wert werden auf eine Weise serialisiert, die Excel und andere Tabellenkalkulationstools erkennen. Diese Bibliothek wird nicht automatisch Formelergebnisse berechnen! Beispielsweise enthält das folgende Arbeitsblatt die Funktion BESSELJ, aber das Ergebnis wird in JavaScript nicht verfügbar sein:```js var worksheet = XLSX.utils.aoa_to_sheet([ [ 3.14159, 2 ], // Row "1" [ { t:'n', f:'BESSELJ(A1,B1)' } ] // Row "2" will be calculated on file open }

Wenn die tatsächlichen Ergebnisse in JS benötigt werden, bietet [SheetJS Pro](https://sheetjs.com/pro)
eine Formelberechnungskomponente zum Auswerten von Ausdrücken, Aktualisieren
von Werten und abhängigen Zellen sowie zum Aktualisieren ganzer Arbeitsmappen.


**Array-Formeln**

_Eine Array-Formel zuweisen_```js
XLSX.utils.sheet_set_array_formula(worksheet, range, formula);

Arrayformeln werden in der oberen linken Zelle des Arrayblocks gespeichert. Alle Zellen einer Arrayformel haben ein F-Feld, das dem Bereich entspricht. Eine Einzelzellenformel kann von einer normalen Formel durch das Vorhandensein des F-Felds unterschieden werden.

Zum Beispiel, um die Zelle C1 auf die Arrayformel {=SUM(A1:A3*B1:B3)} zu setzen:```js // API function XLSX.utils.sheet_set_array_formula(worksheet, "C1", "SUM(A1:A3*B1:B3)");

// ... OR raw operations worksheet['C1'] = { t:'n', f: "SUM(A1:A3*B1:B3)", F:"C1:C1" };

Bei einer Mehrzellen-Arrayformel hat jede Zelle denselben Array-Bereich, aber nur die erste Zelle gibt die Formel an. Betrachten Sie `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" };

Utilities und Writer sollten auf das Vorhandensein eines F-Feldes prüfen und jegliches mögliche Formelelement f in anderen Zellen als der Startzelle ignorieren. Von ihnen wird nicht erwartet, dass sie eine Validierung der Formeln durchführen!

Dynamische Array-Formeln

Eine dynamische Array-Formel zuweisen```js XLSX.utils.sheet_set_array_formula(worksheet, range, formula, true);

Die 2020 veröffentlichten dynamischen Array-Formeln werden in den Dateiformaten XLSX/XLSM und XLSB
unterstützt.  Sie werden wie normale Array-Formeln dargestellt, weisen aber besondere
Zellmetadaten auf, die angeben, dass die Formel den Bereich anpassen darf.

Eine Array-Formel kann als dynamisch markiert werden, indem die `D`-Eigenschaft der Zelle auf
true gesetzt wird.  Der `F`-Bereich wird erwartet, kann aber auf die aktuelle Zelle gesetzt werden:```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

Lokalisierung mit Funktionsnamen

SheetJS arbeitet auf Dateiebene. Excel speichert Formelausdrücke mit den englischen (US-amerikanischen) Funktionsnamen. Für nicht-englische Benutzer verwendet Excel einen lokalisierten Satz von Funktionsnamen.

Wenn z. B. die Computersprache und -region auf Französisch (Frankreich) eingestellt ist, interpretiert Excel =SOMME(A1:C3) so, als ob SOMME die Funktion SUM wäre. In der tatsächlichen Datei speichert Excel jedoch SUM(A1:C3).

Mit Präfix versehene „Future Functions"

Funktionen, die in neueren Excel-Versionen eingeführt wurden, werden beim Speichern in Dateien mit _xlfn. präfigiert. Beim Schreiben von Formelausdrücken mit diesen Funktionen ist das Präfix für maximale Kompatibilität erforderlich:```js // Broadest compatibility XLSX.utils.sheet_set_array_formula(worksheet, "C1", "_xlfn.UNIQUE(A1:A3)", 1);

// Can cause errors in spreadsheet software XLSX.utils.sheet_set_array_formula(worksheet, "C1", "UNIQUE(A1:A3)", 1);

Beim Lesen einer Datei bewahrt die Option `xlfn` die Präfixe.

<details>
  <summary><b> Funktionen, die das Präfix `_xlfn.` erfordern</b> (zum Anzeigen klicken)</summary>

Diese Liste wächst mit jeder Excel-Version.```
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

Zeileneigenschaften: XLSX/M, XLSB, BIFF8 XLS, XLML, SYLK, DOM, ODS

Spalteneigenschaften: XLSX/M, XLSB, BIFF8 XLS, XLML, SYLK, DOM

Es gibt drei verschiedene Breitentypen, die den drei verschiedenen Arten entsprechen,
wie Tabellenkalkulationen Spaltenbreiten speichern:

SYLK und andere Klartextformate verwenden die rohe Zeichenanzahl. Zeitgenössische Werkzeuge
wie Visicalc und Multiplan waren zeichenbasiert. Da die Zeichen die gleiche
Breite hatten, genügte es, eine Anzahl zu speichern. Diese Tradition wurde in den
BIFF-Formaten fortgeführt.

SpreadsheetML (2003) versuchte, sich an HTML anzugleichen, indem es im gesamten
Dokument auf Bildschirmpixel standardisierte. Spaltenbreiten, Zeilenhöhen und andere Maße verwenden
Pixel. Wenn die Pixel- und Zeichenanzahl nicht übereinstimmen, rundet Excel die Werte.

XLSX speichert Spaltenbreiten intern in einer nebulösen "Max Digit Width"-Form. Die
"Max Digit Width" ist die Breite der größten Ziffer bei der Darstellung (in der Regel das
"0"-Zeichen am breitesten ist). Die interne Breite muss ein ganzzahliges Vielfaches der
durch 256 geteilten Breite sein. ECMA-376 beschreibt eine Formel zur Umrechnung
zwischen Pixeln und der internen Breite. Dies stellt einen hybriden Ansatz dar.

Lesefunktionen versuchen, alle drei Eigenschaften zu befüllen. Schreibfunktionen werden
versuchen, angegebene Werte in den gewünschten Typ umzuwandeln. Um mögliche
Konflikte zu vermeiden, sollten bei Manipulationen zuerst die anderen Eigenschaften gelöscht werden. Zum Beispiel
sollten beim Ändern der Pixelbreite die wch- und width-Eigenschaften gelöscht werden.

Zeilenhöhen

Excel speichert Zeilenhöhen intern in Punkten. Die Standardauflösung ist 72 DPI
oder 96 PPI, sodass Pixel- und Punktgröße übereinstimmen sollten. Bei unterschiedlichen Auflösungen
stimmen sie möglicherweise nicht überein, daher trennt die Bibliothek die Konzepte.

Auch wenn alle Informationen bereitgestellt werden, wird von den Schreibfunktionen erwartet,
der Prioritätsreihenfolge zu folgen:

1. hpx-Pixelhöhe verwenden, falls verfügbar
2. hpt-Punkthöhe verwenden, falls verfügbar

Spaltenbreiten

Angesichts der Einschränkungen ist es möglich, die MDW zu bestimmen, ohne tatsächlich
die Schriftart zu untersuchen! Die Parser schätzen die Pixelbreite, indem sie von der Breite
zu Pixeln und zurück umrechnen, dies für alle möglichen MDW wiederholen und die MDW auswählen, die
den Fehler minimiert. XLML speichert tatsächlich die Pixelbreite, daher funktioniert die Schätzung
in die entgegengesetzte Richtung.

Auch wenn alle Informationen bereitgestellt werden, wird von den Schreibfunktionen erwartet,
der Prioritätsreihenfolge zu folgen:

1. das width-Feld verwenden, falls verfügbar
2. die wpx-Pixelbreite verwenden, falls verfügbar
3. die wch-Zeichenanzahl verwenden, falls verfügbar

Die Standardformate sind in ECMA-376 18.8.30 aufgelistet:

Zell-Hyperlinks: XLSX/M, XLSB, BIFF8 XLS, XLML, ODS

Tooltips: XLSX/M, XLSB, BIFF8 XLS, XLML