JSON nach XLSX in Node.JS konvertieren

Das Konvertieren von JSON Daten in eine Excel‑Tabelle ist eine häufige Anforderung für Berichte, Datenanalysen und Integrationsszenarien. Das Aspose.3D Cloud SDK for Node.JS bietet eine leistungsstarke Bibliothek, die diese Transformation effizient serverseitig verarbeitet. In diesem Leitfaden lernen Sie, wie Sie JSON streamen, seine Struktur validieren, es in CSV konvertieren und schließlich mit minimalem Speicherverbrauch eine XLSX Datei erstellen, wobei Aspose.3D verwendet wird.

Vollständiges Codebeispiel: JSON zu XLSX Streaming in Node.JS

Dieses Beispiel zeigt, wie man eine JSON‑Datei liest, sie in ein CSV‑Zwischenergebnis umwandelt und anschließend das Aspose.3D Cloud SDK verwendet, um eine XLSX‑Arbeitsmappe zu erstellen.

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

Hinweis: Dieses Codebeispiel demonstriert die Kernfunktionalität. Bevor Sie es in Ihrem Projekt verwenden, stellen Sie sicher, dass Sie alle Dateipfade und Konfigurationswerte an Ihre tatsächliche Umgebung anpassen, überprüfen Sie, dass alle erforderlichen Abhängigkeiten korrekt installiert sind, und testen Sie gründlich in Ihrer Entwicklungsumgebung. Wenn Sie auf Probleme stoßen, lesen Sie bitte die offizielle Dokumentation oder wenden Sie sich an das Support-Team für Unterstützung.

JSON-zu-XLSX-Konvertierung über REST-API mit cURL

Sie können dasselbe Ergebnis erzielen, ohne Code zu schreiben, indem Sie den Aspose.3D‑Konvertierungsendpunkt direkt aufrufen. Die nachstehenden Schritte zeigen, wie Sie ein Zugriffstoken erhalten, die CSV‑Datei hochladen, die Konvertierung anfordern und die XLSX‑Ausgabe herunterladen.

# 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

Die obigen Befehle veranschaulichen einen vollständigen End‑zu‑End‑Workflow für JSON zu XLSX in Node.JS‑Szenarien, bei denen Sie einen reinen REST‑Ansatz bevorzugen. Weitere Details finden Sie in der offiziellen API‑Dokumentation.

Wie JSON zu XLSX speichereffizient in Node.JS funktioniert

Der Konvertierungsprozess ist in klare Phasen unterteilt, die den Speicherverbrauch gering halten:

1. JSON lesen und validieren - Das Skript verwendet fs.readFileSync, um die JSON‑Datei zu laden, und ruft anschließend validateJsonData auf. Diese Funktion prüft, dass die Wurzel ein Array ist und jedes Element ein Objekt ist, wodurch verhindert wird, dass fehlerhafte Eingaben spätere Schritte erreichen.

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

2. Transform JSON to CSV - Durch einmaliges Durchlaufen des JSON-Arrays erstellt der Code einen CSV-String im Speicher. Die Header-Generierung verwendet Object.keys auf dem ersten Objekt und stellt sicher, dass die Spaltenreihenfolge den Daten entspricht.

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

3. Temporäre CSV-Datei schreiben - Der CSV-Inhalt wird in eine temporäre Datei (temp_input.csv) geschrieben. Dieser Schritt erfüllt die Aspose.3D API, die eine Dateieingabe erwartet, ermöglicht jedoch weiterhin das spätere Streaming.

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

4. Stream File to Buffer - streamFileToBuffer liest die temporäre CSV-Datei mit einem Lesestream und sammelt die Teile in einem einzigen Buffer. Dadurch wird vermieden, dass die gesamte Datei auf einmal in einen großen String geladen wird.

   const inputBuffer = await streamFileToBuffer(tempCsvPath);
   

5. Durchführen der Konvertierung - Ein ConvertDocumentRequest wird mit format: 'xlsx' und dem gepufferten CSV erstellt. Das SDK sendet die Daten an den Cloud‑Dienst, der einen XLSX Buffer zurückgibt.

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

6. XLSX auf die Festplatte schreiben - Der resultierende Puffer wird mit writeBufferToFile ausgegeben, wodurch die Pipeline abgeschlossen wird, ohne dass die vollständige XLSX‑Datei länger als nötig im Speicher gehalten wird.

