Converti JSON in XLSX in Node.JS

Convertire i dati JSON in un foglio di calcolo Excel è una necessità frequente per la creazione di report, l’analisi dei dati e scenari di integrazione. Aspose.3D Cloud SDK for Node.JS fornisce una libreria potente che gestisce questa trasformazione in modo efficiente sul lato server. In questa guida imparerai come trasmettere lo JSON in streaming, convalidare la sua struttura, convertirlo in CSV, e infine produrre un file XLSX con un’impronta di memoria minima usando Aspose.3D.

Esempio di Codice Completo: Streaming JSON a XLSX in Node.JS

Questo esempio dimostra come leggere un file JSON, trasformarlo in un intermedio CSV e quindi utilizzare l’Aspose.3D Cloud SDK per generare una cartella di lavoro XLSX.

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

Nota: Questo esempio di codice dimostra la funzionalità principale. Prima di usarlo nel tuo progetto, assicurati di aggiornare tutti i percorsi dei file e i valori di configurazione per corrispondere al tuo ambiente reale, verifica che tutte le dipendenze richieste siano correttamente installate e testa accuratamente nel tuo ambiente di sviluppo. Se riscontri problemi, consulta la documentazione ufficiale o contatta il team di supporto per assistenza.

Conversione da JSON a XLSX tramite API REST usando cURL

Puoi ottenere lo stesso risultato senza scrivere alcun codice chiamando direttamente l’endpoint di conversione di Aspose.3D. I passaggi seguenti mostrano come ottenere un token di accesso, caricare il file CSV, richiedere la conversione e scaricare l’output XLSX.

# 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

I comandi sopra illustrano un flusso di lavoro completo end‑to‑end per gli scenari JSON to XLSX in Node.JS in cui si preferisce un approccio REST puro. Per ulteriori dettagli, consultare la documentazione ufficiale dell’API.

Come funziona la conversione da JSON a XLSX in modo efficiente in memoria in Node.JS

Il processo di conversione è suddiviso in fasi chiare che mantengono basso l’utilizzo della memoria:

1. Leggi e valida JSON - Lo script utilizza fs.readFileSync per caricare il file JSON e poi chiama validateJsonData. Questa funzione verifica che la radice sia un array e che ogni elemento sia un oggetto, impedendo che dati malformati raggiungano le fasi successive.

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

2. Trasforma JSON in CSV - Iterando sull’array JSON una sola volta, il codice costruisce una stringa CSV in memoria. La generazione dell’intestazione utilizza Object.keys sul primo oggetto, garantendo che l’ordine delle colonne corrisponda ai dati.

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

3. Scrivi file CSV temporaneo - Il contenuto CSV viene scritto in un file temporaneo (temp_input.csv). Questo passaggio soddisfa l’API Aspose.3D, che si aspetta un input file, consentendo comunque lo streaming successivo.

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

4. Stream del file in buffer - streamFileToBuffer legge il CSV temporaneo usando uno stream di lettura, raccogliendo i blocchi in un unico Buffer. Questo evita di caricare l’intero file in una singola grande stringa in una volta.

   const inputBuffer = await streamFileToBuffer(tempCsvPath);
   

5. Esegui la conversione - Viene creato un ConvertDocumentRequest con format: 'xlsx' e il CSV bufferizzato. L’SDK invia i dati al servizio cloud, che restituisce un Buffer XLSX.

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

6. Scrivi XLSX su disco - Il buffer risultante viene scritto con writeBufferToFile, completando la pipeline senza mai mantenere l’intero file XLSX in memoria più a lungo del necessario.

await writeBufferToFile(conversionResult, outputXlsxPath);

Ogni passaggio è progettato per Streaming JSON verso XLSX in Node.JS e JSON verso XLSX con efficienza di memoria in Node.JS, rendendo la soluzione adatta a grandi insiemi di dati.

Preparazione dell’ambiente per l’esportazione da JSON a XLSX - Prerequisiti e configurazione

Prima di iniziare, assicurati che i seguenti prerequisiti siano soddisfatti:

• Node.js 14+ installato sulla tua macchina.
• Un account Aspose Cloud con client ID e client secret.
• Accesso a Internet per le chiamate API.

Installa l’Aspose.3D Cloud SDK per Node.JS tramite npm:

npm install aspose3dcloud

È possibile scaricare anche il pacchetto direttamente dalla pagina di rilascio: Aspose.3D Cloud SDK for Node.JS Download.

Configura le tue credenziali come variabili d’ambiente o impostale in un file .env:

export ASPOSE_CLIENT_ID=YOUR_CLIENT_ID
export ASPOSE_CLIENT_SECRET=YOUR_CLIENT_SECRET

Con l’SDK installato e le credenziali pronte, sei pronto a eseguire lo script di conversione.

Punti chiave

Convertire JSON in XLSX in Node.JS diventa semplice quando si sfrutta il Aspose.3D Cloud SDK for Node.JS. La libreria gestisce lo streaming, la convalida e la conversione del formato mantenendo un basso utilizzo della memoria, il che è essenziale per grandi payload JSON. L’esempio di codice fornito e il flusso di lavoro cURL equivalente ti offrono la flessibilità di scegliere tra una libreria completa o una chiamata REST leggera. Ricorda di proteggere le tue credenziali Aspose Cloud e di ottenere una licenza adeguata per l’uso in produzione. Puoi ottenere una licenza temporanea dalla pagina della licenza temporanea e passare a una licenza completa quando sei pronto per il deployment.

Domande frequenti

Posso convertire JSON in XLSX in Node.JS senza caricare l’intero file in memoria?

Sì. Gli helper di streaming del SDK (streamFileToBuffer) e il formato intermedio CSV ti consentono di elaborare i dati blocco per blocco, ottenendo conversione da JSON a XLSX con efficienza di memoria in Node.JS.

Quale formato di file si aspetta l’SDK come input per la conversione?

L’endpoint di conversione funziona con CSV come formato intermedio. L’esempio crea un file CSV temporaneo perché Aspose.3D richiede un input file prima di generare l’XLSX.

Come gestisco grandi set di dati che superano i limiti di memoria tipici?

Utilizza l’approccio di streaming mostrato nel codice. Legge il file di origine con un flusso di lettura, costruisce il CSV riga per riga e invia il buffer al servizio cloud, garantendo che solo piccole porzioni risiedano in memoria in qualsiasi momento.

Esiste un modo per automatizzare il processo in una pipeline CI/CD?

Assolutamente. Lo stesso script Node.JS può essere invocato dagli script di build e i comandi cURL possono essere integrati nei passaggi della shell. Assicurati solo che le variabili d’ambiente per ASPOSE_CLIENT_ID e ASPOSE_CLIENT_SECRET siano fornite in modo sicuro.

Ulteriori letture

• Converti DOCX in PNG in Node.JS
• Converti GLB in FBX in Node.js - Conversione facile e semplice
• Crea EML in Node.JS