JSON-ის მონაცემების Excel ცხრილში გადაყვანა ხშირად საჭიროა ანგარიშგებისთვის, მონაცემთა ანალიზისთვის და ინტეგრაციის სცენარებისთვის. Aspose.3D Cloud SDK for Node.JS ძლიერი ბიბლიოთეკა, რომელიც ეფექტურად ახორციელებს ამ ტრანსფორმაციას სერვერის მხარეს. ამ გიდში თქვენ გაიგებთ, როგორ გადაიტანოთ JSON, როგორ გადამოწმოთ მისი სტრუქტურა, როგორ გადაიყვანოთ იგი CSV-ში, და საბოლოოდ, როგორ შექმნათ XLSX ფაილი მინიმალურ მეხსიერების მოხმარებით Aspose.3D-ის გამოყენებით.

სრული კოდის მაგალითი: JSON-დან XLSX-ით ნაკადის გადაცემა Node.JS-ში

ეს მაგალითი აჩვენებს, როგორ დავაკითხოთ JSON ფაილი, გადავიტანოთ იგი CSV შუალედურ ფორმატში, შემდეგ კი გამოვიყენოთ Aspose.3D Cloud SDK, რათა შევქმნათ 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);
    }
})();

შენიშვნა: ეს კოდის მაგალითი აჩვენებს ძირითად ფუნქციონირებას. პროექტში მისი გამოყენებამდე, დარწმუნდით, რომ განაახლეთ ყველა ფაილის ბილიკი და კონფიგურაციის მნიშვნელობები, რათა ისინი შეესაბამებოდეს თქვენს რეალურ გარემოს, გადაამოწმეთ, რომ ყველა საჭირო დამოკიდებულება სწორად დაყენებულია, და სრულად გამოცადეთ თქვენი განვითარების გარემოში. თუ რაიმე პრობლემის შეგხვდებით, გთხოვთ მიმართოთ ოფიციალურ დოკუმენტაციას ან დაუკავშირდეთ მხარდაჭერის გუნდს დახმარებისთვის.

JSON‑დან XLSX‑ზე კონვერტირება REST API‑ით cURL‑ის გამოყენებით

თქვენ შეგიძლიათ მიიღოთ იგივე შედეგი კოდის დაწერის გარეშე Aspose.3D კონვერსიის საბოლოო წერტილს პირდაპირ გამოძახებით. ქვემოთ მოცემული ნაბიჯები აჩვენებენ, როგორ მიიღოთ წვდომის ტოკენი, ატვირთოთ CSV ფაილი, მოითხოვოთ კონვერსია და ჩამოტვირთოთ 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

ზემოთ მოცემული ბრძანებები აჩვენებს სრულ დასრულებული სამუშაო პროცესს JSON‑დან XLSX‑ზე Node.JS სცენარებში, როდესაც თქვენ უპირატესობას აძლევთ სუფთა REST მიდგომას. მეტი დეტალებისთვის იხილეთ ოფიციალური API დოკუმენტაცია.

JSON-ის XLSX-ში მეხსიერების ეფექტური გადაყვანა Node.JS-ში როგორ მუშაობს

კონვერტაციის პროცესი დაყოფილია ცხადყოფილ ეტაპებზე, რაც შენარჩუნებს ნაკლები მეხსიერების მოხმარებას:

  1. JSON-ის წაკითხვა და გადამოწმება - სკრიპტი იყენებს fs.readFileSync-ს JSON ფაილის ჩატვირთვისთვის და შემდეგ ირჩევს validateJsonData. ეს ფუნქცია შემოწმებს, რომ ძირითადი ელემენტი არის მასივი და თითოეული ელემენტი არის ობიექტი, რაც აცილებს არასწორ შეყვანას უფრო მოგვიანებით.

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

  2. JSON-ის გადაყვანა CSV-ში - JSON მასივის ერთჯერად გადახვევით, კოდი ქმნის CSV სტრიქონს მეხსიერებაში. სათაურის გენერაცია იყენებს Object.keys‑ის პირველ ობიექტზე, რაც უზრუნველყოფს სვეტების რიგის შესაბამისობას მონაცემებთან.

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

  3. დროებით CSV ფაილის შექმნა - CSV-ის შემცველობა დროებით ფაილში (temp_input.csv) იწერება. ეს ნაბიჯი აკმაყოფილებს Aspose.3D API-ს, რომელიც ფაილის შეყვანას მოითხოვს, თუმცა მოგვიანებით ნაკადის მხარდაჭერასაც იძლევა.

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

  1. ფაილის ნაკადის ბუფერში - streamFileToBuffer დროებით CSV‑ს იკითხავს წაკითხვის ნაკადის საშუალებით, აგროვებს ბლოკებს ერთ Buffer‑ში. ამას შეუძლია თავიდან აიცილოს მთელი ფაილის ერთჯერადად დიდი სტრინგში ჩატვირთვა.

    const inputBuffer = await streamFileToBuffer(tempCsvPath);

  2. გადაყვანის შესრულება - ConvertDocumentRequest შექმნილია format: 'xlsx' და ბუფერირებულ CSV-ით. SDK-მა მონაცემები აგზავნის ღრუბლოვან სერვისს, რომელიც აბრუნებს XLSX Buffer-ს.

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

  3. XLSX-ის დისკზე ჩაწერა - შედეგური ბუფერი იწერება writeBufferToFile-ით, რაც პაიპლაინის დასრულებას უზრუნველყოფს, არ დატოვებს სრულ XLSX ფაილს მეხსიერებაში უფრო გრძელ დროისთვის, ვიდრე საჭიროა.

    await writeBufferToFile(conversionResult, outputXlsxPath);

