_राष्ट्रपतियों के लिए फ़िल्टरिंग_

डेटासेट में Aaron Burr शामिल है, जो एक उपराष्ट्रपति थे जो कभी राष्ट्रपति नहीं बने!

`Array#filter` वांछित पंक्तियों के साथ एक नई सरणी बनाता है।  एक राष्ट्रपति ने
कम से कम एक कार्यकाल में सेवा की, जिसमें `type` सेट `"prez"` है।  यह जाँचने के लिए कि किसी विशेष पंक्ति में
कम से कम एक `"prez"` कार्यकाल है, `Array#some` एक और नेटिव JS फ़ंक्शन है।  पूर्ण
फ़िल्टर इस प्रकार होगा:```js
const prez = raw_data.filter(row => row.terms.some(term => term.type === "prez"));

परिणाम बिना किसी नेस्टिंग के "सरल" ऑब्जेक्ट्स की एक सरणी है:```js
[
  { name: "George Washington", birthday: "1732-02-22" },
  { name: "John Adams", birthday: "1735-10-19" },
  // ... one row per President
]

`XLSX.utils.book_new` एक नई कार्यपुस्तिका बनाता है और `XLSX.utils.book_append_sheet`
कार्यपुस्तिका में एक वर्कशीट जोड़ता है। नई वर्कशीट को "Dates" कहा जाएगा:```js
const workbook = XLSX.utils.book_new();
XLSX.utils.book_append_sheet(workbook, worksheet, "Dates");

_कॉलम की चौड़ाई ठीक करना_

कुछ नाम डिफ़ॉल्ट कॉलम चौड़ाई से लंबे हैं।  कॉलम की चौड़ाई
[वर्कशीट प्रॉपर्टी `"!cols"` सेट करके](#row-and-column-properties) निर्धारित की जाती है।

निम्न पंक्ति कॉलम A की चौड़ाई लगभग 10 वर्णों पर सेट करती है:```js
worksheet["!cols"] = [ { wch: 10 } ]; // set column A width to 10 characters

नोट: यदि प्रारंभिक बिंदु कोई फ़ाइल या HTML तालिका थी, तो `XLSX.utils.sheet_to_json`
JS ऑब्जेक्ट्स की एक सरणी उत्पन्न करेगा।

**पैकेज और रिलीज़ डेटा**

`XLSX.writeFile` एक स्प्रेडशीट फ़ाइल बनाता है और उसे सिस्टम में लिखने का प्रयास करता है।
ब्राउज़र में, यह उपयोगकर्ता को फ़ाइल डाउनलोड करने के लिए संकेत देने का प्रयास करेगा। NodeJS में,
यह स्थानीय निर्देशिका में लिखेगा।```js
XLSX.writeFile(workbook, "Presidents.xlsx");

वेब ब्राउज़र में उपयोग के लिए, यह मानते हुए कि स्निपेट `snippet.js` में सहेजा गया है,
`axios` और `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>

For Node ESM के लिए, `readFile` सहायक सक्षम नहीं है। इसके बजाय, `fs.readFileSync` का उपयोग फ़ाइल डेटा को `Buffer` के रूप में पढ़ने के लिए किया जाना चाहिए, ताकि इसे `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);

Applications reading files must be invoked with the `--allow-read` flag.  The
[`deno` डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/deno/) में और उदाहरण हैं

</details>

<details>
  <summary><b>वेब पेज में उपयोगकर्ता द्वारा सबमिट की गई फ़ाइल ("Drag-and-Drop")</b> (देखने के लिए क्लिक करें)</summary>

Chrome 76+ को लक्षित करने वाली आधुनिक वेबसाइटों के लिए, `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);

/* DO SOMETHING WITH workbook HERE */

<https://oss.sheetjs.com/sheetjs/> FileReader तकनीक को प्रदर्शित करता है।

</details>

<details>
  <summary><b>HTML INPUT तत्व के साथ उपयोगकर्ता द्वारा सबमिट की गई फ़ाइल</b> (दिखाने के लिए क्लिक करें)</summary>

एक HTML INPUT तत्व से शुरू करें जिसमें `type="file"` है:```html
<input type="file" id="input_dom_element">

व्यापक समर्थन (IE10+ सहित) के लिए, `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);

व्यापक समर्थन के लिए, `XMLHttpRequest` दृष्टिकोण अनुशंसित है:```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();

[`extendscript` डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/extendscript/) में एक अधिक जटिल उदाहरण शामिल है।

</details>

<details>
  <summary><b>Electron ऐप में स्थानीय फ़ाइल</b> (दिखाने के लिए क्लिक करें)</summary>

`readFile` का उपयोग रेंडरर प्रक्रिया में किया जा सकता है:```js
/* From the renderer process */
var XLSX = require("xlsx");

