Convertir los cuerpos de correo electrónico sin procesar en cadenas comparables es una necesidad frecuente al crear filtros antispam, sistemas de tickets o generadores de respuestas automáticas. Aspose.Email Cloud SDK for Node.js proporciona una API potente que hace que comparar texto en correos electrónicos en Node.JS sea sencillo en aplicaciones Node.js. En esta guía aprenderá cómo configurar el SDK, ejecutar un ejemplo de código completo que lee archivos .EML, realizar verificaciones de similitud por lotes, ajustar finamente los umbrales y ejecutar la misma operación mediante llamadas REST cURL.

Comparar texto en correos electrónicos en Node.JS en 5 pasos

Este tutorial muestra cómo comparar texto en correos electrónicos en Node.JS usando el SDK de Aspose.Email Cloud.

  1. Instalar el SDK y configurar credenciales: Añade el paquete a tu proyecto y crea un objeto Configuration con tu ID de cliente y secreto.
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. Cargue los archivos EML de origen y destino: Use fs.readFileSync para leer los bytes sin procesar de cada correo electrónico.
const fs = require('fs');
function readEmailFile(filePath) {
    return fs.readFileSync(filePath);
}
  1. Establecer opciones de comparación: Cree una instancia de CompareOptions y configure banderas como ignoreCase, ignoreWhitespace y similarityThreshold.
const { CompareOptions } = require('asposeemailcloud');
const compareOpts = new CompareOptions();
compareOpts.ignoreCase = true;
compareOpts.ignoreWhitespace = true;
compareOpts.ignorePunctuation = false;
compareOpts.similarityThreshold = 0.8; // 80%
  1. Ejecute la operación de comparación: Llame a emailApi.compare con las opciones preparadas. La respuesta contiene similarity (0‑1) y isSimilar (boolean).
compareOpts.leftEmail = leftBytes;
compareOpts.rightEmail = rightBytes;
const result = await emailApi.compare(compareOpts);
console.log(`Similarity: ${result.similarity}, IsSimilar: ${result.isSimilar}`);
  1. Procesar resultados por lotes: Itera sobre una carpeta de correos electrónicos, compara cada archivo con un correo electrónico de referencia y registra los resultados.
    Para obtener más detalles sobre la API, consulte la Referencia de la API de Email.

Ejemplo completo de funcionamiento para la comparación de texto de correo electrónico en Node.JS

El siguiente código demuestra cómo comparar texto en correos electrónicos en Node.JS con una única función que maneja tanto comparaciones individuales como por lotes.

// 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: Este ejemplo de código demuestra la funcionalidad principal. Antes de usarlo en su proyecto, asegúrese de actualizar cualquier ruta de archivo y valores de configuración para que coincidan con su entorno real, verifique que todas las dependencias requeridas estén correctamente instaladas y pruebe exhaustivamente en su entorno de desarrollo. Si encuentra algún problema, consulte la documentación oficial o póngase en contacto con el equipo de soporte para obtener ayuda.

Comparar texto de correo electrónico mediante la API REST usando cURL

La misma comparación se puede realizar con llamadas REST directas. A continuación se muestra un flujo de trabajo mínimo.

  1. Obtener un token de acceso (reemplaza los marcadores de posición con tus credenciales).
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. Cargar el correo electrónico izquierdo (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. Cargar el correo electrónico correcto (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. Ejecute la operación de comparación con las opciones deseadas.
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 respuesta devuelve similarity y isSimilar. Para obtener más detalles, consulte la documentación oficial de la API.

Instalación y configuración de Aspose.Email Cloud SDK para Node.JS

Instale la biblioteca a través de npm y verifique la fuente de descarga.

npm install @asposecloud/aspose-email-cloud

También puedes clonar el código fuente desde el repositorio de GitHub: Aspose.Email Cloud SDK for Node.js.
Asegúrate de que tu entorno de ejecución sea Node.js 14 o superior y de que tengas una cuenta válida de Aspose Cloud con credenciales de cliente.

Configuración de opciones de comparación para la similitud de texto de correo electrónico

El SDK expone varios indicadores que influyen en el algoritmo de similitud:

  • ignoreCase - Cuando true, la comparación ignora mayúsculas y minúsculas.
  • ignoreWhitespace - Omite espacios, saltos de línea y tabulaciones.
  • ignorePunctuation - Elimina los caracteres de puntuación antes de la comparación.
  • similarityThreshold - Un valor entre 0 y 1 que define el umbral para considerar dos correos electrónicos similares.

Puede ajustar estas opciones directamente en el objeto CompareOptions como se muestra en los fragmentos de código anteriores. Para obtener una lista completa de los parámetros, consulte la Referencia de la API de Email.

Reflexiones finales

Integrar verificaciones de similitud de texto de correo electrónico en un backend Node.js ahora está a solo unas líneas de código gracias al Aspose.Email Cloud SDK for Node.js. Configurando las opciones de comparación puedes adaptar el algoritmo a tu caso de uso específico, ya sea que necesites una coincidencia estricta o una puntuación de similitud más tolerante. Recuerda que los despliegues en producción requieren una licencia adecuada; puedes ver los detalles de precios en la página del producto y obtener una licencia temporal desde la página de licencia temporal. Con el SDK puedes comparar fácilmente texto en correos electrónicos en Node.JS y escalar la solución para manejar grandes volúmenes.

Preguntas comunes

  • ¿Cuál es la mejor manera de manejar diferentes codificaciones de correo electrónico al usar compare text en correos electrónicos en Node.JS?
    El SDK detecta automáticamente UTF‑8, UTF‑16 y otras codificaciones comunes. Si encuentra un formato no compatible, convierta el mensaje a UTF‑8 antes de pasarlo al método compare. Consulte la documentación oficial para obtener ayudantes de conversión.

  • ¿Puedo comparar los cuerpos de correo electrónico sin archivos adjuntos?
    Sí. La operación compare funciona solo con el contenido bruto del correo electrónico. Los archivos adjuntos se ignoran a menos que los extraigas y compares por separado.

  • ¿Cómo aumento el rendimiento para lotes grandes?
    Use el patrón worker‑pool mostrado en el código de ejemplo y ajuste la variable concurrency. También considere cargar los archivos en Aspose Cloud storage una vez y reutilizar las referencias almacenadas para múltiples comparaciones.

  • ¿Hay un límite al tamaño de los correos electrónicos que puedo comparar?
    El servicio en la nube acepta correos electrónicos de hasta 10 MB cada uno. Los mensajes más grandes deben dividirse o recortarse antes de la comparación.

Sigue explorando