თითოეული ნაბიჯი განკუთვნილია JSON‑დან XLSX‑ის ნაკადის შექმნა Node.JS-ში და JSON‑დან XLSX‑ის მეხსიერების ეფექტური გამოყენება Node.JS-ში, რაც გადაწყვეტას აძლიერებს დიდი მონაცემთა ნაკადებისთვის.

JSON‑დან XLSX‑ში ექსპორტის გარემოს მომზადება - წინაპირობები და დაყენება

დაწყებამდე, დარწმუნდით, რომ შემდეგი წინაპირობები დაკმაყოფილებულია:

  • Node.js 14+ დაყენებული თქვენს მანქანაზე.
  • Aspose Cloud ანგარიში, რომელიც შეიცავს client ID-ს და client secret-ს.
  • ინტერნეტთან წვდომა API მოთხოვნებისთვის.

დააყენეთ Aspose.3D Cloud SDK for Node.JS npm-ის საშუალებით:

npm install aspose3dcloud

თქვენ ასევე შეგიძლიათ პაკეტი პირდაპირ გადმოწეროთ რელიზის გვერდიდან: Aspose.3D Cloud SDK for Node.JS Download.

კონფიგურირეთ თქვენი ავტორიზაციის დეტალები როგორც გარემოს ცვლადებში ან დააყენეთ ისინი .env ფაილში:

export ASPOSE_CLIENT_ID=YOUR_CLIENT_ID
export ASPOSE_CLIENT_SECRET=YOUR_CLIENT_SECRET

SDK-ის დაყენებით და ავტორიზაციის დეტალებით, თქვენ მზად ხართ კონვერსიის სკრიპტის გაშვებისთვის.

მნიშვნელოვანი დასკვნები

JSON-ის XLSX ფორმატში გადაყვანა Node.JS-ში ხდება მარტივი, როდესაც იყენებთ Aspose.3D Cloud SDK for Node.JS. ბიბლიოთეკა მართავს სტრიმინგს, ვალიდაციას და ფორმატის გადაყვანას, ხოლო მეხსიერების გამოყენება დარჩება დაბალი, რაც აუცილებელია დიდი JSON მონაცემებისთვის. მოცემული კოდის მაგალითი და შესაბამისი cURL სამუშაო ნაკადი მოგაწვდით მოქნილობას, რომ აირჩიოთ სრულყოფილი ბიბლიოთეკა ან მსუბუქი REST მოთხოვნა. დამახსოვრეთ, რომ უსაფრთხოთ გახადოთ თქვენი Aspose Cloud-ის ავტორიზაციის დეტალები და მიიღოთ შესაბამისი ლიცენზია პროდუქციის გამოყენებისთვის. დროებითი ლიცენზია შეგიძლიათ მიიღოთ დროებითი ლიცენზიის გვერდიდან და განაახლოთ სრულ ლიცენზიაზე, როდესაც მზად იქნებით განთავსებისთვის.

ხშირად დასმული კითხვები

შეიძლება JSON‑ის კონვერტირება XLSX-ში Node.JS-ში, მთელი ფაილის მეხსიერებაში ჩატვირთვის გარეშე?

დიახ. SDK-ის ნაკადის დამხმარე ფუნქციები (streamFileToBuffer) და CSV-ის შუალედური ფორმატი საშუალებას გაძლევთ მონაცემები ცალკეული ბლოკებად დამუშავოთ, რაც საშუალებას აძლევს JSON‑დან XLSX-ში მეხსიერების ეფექტური გადაყვანას Node.JS-ში.

SDK-მა გადაყვანისას როგორც შეყვანის ფორმატი რომელი ფაილის ფორმატია?

გარდასაქმნის ბოლო წერტილი მუშაობს CSV-ით როგორც შუალედურ ფორმატად. მაგალითი ქმნის დროებით CSV ფაილს, რადგან Aspose.3D მოითხოვს ფაილის შეყვანას XLSX-ის გენერირებამდე.

როგორ დავამუშაო დიდი მონაცემთა ნაკრები, რომლებიც გადალახავს ჩვეულებრივი მეხსიერების ლიმიტებს?

გამოიყენეთ კოდში წარმოდგენილი ნაკადის მიდგომა. იგი კითხულობს წყაროს ფაილს წაკითხვის ნაკადის საშუალებით, ქმნის CSV-ს ხაზზე‑ხაზზე და აგზავნის ბუფერს ღრუბლოვან სერვისს, რაც უზრუნველყოფს, რომ მხოლოდ პატარა ნაწილები იყოს მეხსიერებაში ნებისმიერი დრო.

CI/CD პაიპლაინში პროცესის ავტომატიზაციის გზა არსებობს?

აბსოლუტურად. იგივე Node.JS სკრიპტს შეიძლება გამოვიძახოთ ბილ్డ్-სკრიპტებიდან, ხოლო cURL ბრძანებებს შეიძლება ინტეგრიროთ შელ-ნაბიჯებში. მხოლოდ დარწმუნდით, რომ გარემოს ცვლადები ASPOSE_CLIENT_ID და ASPOSE_CLIENT_SECRET უსაფრთხოდ გადაეცემა.

დამატებითი მასალები