var workbook = XLSX.readFile(path);

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

`ascii` एन्कोडिंग बाइनरी स्ट्रिंग्स लौटाता है जो `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"});

/* DO SOMETHING WITH workbook HERE */

[`server` डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/server) में अधिक उन्नत उदाहरण हैं।

</details>

<details>
  <summary><b>NodeJS प्रोसेस में फ़ाइलें डाउनलोड करें</b> (देखने के लिए क्लिक करें)</summary>

Node 17.5 और 18.0 में fetch के लिए मूल समर्थन है:```js
const XLSX = require("xlsx");

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

[`axios`](https://npm.im/axios) ब्राउज़र और 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 */
})();

/* DO SOMETHING WITH workbook HERE */

</details>

<details>
  <summary><b>NodeJS में Readable Streams</b> (देखने के लिए क्लिक करें)</summary>

Readable Streams के साथ काम करते समय, सबसे आसान तरीका है स्ट्रीम को बफ़र करना
और अंत में पूरी चीज़ को प्रोसेस करना:```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);
  });
}

</details>

अधिक विस्तृत उदाहरण [शामिल डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/) में दिए गए हैं।

### JSON और JS डेटा की प्रोसेसिंग

JSON और JS डेटा आमतौर पर एकल वर्कशीट का प्रतिनिधित्व करते हैं।  यह अनुभाग कुछ उपयोगिता फ़ंक्शनों का  
उपयोग करके वर्कबुक उत्पन्न करेगा।

_एक नई Workbook बनाएँ_```js
var workbook = XLSX.utils.book_new();

`aoa_to_sheet` उपयोगिता फ़ंक्शन "ऐरे ऑफ ऐरे" को row-major
क्रम में ट्रैवर्स करता है, जिससे एक worksheet ऑब्जेक्ट उत्पन्न होता है।  निम्नलिखित स्निपेट एक शीट उत्पन्न करता है
जिसमें सेल `A1` स्ट्रिंग `A1` पर सेट है, सेल `B1` `B1` पर सेट है, आदि:```js
var worksheet = XLSX.utils.aoa_to_sheet([
  ["A1", "B1", "C1"],
  ["A2", "B2", "C2"],
  ["A3", "B3", "C3"]
]);

`json_to_sheet` उपयोगिता फ़ंक्शन JS ऑब्जेक्ट्स की एक सरणी को क्रम में ट्रैवर्स करता है,
एक worksheet ऑब्जेक्ट उत्पन्न करता है।  डिफ़ॉल्ट रूप से, यह एक हेडर पंक्ति और
सरणी में प्रत्येक ऑब्जेक्ट के लिए एक पंक्ति उत्पन्न करेगा।  वैकल्पिक `opts` आर्गुमेंट में
कॉलम क्रम और हेडर आउटपुट को नियंत्रित करने की सेटिंग्स होती हैं।

["ऑब्जेक्ट्स की सरणी इनपुट"](#array-of-arrays-input) फ़ंक्शन और
वैकल्पिक `opts` आर्गुमेंट का अधिक विवरण देता है।

**उदाहरण**

["SheetJS का ज़ेन"](#the-zen-of-sheetjs) में "JSON एंडपॉइंट से
डेटा प्राप्त करें और एक Workbook बनाएं" नामक एक विस्तृत उदाहरण शामिल है।


[`x-spreadsheet`](https://github.com/myliang/x-spreadsheet) एक इंटरैक्टिव
डेटा ग्रिड है जो वेब ब्राउज़र में संरचित डेटा को पूर्वावलोकन और संशोधित करने के लिए है।
यह [`xspreadsheet` डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/xspreadsheet) एक नमूना स्क्रिप्ट शामिल करता है जिसमें
`xtos` फ़ंक्शन है जो x-spreadsheet डेटा ऑब्जेक्ट से workbook में परिवर्तित करता है।
<https://oss.sheetjs.com/sheetjs/x-spreadsheet> एक लाइव डेमो है।

<details>
  <summary><b>डेटाबेस क्वेरी (SQL या no-SQL) से रिकॉर्ड्स</b> (दिखाने के लिए क्लिक करें)</summary>

[`database` डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/database/) में डेटाबेस और
क्वेरी परिणामों के साथ काम करने के उदाहरण शामिल हैं।

</details>


<details>
  <summary><b>TensorFlow.js के साथ संख्यात्मक गणनाएँ</b> (दिखाने के लिए क्लिक करें)</summary>

[`@tensorflow/tfjs`](https://github.com/weareu/xlsx/blob/HEAD/@tensorflow/tfjs) और अन्य लाइब्रेरीज़ डेटा को सरल
सरणियों में अपेक्षा करती हैं, जो worksheets के लिए उपयुक्त हैं जहाँ प्रत्येक कॉलम एक डेटा वेक्टर है।  यह
उस तरीके का ट्रांसपोज़ है जिसमें अधिकांश लोग स्प्रेडशीट का उपयोग करते हैं, जहाँ प्रत्येक पंक्ति एक वेक्टर होती है।

`tfjs` से डेटा प्राप्त करते समय, लौटाए गए डेटा बिंदु एक typed
array में संग्रहीत होते हैं।  लूप्स के साथ सरणियों की एक सरणी बनाई जा सकती है। `Array#unshift`
रूपांतरण से पहले एक शीर्षक पंक्ति जोड़ सकता है:```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);

वेब पेज पर कई तालिकाओं को अलग-अलग वर्कशीट में परिवर्तित किया जा सकता है:```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 */

