Convertir les corps d’e‑mails bruts en chaînes comparables est un besoin fréquent lors de la création de filtres anti‑spam, de systèmes de billetterie ou de générateurs de réponses automatisées. Aspose.Email Cloud SDK for Node.js fournit une API puissante qui rend la comparaison de texte dans les e‑mails en Node.JS simple dans les applications Node.js. Dans ce guide, vous apprendrez comment configurer le SDK, exécuter un exemple de code complet qui lit les fichiers .EML, effectuer des vérifications de similarité par lots, affiner les seuils, et invoquer la même opération via des appels REST cURL.

Comparer le texte dans les e‑mails en Node.JS en 5 étapes

Ce tutoriel montre comment comparer le texte dans les e‑mails en Node.JS en utilisant le Aspose.Email Cloud SDK.

  1. Installer le SDK et configurer les informations d’identification : Ajoutez le package à votre projet et créez un objet Configuration avec votre ID client et 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. Chargez les fichiers source et cible EML : utilisez fs.readFileSync pour lire les octets bruts de chaque e‑mail.
const fs = require('fs');
function readEmailFile(filePath) {
    return fs.readFileSync(filePath);
}
  1. Définir les options de comparaison : Créez une instance de CompareOptions et configurez les indicateurs tels que ignoreCase, ignoreWhitespace et similarityThreshold.
const { CompareOptions } = require('asposeemailcloud');
const compareOpts = new CompareOptions();
compareOpts.ignoreCase = true;
compareOpts.ignoreWhitespace = true;
compareOpts.ignorePunctuation = false;
compareOpts.similarityThreshold = 0.8; // 80%
  1. Exécuter l’opération de comparaison : Appelez emailApi.compare avec les options préparées. La réponse contient similarity (0‑1) et isSimilar (booléen).
compareOpts.leftEmail = leftBytes;
compareOpts.rightEmail = rightBytes;
const result = await emailApi.compare(compareOpts);
console.log(`Similarity: ${result.similarity}, IsSimilar: ${result.isSimilar}`);
  1. Traitement des résultats par lot : Parcourez un dossier d’e-mails, comparez chaque fichier à un e-mail de référence et consignez les résultats.
    Pour plus de détails sur l’API, consultez la Référence de l’API Email.

Exemple complet fonctionnel de comparaison de texte d’e‑mail en Node.JS

Le code suivant montre comment comparer le texte des e‑mails en Node.JS à l’aide d’une fonction unique qui gère à la fois les comparaisons individuelles et par lots.

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

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.

Comparer le texte d’e-mail via l’API REST en utilisant cURL

La même comparaison peut être effectuée avec des appels REST directs. Ci-dessous se trouve un flux de travail minimal.

  1. Obtenez un jeton d’accès (remplacez les espaces réservés par vos informations d’identification).
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. Téléverser l’e‑mail de gauche (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. Téléverser le bon e‑mail (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. Exécuter l’opération de comparaison avec les options souhaitées.
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 réponse renvoie similarity et isSimilar. Pour plus de détails, consultez la documentation officielle de l’API.

Installation et configuration d’Aspose.Email Cloud SDK pour Node.JS

Installez la bibliothèque via npm et vérifiez la source de téléchargement.

npm install @asposecloud/aspose-email-cloud

Vous pouvez également cloner le code source depuis le dépôt GitHub : Aspose.Email Cloud SDK for Node.js.
Assurez-vous que votre environnement d’exécution est Node.js 14 ou une version plus récente et que vous disposez d’un compte Aspose Cloud valide avec des identifiants client.

Configuration des options de comparaison pour la similarité du texte d’e‑mail

Le SDK expose plusieurs indicateurs qui influencent l’algorithme de similarité :

  • ignoreCase - Lorsque true, la comparaison ignore la casse des lettres.
  • ignoreWhitespace - Ignore les espaces, les sauts de ligne et les tabulations.
  • ignorePunctuation - Supprime les caractères de ponctuation avant la comparaison.
  • similarityThreshold - Une valeur comprise entre 0 et 1 qui définit le seuil de coupure pour considérer deux e‑mails similaires.

Vous pouvez ajuster ces options directement sur l’objet CompareOptions comme indiqué dans les extraits de code ci‑dessus. Pour obtenir la liste complète des paramètres, consultez la Référence de l’API Email.

Dernières réflexions

Intégrer des vérifications de similarité de texte d’e‑mail dans un backend Node.js n’est plus qu’à quelques lignes de code grâce au Aspose.Email Cloud SDK for Node.js. En configurant les options de comparaison, vous pouvez adapter l’algorithme à votre cas d’utilisation spécifique, que vous ayez besoin d’une correspondance stricte ou d’un score de similarité plus tolérant. N’oubliez pas que les déploiements en production nécessitent une licence appropriée ; vous pouvez consulter les détails tarifaires sur la page du produit et obtenir une licence temporaire depuis la page de licence temporaire. Avec le SDK, vous pouvez facilement comparer le texte des e‑mails dans Node.JS et faire évoluer la solution pour gérer de gros volumes.

Questions courantes

  • Quelle est la meilleure façon de gérer les différents encodages d’e‑mail lors de l’utilisation de la comparaison de texte dans les e‑mails en Node.JS ?
    Le SDK détecte automatiquement UTF‑8, UTF‑16 et d’autres encodages courants. Si vous rencontrez un format non pris en charge, convertissez le message en UTF‑8 avant de le transmettre à la méthode compare. Consultez la documentation officielle pour les outils de conversion.

  • Puis-je comparer le corps des e‑mails sans pièces jointes ?
    Oui. L’opération compare fonctionne uniquement sur le contenu brut de l’e‑mail. Les pièces jointes sont ignorées sauf si vous les extrayez et les comparez explicitement séparément.

  • Comment augmenter les performances pour de gros lots ?
    Utilisez le modèle de pool de travailleurs présenté dans le code d’exemple et ajustez la variable concurrency. Envisagez également de télécharger les fichiers vers le stockage Aspose Cloud une fois et de réutiliser les références stockées pour plusieurs comparaisons.

  • Y a-t-il une limite à la taille des e‑mails que je peux comparer ?
    Le service cloud accepte les e‑mails jusqu’à 10 Mo chacun. Les messages plus volumineux doivent être divisés ou réduits avant la comparaison.

Continuez à explorer