Convertire i corpi delle email grezze in stringhe confrontabili è una necessità comune quando si costruiscono filtri antispam, sistemi di ticketing o generatori di risposte automatiche. Aspose.Email Cloud SDK for Node.js fornisce un’API potente che rende confrontare il testo nelle email in Node.JS semplice nelle applicazioni Node.js. In questa guida imparerai come configurare l’SDK, eseguire un esempio di codice completo che legge file .EML, eseguire controlli di similarità in batch, affinare le soglie e invocare la stessa operazione tramite chiamate REST cURL.

Confronta il testo nelle email in Node.JS in 5 passaggi

Questo tutorial mostra come confrontare il testo nelle email in Node.JS utilizzando l’Aspose.Email Cloud SDK.

  1. Installa l’SDK e configura le credenziali: Aggiungi il pacchetto al tuo progetto e crea un oggetto Configuration con il tuo client ID e secret.
const { EmailApi, Configuration } = require('asposeemailcloud');
const config = new Configuration({
    clientId: process.env.ASPose_CLIENT_ID || 'YOUR_CLIENT_ID',
    clientSecret: process.env.ASPose_CLIENT_SECRET || 'YOUR_CLIENT_SECRET'
});
const emailApi = new EmailApi(config);
  1. Carica i file EML di origine e destinazione: Usa fs.readFileSync per leggere i byte grezzi di ogni email.
const fs = require('fs');
function readEmailFile(filePath) {
    return fs.readFileSync(filePath);
}
  1. Imposta le opzioni di confronto: Crea un’istanza di CompareOptions e configura i flag come ignoreCase, ignoreWhitespace e similarityThreshold.
const { CompareOptions } = require('asposeemailcloud');
const compareOpts = new CompareOptions();
compareOpts.ignoreCase = true;
compareOpts.ignoreWhitespace = true;
compareOpts.ignorePunctuation = false;
compareOpts.similarityThreshold = 0.8; // 80%
  1. Esegui l’operazione di confronto: Chiama emailApi.compare con le opzioni preparate. La risposta contiene similarity (0‑1) e isSimilar (boolean).
compareOpts.leftEmail = leftBytes;
compareOpts.rightEmail = rightBytes;
const result = await emailApi.compare(compareOpts);
console.log(`Similarity: ${result.similarity}, IsSimilar: ${result.isSimilar}`);
  1. Elabora i risultati batch: Itera su una cartella di email, confronta ogni file con un’email di riferimento e registra i risultati.
    Per ulteriori dettagli sull’API, consulta la Riferimento API Email.

Esempio completo funzionante per il confronto del testo delle email in Node.JS

Il codice seguente dimostra come confrontare il testo nelle email in Node.JS con una singola funzione che gestisce sia confronti singoli che batch.

// Compare Text in Emails using Aspose.Email Cloud SDK for Node.js

const fs = require('fs');
const path = require('path');
const { EmailApi, CompareOptions, Configuration } = require('asposeemailcloud');

// -----------------------------------------------------------------------------
// Configuration – replace with your Aspose Cloud credentials
// -----------------------------------------------------------------------------
const config = new Configuration({
    clientId: process.env.ASPose_CLIENT_ID || 'YOUR_CLIENT_ID',
    clientSecret: process.env.ASPose_CLIENT_SECRET || 'YOUR_CLIENT_SECRET'
});
const emailApi = new EmailApi(config);

// -----------------------------------------------------------------------------
// Helper: read an .eml file and return its raw bytes (Buffer)
// -----------------------------------------------------------------------------
function readEmailFile(filePath) {
    return fs.readFileSync(filePath);
}

// -----------------------------------------------------------------------------
// Compare two email bodies and return similarity (0‑1)
// -----------------------------------------------------------------------------
async function compareEmailTexts(leftPath, rightPath, options) {
    const leftBytes = readEmailFile(leftPath);
    const rightBytes = readEmailFile(rightPath);

const compareOpts = new CompareOptions();
    compareOpts.leftEmail = leftBytes;
    compareOpts.rightEmail = rightBytes;
    compareOpts.ignoreCase = options.ignoreCase ?? true;
    compareOpts.ignoreWhitespace = options.ignoreWhitespace ?? true;
    compareOpts.ignorePunctuation = options.ignorePunctuation ?? false;
    compareOpts.similarityThreshold = options.similarityThreshold ?? 0.8; // default 80%

// API call – returns { similarity: number, isSimilar: boolean }
    const result = await emailApi.compare(compareOpts);
    return result;
}

// -----------------------------------------------------------------------------
// Batch processing – compare a reference email against many others
// -----------------------------------------------------------------------------
// Performance tip: limit parallelism to avoid overwhelming the service.
// Here we process 5 emails concurrently.
async function batchCompare(referenceEmailPath, emailsFolder, options) {
    const files = fs.readdirSync(emailsFolder)
        .filter(f => f.toLowerCase().endsWith('.eml'))
        .map(f => path.join(emailsFolder, f));

const concurrency = 5;
    let index = 0;
    const results = [];

async function worker() {
        while (true) {
            const i = index++;
            if (i >= files.length) break;
            const targetPath = files[i];
            try {
                const res = await compareEmailTexts(referenceEmailPath, targetPath, options);
                results.push({
                    target: path.basename(targetPath),
                    similarity: res.similarity,
                    isSimilar: res.isSimilar
                });
                console.log(`[${path.basename(targetPath)}] Similarity: ${res.similarity.toFixed(3)} – ${res.isSimilar ? 'Similar' : 'Different'}`);
            } catch (err) {
                console.error(`Error comparing ${targetPath}:`, err.message);
            }
        }
    }

// launch workers
    const workers = [];
    for (let i = 0; i < concurrency; i++) workers.push(worker());
    await Promise.all(workers);
    return results;
}

