Konverter JSON til XLSX i Node.JS

Konvertering af JSON data til et Excel‑regneark er et hyppigt krav til rapportering, dataanalyse og integrationsscenarier. Aspose.3D Cloud SDK for Node.JS leverer et kraftfuldt bibliotek, der håndterer denne transformation effektivt på serversiden. I denne vejledning vil du lære, hvordan du streamer JSON, validerer dens struktur, konverterer den til CSV, og endelig producerer en XLSX fil med minimal hukommelsesforbrug ved hjælp af Aspose.3D.

Komplet kodeeksempel: JSON til XLSX streaming i Node.JS

Dette eksempel demonstrerer, hvordan man læser en JSON‑fil, konverterer den til en CSV‑mellemfil, og derefter bruger Aspose.3D Cloud SDK til at generere en XLSX‑arbejdsbog.

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

Bemærk: Dette kodeeksempel demonstrerer kernefunktionaliteten. Før du bruger det i dit projekt, skal du sikre dig, at du opdaterer alle filstier og konfigurationsværdier, så de matcher dit faktiske miljø, bekræfter at alle nødvendige afhængigheder er korrekt installeret, og tester grundigt i dit udviklingsmiljø. Hvis du støder på problemer, så se venligst den officielle dokumentation eller kontakt supportteamet for assistance.

JSON til XLSX-konvertering via REST API ved hjælp af cURL

Du kan opnå det samme resultat uden at skrive nogen kode ved at kalde Aspose.3D‑konverterings‑endpoint direkte. Trinnene nedenfor viser, hvordan du får en adgangstoken, uploader CSV‑filen, anmoder om konvertering og downloader XLSX‑outputtet.

# 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

De ovenstående kommandoer illustrerer en komplet end‑to‑end‑arbejdsgang for JSON til XLSX i Node.JS scenarier, hvor du foretrækker en ren REST‑tilgang. For flere detaljer, se den officielle API-dokumentation.

Hvordan JSON til XLSX fungerer hukommelseseffektivt i Node.JS

Konverteringsprocessen er opdelt i klare trin, der holder hukommelsesforbruget lavt:

Læs og valider JSON - Scriptet bruger fs.readFileSync til at indlæse JSON-filen og kalder derefter validateJsonData. Denne funktion kontrollerer, at roden er et array, og at hvert element er et objekt, hvilket forhindrer fejlbehæftet input i at nå de senere trin.

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

