L'obiettivo è generare un foglio di lavoro XLSB con i nomi e i compleanni dei Presidenti degli Stati Uniti.

Acquisisci Dati

Dati Grezzi

https://theunitedstates.io/congress-legislators/executive.json contiene i dati desiderati. Ad esempio, 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" ] }

_Filtraggio per Presidenti_

Il dataset include Aaron Burr, un Vicepresidente che non è mai stato Presidente!

`Array#filter` crea un nuovo array con le righe desiderate. Un Presidente ha servito almeno un mandato con `type` impostato a `"prez"`. Per verificare se una particolare riga ha almeno un mandato `"prez"`, `Array#some` è un'altra funzione nativa di JS. Il filtro completo sarebbe:```js
const prez = raw_data.filter(row => row.terms.some(term => term.type === "prez"));

Lining up the data

Per questo esempio, il nome sarà il nome proprio combinato con il cognome (row.name.first + " " + row.name.last) e la data di nascita sarà il sottocampo row.bio.birthday. Utilizzando Array#map, il dataset può essere elaborato in una singola chiamata:```js const rows = prez.map(row => ({ name: row.name.first + " " + row.name.last, birthday: row.bio.birthday }));

Il risultato è un array di oggetti "semplici" senza annidamento:```js
[
  { name: "George Washington", birthday: "1732-02-22" },
  { name: "John Adams", birthday: "1735-10-19" },
  // ... one row per President
]

Estrarre i dati

Con il dataset pulito, XLSX.utils.json_to_sheet genera un foglio di lavoro:```js const worksheet = XLSX.utils.json_to_sheet(rows);

`XLSX.utils.book_new` crea una nuova cartella di lavoro e `XLSX.utils.book_append_sheet` aggiunge un foglio di lavoro alla cartella. Il nuovo foglio di lavoro si chiamerà "Dates":```js
const workbook = XLSX.utils.book_new();
XLSX.utils.book_append_sheet(workbook, worksheet, "Dates");

Elabora i dati

Correggere le intestazioni

Per impostazione predefinita, json_to_sheet crea un foglio di lavoro con una riga di intestazione. In questo caso, le intestazioni provengono dalle chiavi dell'oggetto JS: "name" e "birthday".

Le intestazioni sono nelle celle A1 e B1. XLSX.utils.sheet_add_aoa può scrivere valori di testo nel foglio di lavoro esistente a partire dalla cella A1:```js XLSX.utils.sheet_add_aoa(worksheet, [["Name", "Birthday"]], { origin: "A1" });

_Fissaggio delle Larghezze delle Colonne_

Alcuni nomi sono più lunghi della larghezza predefinita delle colonne.  Le larghezze delle colonne vengono impostate tramite [l'impostazione della proprietà `"!cols"` del foglio di lavoro](#row-and-column-properties).

La seguente riga imposta la larghezza della colonna A a circa 10 caratteri:```js
worksheet["!cols"] = [ { wch: 10 } ]; // set column A width to 10 characters

Una chiamata Array#reduce su rows può calcolare la larghezza massima:```js const max_width = rows.reduce((w, r) => Math.max(w, r.name.length), 10); worksheet["!cols"] = [ { wch: max_width } ];

**Nota:** Se il punto di partenza era un file o una tabella HTML, `XLSX.utils.sheet_to_json`
genererà un array di oggetti JS.

**Dati del pacchetto e della release**

`XLSX.writeFile` crea un file di foglio di calcolo e prova a scriverlo nel sistema.
Nel browser, cercherà di chiedere all'utente di scaricare il file.  In NodeJS,
scriverà nella directory locale.```js
XLSX.writeFile(workbook, "Presidents.xlsx");

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

Per l'uso nel browser web, supponendo che lo snippet sia salvato come `snippet.js`, si devono usare tag script per includere le build standalone di `axios` e `xlsx`:```html
<script src="https://unpkg.com/xlsx/dist/xlsx.full.min.js"></script>
<script src="https://unpkg.com/axios/dist/axios.min.js"></script>
<script src="snippet.js"></script>

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

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

Per Node ESM, l'helper `readFile` non è abilitato. Invece, `fs.readFileSync` dovrebbe essere usato per leggere i dati del file come `Buffer` per l'utilizzo con `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 utilizza Deno.readFileSync internamente:```js // @deno-types="https://deno.land/x/sheetjs/types/index.d.ts" import * as XLSX from 'https://deno.land/x/sheetjs/xlsx.mjs'

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

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

</details>

<details>
  <summary><b>File inviato dall'utente in una pagina web ("Drag-and-Drop")</b> (clicca per visualizzare)</summary>

Per i siti web moderni che targettizzano Chrome 76+, si consiglia `File#arrayBuffer`:```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);

Per una compatibilità massima, dovrebbe essere utilizzata l'API FileReader:```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/> dimostra la tecnica FileReader.

</details>

<details>
  <summary><b>File inviato dall'utente con un elemento INPUT HTML</b> (clicca per mostrare)</summary>

Partendo da un elemento INPUT HTML con `type="file"`:```html
<input type="file" id="input_dom_element">

Per i siti web moderni che hanno come target Chrome 76+, si consiglia Blob#arrayBuffer:```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);

Per un supporto più ampio (incluso IE10+), si consiglia l'approccio `FileReader`:```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);

Il oldie demo mostra uno scenario di fallback compatibile con IE.

Per i siti web moderni che hanno come target Chrome 42+, fetch è consigliato:```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 */ })();

Per un supporto più ampio, l'approccio `XMLHttpRequest` è raccomandato:```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 include una discussione più approfondita e ulteriori esempi.

http://oss.sheetjs.com/sheetjs/ajax.html mostra approcci di fallback per IE6+.

readFile incapsula la logica File in Photoshop e altri target ExtendScript. Il percorso specificato deve essere un percorso assoluto:```js #include "xlsx.extendscript.js"

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

The [`extendscript` demo](https://github.com/weareu/xlsx/blob/HEAD/demos/extendscript/) include un esempio più complesso.

</details>

<details>
  <summary><b>File locale in un'app Electron</b> (clicca per mostrare)</summary>

`readFile` può essere usato nel processo renderer:```js
/* From the renderer process */
var XLSX = require("xlsx");

var workbook = XLSX.readFile(path);

Le API di Electron sono cambiate nel tempo. La demo electron mostra un esempio completo e descrive le impostazioni specifiche per versione richieste.

La demo react include un'app React Native di esempio.

Poiché React Native non fornisce un modo per leggere file dal filesystem, è necessario utilizzare una libreria di terze parti. Le seguenti librerie sono state testate:

• react-native-file-access

La codifica base64 restituisce stringhe compatibili con il tipo base64:```js import XLSX from "xlsx"; import { FileSystem } from "react-native-file-access";

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

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

La codifica `ascii` restituisce stringhe binarie compatibili con il tipo `binary`:```js
import XLSX from "xlsx";
import { readFile } from "react-native-fs";

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