// -----------------------------------------------------------------------------
// Main execution
// -----------------------------------------------------------------------------
(async () => {
    try {
        const referenceEmail = path.resolve(__dirname, 'reference.eml'); // reference email
        const emailsDir = path.resolve(__dirname, 'emails'); // folder with .eml files to compare

const compareOptions = {
            ignoreCase: true,
            ignoreWhitespace: true,
            ignorePunctuation: false,
            similarityThreshold: 0.75 // 75% similarity required to be considered similar
        };

console.log('Starting batch comparison...');
        const batchResults = await batchCompare(referenceEmail, emailsDir, compareOptions);

// Example: summarize results
        const similarCount = batchResults.filter(r => r.isSimilar).length;
        console.log(`\nBatch completed. ${similarCount} out of ${batchResults.length} emails are similar to the reference.`);
    } catch (err) {
        console.error('Unexpected error:', err);
    }
})();

Nota: Questo esempio di codice dimostra la funzionalità principale. Prima di utilizzarlo 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 installate correttamente e testa accuratamente nel tuo ambiente di sviluppo. Se incontri problemi, consulta la documentazione ufficiale o contatta il team di supporto per assistenza.

Confronta il testo dell’e‑mail tramite REST API usando cURL

La stessa comparazione può essere eseguita con chiamate REST dirette. Di seguito è riportato un flusso di lavoro minimale.

  1. Ottieni un token di accesso (sostituisci i segnaposto con le tue credenziali).
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"
  1. Carica l’email sinistra (left.eml).
curl -X PUT "https://api.aspose.cloud/v4.0/email/storage/file/left.eml" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/octet-stream" \
     --data-binary @left.eml
  1. Carica l’email right.eml.
curl -X PUT "https://api.aspose.cloud/v4.0/email/storage/file/right.eml" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/octet-stream" \
     --data-binary @right.eml
  1. Esegui l’operazione di confronto con le opzioni desiderate.
curl -X POST "https://api.aspose.cloud/v4.0/email/compare" \
     -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{
           "leftEmail": "left.eml",
           "rightEmail": "right.eml",
           "ignoreCase": true,
           "ignoreWhitespace": true,
           "ignorePunctuation": false,
           "similarityThreshold": 0.75
         }'

La risposta restituisce similarity e isSimilar. Per ulteriori dettagli, consultare la documentazione API ufficiale.

Installazione e configurazione di Aspose.Email Cloud SDK per Node.JS

Installa la libreria tramite npm e verifica la fonte di download.

npm install @asposecloud/aspose-email-cloud

Puoi anche clonare il sorgente dal repository GitHub: Aspose.Email Cloud SDK for Node.js.
Assicurati che il tuo runtime sia Node.js 14 o versioni successive e che tu disponga di un account Aspose Cloud valido con credenziali client.

Configurazione delle opzioni di confronto per la somiglianza del testo email

L’SDK espone diverse opzioni che influenzano l’algoritmo di similarità:

  • ignoreCase - Quando true, il confronto ignora la differenza tra maiuscole e minuscole.
  • ignoreWhitespace - Salta spazi, interruzioni di riga e tabulazioni.
  • ignorePunctuation - Rimuove i caratteri di punteggiatura prima del confronto.
  • similarityThreshold - Un valore compreso tra 0 e 1 che definisce la soglia per considerare due email simili.

Puoi regolare queste opzioni direttamente sull’oggetto CompareOptions come mostrato nei frammenti di codice sopra. Per un elenco completo dei parametri, consulta il Riferimento API Email.

Considerazioni finali

Integrare controlli di similarità del testo delle email in un backend Node.js è ora a poche righe di codice grazie al Aspose.Email Cloud SDK for Node.js. Configurando le opzioni di confronto è possibile adattare l’algoritmo al proprio caso d’uso specifico, sia che serva una corrispondenza rigorosa sia un punteggio di similarità più tollerante. Ricorda che le distribuzioni in produzione richiedono una licenza adeguata; è possibile visualizzare i dettagli dei prezzi nella pagina del prodotto e ottenere una licenza temporanea dalla pagina della licenza temporanea. Con l’SDK è facile confrontare il testo nelle email in Node.JS e scalare la soluzione per gestire grandi volumi.

Domande comuni

  • Qual è il modo migliore per gestire diverse codifiche email quando si utilizza il confronto di testo nelle email in Node.JS?
    L’SDK rileva automaticamente UTF‑8, UTF‑16 e altre codifiche comuni. Se incontri un formato non supportato, converti il messaggio in UTF‑8 prima di passarlo al metodo compare. Consulta la documentazione ufficiale per gli helper di conversione.

  • Posso confrontare i corpi delle email senza allegati?
    Sì. L’operazione compare funziona solo sul contenuto grezzo dell’email. Gli allegati vengono ignorati a meno che non vengano estratti e confrontati separatamente.

  • Come posso aumentare le prestazioni per grandi batch?
    Utilizza il modello worker‑pool mostrato nel codice di esempio e regola la variabile concurrency. Considera anche di caricare i file su Aspose Cloud storage una sola volta e riutilizzare i riferimenti memorizzati per più confronti.

  • Esiste un limite alla dimensione delle email che posso confrontare?
    Il servizio cloud accetta email fino a 10 MB ciascuna. I messaggi più grandi dovrebbero essere suddivisi o ridotti prima del confronto.

Continua a Esplorare