यह [`chrome` demo](https://github.com/weareu/xlsx/blob/HEAD/demos/chrome/) एक पूर्ण उदाहरण दिखाता है और आवश्यक अनुमतियों तथा अन्य सेटिंग्स का विवरण देता है।

एक एक्सटेंशन में, वर्कबुक को कंटेंट स्क्रिप्ट में उत्पन्न करने और ऑब्जेक्ट को वापस एक्सटेंशन में भेजने की अनुशंसा की जाती है:```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);
});

/* DO SOMETHING WITH workbook HERE */

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

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

</details>

<details>
  <summary><b>हेडलेस WebKit के साथ सर्वर-साइड HTML तालिकाएँ</b> (दिखाने के लिए क्लिक करें)</summary>

The [`headless` डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/headless/) में HTML फ़ाइलों को XLSB वर्कबुक में बदलने
के लिए [PhantomJS](https://phantomjs.org/) का उपयोग करके एक संपूर्ण डेमो शामिल है। मुख्य विचार
पृष्ठ पर स्क्रिप्ट जोड़ना, पृष्ठ संदर्भ में तालिका को पार्स करना, एक `binary` वर्कबुक
उत्पन्न करना और आगे की प्रक्रिया के लिए उसे वापस भेजना है:```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();
  });
});

</details>

## डेटा प्रोसेसिंग

["Common Spreadsheet Format"](#common-spreadsheet-format) कार्यपुस्तिका की मूल अवधारणाओं का एक सरल ऑब्जेक्ट प्रतिनिधित्व है।
उपयोगिता फ़ंक्शन इस ऑब्जेक्ट प्रतिनिधित्व के साथ काम करते हैं
और सामान्य उपयोग के मामलों को संभालने के लिए अभिप्रेत हैं।

### कार्यपुस्तिका संरचना को संशोधित करना

**API**

_किसी कार्यपुस्तिका में एक वर्कशीट जोड़ना_```js
XLSX.utils.book_append_sheet(workbook, worksheet, sheet_name);

यदि चौथा तर्क `true` है, तो फ़ंक्शन निर्दिष्ट  
वर्कशीट नाम से प्रारंभ होगा।  यदि शीट नाम वर्कबुक में मौजूद है, तो एक नया वर्कशीट नाम  
नाम स्टेम ढूंढकर और काउंटर बढ़ाकर चुना जाएगा:```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

workbook ऑब्जेक्ट की `SheetNames` प्रॉपर्टी, worksheet नामों की एक सूची है, जो
"टैब क्रम" में होती है।  API फ़ंक्शन इस array को देखेंगे।

_किसी Worksheet को उसी स्थान पर बदलें_```js
workbook.Sheets[sheet_name] = new_worksheet;

Node ESM के लिए, `writeFile` सहायक सक्षम नहीं है। इसके बजाय, `fs.writeFileSync`
का उपयोग फ़ाइल डेटा को `Buffer` में लिखने के लिए किया जाना चाहिए, ताकि `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);

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

</details>

<details>
  <summary><b>फोटोशॉप या InDesign प्लगइन में स्थानीय फ़ाइल</b> (देखने के लिए क्लिक करें)</summary>

