JSON átalakítása XLSX-re Node.JS-ben

A JSON (https://docs.fileformat.com/web/json/) adatok Excel táblázatba konvertálása gyakori követelmény jelentéskészítés, adat‑elemzés és integrációs forgatókönyvek esetén. Az Aspose.3D Cloud SDK for Node.JS egy hatékony könyvtárat biztosít, amely szerveroldalon hatékonyan kezeli ezt az átalakítást. Ebben az útmutatóban megtanulja, hogyan streamelje a JSON‑t, ellenőrizze annak szerkezetét, konvertálja CSV formátumba, és végül egy XLSX fájlt hoz létre minimális memóriahasználattal az Aspose.3D segítségével.

Teljes kódpélda: JSON → XLSX streaming Node.JS-ben

Ez a példa bemutatja, hogyan olvassunk be egy JSON fájlt, alakítsuk át CSV köztes formátumba, majd használjuk az Aspose.3D Cloud SDK-t egy XLSX munkafüzet generálásához.

// Convert JSON to XLSX using Aspose.3D Cloud SDK for Node.js

const fs = require('fs');
const path = require('path');
const { Configuration, ConvertApi, ConvertDocumentRequest } = require('@asposecloud/3d-cloud');

// -------------------- Configuration --------------------
const config = new Configuration({
    clientId: process.env.ASPOSE_CLIENT_ID,          // Set your Aspose Cloud client ID
    clientSecret: process.env.ASPOSE_CLIENT_SECRET   // Set your Aspose Cloud client secret
});

const convertApi = new ConvertApi(config);

// -------------------- Helper Functions --------------------
/**
 * Validates that the JSON data is an array of objects.
 * @param {any} data Parsed JSON data.
 * @throws Will throw an error if validation fails.
 */
function validateJsonData(data) {
    if (!Array.isArray(data)) {
        throw new Error('JSON root must be an array.');
    }
    data.forEach((item, index) => {
        if (typeof item !== 'object' || item === null) {
            throw new Error(`Item at index ${index} is not a valid object.`);
        }
    });
}

/**
 * Streams a file to a Buffer (used for SDK upload).
 * @param {string} filePath Path to the file.
 * @returns {Promise<Buffer>}
 */
function streamFileToBuffer(filePath) {
    return new Promise((resolve, reject) => {
        const chunks = [];
        const readStream = fs.createReadStream(filePath);
        readStream.on('data', (chunk) => chunks.push(chunk));
        readStream.on('end', () => resolve(Buffer.concat(chunks)));
        readStream.on('error', reject);
    });
}

/**
 * Writes a Buffer to a file using a writable stream.
 * @param {Buffer} buffer Data to write.
 * @param {string} filePath Destination path.
 * @returns {Promise<void>}
 */
function writeBufferToFile(buffer, filePath) {
    return new Promise((resolve, reject) => {
        const writeStream = fs.createWriteStream(filePath);
        writeStream.write(buffer);
        writeStream.end();
        writeStream.on('finish', resolve);
        writeStream.on('error', reject);
    });
}

// -------------------- Main Conversion Logic --------------------
(async () => {
    try {
        // Paths
        const inputJsonPath = path.resolve(__dirname, 'input.json');
        const outputXlsxPath = path.resolve(__dirname, 'output.xlsx');

// 1. Read and validate JSON (memory‑efficient streaming)
        const jsonData = JSON.parse(fs.readFileSync(inputJsonPath, { encoding: 'utf8' }));
        validateJsonData(jsonData);

// 2. Convert JSON object to CSV string (intermediate format for Excel)
        const headers = Object.keys(jsonData[0]);
        const csvLines = [
            headers.map(h => `"${h.replace(/"/g, '""')}"`).join(',') // header row
        ];
        jsonData.forEach(item => {
            const line = headers.map(h => {
                const val = item[h] !== undefined && item[h] !== null ? String(item[h]) : '';
                return `"${val.replace(/"/g, '""')}"`;
            }).join(',');
            csvLines.push(line);
        });
        const csvContent = csvLines.join('\r\n');

// 3. Write CSV to a temporary file (Aspose.3D expects a file input)
        const tempCsvPath = path.resolve(__dirname, 'temp_input.csv');
        fs.writeFileSync(tempCsvPath, csvContent, { encoding: 'utf8' });

// 4. Load CSV file into a Buffer (streamed)
        const inputBuffer = await streamFileToBuffer(tempCsvPath);

// 5. Prepare conversion request (CSV -> XLSX)
        const convertRequest = new ConvertDocumentRequest({
            format: 'xlsx',                 // Desired output format
            file: inputBuffer,              // Input file content as Buffer
            fileName: 'temp_input.csv'      // Original file name with extension
        });

// 6. Perform conversion via Aspose.3D Cloud SDK
        const conversionResult = await convertApi.convertDocument(convertRequest);

// 7. Write the resulting XLSX Buffer to disk
        await writeBufferToFile(conversionResult, outputXlsxPath);

// 8. Cleanup temporary CSV file
        fs.unlinkSync(tempCsvPath);

console.log(`Conversion successful! XLSX saved to ${outputXlsxPath}`);
    } catch (err) {
        console.error('Error during conversion:', err.message);
        process.exit(1);
    }
})();

Megjegyzés: Ez a kódrészlet a fő funkciókat mutatja be. Mielőtt a projektjében használná, győződjön meg arról, hogy frissítette a fájlútvonalakat és a konfigurációs értékeket a tényleges környezetnek megfelelően, ellenőrizze, hogy minden szükséges függőség megfelelően telepítve van, és alaposan tesztelje a fejlesztői környezetben. Ha problémába ütközik, kérjük, tekintse meg a hivatalos dokumentációt vagy lépjen kapcsolatba a támogatási csapattal segítségért.

JSON to XLSX átalakítás REST API-n keresztül cURL használatával

Ugyanazt az eredményt elérheti anélkül, hogy kódot írna, ha közvetlenül meghívja az Aspose.3D konverziós végpontot. Az alábbi lépések bemutatják, hogyan szerezhet hozzáférési tokent, töltheti fel a CSV fájlt, kérheti a konverziót, és letöltheti az XLSX kimenetet.

# 1. Get an access token
curl -X POST "https://api.aspose.cloud/connect/token" \
  -H "Content-Type: application/x-www-form-urlencoded" \
  -d "grant_type=client_credentials&client_id=YOUR_CLIENT_ID&client_secret=YOUR_CLIENT_SECRET"

# 2. Upload the temporary CSV file (replace ACCESS_TOKEN)
curl -X PUT "https://api.aspose.cloud/v3.0/3d/storage/file/temp_input.csv" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: text/csv" \
  --data-binary "@temp_input.csv"

# 3. Request conversion from CSV to XLSX
curl -X POST "https://api.aspose.cloud/v3.0/3d/convert?format=xlsx" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -H "Content-Type: application/octet-stream" \
  --data-binary "@temp_input.csv" \
  -o output.xlsx

# 4. Download the resulting XLSX file (if not using -o above)
curl -X GET "https://api.aspose.cloud/v3.0/3d/storage/file/output.xlsx" \
  -H "Authorization: Bearer ACCESS_TOKEN" \
  -o output.xlsx

A fenti parancsok egy teljes vég‑ponttól‑végig munkafolyamatot mutatnak be a JSON‑ról XLSX‑re Node.JS környezetben, ahol a tiszta REST megközelítést részesíted előnyben. További részletekért tekintsd meg a hivatalos API dokumentációt.

JSON átalakítása XLSX-re memóriahatékony módon Node.JS-ben

A konverziós folyamat világos szakaszokra van bontva, amelyek alacsony memóriahasználatot biztosítanak:

1. JSON olvasása és érvényesítése - A szkript a fs.readFileSync‑et használja a JSON fájl betöltéséhez, majd meghívja a validateJsonData függvényt. Ez a függvény ellenőrzi, hogy a gyökér egy tömb‑e, és hogy minden elem egy objektum‑e, megakadályozva, hogy a hibás bemenet eljusson a későbbi szakaszokba.

   const jsonData = JSON.parse(fs.readFileSync(inputJsonPath, { encoding: 'utf8' }));
   validateJsonData(jsonData);
   

2. JSON átalakítása CSV-re - A JSON tömbön csak egyszer végzett iterációval a kód egy CSV karakterláncot épít a memóriában. A fejléc generálása az első objektum Object.keys metódusát használja, biztosítva, hogy az oszlopsorrend megegyezzen az adatokkal.

const headers = Object.keys(jsonData[0]);
const csvLines = [headers.map(h => `"${h.replace(/"/g, '""')}"`).join(',')];

3. Ideiglenes CSV fájl írása - A CSV tartalom egy ideiglenes fájlba (temp_input.csv) kerül írásra. Ez a lépés megfelel az Aspose.3D API-nak, amely fájl bemenetet vár, miközben később még mindig lehetővé teszi a streaminget.

fs.writeFileSync(tempCsvPath, csvContent, { encoding: 'utf8' });

4. Fájl streamelése bufferbe - streamFileToBuffer beolvassa az ideiglenes CSV-t egy olvasási stream segítségével, és a darabokat egyetlen Buffer-be gyűjti. Ez megakadályozza, hogy az egész fájlt egyszerre egy nagy karakterláncba töltsük be.

   const inputBuffer = await streamFileToBuffer(tempCsvPath);
   

5. Konvertálás végrehajtása - A ConvertDocumentRequest létre van hozva a format: 'xlsx' és a pufferelt CSV használatával. Az SDK elküldi az adatokat a felhőszolgáltatásnak, amely visszaad egy XLSX Buffer-t.

   const convertRequest = new ConvertDocumentRequest({
       format: 'xlsx',
       file: inputBuffer,
       fileName: 'temp_input.csv'
   });
   const conversionResult = await convertApi.convertDocument(convertRequest);
   

6. XLSX írása lemezre - A kapott puffer a writeBufferToFile segítségével kerül kiírásra, befejezve a folyamatot anélkül, hogy a teljes XLSX fájlt hosszabb ideig memóriában tartanánk, mint szükséges.

await writeBufferToFile(conversionResult, outputXlsxPath);

Minden lépés úgy van tervezve, hogy JSON to XLSX Streaming in Node.JS és JSON to XLSX memory efficient in Node.JS esetén is működjön, így a megoldás nagy adathalmazokhoz is alkalmas.

Környezet előkészítése JSON → XLSX exporthoz – Előfeltételek és beállítás

Mielőtt elkezdené, ellenőrizze, hogy a következő előfeltételek teljesülnek:

• Node.js 14+ telepítve legyen a gépén.
• Aspose Cloud fiók client ID‑vel és client secret‑tel.
• Internetkapcsolat az API hívásokhoz.

Telepítse a Aspose.3D Cloud SDK for Node.JS via npm:

npm install aspose3dcloud

A csomagot közvetlenül a kiadási oldalról is letöltheti: Aspose.3D Cloud SDK for Node.JS Letöltés.

Állítsa be a hitelesítő adatait környezeti változóként, vagy adja meg őket egy .env fájlban:

export ASPOSE_CLIENT_ID=YOUR_CLIENT_ID
export ASPOSE_CLIENT_SECRET=YOUR_CLIENT_SECRET

Az SDK telepítve van, és a hitelesítő adatok készen állnak, így készen állsz a konverziós szkript futtatására.

Főbb tanulságok

A JSON-t XLSX formátumba konvertálása Node.JS-ben egyszerűvé válik, ha kihasználja a Aspose.3D Cloud SDK for Node.JS-t. A könyvtár kezeli a streaminget, az érvényesítést és a formátumkonverziót, miközben alacsony memóriahasználatot biztosít, ami nagy JSON terhek esetén elengedhetetlen. A megadott kódrészlet és az ekvivalens cURL munkafolyamat rugalmasságot biztosít a teljes funkcionalitású könyvtár vagy egy könnyűsúlyú REST hívás közötti választáshoz. Ne felejtse el biztonságosra tenni az Aspose Cloud hitelesítő adatait, és megfelelő licencet beszerezni a termelési környezethez. Ideiglenes licencet szerezhet a ideiglenes licenc oldal oldalról, és frissíthet teljes licencre, amikor készen áll a bevezetésre.

GYIK

Átalakíthatom a JSON-t XLSX formátumba Node.JS-ben anélkül, hogy az egész fájlt memóriába tölteném?

Igen. Az SDK streaming segítői (streamFileToBuffer) és a CSV köztes formátum lehetővé teszik, hogy adatot darabonként dolgozzon fel, így JSON to XLSX memóriahatékony Node.JS konverziót érhet el.

Milyen fájlformátumot vár a SDK bemenetként a konverzióhoz?

A konverziós végpont CSV-t használ köztes formátumként.
A példa egy ideiglenes CSV-fájlt hoz létre, mert az Aspose.3D fájlbemenetet vár a XLSX generálása előtt.

Hogyan kezeljem a nagy adatállományokat, amelyek meghaladják a szokásos memóriahatárokat?

Használja a kódban bemutatott streaming megközelítést. A forrásfájlt olvasási streammel olvassa, soronként építi fel a CSV-t, és a puffert a felhőszolgáltatásnak küldi, biztosítva, hogy egyszerre csak kis részek legyenek a memóriában.

Van‑e mód a folyamat automatizálására egy CI/CD csővezetékben?

Abszolút. Ugyanaz a Node.JS script meghívható építési szkriptekből, és a cURL parancsok integrálhatók a shell lépésekbe. Csak győződjön meg róla, hogy az ASPOSE_CLIENT_ID és ASPOSE_CLIENT_SECRET környezeti változók biztonságosan vannak megadva.

További olvasnivaló

• DOCX konvertálása PNG-re Node.JS-ben
• GLB konvertálása FBX-re Node.js-ben – könnyű és egyszerű átalakítás
• EML létrehozása Node.JS-ben