read può accettare un buffer NodeJS. readFile può leggere file generati da un parser del corpo di una richiesta HTTP POST come 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](https://github.com/weareu/xlsx/blob/HEAD/demos/server) contiene esempi più avanzati.

</details>

<details>
  <summary><b>Scaricare file in un processo NodeJS</b> (clicca per mostrare)</summary>

Node 17.5 e 18.0 hanno supporto nativo per fetch:```js
const XLSX = require("xlsx");

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

Per una maggiore compatibilità, si consigliano moduli di terze parti.

request richiede una codifica null per produrre 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`](https://npm.im/axios) funziona allo stesso modo nel browser e 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 */
})();

Il modulo net nel processo principale può effettuare richieste HTTP/HTTPS a risorse esterne. Le risposte devono essere concatenate manualmente usando Buffer.concat:```js const XLSX = require("xlsx"); const { net } = require("electron");

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

/* DO SOMETHING WITH workbook HERE */

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

</details>

<details>
  <summary><b>Stream leggibili in NodeJS</b> (clicca per mostrare)</summary>

Quando si ha a che fare con flussi leggibili (Readable Streams), l'approccio più semplice è quello di bufferizzare il flusso ed elaborare l'intero contenuto alla fine:```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);
  });
}

Quando si ha a che fare con ReadableStream, l'approccio più semplice è bufferizzare lo stream ed elaborare il tutto alla fine:```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>