`writeFile` फोटोशॉप और अन्य ExtendScript लक्ष्यों में `File` तर्क को लपेटता है।
निर्दिष्ट पथ एक पूर्ण पथ होना चाहिए:```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>विरासती ब्राउज़रों में फ़ाइल डाउनलोड करें</b> (दिखाने के लिए क्लिक करें)</summary>

`XLSX.writeFile` तकनीकें अधिकांश आधुनिक ब्राउज़रों के साथ-साथ पुराने IE के लिए भी काम करती हैं।
इससे भी पुराने ब्राउज़रों के लिए, रैपर लाइब्रेरीज़ द्वारा लागू किए गए वर्कअराउंड मौजूद हैं।

[`FileSaver.js`](https://github.com/eligrey/FileSaver.js/) `saveAs` लागू करता है।
ध्यान दें: यदि उपलब्ध हो, तो `XLSX.writeFile` स्वचालित रूप से `saveAs` को कॉल करेगा।```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");

यह [`oldie` डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/oldie/) IE-संगत फ़ॉलबैक परिदृश्य दिखाता है।

</details>

<details>
  <summary><b>ब्राउज़र फ़ाइल अपलोड (ajax)</b> (दिखाने के लिए क्लिक करें)</summary>

XHR का उपयोग करने वाला एक संपूर्ण उदाहरण [XHR डेमो में शामिल है](https://github.com/weareu/xlsx/blob/HEAD/demos/xhr/), साथ ही
fetch और रैपर लाइब्रेरीज़ के उदाहरण भी हैं।  यह उदाहरण मानता है कि सर्वर
Base64-एन्कोडेड फ़ाइलों को संभाल सकता है (बुनियादी nodejs सर्वर के लिए डेमो देखें):```js
/* in this example, send a base64 string to the server */
var wopts = { bookType:"xlsx", bookSST:false, type:"base64" };

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

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

नोट: अनुभाग ["HTML तालिकाओं को प्रोसेस करना"](#processing-html-tables) दिखाता है कि
"Headless WebKit" में किसी पृष्ठ की HTML तालिकाओं से वर्कबुक कैसे उत्पन्न करें।

</details>



[शामिल डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/) मोबाइल ऐप्स और अन्य विशेष परिनियोजनों को कवर करते हैं।

### लेखन उदाहरण

- <http://sheetjs.com/demos/table.html> एक HTML तालिका निर्यात करना
- <http://sheetjs.com/demos/writexlsx.html> एक सरल फ़ाइल उत्पन्न करता है

### स्ट्रीमिंग लेखन

स्ट्रीमिंग लेखन फ़ंक्शन `XLSX.stream` ऑब्जेक्ट में उपलब्ध हैं।  वे
सामान्य लेखन फ़ंक्शनों के समान तर्क लेते हैं लेकिन एक NodeJS
Readable Stream लौटाते हैं।

- `XLSX.stream.to_csv` `XLSX.utils.sheet_to_csv` का स्ट्रीमिंग संस्करण है।
- `XLSX.stream.to_html` `XLSX.utils.sheet_to_html` का स्ट्रीमिंग संस्करण है।
- `XLSX.stream.to_json` `XLSX.utils.sheet_to_json` का स्ट्रीमिंग संस्करण है।

<details>
  <summary><b>nodejs को CSV में बदलें और फ़ाइल लिखें</b> (दिखाने के लिए क्लिक करें)</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>NUMBERS फ़ाइलें निर्यात करना</b> (दिखाने के लिए क्लिक करें)</summary>

NUMBERS लेखक को काफी बड़े आधार की आवश्यकता होती है।  सहायक `xlsx.zahl`
स्क्रिप्ट समर्थन प्रदान करती हैं।  `xlsx.zahl.js` स्टैंडअलोन और NodeJS
उपयोग के लिए डिज़ाइन की गई है, जबकि `xlsx.zahl.mjs` ESM के लिए उपयुक्त है।

_ब्राउज़र_```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});