Transform JSON to CSV - Ved at iterere over JSON-arrayet kun én gang, bygger koden en CSV‑streng i hukommelsen. Header‑generering bruger Object.keys på det første objekt, hvilket sikrer, at kolonneordenen matcher dataene.
```
const headers = Object.keys(jsonData[0]);
const csvLines = [headers.map(h => `"${h.replace(/"/g, '""')}"`).join(',')];
```
Skriv midlertidig CSV-fil - CSV-indholdet skrives til en midlertidig fil (temp_input.csv). Dette trin opfylder Aspose.3D API’en, som forventer en filinput, mens det stadig tillader streaming senere.

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

Stream fil til Buffer - streamFileToBuffer læser den midlertidige CSV ved hjælp af en læse‑stream, samler bidder i en enkelt Buffer. Dette undgår at indlæse hele filen i en enkelt stor streng på én gang.
```
const inputBuffer = await streamFileToBuffer(tempCsvPath);
```

Udfør konvertering - En ConvertDocumentRequest oprettes med format: 'xlsx' og den bufferede CSV. SDK’en sender dataene til cloud-tjenesten, som returnerer en XLSX Buffer.

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

Skriv XLSX til Disk - Den resulterende buffer skrives ud med writeBufferToFile, hvilket fuldfører pipeline’en uden nogensinde at holde den fulde XLSX‑fil i hukommelsen længere end nødvendigt.
```
await writeBufferToFile(conversionResult, outputXlsxPath);
```

Hvert trin er designet til JSON til XLSX streaming i Node.JS og JSON til XLSX hukommelses‑effektiv i Node.JS, hvilket gør løsningen egnet til store datasæt.

Forbereder miljøet til JSON til XLSX eksport - Forudsætninger og opsætning

Før du starter, skal du sikre, at følgende forudsætninger er opfyldt:

Node.js 14+ installeret på din maskine.
En Aspose Cloud-konto med klient‑ID og klienthemmelighed.
Adgang til internettet for API‑opkald.

Installer Aspose.3D Cloud SDK til Node.JS via npm:

npm install aspose3dcloud

Du kan også downloade pakken direkte fra udgivelsessiden: Aspose.3D Cloud SDK for Node.JS Download.

Konfigurer dine legitimationsoplysninger som miljøvariabler eller angiv dem i en .env-fil:

export ASPOSE_CLIENT_ID=YOUR_CLIENT_ID
export ASPOSE_CLIENT_SECRET=YOUR_CLIENT_SECRET

Med SDK’en installeret og legitimationsoplysningerne klar, er du klar til at køre konverteringsscriptet.

Vigtige punkter

Konvertering af JSON til XLSX i Node.JS bliver enkelt, når du udnytter Aspose.3D Cloud SDK for Node.JS. Biblioteket håndterer streaming, validering og formatkonvertering, samtidig med at det holder hukommelsesforbruget lavt, hvilket er vigtigt for store JSON‑payloads. Det medfølgende kodeeksempel og den tilsvarende cURL‑arbejdsgang giver dig fleksibilitet til at vælge mellem et fuldt udstyret bibliotek eller et letvægts‑REST‑kald. Husk at sikre dine Aspose Cloud‑legitimationsoplysninger og skaffe en korrekt licens til produktionsbrug. Du kan få en midlertidig licens fra midlertidig licensside og opgradere til en fuld licens, når du er klar til at implementere.

FAQs

Kan jeg konvertere JSON til XLSX i Node.JS uden at indlæse hele filen i hukommelsen?

Ja. SDK’ens streaming‑hjælpefunktioner (streamFileToBuffer) og det mellemliggende CSV‑format gør det muligt at behandle data stykke for stykke, hvilket giver en JSON til XLSX hukommelseseffektiv i Node.JS konvertering.

Hvilket filformat forventer SDK’et som input til konverteringen?

Konverterings‑endpointet fungerer med CSV som det mellemliggende format. Eksemplet opretter en midlertidig CSV‑fil, fordi Aspose.3D forventer en filinput, før XLSX genereres.

Hvordan håndterer jeg store datasæt, der overstiger typiske hukommelsesgrænser?

Brug den streaming‑tilgang, der demonstreres i koden. Den læser kildefilen med en læse‑stream, bygger CSV‑filen linje for linje og sender bufferten til cloud‑tjenesten, hvilket sikrer, at kun små dele er i hukommelsen ad gangen.

Er der en måde at automatisere processen i en CI/CD-pipeline?

Absolut. Det samme Node.JS‑script kan kaldes fra build‑scripts, og cURL‑kommandoerne kan integreres i shell‑trin. Sørg blot for, at miljøvariablerne for ASPOSE_CLIENT_ID og ASPOSE_CLIENT_SECRET leveres sikkert.

Komplet kodeeksempel: JSON til XLSX streaming i Node.JS#

JSON til XLSX-konvertering via REST API ved hjælp af cURL#

Hvordan JSON til XLSX fungerer hukommelseseffektivt i Node.JS#

Forbereder miljøet til JSON til XLSX eksport - Forudsætninger og opsætning#

Vigtige punkter#

FAQs#

Kan jeg konvertere JSON til XLSX i Node.JS uden at indlæse hele filen i hukommelsen?#

Hvilket filformat forventer SDK’et som input til konverteringen?#

Hvordan håndterer jeg store datasæt, der overstiger typiske hukommelsesgrænser?#

Er der en måde at automatisere processen i en CI/CD-pipeline?#

Yderligere læsning#