Convertir JSON a XLSX en Node.JS

Convertir datos JSON a una hoja de cálculo Excel es un requisito frecuente para informes, análisis de datos y escenarios de integración. Aspose.3D Cloud SDK for Node.JS proporciona una biblioteca potente que maneja esta transformación de manera eficiente en el lado del servidor. En esta guía aprenderá cómo transmitir JSON, validar su estructura, convertirlo a CSV, y finalmente generar un archivo XLSX con una huella de memoria mínima usando Aspose.3D.

Ejemplo completo de código: transmisión de JSON a XLSX en Node.JS

Este ejemplo muestra cómo leer un archivo JSON, convertirlo en un intermedio CSV y luego usar el Aspose.3D Cloud SDK para generar un libro de trabajo 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: Este ejemplo de código demuestra la funcionalidad principal. Antes de usarlo en su proyecto, asegúrese de actualizar cualquier ruta de archivo y valores de configuración para que coincidan con su entorno real, verifique que todas las dependencias requeridas estén correctamente instaladas y pruebe exhaustivamente en su entorno de desarrollo. Si encuentra algún problema, consulte la documentación oficial o póngase en contacto con el equipo de soporte para obtener ayuda.

Conversión de JSON a XLSX mediante API REST usando cURL

Puedes lograr el mismo resultado sin escribir ningún código llamando directamente al endpoint de conversión de Aspose.3D. Los pasos a continuación muestran cómo obtener un token de acceso, cargar el archivo CSV, solicitar la conversión y descargar la salida 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

Los comandos anteriores ilustran un flujo de trabajo completo de extremo a extremo para JSON a XLSX en Node.JS escenarios donde prefieres un enfoque puramente REST. Para obtener más detalles, consulta la documentación oficial de la API.

Cómo funciona JSON a XLSX de forma eficiente en memoria en Node.JS

El proceso de conversión se divide en etapas claras que mantienen bajo el uso de memoria:

Leer y validar JSON - El script usa fs.readFileSync para cargar el archivo JSON y luego llama a validateJsonData. Esta función verifica que la raíz sea un arreglo y que cada elemento sea un objeto, evitando que una entrada malformada llegue a etapas posteriores.

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

Transform JSON to CSV - Al iterar sobre el arreglo JSON solo una vez, el código construye una cadena CSV en memoria. La generación del encabezado usa Object.keys en el primer objeto, asegurando que el orden de las columnas coincida con los datos.
```
const headers = Object.keys(jsonData[0]);
const csvLines = [headers.map(h => `"${h.replace(/"/g, '""')}"`).join(',')];
```
Escribir archivo CSV temporal - El contenido CSV se escribe en un archivo temporal (temp_input.csv). Este paso satisface la API Aspose.3D, que espera una entrada de archivo, mientras sigue permitiendo la transmisión posterior.

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

Transmitir archivo a Buffer - streamFileToBuffer lee el CSV temporal usando un flujo de lectura, recopilando fragmentos en un único Buffer. Esto evita cargar todo el archivo en una única cadena grande de una sola vez.
```
const inputBuffer = await streamFileToBuffer(tempCsvPath);
```

Realizar conversión - Se crea un ConvertDocumentRequest con format: 'xlsx' y el CSV en búfer. El SDK envía los datos al servicio en la nube, que devuelve un Buffer XLSX.

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

Write XLSX to Disk - El búfer resultante se escribe con writeBufferToFile, completando la canalización sin mantener nunca el archivo XLSX completo en memoria más tiempo del necesario.
```
await writeBufferToFile(conversionResult, outputXlsxPath);
```

Cada paso está diseñado para JSON a XLSX Streaming en Node.JS y JSON a XLSX eficiente en memoria en Node.JS, lo que hace que la solución sea adecuada para conjuntos de datos grandes.

Preparación del entorno para la exportación de JSON a XLSX - Requisitos y configuración

Antes de comenzar, asegúrese de que se cumplan los siguientes requisitos:

Node.js 14+ instalado en su máquina.
Una cuenta de Aspose Cloud con ID de cliente y secreto de cliente.
Acceso a Internet para llamadas a la API.

Instale el SDK de Aspose.3D Cloud para Node.JS a través de npm:

npm install aspose3dcloud

También puedes descargar el paquete directamente desde la página de lanzamientos: Aspose.3D Cloud SDK for Node.JS Descargar.

Configure sus credenciales como variables de entorno o establézcalas en un archivo .env:

export ASPOSE_CLIENT_ID=YOUR_CLIENT_ID
export ASPOSE_CLIENT_SECRET=YOUR_CLIENT_SECRET

Con el SDK instalado y las credenciales listas, estás preparado para ejecutar el script de conversión.

Conclusiones clave

Convertir JSON a XLSX en Node.JS se vuelve sencillo cuando aprovechas el Aspose.3D Cloud SDK for Node.JS. La biblioteca maneja la transmisión, validación y conversión de formatos mientras mantiene bajo el uso de memoria, lo que es esencial para cargas JSON grandes. El ejemplo de código proporcionado y el flujo de trabajo equivalente en cURL te brindan flexibilidad para elegir entre una biblioteca completa o una llamada REST ligera. Recuerda asegurar tus credenciales de Aspose Cloud y obtener una licencia adecuada para uso en producción. Puedes adquirir una licencia temporal en la página de licencia temporal y actualizar a una licencia completa cuando estés listo para desplegar.

Preguntas frecuentes

¿Puedo convertir JSON a XLSX en Node.JS sin cargar todo el archivo en memoria?

Sí. Los helpers de streaming del SDK (streamFileToBuffer) y el formato intermedio CSV le permiten procesar los datos por fragmentos, logrando una conversión JSON a XLSX de manera eficiente en memoria en Node.JS.

¿Qué formato de archivo espera el SDK como entrada para la conversión?

El endpoint de conversión funciona con CSV como formato intermedio. El ejemplo crea un archivo CSV temporal porque Aspose.3D espera una entrada de archivo antes de generar el XLSX.

¿Cómo manejo conjuntos de datos grandes que superan los límites típicos de memoria?

Utilice el enfoque de transmisión demostrado en el código. Lee el archivo de origen con un flujo de lectura, construye el CSV línea por línea y envía el búfer al servicio en la nube, asegurando que solo pequeñas porciones permanezcan en la memoria en cualquier momento.

¿Hay una manera de automatizar el proceso en una canalización CI/CD?

Absolutamente. El mismo script de Node.JS puede invocarse desde scripts de compilación, y los comandos cURL pueden integrarse en pasos de shell. Simplemente asegúrate de que las variables de entorno ASPOSE_CLIENT_ID y ASPOSE_CLIENT_SECRET se proporcionen de forma segura.

Ejemplo completo de código: transmisión de JSON a XLSX en Node.JS#

Conversión de JSON a XLSX mediante API REST usando cURL#

Cómo funciona JSON a XLSX de forma eficiente en memoria en Node.JS#

Preparación del entorno para la exportación de JSON a XLSX - Requisitos y configuración#

Conclusiones clave#

Preguntas frecuentes#

¿Puedo convertir JSON a XLSX en Node.JS sin cargar todo el archivo en memoria?#

¿Qué formato de archivo espera el SDK como entrada para la conversión?#

¿Cómo manejo conjuntos de datos grandes que superan los límites típicos de memoria?#

¿Hay una manera de automatizar el proceso en una canalización CI/CD?#

Further Reading#