Esempi più dettagliati sono coperti nelle [demo incluse](https://github.com/weareu/xlsx/blob/HEAD/demos/)

### Elaborazione di dati JSON e JS

I dati JSON e JS tendono a rappresentare singoli fogli di lavoro. Questa sezione utilizzerà alcune funzioni di utilità per generare cartelle di lavoro.

_Crea un nuovo Workbook_```js
var workbook = XLSX.utils.book_new();

La funzione di utilità book_new crea una cartella di lavoro vuota senza fogli di lavoro.

Il software per fogli di calcolo generalmente richiede almeno un foglio di lavoro e impone tale requisito nell'interfaccia utente. Questa libreria impone il requisito al momento della scrittura, generando errori se una cartella di lavoro vuota viene passata alle funzioni di scrittura.

API

Crea un foglio di lavoro da un array di array di valori JS```js var worksheet = XLSX.utils.aoa_to_sheet(aoa, opts);

La funzione di utilità `aoa_to_sheet` esamina un "array di array" in ordine per righe, generando un oggetto foglio di lavoro. Il seguente frammento genera un foglio con la cella `A1` impostata alla stringa `A1`, la cella `B1` impostata a `B1`, ecc.:```js
var worksheet = XLSX.utils.aoa_to_sheet([
  ["A1", "B1", "C1"],
  ["A2", "B2", "C2"],
  ["A3", "B3", "C3"]
]);

"Input di Array di Array" descrive la funzione e l'argomento facoltativo opts in maggior dettaglio.

Crea un foglio di lavoro da un array di oggetti JS```js var worksheet = XLSX.utils.json_to_sheet(jsa, opts);

La funzione di utilità `json_to_sheet` attraversa un array di oggetti JS in ordine,
generando un oggetto foglio di lavoro. Per impostazione predefinita, genererà una riga di intestazione e
una riga per ogni oggetto nell'array. L'argomento opzionale `opts` ha impostazioni per
controllare l'ordine delle colonne e l'output dell'intestazione.

["Input di Array di Oggetti"](#array-of-arrays-input) descrive la funzione e
l'argomento opzionale `opts` in maggior dettaglio.

**Esempi**

["Lo Zen di SheetJS"](#the-zen-of-sheetjs) contiene un esempio dettagliato "Ottenere Dati
da un Endpoint JSON e Generare una Cartella di Lavoro"


[`x-spreadsheet`](https://github.com/myliang/x-spreadsheet) è una griglia di dati interattiva
per visualizzare in anteprima e modificare dati strutturati nel browser web. La
[demo di `xspreadsheet`](https://github.com/weareu/xlsx/blob/HEAD/demos/xspreadsheet) include uno script di esempio con la
funzione `xtos` per convertire da oggetto dati x-spreadsheet a una cartella di lavoro.
<https://oss.sheetjs.com/sheetjs/x-spreadsheet> è una demo live.

<details>
  <summary><b>Record da una query del database (SQL o no-SQL)</b> (clicca per mostrare)</summary>

La [demo del `database`](https://github.com/weareu/xlsx/blob/HEAD/demos/database/) include esempi di lavoro con
database e risultati di query.

</details>


<details>
  <summary><b>Calcoli Numerici con TensorFlow.js</b> (clicca per mostrare)</summary>

[`@tensorflow/tfjs`](https://github.com/weareu/xlsx/blob/HEAD/@tensorflow/tfjs) e altre librerie si aspettano dati in array
semplici, ben adatti a fogli di lavoro dove ogni colonna è un vettore di dati. Questa è
la trasposizione di come la maggior parte delle persone usa i fogli elettronici, dove ogni riga è un vettore.

Quando si recuperano dati da `tfjs`, i punti dati restituiti sono memorizzati in un array
tipizzato. Un array di array può essere costruito con cicli. `Array#unshift` può
preporre una riga di titolo prima della conversione:```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 mostra un esempio completo.

Più tabelle in una pagina web possono essere convertite in fogli di lavoro individuali:```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 */

In alternativa, il codice HTML può essere estratto e analizzato:```js var htmlstr = document.getElementById("tableau").outerHTML; var workbook = XLSX.read(htmlstr, {type:"string"});

</details>

<details>
  <summary><b>Estensione Chrome/Chromium</b> (click per mostrare)</summary>

La demo [`chrome`](https://github.com/weareu/xlsx/blob/HEAD/demos/chrome/) mostra un esempio completo e descrive le
autorizzazioni richieste e altre impostazioni.

In un'estensione, si consiglia di generare la cartella di lavoro in un content script
e passare l'oggetto all'estensione:```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);
});

La demo headless include una demo completa per convertire file HTML in workbook XLSB. L'idea principale è aggiungere lo script alla pagina, analizzare la tabella nel contesto della pagina, generare un workbook in base64 e inviarlo indietro per ulteriori elaborazioni:```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>Tabelle HTML lato server con WebKit headless</b> (clicca per mostrare)</summary>

La demo [`headless`](https://github.com/weareu/xlsx/blob/HEAD/demos/headless/) include una demo completa per convertire file HTML in workbook XLSB utilizzando [PhantomJS](https://phantomjs.org/). L'idea principale è aggiungere lo script alla pagina, analizzare la tabella nel contesto della pagina, generare un workbook `binary` e inviarlo per ulteriori elaborazioni:```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 non include un'implementazione DOM e Puppeteer richiede una pesante build di Chromium. jsdom è un'alternativa leggera:```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>

## Elaborazione dei Dati

Il ["Formato Foglio di Calcolo Comune"](#common-spreadsheet-format) è una semplice rappresentazione oggetto dei concetti fondamentali di una cartella di lavoro. Le funzioni di utilità lavorano con la rappresentazione oggetto e sono progettate per gestire casi d'uso comuni.

### Modifica della Struttura della Cartella di Lavoro

**API**

_Aggiungi un Foglio di Lavoro a una Cartella di Lavoro_```js
XLSX.utils.book_append_sheet(workbook, worksheet, sheet_name);

La funzione di utilità book_append_sheet aggiunge un foglio di lavoro alla cartella di lavoro. Il terzo argomento specifica il nome desiderato del foglio di lavoro. È possibile aggiungere più fogli di lavoro a una cartella di lavoro chiamando la funzione più volte. Se il nome del foglio di lavoro è già utilizzato nella cartella di lavoro, verrà generato un errore.

Aggiungi un foglio di lavoro a una cartella di lavoro e trova un nome univoco```js var new_name = XLSX.utils.book_append_sheet(workbook, worksheet, name, true);

Se il quarto argomento è `true`, la funzione partirà dal nome del foglio di lavoro specificato. Se il nome del foglio esiste già nella cartella di lavoro, verrà scelto un nuovo nome di foglio trovando la radice del nome e incrementando il contatore:```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

Elenca i nomi dei Worksheet in ordine di tab```js var wsnames = workbook.SheetNames;

La proprietà `SheetNames` dell'oggetto workbook è un elenco dei nomi dei fogli di lavoro
in "ordine di tabulazione".  Le funzioni API guarderanno questo array.

_Sostituire un foglio di lavoro sul posto_```js
workbook.Sheets[sheet_name] = new_worksheet;

La proprietà Sheets dell'oggetto workbook è un oggetto le cui chiavi sono nomi e i cui valori sono oggetti worksheet. Riassegnando a una proprietà dell'oggetto Sheets, l'oggetto worksheet può essere modificato senza interrompere il resto della struttura del worksheet.

Esempi

</details>

### Modifica dei valori delle celle

**API**

_Modificare un singolo valore di cella in un foglio di lavoro_```js
XLSX.utils.sheet_add_aoa(worksheet, [[new_value]], { origin: address });

La funzione di utilità `sheet_add_aoa` modifica i valori delle celle in un foglio di lavoro.  Il
primo argomento è l'oggetto foglio di lavoro.  Il secondo argomento è un array di
array di valori.  La chiave `origin` del terzo argomento controlla dove le celle
verranno scritte.  Il seguente frammento imposta `B3=1` e `E5="abc"`:```js
XLSX.utils.sheet_add_aoa(worksheet, [
  [1],                             // <-- Write 1 to cell B3
  ,                                // <-- Do nothing in row 4
  [/*B5*/, /*C5*/, /*D5*/, "abc"]  // <-- Write "abc" to cell E5
], { origin: "B3" });

Opzioni di Parsing

Le funzioni esportate read e readFile accettano un argomento di opzioni:

• Anche se cellNF è false, il testo formattato verrà generato e salvato in .w
• In alcuni casi, i fogli possono essere analizzati anche se bookSheets è false.
• Excel cerca aggressivamente di interpretare i valori da CSV e altri testi semplici. Questo porta a comportamenti sorprendenti! L'opzione raw sopprime l'analisi dei valori.
• bookSheets e bookProps si combinano per dare entrambi i set di informazioni
• Deps sarà un oggetto vuoto se bookDeps è false
• Il comportamento di bookFiles dipende dal tipo di file:
  • Array keys (percorsi nello ZIP) per formati basati su ZIP
  • Hash files (mappatura percorsi a oggetti che rappresentano i file) per ZIP
  • Oggetto cfb per formati che usano contenitori CFB

Tipo di Input

Le stringhe possono essere interpretate in più modi. Il parametro type per read dice alla libreria come analizzare l'argomento dati:

Riconoscimento del Tipo di File

</details>

## Opzioni di scrittura

Le funzioni esportate `write` e `writeFile` accettano un argomento opzioni:

| Nome opzione   |  Valore predefinito | Descrizione                                         |
| :------------- | ------------------: | :-------------------------------------------------- |
|`type`          |                     | Codifica dei dati di output (vedi Tipo di output di seguito) |
|`cellDates`     |  `false`            | Memorizza le date come tipo `d` (predefinito è `n`) |
|`bookSST`       |  `false`            | Genera la tabella delle stringhe condivise **       |
|`bookType`      | `"xlsx"`            | Tipo di cartella di lavoro (vedi formati supportati di seguito) |
|`sheet`         |     `""`            | Nome del foglio di lavoro per formati a foglio singolo ** |
|`compression`   |  `false`            | Usa compressione ZIP per formati basati su ZIP **   |
|`Props`         |                     | Sovrascrive le proprietà della cartella di lavoro durante la scrittura ** |
|`themeXLSX`     |                     | Sovrascrive il tema XML durante la scrittura di XLSX/XLSB/XLSM ** |
|`ignoreEC`      |   `true`            | Sopprime gli errori "numero come testo" **          |
|`numbers`       |                     | Payload per esportazione NUMBERS **                 |

- `bookSST` è più lento e utilizza più memoria, ma ha una migliore compatibilità
  con versioni obsolete di iOS Numbers
- I dati grezzi sono l'unica cosa garantita da salvare. Le funzionalità non descritte
  in questo README potrebbero non essere serializzate.
- `cellDates` si applica solo all'output XLSX e non è garantito che funzioni con
  lettori di terze parti. Excel stesso di solito non scrive celle con tipo `d`,
  quindi strumenti non Excel potrebbero ignorare i dati o generare errori in presenza di date.
- `Props` è un oggetto che rispecchia il campo `Props` della cartella di lavoro. Vedi la tabella
  nella sezione [Proprietà del file della cartella di lavoro](#workbook-file-properties).
- Se specificata, la stringa da `themeXLSX` verrà salvata come tema principale
  per i file XLSX/XLSB/XLSM (in `xl/theme/theme1.xml` all'interno del ZIP).
- A causa di un bug nel programma, alcune funzionalità come "Testo in colonne" causeranno il crash
  di Excel nei fogli di lavoro in cui gli errori vengono ignorati. Lo scrittore contrassegnerà
  i file per ignorare l'errore per impostazione predefinita. Imposta `ignoreEC` su `false` per sopprimerlo.
- A causa delle dimensioni dei dati, i dati NUMBERS non sono inclusi per impostazione predefinita. Gli script
  `xlsx.zahl.js` e `xlsx.zahl.mjs` inclusi contengono i dati.

### Formati di output supportati

Per un'ampia compatibilità con strumenti di terze parti, questa libreria supporta molti
formati di output. Il tipo di file specifico è controllato con l'opzione `bookType`:

| `bookType` | estensione file | contenitore | fogli | Descrizione                     |
| :--------- | --------------: | :---------: | :---- |:------------------------------- |
| `xlsx`     | `.xlsx`         |    ZIP      | multi | Formato XML Excel 2007+          |
| `xlsm`     | `.xlsm`         |    ZIP      | multi | Formato XML con macro Excel 2007+|
| `xlsb`     | `.xlsb`         |    ZIP      | multi | Formato binario Excel 2007+      |
| `biff8`    | `.xls`          |    CFB      | multi | Formato cartella di lavoro Excel 97-2004|
| `biff5`    | `.xls`          |    CFB      | multi | Formato cartella di lavoro Excel 5.0/95|
| `biff4`    | `.xls`          |   nessuno   | singolo| Formato foglio di lavoro Excel 4.0|
| `biff3`    | `.xls`          |   nessuno   | singolo| Formato foglio di lavoro Excel 3.0|
| `biff2`    | `.xls`          |   nessuno   | singolo| Formato foglio di lavoro Excel 2.0|
| `xlml`     | `.xls`          |   nessuno   | multi  | Excel 2003-2004 (SpreadsheetML) |
| `numbers`  |`.numbers`       |    ZIP      | singolo| Foglio di calcolo Numbers 3.0+   |
| `ods`      | `.ods`          |    ZIP      | multi  | Foglio di calcolo OpenDocument   |
| `fods`     | `.fods`         |   nessuno   | multi  | Foglio di calcolo OpenDocument piatto|
| `wk3`      | `.wk3`          |   nessuno   | multi  | Cartella di lavoro Lotus (WK3)   |
| `csv`      | `.csv`          |   nessuno   | singolo| Valori separati da virgola       |
| `txt`      | `.txt`          |   nessuno   | singolo| Testo Unicode UTF-16 (TXT)       |
| `sylk`     | `.sylk`         |   nessuno   | singolo| Collegamento simbolico (SYLK)    |
| `html`     | `.html`         |   nessuno   | singolo| Documento HTML                   |
| `dif`      | `.dif`          |   nessuno   | singolo| Formato scambio dati (DIF)       |
| `dbf`      | `.dbf`          |   nessuno   | singolo| dBASE II + estensioni VFP (DBF)  |
| `wk1`      | `.wk1`          |   nessuno   | singolo| Foglio di lavoro Lotus (WK1)     |
| `rtf`      | `.rtf`          |   nessuno   | singolo| Formato Rich Text (RTF)          |
| `prn`      | `.prn`          |   nessuno   | singolo| Testo formattato Lotus           |
| `eth`      | `.eth`          |   nessuno   | singolo| Formato record Ethercalc (ETH)   |

- `compression` si applica solo ai formati con contenitori ZIP.
- I formati che supportano un solo foglio richiedono l'opzione `sheet` che specifica
  il foglio di lavoro. Se la stringa è vuota, viene utilizzato il primo foglio.
- `writeFile` indovinerà automaticamente il formato del file di output in base all'estensione
  del file se `bookType` non viene specificato. Sceglierà il primo formato nella
  tabella sopra che corrisponde all'estensione.

### Tipo di output

L'argomento `type` per `write` rispecchia l'argomento `type` per `read`:

| `type`     | output                                                          |
|------------|-----------------------------------------------------------------|
| `"base64"` | stringa: codifica Base64 del file                               |
| `"binary"` | stringa: stringa binaria (il byte `n` è `data.charCodeAt(n)`)   |
| `"string"` | stringa: stringa JS (i caratteri interpretati come UTF8)        |
| `"buffer"` | Buffer nodejs                                                   |
| `"array"`  | ArrayBuffer, array di fallback di interi senza segno a 8 bit    |
| `"file"`   | stringa: percorso del file che verrà creato (solo nodejs)       |

- Per compatibilità con Excel, l'output `csv` includerà sempre il byte order mark
  UTF-8.

## Funzioni di utilità

Le funzioni `sheet_to_*` accettano un foglio di lavoro e un oggetto opzioni opzionale.

Le funzioni `*_to_sheet` accettano un oggetto dati e un oggetto opzioni opzionale.

Gli esempi si basano sul seguente foglio di lavoro:```
XXX| A | B | C | D | E | F | G |
---+---+---+---+---+---+---+---+
 1 | S | h | e | e | t | J | S |
 2 | 1 | 2 | 3 | 4 | 5 | 6 | 7 |
 3 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |

Il valore speciale di origine -1 indica a sheet_add_aoa di iniziare nella colonna A della riga successiva all'ultima riga nell'intervallo, aggiungendo i dati:```js XLSX.utils.sheet_add_aoa(worksheet, [ ["first row after data", 1], ["second row after data", 2] ], { origin: -1 });

</details>


### Modifica di altre proprietà di foglio di lavoro / cartella di lavoro / cella

La sezione ["Common Spreadsheet Format"](#common-spreadsheet-format) descrive
le strutture degli oggetti in maggior dettaglio.

## Impacchettamento e rilascio dei dati

### Scrittura di cartelle di lavoro

**API**

_Genera byte del foglio di calcolo (file) dai dati_```js
var data = XLSX.write(workbook, opts);

Il metodo write tenta di impacchettare i dati dal workbook in un file in memoria. Di default, vengono generati file XLSX, ma ciò può essere controllato con la proprietà bookType dell'argomento opts. In base all'opzione type, i dati possono essere memorizzati come "stringa binaria", stringa JS, Uint8Array o Buffer.

Il secondo argomento opts è obbligatorio. "Opzioni di scrittura" copre le proprietà e i comportamenti supportati.

Genera e tenta di salvare il file```js XLSX.writeFile(workbook, filename, opts);

Il metodo `writeFile` impacchetta i dati e tenta di salvare il nuovo file. Il formato del file di esportazione è determinato dall'estensione di `filename` (`SheetJS.xlsx` indica esportazione XLSX, `SheetJS.xlsb` indica esportazione XLSB, ecc.).

Il metodo `writeFile` utilizza API specifiche della piattaforma per avviare il salvataggio del file. In NodeJS, `fs.readFileSync` può creare un file. Nel browser web, viene tentato un download utilizzando l'attributo `download` di HTML5, con fallback per IE.

_Genera e tenta di salvare un file XLSX_```js
XLSX.writeFileXLSX(workbook, filename, opts);

Il metodo writeFile incorpora una serie di funzioni di esportazione differenti. Ciò è ottimo per l'esperienza dello sviluppatore ma non è adatto al tree shaking con gli attuali strumenti di sviluppo. Quando sono necessarie solo esportazioni XLSX, questo metodo evita di fare riferimento alle altre funzioni di esportazione.

Il secondo argomento opts è opzionale. "Opzioni di Scrittura" copre le proprietà e i comportamenti supportati.

Esempi

Per Node ESM, l'helper `writeFile` non è abilitato. Invece, `fs.writeFileSync` dovrebbe essere usato per scrivere i dati del file in un `Buffer` da utilizzare con `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);

Le applicazioni che scrivono file devono essere invocate con il flag `--allow-write`. La
[`deno` demo](https://github.com/weareu/xlsx/blob/HEAD/demos/deno/) contiene ulteriori esempi

</details>

<details>
  <summary><b>File locale in un plugin di PhotoShop o InDesign</b> (clicca per mostrare)</summary>

`writeFile` incapsula la logica `File` in Photoshop e in altri target di ExtendScript.
Il percorso specificato deve essere un percorso assoluto:```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>Scaricare un file in browser legacy</b> (clicca per mostrare)</summary>

`XLSX.writeFile` le tecniche funzionano per la maggior parte dei browser moderni e anche per le versioni precedenti di IE.
Per browser molto più datati, esistono soluzioni alternative implementate da librerie wrapper.

[`FileSaver.js`](https://github.com/eligrey/FileSaver.js/) implementa `saveAs`.
Nota: `XLSX.writeFile` chiamerà automaticamente `saveAs` se disponibile.```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");

Nota: La sezione ["Elaborazione di tabelle HTML"](#processing-html-tables) mostra come
generare un workbook da tabelle HTML in una pagina in "Headless WebKit".

</details>



Le [demo incluse](https://github.com/weareu/xlsx/blob/HEAD/demos/) coprono app mobili e altre distribuzioni speciali.

### Esempi di scrittura

- <http://sheetjs.com/demos/table.html> esportazione di una tabella HTML
- <http://sheetjs.com/demos/writexlsx.html> genera un file semplice

### Scrittura in streaming

Le funzioni di scrittura in streaming sono disponibili nell'oggetto `XLSX.stream`. Esse
accettano gli stessi argomenti delle normali funzioni di scrittura ma restituiscono uno stream leggibile di NodeJS.

- `XLSX.stream.to_csv` è la versione in streaming di `XLSX.utils.sheet_to_csv`.
- `XLSX.stream.to_html` è la versione in streaming di `XLSX.utils.sheet_to_html`.
- `XLSX.stream.to_json` è la versione in streaming di `XLSX.utils.sheet_to_json`.

<details>
  <summary><b>nodejs convertire in CSV e scrivere file</b> (clicca per mostrare)</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>Esportazione di file NUMBERS</b> (clicca per mostrare)</summary>

Lo scrittore NUMBERS richiede una base abbastanza grande.  Gli script supplementari `xlsx.zahl` forniscono supporto.  `xlsx.zahl.js` è progettato per l'uso standalone e NodeJS, mentre `xlsx.zahl.mjs` è adatto per ESM.

_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 invia flussi di scrittura alla risposta nodejs.

Generazione di dati JSON e JS

I dati JSON e JS tendono a rappresentare singoli fogli di lavoro. Le funzioni di utilità in questa sezione lavorano con singoli fogli di lavoro.

La sezione "Formato foglio di calcolo comune" descrive la struttura dell'oggetto in maggior dettaglio. workbook.SheetNames è un elenco ordinato dei nomi dei fogli di lavoro. workbook.Sheets è un oggetto le cui chiavi sono i nomi dei fogli e i cui valori sono oggetti foglio di lavoro.

Il "primo foglio di lavoro" è memorizzato in workbook.Sheets[workbook.SheetNames[0]].

API

Crea un array di oggetti JS da un foglio di lavoro```js var jsa = XLSX.utils.sheet_to_json(worksheet, opts);

_Crea un array di array di valori JS da un foglio di lavoro_```js
var aoa = XLSX.utils.sheet_to_json(worksheet, {...opts, header: 1});

La funzione utilitaria sheet_to_json esplora un workbook in ordine row-major, generando un array di oggetti. Il secondo argomento opts controlla una serie di decisioni di esportazione, incluso il tipo di valori (valori JS o testo formattato). La sezione "JSON" descrive l'argomento più in dettaglio.

Per impostazione predefinita, sheet_to_json esamina la prima riga e utilizza i valori come intestazioni. Con l'opzione header: 1, la funzione esporta un array di array di valori.

Esempi

x-spreadsheet è una griglia dati interattiva per visualizzare e modificare dati strutturati nel browser web. La demo xspreadsheet include uno script di esempio con la funzione stox per convertire da un workbook a un oggetto dati x-spreadsheet. https://oss.sheetjs.com/sheetjs/x-spreadsheet è una demo live.

/* 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>Anteprima dei dati in una griglia dati VueJS</b> (clicca per mostrare)</summary>

[`vue3-table-lite`](https://github.com/linmasahiro/vue3-table-lite) è una tabella dati semplice per VueJS 3. È presente nella [demo VueJS](https://github.com/weareu/xlsx/blob/HEAD/demos/vue/modify/).

</details>

<details>
  <summary><b>Popolare un database (SQL o no-SQL)</b> (clicca per mostrare)</summary>

La [`demo database`](https://github.com/weareu/xlsx/blob/HEAD/demos/database/) include esempi di lavoro con database e risultati di query.

</details>

<details>
  <summary><b>Calcoli numerici con TensorFlow.js</b> (clicca per mostrare)</summary>

[`@tensorflow/tfjs`](https://github.com/weareu/xlsx/blob/HEAD/@tensorflow/tfjs) e altre librerie si aspettano dati in array semplici, adatti per fogli di lavoro in cui ogni colonna è un vettore di dati. Questa è la trasposizione di come la maggior parte delle persone usa i fogli di calcolo, in cui ogni riga è un vettore.

Un singolo `Array#map` può estrarre singole righe nominate dall'esportazione di `sheet_to_json`:```js
const XLSX = require("xlsx");
const tf = require('@tensorflow/tfjs');

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

La [`react` demo](https://github.com/weareu/xlsx/blob/HEAD/demos/react) include ulteriori esempi di React.

</details>

<details>
  <summary><b>VueJS recupera il workbook e genera anteprime di tabelle HTML</b> (clicca per mostrare)</summary>

Generalmente si consiglia di utilizzare un flusso di lavoro compatibile con VueJS, ma è possibile generare HTML e utilizzarlo in VueJS con la direttiva `v-html`:```jsx
import { read, utils } from 'xlsx';
import { reactive } from 'vue';

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

Generazione di Snapshot per Singolo Foglio di Lavoro

Le funzioni sheet_to_* accettano un oggetto foglio di lavoro.

API

Genera un CSV da un singolo foglio di lavoro```js var csv = XLSX.utils.sheet_to_csv(worksheet, opts);

Questo snapshot è progettato per replicare il tipo di output "CSV UTF8 (`.csv`)".
["Output separato da delimitatore"](#delimiter-separated-output) descrive la
funzione e l'argomento opzionale `opts` in maggior dettaglio.

_Generare "Testo" da un singolo foglio di lavoro_```js
var txt = XLSX.utils.sheet_to_txt(worksheet, opts);

Questo snapshot è progettato per replicare il tipo di output "Testo UTF16 (.txt)". "Output con delimitatore" descrive la funzione e l'argomento opzionale opts in maggiore dettaglio.

Genera un elenco di formule da un singolo foglio di lavoro```js var fmla = XLSX.utils.sheet_to_formulae(worksheet);

Questo snapshot genera un array di voci che rappresentano le formule incorporate.
Le formule matriciali sono visualizzate nella forma `range=formula` mentre le celle semplici sono visualizzate nella forma `cell=formula o valore`. I valori letterali di stringa sono preceduti da un apostrofo `'`, in coerenza con la visualizzazione della barra della formula di Excel.

["Output delle formule"](#formulae-output) descrive la funzione in maggior dettaglio.

## Interface

`XLSX` è la variabile esposta nel browser e la variabile esportata di Node

`XLSX.version` è la versione della libreria (aggiunta dallo script di build).

`XLSX.SSF` è una versione incorporata della [libreria di formati](https://git.io/ssf).

### Parsing functions

`XLSX.read(data, read_opts)` tenta di analizzare `data`.

`XLSX.readFile(filename, read_opts)` tenta di leggere `filename` e analizzarlo.

Le opzioni di analisi sono descritte nella sezione [Opzioni di analisi](#parsing-options).

### Writing functions

`XLSX.write(wb, write_opts)` tenta di scrivere la cartella di lavoro `wb`

`XLSX.writeFile(wb, filename, write_opts)` tenta di scrivere `wb` in `filename`. In ambienti basati su browser, tenterà di forzare un download lato client.

`XLSX.writeFileAsync(wb, filename, o, cb)` tenta di scrivere `wb` in `filename`. Se `o` viene omesso, lo scrittore utilizzerà il terzo argomento come callback.

`XLSX.stream` contiene un insieme di funzioni di scrittura in streaming.

Le opzioni di scrittura sono descritte nella sezione [Opzioni di scrittura](#writing-options).

### Utilities

Le utility sono disponibili nell'oggetto `XLSX.utils` e sono descritte nella sezione [Funzioni di utility](#utility-functions):

**Costruzione:**

- `book_new` crea una cartella di lavoro vuota
- `book_append_sheet` aggiunge un foglio di lavoro a una cartella di lavoro

**Importazione:**

- `aoa_to_sheet` converte un array di array di dati JS in un foglio di lavoro.
- `json_to_sheet` converte un array di oggetti JS in un foglio di lavoro.
- `table_to_sheet` converte un elemento DOM TABLE in un foglio di lavoro.
- `sheet_add_aoa` aggiunge un array di array di dati JS a un foglio di lavoro esistente.
- `sheet_add_json` aggiunge un array di oggetti JS a un foglio di lavoro esistente.

**Esportazione:**

- `sheet_to_json` converte un oggetto foglio di lavoro in un array di oggetti JSON.
- `sheet_to_csv` genera output di valori separati da delimitatore.
- `sheet_to_txt` genera testo formattato UTF16.
- `sheet_to_html` genera output HTML.
- `sheet_to_formulae` genera un elenco delle formule (con valori di fallback).

**Manipolazione delle celle e degli indirizzi di cella:**

- `format_cell` genera il valore testuale per una cella (utilizzando i formati numerici).
- `encode_row / decode_row` converte tra righe con indice a 0 e righe con indice a 1.
- `encode_col / decode_col` converte tra colonne con indice a 0 e nomi di colonna.
- `encode_cell / decode_cell` converte indirizzi di cella.
- `encode_range / decode_range` converte intervalli di celle.

## Common Spreadsheet Format

SheetJS è conforme al Common Spreadsheet Format (CSF):

### General Structures

Gli oggetti indirizzo di cella sono memorizzati come `{c:C, r:R}` dove `C` e `R` sono rispettivamente i numeri di colonna e riga con indice a 0. Ad esempio, l'indirizzo di cella `B5` è rappresentato dall'oggetto `{c:1, r:4}`.

Gli oggetti intervallo di celle sono memorizzati come `{s:S, e:E}` dove `S` è la prima cella e `E` è l'ultima cella nell'intervallo. Gli intervalli sono inclusivi. Ad esempio, l'intervallo `A3:B7` è rappresentato dall'oggetto `{s:{c:0, r:2}, e:{c:1, r:6}}`.
Le funzioni di utility eseguono una traversata in ordine row-major di un intervallo di foglio:```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);
  }
}

Oggetto Cella

Gli oggetti cella sono oggetti JS semplici con chiavi e valori che seguono la convenzione:

Le utilità di esportazione integrate (come l'esportatore CSV) useranno il testo w se disponibile. Per modificare un valore, assicurati di eliminare cell.w (o impostarlo a undefined) prima di tentare l'esportazione. Le utilità rigenereranno il testo w dal formato numerico (cell.z) e dal valore grezzo, se possibile.

La formula matriciale effettiva è memorizzata nel campo f della prima cella nell'intervallo della matrice. Le altre celle nell'intervallo ometteranno il campo f.

Tipi di Dato

Il valore grezzo è memorizzato nella proprietà v, interpretato in base al tipo t. Questa separazione consente la rappresentazione di numeri e di testi numerici. Esistono 6 tipi di cella validi:

Il tipo n è il tipo Numero. Include tutte le forme di dati che Excel memorizza come numeri, come date/ore e campi booleani. Excel utilizza esclusivamente dati che possono essere inseriti in un numero a virgola mobile IEEE754, proprio come un Number JS, quindi il campo v contiene il numero grezzo. Il campo w contiene il testo formattato. Le date sono memorizzate come numeri per impostazione predefinita e convertite con XLSX.SSF.parse_date_code.

Il tipo d è il tipo Data, generato solo quando è passata l'opzione cellDates. Poiché JSON non ha un tipo Data naturale, ci si aspetta generalmente che i parser memorizzino stringhe di data ISO 8601 come quelle ottenute da date.toISOString(). D'altro canto, scrittori ed esportatori dovrebbero essere in grado di gestire stringhe di data e oggetti Date JS. Nota che Excel ignora i modificatori di fuso orario e tratta tutte le date nel fuso orario locale. La libreria non corregge questo errore.

Il tipo s è il tipo Stringa. I valori sono memorizzati esplicitamente come testo. Excel interpreterà queste celle come "numero memorizzato come testo". I file Excel generati sopprimono automaticamente questa classe di errore, ma altri formati possono generare errori.

Il tipo z rappresenta celle stub vuote. Sono generate in casi in cui le celle non hanno un valore assegnato ma contengono commenti o altri metadati. Sono ignorate dalle funzioni di utilità di elaborazione dati della libreria principale. Per impostazione predefinita, queste celle non sono generate; l'opzione del parser sheetStubs deve essere impostata a true.

Date

</details>

### Oggetti del Foglio

Ogni chiave che non inizia con `!` corrisponde a una cella (utilizzando la notazione `A-1`)

`sheet[address]` restituisce l'oggetto cella per l'indirizzo specificato.

**Chiavi speciali del foglio (accessibili come `sheet[key]`, ciascuna inizianti con `!`):**

- `sheet['!ref']`: Intervallo basato sulla notazione A-1 che rappresenta l'intervallo del foglio. Le funzioni che lavorano con i fogli dovrebbero usare questo parametro per determinare l'intervallo. Le celle assegnate al di fuori dell'intervallo non vengono elaborate. In particolare, quando si scrive un foglio a mano, le celle al di fuori dell'intervallo non vengono incluse.

  Le funzioni che gestiscono i fogli dovrebbero verificare la presenza del campo `!ref`. Se `!ref` viene omesso o non è un intervallo valido, le funzioni sono libere di trattare il foglio come vuoto o tentare di indovinare l'intervallo. Le utility standard fornite con questa libreria trattano i fogli come vuoti (ad esempio, l'output CSV è una stringa vuota).

  Quando si legge un foglio di lavoro con la proprietà `sheetRows` impostata, il parametro ref utilizzerà l'intervallo ristretto. L'intervallo originale è impostato in `ws['!fullref']`

- `sheet['!margins']`: Oggetto che rappresenta i margini di pagina. I valori predefiniti seguono il preset 'normale' di Excel. Excel ha anche un preset 'ampio' e uno 'stretto', ma vengono memorizzati come misure grezze. Le proprietà principali sono elencate di seguito:

<details>
  <summary><b>Dettagli dei margini di pagina</b> (clicca per mostrare)</summary>

| key      | description                  | "normal" | "wide" | "narrow" |
|----------|------------------------------|:---------|:-------|:-------- |
| `left`   | margine sinistro (pollici)   | `0.7`    | `1.0`  | `0.25`   |
| `right`  | margine destro (pollici)     | `0.7`    | `1.0`  | `0.25`   |
| `top`    | margine superiore (pollici)  | `0.75`   | `1.0`  | `0.75`   |
| `bottom` | margine inferiore (pollici)  | `0.75`   | `1.0`  | `0.75`   |
| `header` | margine dell'intestazione (pollici) | `0.3`    | `0.5`  | `0.3`    |
| `footer` | margine del piè di pagina (pollici) | `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}

Oggetto Foglio di Lavoro

Oltre alle chiavi base del foglio, i fogli di lavoro aggiungono anche:

• ws['!cols']: array di oggetti delle proprietà delle colonne. Le larghezze delle colonne sono effettivamente memorizzate nei file in modo normalizzato, misurate in termini di "Larghezza massima delle cifre" (la larghezza maggiore delle cifre renderizzate 0-9, in pixel). Una volta analizzato, gli oggetti colonna memorizzano la larghezza in pixel nel campo wpx, la larghezza in caratteri nel campo wch e la larghezza massima delle cifre nel campo MDW.

• ws['!rows']: array di oggetti delle proprietà delle righe come spiegato più avanti nella documentazione. Ogni oggetto riga codifica proprietà tra cui l'altezza e la visibilità della riga.

• ws['!merges']: array di oggetti intervallo corrispondenti alle celle unite nel foglio di lavoro. I formati di testo semplice non supportano le celle unite. L'esportazione CSV scriverà tutte le celle nell'intervallo di unione se esistono, quindi assicurati che sia impostata solo la prima cella (in alto a sinistra) dell'intervallo.

• ws['!outline']: configurare come devono comportarsi i contorni. Le opzioni predefinite corrispondono alle impostazioni predefinite in Excel 2019:

• ws['!protect']: oggetto delle proprietà di protezione del foglio in scrittura. La chiave password specifica la password per i formati che supportano fogli protetti da password (XLSX/XLSB/XLS). Lo scrittore utilizza il metodo di offuscamento XOR. Le seguenti chiavi controllano la protezione del foglio -- impostare a false per abilitare una funzionalità quando il foglio è bloccato o impostare a true per disabilitare una funzionalità:

• ws['!autofilter']: Oggetto AutoFilter che segue lo schema:```typescript type AutoFilter = { ref:string; // A-1 based range representing the AutoFilter table range }

#### Oggetto Chartsheet

I Chartsheet sono rappresentati come fogli standard. Sono distinti dalla
proprietà `!type` impostata a `"chart"`.

I dati sottostanti e `!ref` si riferiscono ai dati memorizzati nella cache nel chartsheet. La
prima riga del chartsheet è l'intestazione sottostante.

#### Oggetto Macrosheet

I Macrosheet sono rappresentati come fogli standard. Sono distinti dalla
proprietà `!type` impostata a `"macro"`.

#### Oggetto Dialogsheet

I Dialogsheet sono rappresentati come fogli standard. Sono distinti dalla
proprietà `!type` impostata a `"dialog"`.

### Oggetto Workbook

`workbook.SheetNames` è una lista ordinata dei fogli nel workbook

`wb.Sheets[sheetname]` restituisce un oggetto che rappresenta il foglio di lavoro.

`wb.Props` è un oggetto che memorizza le proprietà standard. `wb.Custprops` memorizza
proprietà personalizzate. Poiché le proprietà standard XLS differiscono dallo standard
XLSX, l'analisi XLS memorizza le proprietà principali in entrambi i posti.

`wb.Workbook` memorizza [attributi a livello di workbook](#attributi-a-livello-di-workbook).

#### Proprietà del file del Workbook

I vari formati di file utilizzano nomi interni diversi per le proprietà del file. L'oggetto
`Props` del workbook normalizza i nomi:

<details>
  <summary><b>Proprietà del file</b> (clicca per mostrare)</summary>

| Nome JS       | Descrizione Excel             |
|:--------------|:------------------------------|
| `Title`       | Scheda Riepilogo "Titolo"     |
| `Subject`     | Scheda Riepilogo "Oggetto"    |
| `Author`      | Scheda Riepilogo "Autore"     |
| `Manager`     | Scheda Riepilogo "Manager"    |
| `Company`     | Scheda Riepilogo "Società"    |
| `Category`    | Scheda Riepilogo "Categoria"  |
| `Keywords`    | Scheda Riepilogo "Parole chiave" |
| `Comments`    | Scheda Riepilogo "Commenti"   |
| `LastAuthor`  | Scheda Statistiche "Ultimo salvataggio di" |
| `CreatedDate` | Scheda Statistiche "Creato"   |

</details>

Ad esempio, per impostare la proprietà del titolo del workbook:```js
if(!wb.Props) wb.Props = {};
wb.Props.Title = "Insert Title Here";

Le proprietà personalizzate vengono aggiunte nell'oggetto Custprops della cartella di lavoro:```js if(!wb.Custprops) wb.Custprops = {}; wb.Custprops["Custom Property"] = "Custom Value";

Gli scrittori elaboreranno la chiave `Props` dell'oggetto delle opzioni:```js
/* force the Author to be "SheetJS" */
XLSX.write(wb, {Props:{Author:"SheetJS"}});

Attributi a livello di cartella di lavoro

wb.Workbook memorizza gli attributi a livello di cartella di lavoro.

Nomi definiti

wb.Workbook.Names è un array di oggetti nome definito che hanno le seguenti chiavi:

Excel consente a due nomi definiti con ambito foglio di condividere lo stesso nome. Tuttavia, un nome con ambito foglio non può entrare in conflitto con un nome con ambito cartella di lavoro. I writer di cartelle di lavoro potrebbero non applicare questo vincolo.

Viste della cartella di lavoro

wb.Workbook.Views è un array di oggetti vista della cartella di lavoro che hanno le seguenti chiavi:

Proprietà varie della cartella di lavoro

wb.Workbook.WBProps contiene altre proprietà della cartella di lavoro:

Funzionalità del documento

Anche per funzionalità di base come la memorizzazione delle date, i formati Excel ufficiali memorizzano lo stesso contenuto in modi diversi. I parser devono convertire dalla rappresentazione del formato file sottostante al Formato Foglio di Calcolo Comune (CSF). I writer devono riconvertire dal CSF al formato file sottostante.

Formule

La stringa della formula in stile A1 è memorizzata nel campo f. Anche se diversi formati di file memorizzano le formule in modi diversi, i formati vengono tradotti. Anche se alcuni formati memorizzano le formule con un segno di uguale iniziale, le formule CSF non iniziano con =.

Formule a cella singola

Per formule semplici, la chiave f della cella desiderata può essere impostata sul testo effettivo della formula. Questo foglio di lavoro rappresenta A1=1, A2=2 e A3=A1+A2:```js var worksheet = { "!ref": "A1:A3", A1: { t:'n', v:1 }, A2: { t:'n', v:2 }, A3: { t:'n', v:3, f:'A1+A2' } };

Utility come `aoa_to_sheet` accettano oggetti cella al posto dei valori:```js
var worksheet = XLSX.utils.aoa_to_sheet([
  [ 1 ], // A1
  [ 2 ], // A2
  [ {t: "n", v: 3, f: "A1+A2"} ] // A3
]);

Le celle con voci di formula ma senza valore verranno serializzate in modo che Excel e altri strumenti per fogli di calcolo le riconoscano. Questa libreria non calcolerà automaticamente i risultati delle formule! Ad esempio, il seguente foglio di lavoro includerà la funzione BESSELJ ma il risultato non sarà disponibile in JavaScript:```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 }

Se i risultati effettivi sono necessari in JS, [SheetJS Pro](https://sheetjs.com/pro) offre un componente calcolatore di formule per valutare espressioni, aggiornare valori e celle dipendenti, e aggiornare interi workbook.


**Formule Matriciali**

_Assegnare una formula matriciale_```js
XLSX.utils.sheet_set_array_formula(worksheet, range, formula);

Le formule matriciali sono memorizzate nella cella in alto a sinistra del blocco della matrice. Tutte le celle di una formula matriciale hanno un campo F corrispondente all'intervallo. Una formula a singola cella può essere distinta da una formula normale per la presenza del campo F.

Ad esempio, impostando la cella C1 alla formula matriciale {=SUM(A1:A3*B1:B3)}:```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" };

Per una formula matriciale multi-cella, ogni cella ha lo stesso intervallo di matrice ma solo la prima cella specifica la formula.  Considera `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 and writers are expected to check for the presence of a F field and ignore any possible formula element f in cells other than the starting cell. They are not expected to perform validation of the formulae!

Formule Dynamic Array

Assegna una formula di array dinamico```js XLSX.utils.sheet_set_array_formula(worksheet, range, formula, true);

Rilasciate nel 2020, le Formule di matrice dinamiche sono supportate nei formati di file XLSX/XLSM e XLSB. Sono rappresentate come normali formule di matrice ma hanno metadati speciali sulle celle che indicano che la formula dovrebbe poter regolare l'intervallo.

Una formula di matrice può essere contrassegnata come dinamica impostando la proprietà `D` della cella a true. L'intervallo `F` è previsto ma può essere impostato sulla cella corrente:```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

Localizzazione con nomi di funzione

SheetJS opera a livello di file. Excel memorizza le espressioni delle formule utilizzando i nomi di funzione in inglese (Stati Uniti). Per gli utenti non inglesi, Excel utilizza un insieme localizzato di nomi di funzione.

Ad esempio, quando la lingua e la regione del computer sono impostate su Francese (Francia), Excel interpreta =SOMME(A1:C3) come se SOMME fosse la funzione SUM. Tuttavia, nel file effettivo, Excel memorizza SUM(A1:C3).

Funzioni "Future" con prefisso

Le funzioni introdotte nelle versioni più recenti di Excel sono precedute da _xlfn. quando vengono memorizzate nei file. Quando si scrivono espressioni di formula utilizzando queste funzioni, il prefisso è necessario per la massima compatibilità:```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);

Quando si legge un file, l'opzione `xlfn` preserva i prefissi.

<details>
  <summary><b> Funzioni che richiedono il prefisso `_xlfn.`</b> (clicca per mostrare)</summary>

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

Proprietà delle righe: XLSX/M, XLSB, BIFF8 XLS, XLML, SYLK, DOM, ODS

Proprietà delle colonne: XLSX/M, XLSB, BIFF8 XLS, XLML, SYLK, DOM

Esistono tre diversi tipi di larghezza corrispondenti ai tre diversi modi in cui i fogli di calcolo memorizzano le larghezze delle colonne:

I formati SYLK e altri formati di testo semplice utilizzano il conteggio grezzo dei caratteri. Gli strumenti coevi come Visicalc e Multiplan erano basati sui caratteri. Poiché i caratteri avevano la stessa larghezza, era sufficiente memorizzare un conteggio. Questa tradizione è continuata nei formati BIFF.

SpreadsheetML (2003) ha tentato di allinearsi con HTML standardizzando il conteggio dei pixel sullo schermo in tutto il file. Le larghezze delle colonne, le altezze delle righe e altre misure utilizzano i pixel. Quando i conteggi di pixel e caratteri non coincidono, Excel arrotonda i valori.

XLSX memorizza internamente le larghezze delle colonne in una nebulosa forma di "Larghezza massima della cifra" (Max Digit Width). La Larghezza massima della cifra è la larghezza della cifra più grande quando viene visualizzata (generalmente il carattere "0" è il più largo). La larghezza interna deve essere un multiplo intero della larghezza divisa per 256. ECMA-376 descrive una formula per la conversione tra pixel e larghezza interna. Questo rappresenta un approccio ibrido.

Le funzioni di lettura tentano di popolare tutte e tre le proprietà. Le funzioni di scrittura tenteranno di convertire i valori specificati nel tipo desiderato. Per evitare potenziali conflitti, la manipolazione dovrebbe prima eliminare le altre proprietà. Per esempio, quando si modifica la larghezza in pixel, eliminare le proprietà wch e width.

Altezze delle righe

Excel memorizza internamente le altezze delle righe in punti. La risoluzione predefinita è 72 DPI o 96 PPI, quindi la dimensione in pixel e in punti dovrebbe coincidere. Per risoluzioni diverse potrebbero non coincidere, quindi la libreria separa i concetti.

Anche se tutte le informazioni sono disponibili, ci si aspetta che gli scrittori seguano l'ordine di priorità:

1. utilizzare l'altezza in pixel hpx se disponibile
2. utilizzare l'altezza in punti hpt se disponibile

Larghezze delle colonne

Date le limitazioni, è possibile determinare la MDW senza effettivamente ispezionare il font! I parser indovinano la larghezza in pixel convertendo dalla larghezza a pixel e viceversa, ripetendo per tutte le possibili MDW e selezionando la MDW che minimizza l'errore. XLML memorizza effettivamente la larghezza in pixel, quindi l'ipotesi funziona nella direzione opposta.

Anche se tutte le informazioni sono disponibili, ci si aspetta che gli scrittori seguano l'ordine di priorità:

1. utilizzare il campo width se disponibile
2. utilizzare la larghezza in pixel wpx se disponibile
3. utilizzare il conteggio dei caratteri wch se disponibile

I formati predefiniti sono elencati in ECMA-376 18.8.30:

Collegamenti ipertestuali delle celle: XLSX/M, XLSB, BIFF8 XLS, XLML, ODS

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

Read more