Convertir JSON en XLSX dans Node.JS

Convertir les données JSON en une feuille de calcul Excel est une exigence fréquente pour les rapports, l’analyse de données et les scénarios d’intégration. Aspose.3D Cloud SDK for Node.JS fournit une bibliothèque puissante qui gère cette transformation efficacement côté serveur. Dans ce guide, vous apprendrez comment diffuser le JSON, valider sa structure, le convertir en CSV, et enfin produire un fichier XLSX avec une empreinte mémoire minimale en utilisant Aspose.3D.

Exemple complet de code : JSON vers XLSX en streaming avec Node.JS

Cet exemple montre comment lire un fichier JSON, le transformer en un intermédiaire CSV, puis utiliser le Aspose.3D Cloud SDK pour générer un classeur 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);
    }
})();

Remarque : Cet exemple de code démontre la fonctionnalité principale. Avant de l’utiliser dans votre projet, assurez‑vous de mettre à jour tous les chemins de fichiers et les valeurs de configuration pour qu’ils correspondent à votre environnement réel, vérifiez que toutes les dépendances requises sont correctement installées et testez soigneusement dans votre environnement de développement. Si vous rencontrez des problèmes, veuillez consulter la documentation officielle ou contacter l’équipe de support pour obtenir de l’aide.

Conversion JSON en XLSX via l’API REST avec cURL

Vous pouvez obtenir le même résultat sans écrire de code en appelant directement le point de terminaison de conversion Aspose.3D. Les étapes ci‑dessous montrent comment obtenir un jeton d’accès, télécharger le fichier CSV, demander la conversion et télécharger le résultat 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

Les commandes ci‑dessus illustrent un flux de travail complet de bout en bout pour les scénarios JSON vers XLSX en Node.JS où vous préférez une approche purement REST. Pour plus de détails, consultez la documentation officielle de l’API.

Comment la conversion JSON en XLSX efficace en mémoire fonctionne dans Node.JS

Le processus de conversion est divisé en étapes claires qui maintiennent une faible utilisation de la mémoire :

Lire et valider le JSON - Le script utilise fs.readFileSync pour charger le fichier JSON puis appelle validateJsonData. Cette fonction vérifie que la racine est un tableau et que chaque élément est un objet, empêchant ainsi les entrées malformées d’atteindre les étapes ultérieures.

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