await writeBufferToFile(conversionResult, outputXlsxPath);

Jeder Schritt ist für JSON zu XLSX Streaming in Node.JS und JSON zu XLSX speichereffizient in Node.JS konzipiert, wodurch die Lösung für große Datensätze geeignet ist.

Umgebung für den Export von JSON nach XLSX vorbereiten - Voraussetzungen und Einrichtung

Bevor Sie beginnen, stellen Sie sicher, dass die folgenden Voraussetzungen erfüllt sind:

• Node.js 14+ auf Ihrem Rechner installiert.
• Ein Aspose Cloud‑Konto mit Client‑ID und Client‑Secret.
• Zugriff auf das Internet für API‑Aufrufe.

Installieren Sie das Aspose.3D Cloud SDK für Node.JS über npm:

npm install aspose3dcloud

Sie können das Paket auch direkt von der Release‑Seite herunterladen: Aspose.3D Cloud SDK for Node.JS Download.

Konfigurieren Sie Ihre Anmeldeinformationen als Umgebungsvariablen oder legen Sie sie in einer .env‑Datei fest:

export ASPOSE_CLIENT_ID=YOUR_CLIENT_ID
export ASPOSE_CLIENT_SECRET=YOUR_CLIENT_SECRET

Mit dem installierten SDK und den bereitstehenden Anmeldeinformationen sind Sie bereit, das Konvertierungsskript auszuführen.

Wichtige Erkenntnisse

Die Umwandlung von JSON zu XLSX in Node.JS wird einfach, wenn Sie das Aspose.3D Cloud SDK for Node.JS nutzen. Die Bibliothek übernimmt Streaming, Validierung und Formatkonvertierung, während sie den Speicherverbrauch niedrig hält, was bei großen JSON‑Payloads entscheidend ist. Das bereitgestellte Code‑Beispiel und der entsprechende cURL‑Workflow geben Ihnen die Flexibilität, zwischen einer vollwertigen Bibliothek und einem leichten REST‑Aufruf zu wählen. Denken Sie daran, Ihre Aspose Cloud‑Anmeldeinformationen zu sichern und eine geeignete Lizenz für den Produktionseinsatz zu erhalten. Sie können eine temporäre Lizenz von der temporären Lizenzseite beziehen und zu einer Voll‑Lizenz wechseln, wenn Sie bereit sind, die Anwendung bereitzustellen.

FAQ

Kann ich JSON in XLSX in Node.JS konvertieren, ohne die gesamte Datei in den Speicher zu laden?

Ja. Die Streaming‑Hilfsfunktionen des SDK (streamFileToBuffer) und das CSV‑Zwischenformat ermöglichen es Ihnen, Daten Stück für Stück zu verarbeiten und dabei eine JSON zu XLSX speichereffiziente Konvertierung in Node.JS zu erreichen.

Welches Dateiformat erwartet das SDK als Eingabe für die Konvertierung?

Der Konvertierungsendpunkt arbeitet mit CSV als Zwischenformat. Das Beispiel erstellt eine temporäre CSV‑Datei, weil Aspose.3D eine Dateieingabe erwartet, bevor die XLSX erzeugt wird.

Wie gehe ich mit großen Datensätzen um, die die typischen Speichergrenzen überschreiten?

Verwenden Sie den im Code gezeigten Streaming‑Ansatz. Er liest die Quelldatei mit einem Lesestream, erstellt die CSV Zeile für Zeile und sendet den Puffer an den Cloud‑Dienst, wobei nur kleine Teile gleichzeitig im Speicher verbleiben.

Gibt es eine Möglichkeit, den Prozess in einer CI/CD-Pipeline zu automatisieren?

Absolut. Das gleiche Node.JS‑Skript kann aus Build‑Skripten aufgerufen werden, und die cURL‑Befehle können in Shell‑Schritte integriert werden. Stellen Sie einfach sicher, dass die Umgebungsvariablen für ASPOSE_CLIENT_ID und ASPOSE_CLIENT_SECRET sicher bereitgestellt werden.

Weiterführende Lektüre

• DOCX nach PNG in Node.JS konvertieren
• GLB nach FBX in Node.js – Einfache und unkomplizierte Konvertierung
• EML in Node.JS erstellen