Converter corpos de e‑mail brutos em strings comparáveis é uma necessidade comum ao criar filtros de spam, sistemas de tickets ou geradores automáticos de respostas. Aspose.Email Cloud SDK for Node.js fornece uma API poderosa que torna comparar texto em e‑mails no Node.JS simples em aplicações Node.js. Neste guia, você aprenderá como configurar o SDK, executar um exemplo de código completo que lê arquivos .EML, realizar verificações de similaridade em lote, ajustar finamente os limites e invocar a mesma operação via chamadas REST cURL.

Comparar Texto em E‑mails no Node.JS em 5 Etapas

Este tutorial mostra como comparar texto em e‑mails no Node.JS usando o Aspose.Email Cloud SDK.

  1. Instalar o SDK e configurar credenciais: Adicione o pacote ao seu projeto e crie um objeto Configuration com seu ID de cliente e segredo.
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. Carregue os arquivos EML de origem e destino: Use fs.readFileSync para ler os bytes brutos de cada e‑mail.
const fs = require('fs');
function readEmailFile(filePath) {
    return fs.readFileSync(filePath);
}
  1. Definir opções de comparação: Crie uma instância de CompareOptions e configure as flags como 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. Execute a operação de comparação: Chame emailApi.compare com as opções preparadas. A resposta contém 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. Processar resultados em lote: Percorra uma pasta de e‑mails, compare cada arquivo com um e‑mail de referência e registre os resultados.
    Para mais detalhes sobre a API, consulte a Referência da API de Email.

Exemplo Completo de Funcionamento para Comparação de Texto de Email em Node.JS

O código a seguir demonstra como comparar texto em e‑mails no Node.JS com uma única função que lida tanto com comparações individuais quanto em lote.

// 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 exemplo de código demonstra a funcionalidade principal. Antes de usá‑lo em seu projeto, certifique‑se de atualizar quaisquer caminhos de arquivo e valores de configuração para corresponder ao seu ambiente real, verifique se todas as dependências necessárias estão devidamente instaladas e teste minuciosamente em seu ambiente de desenvolvimento. Se encontrar algum problema, consulte a documentação oficial ou entre em contato com a equipe de suporte para obter assistência.

Comparar Texto de Email via API REST usando cURL

A mesma comparação pode ser realizada com chamadas REST diretas. Abaixo está um fluxo de trabalho mínimo.

  1. Obtenha um token de acesso (substitua os marcadores de posição pelas suas credenciais).
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. Faça upload do e‑mail esquerdo (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. Carregue o e‑mail correto (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. Execute a operação de comparação com as opções desejadas.
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
         }'

A resposta retorna similarity e isSimilar. Para mais detalhes, veja a documentação oficial da API.

Instalando e Configurando Aspose.Email Cloud SDK for Node.JS

Instale a biblioteca via npm e verifique a origem do download.

npm install @asposecloud/aspose-email-cloud

Você também pode clonar o código-fonte do repositório GitHub: Aspose.Email Cloud SDK for Node.js.
Certifique-se de que seu runtime seja Node.js 14 ou mais recente e de que você possua uma conta válida da Aspose Cloud com credenciais de cliente.

Configurando Opções de Comparação para Similaridade de Texto de Email

O SDK expõe várias flags que influenciam o algoritmo de similaridade:

  • ignoreCase - Quando true, a comparação ignora maiúsculas e minúsculas.
  • ignoreWhitespace - Ignora espaços, quebras de linha e tabulações.
  • ignorePunctuation - Remove caracteres de pontuação antes da comparação.
  • similarityThreshold - Um valor entre 0 e 1 que define o limite para considerar dois e‑mails semelhantes.

Você pode ajustar essas opções diretamente no objeto CompareOptions, conforme mostrado nos trechos de código acima. Para obter uma lista completa de parâmetros, consulte a Referência da API de Email.

Considerações Finais

Integrar verificações de similaridade de texto de e‑mail em um backend Node.js agora está a apenas algumas linhas de código graças ao Aspose.Email Cloud SDK for Node.js. Configurando as opções de comparação, você pode adaptar o algoritmo ao seu caso de uso específico, seja precisando de correspondência estrita ou de uma pontuação de similaridade mais tolerante. Lembre‑se de que implantações em produção exigem uma licença adequada; você pode ver os detalhes de preços na página do produto e obter uma licença temporária na página de licença temporária. Com o SDK, você pode facilmente comparar texto em e‑mails no Node.JS e escalar a solução para lidar com grandes volumes.

Perguntas Comuns

  • Qual é a melhor maneira de lidar com diferentes codificações de e‑mail ao usar compare text em e‑mails no Node.JS?
    O SDK detecta automaticamente UTF‑8, UTF‑16 e outras codificações comuns. Se você encontrar um formato não suportado, converta a mensagem para UTF‑8 antes de passá‑la ao método compare. Consulte a documentação oficial para auxiliares de conversão.

  • Posso comparar o corpo dos e‑mails sem anexos?
    Sim. A operação compare funciona apenas no conteúdo bruto do e‑mail. Os anexos são ignorados, a menos que você os extraia e compare separadamente.

  • Como aumento o desempenho para lotes grandes?
    Use o padrão worker‑pool mostrado no código de exemplo e ajuste a variável concurrency. Também considere fazer upload dos arquivos para o Aspose Cloud storage uma vez e reutilizar as referências armazenadas para múltiplas comparações.

  • Existe um limite para o tamanho dos e‑mails que posso comparar?
    O serviço em nuvem aceita e‑mails de até 10 MB cada. Mensagens maiores devem ser divididas ou reduzidas antes da comparação.

Continue Explorando