Transform JSON to CSV - En itérant sur le tableau JSON une seule fois, le code construit une chaîne CSV en mémoire. La génération de l’en‑tête utilise Object.keys sur le premier objet, garantissant que l’ordre des colonnes correspond aux données.
```
const headers = Object.keys(jsonData[0]);
const csvLines = [headers.map(h => `"${h.replace(/"/g, '""')}"`).join(',')];
```
Écrire un fichier CSV temporaire - Le contenu CSV est écrit dans un fichier temporaire (temp_input.csv). Cette étape satisfait l’Aspose.3D API, qui attend une entrée de fichier, tout en permettant le streaming ultérieur.

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

Diffusion du fichier vers le tampon - streamFileToBuffer lit le CSV temporaire à l’aide d’un flux de lecture, collectant les morceaux dans un seul Buffer. Cela évite de charger l’intégralité du fichier dans une seule grande chaîne d’un coup.

const inputBuffer = await streamFileToBuffer(tempCsvPath);

Effectuer la conversion - Une ConvertDocumentRequest est créée avec format: 'xlsx' et le CSV tamponné. Le SDK envoie les données au service cloud, qui renvoie un Buffer XLSX.

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

Écrire le XLSX sur le disque - Le tampon résultant est écrit avec writeBufferToFile, complétant le pipeline sans jamais conserver le fichier XLSX complet en mémoire plus longtemps que nécessaire.
```
await writeBufferToFile(conversionResult, outputXlsxPath);
```

Chaque étape est conçue pour JSON vers XLSX en streaming dans Node.JS et JSON vers XLSX avec une utilisation efficace de la mémoire dans Node.JS, rendant la solution adaptée aux grands ensembles de données.

Préparer l’environnement pour l’exportation JSON vers XLSX - Prérequis et configuration

Avant de commencer, assurez‑vous que les prérequis suivants sont remplis :

Node.js 14+ installé sur votre machine.
Un compte Aspose Cloud avec ID client et secret client.
Accès à Internet pour les appels d’API.

Installez le Aspose.3D Cloud SDK for Node.JS via npm:

npm install aspose3dcloud

Vous pouvez également télécharger le package directement depuis la page de publication : Aspose.3D Cloud SDK for Node.JS Download.

Configurez vos identifiants en tant que variables d’environnement ou définissez‑les dans un fichier .env :

export ASPOSE_CLIENT_ID=YOUR_CLIENT_ID
export ASPOSE_CLIENT_SECRET=YOUR_CLIENT_SECRET

Avec le SDK installé et les informations d’identification prêtes, vous êtes prêt à exécuter le script de conversion.

Points clés

La conversion de JSON en XLSX sous Node.JS devient simple lorsque vous utilisez le Aspose.3D Cloud SDK for Node.JS. La bibliothèque gère le streaming, la validation et la conversion de format tout en maintenant une faible utilisation de la mémoire, ce qui est essentiel pour les gros chargements JSON. L’exemple de code fourni et le flux de travail cURL équivalent vous offrent la flexibilité de choisir entre une bibliothèque complète ou un appel REST léger. N’oubliez pas de sécuriser vos identifiants Aspose Cloud et d’obtenir une licence appropriée pour l’utilisation en production. Vous pouvez obtenir une licence temporaire depuis la page de licence temporaire et passer à une licence complète lorsque vous êtes prêt à déployer.

FAQs

Puis-je convertir JSON en XLSX dans Node.JS sans charger le fichier entier en mémoire ?

Oui. Les assistants de streaming du SDK (streamFileToBuffer) et le format intermédiaire CSV vous permettent de traiter les données morceau par morceau, réalisant une conversion JSON vers XLSX efficace en mémoire dans Node.JS.

Quel format de fichier le SDK attend‑il comme entrée pour la conversion ?

Le point de terminaison de conversion fonctionne avec CSV comme format intermédiaire. L’exemple crée un fichier CSV temporaire car Aspose.3D attend une entrée de fichier avant de générer le XLSX.

Comment gérer les grands ensembles de données qui dépassent les limites de mémoire habituelles ?

Utilisez l’approche de diffusion démontrée dans le code. Elle lit le fichier source avec un flux de lecture, construit le CSV ligne par ligne et envoie le tampon au service cloud, garantissant que seules de petites portions résident en mémoire à tout moment.

Existe-t-il un moyen d’automatiser le processus dans un pipeline CI/CD ?

Absolument. Le même script Node.JS peut être invoqué depuis les scripts de build, et les commandes cURL peuvent être intégrées dans les étapes de shell. Assurez‑vous simplement que les variables d’environnement ASPOSE_CLIENT_ID et ASPOSE_CLIENT_SECRET sont fournies de manière sécurisée.

Exemple complet de code : JSON vers XLSX en streaming avec Node.JS#

Conversion JSON en XLSX via l’API REST avec cURL#

Comment la conversion JSON en XLSX efficace en mémoire fonctionne dans Node.JS#

Préparer l’environnement pour l’exportation JSON vers XLSX - Prérequis et configuration#

Points clés#

FAQs#

Puis-je convertir JSON en XLSX dans Node.JS sans charger le fichier entier en mémoire ?#

Quel format de fichier le SDK attend‑il comme entrée pour la conversion ?#

Comment gérer les grands ensembles de données qui dépassent les limites de mémoire habituelles ?#

Existe-t-il un moyen d’automatiser le processus dans un pipeline CI/CD ?#

Lectures complémentaires#