/* 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>VueJS डेटा ग्रिड में डेटा का पूर्वावलोकन</b> (दिखाने के लिए क्लिक करें)</summary>

[`vue3-table-lite`](https://github.com/linmasahiro/vue3-table-lite) एक सरल
VueJS 3 डेटा टेबल है। इसे [VueJS डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/vue/modify/) में दिखाया गया है।

</details>

<details>
  <summary><b>डेटाबेस (SQL या no-SQL) में डेटा भरना</b> (दिखाने के लिए क्लिक करें)</summary>

[`database` डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/database/) में डेटाबेस और क्वेरी परिणामों के साथ काम करने के
उदाहरण शामिल हैं।

</details>

<details>
  <summary><b>TensorFlow.js के साथ संख्यात्मक गणना</b> (दिखाने के लिए क्लिक करें)</summary>

[`@tensorflow/tfjs`](https://github.com/weareu/xlsx/blob/HEAD/@tensorflow/tfjs) और अन्य लाइब्रेरीज़ डेटा को सरल
ऐरे में अपेक्षा करती हैं, जो उन वर्कशीटों के लिए उपयुक्त हैं जहाँ प्रत्येक कॉलम एक डेटा वेक्टर होता है। यह
उस तरीके का ट्रांसपोज़ है जिस तरह अधिकांश लोग स्प्रेडशीट का उपयोग करते हैं, जहाँ प्रत्येक पंक्ति एक वेक्टर होती है।

एक अकेला `Array#map` `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);

The [`array` डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/array/) एक संपूर्ण उदाहरण दिखाता है।

</details>


### HTML तालिकाएँ उत्पन्न करना

**API**

_वर्कशीट से HTML तालिका उत्पन्न करें_```js
var html = XLSX.utils.sheet_to_html(worksheet);

`fetch` के साथ संयोजन करके, एक वर्कबुक से साइट बनाना सीधा है:

<details>
  <summary><b>वेनिला JS + HTML fetch वर्कबुक और टेबल पूर्वावलोकन जनरेट करें</b> (क्लिक करके दिखाएँ)</summary>```html
<body>
  <style>TABLE { border-collapse: collapse; } TD { border: 1px solid; }</style>
  <div id="tavolo"></div>
  <script src="https://unpkg.com/xlsx/dist/xlsx.full.min.js"></script>
  <script type="text/javascript">
(async() => {
  /* fetch and parse workbook -- see the fetch example for details */
  const workbook = XLSX.read(await (await fetch("sheetjs.xlsx")).arrayBuffer());

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

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

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

यह [`react` डेमो](https://github.com/weareu/xlsx/blob/HEAD/demos/react) में और अधिक React उदाहरण शामिल हैं।

</details>

<details>
  <summary><b>VueJS वर्कबुक प्राप्त करें और HTML तालिका पूर्वावलोकन उत्पन्न करें</b> (दिखाने के लिए क्लिक करें)</summary>

सामान्यतः VueJS-अनुकूल वर्कफ़्लो का उपयोग करने की सलाह दी जाती है, लेकिन यह संभव है
कि HTML उत्पन्न करके इसे `v-html` निर्देश के साथ VueJS में उपयोग किया जाए:```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>`
};

</details>

### शीट ऑब्जेक्ट्स

प्रत्येक कुंजी जो `!` से प्रारंभ नहीं होती, एक सेल से मैप होती है (`A-1` संकेतन का उपयोग करके)

`sheet[address]` निर्दिष्ट पते के लिए सेल ऑब्जेक्ट लौटाता है।

**विशेष शीट कुंजियाँ (`sheet[key]` के रूप में पहुँच योग्य, प्रत्येक `!` से प्रारंभ होती हैं):**

- `sheet['!ref']`: शीट रेंज का प्रतिनिधित्व करने वाली A-1 आधारित रेंज।  जो फ़ंक्शन
  शीट के साथ काम करते हैं, उन्हें रेंज निर्धारित करने के लिए इस पैरामीटर का उपयोग करना चाहिए।  रेंज के बाहर निर्दिष्ट किए गए सेल
  प्रोसेस नहीं होते हैं।  विशेष रूप से, जब
  शीट को हाथ से लिखा जाता है, तो रेंज के बाहर के सेल शामिल नहीं होते हैं

  शीट को संभालने वाले फ़ंक्शनों को `!ref` फ़ील्ड की उपस्थिति की जाँच करनी चाहिए।
  यदि `!ref` छोड़ दिया गया है या मान्य रेंज नहीं है, तो फ़ंक्शन
  शीट को खाली मानने या रेंज का अनुमान लगाने के लिए स्वतंत्र हैं।  जो मानक उपकरण
  इस लाइब्रेरी के साथ आते हैं, वे शीट को खाली मानते हैं (उदाहरण के लिए, CSV आउटपुट
  खाली स्ट्रिंग है)।

  जब `sheetRows` प्रॉपर्टी सेट होने पर वर्कशीट पढ़ी जाती है, तो ref पैरामीटर
  प्रतिबंधित रेंज का उपयोग करेगा।  मूल रेंज `ws['!fullref']` पर सेट होती है

- `sheet['!margins']`: पेज मार्जिन का प्रतिनिधित्व करने वाला ऑब्जेक्ट।  डिफ़ॉल्ट मान
  Excel के "normal" प्रीसेट का अनुसरण करते हैं।  Excel में "wide" और "narrow" प्रीसेट भी हैं
  लेकिन वे कच्चे माप के रूप में संग्रहीत होते हैं। मुख्य प्रॉपर्टीज़ नीचे सूचीबद्ध हैं:

<details>