Destaque a diferença entre duas strings no PHP

Qual é a maneira mais fácil de destacar a diferença entre duas strings no PHP?

Estou pensando nas linhas da página Histórico de edições do estouro de pilha, onde o novo texto está em verde e o texto removido está em vermelho. Se houver alguma função ou classe pré-escrita disponível, isso seria o ideal.

Você conseguiu usar o pacote PHP Horde_Text_Diff.

No entanto, este pacote não está mais disponível.

Acabei de escrever uma classe para calcular o menor número (não para ser tomado literalmente) de edições para transformar uma string em outra string:

http://www.raymondhill.net/finediff/

Ele tem uma função estática para renderizar uma versão HTML do diff.

É uma primeira versão, e provavelmente será aprimorada, mas funciona muito bem a partir de agora, então estou lançando-a no caso de alguém precisar gerar um diff compacto com eficiência, como eu precisava.

Edit: Já está no Github: https://github.com/gorhill/PHP-FineDiff

Se você deseja uma biblioteca robusta, o Text_Diff (um pacote PEAR) parece ser muito bom. Tem alguns recursos bem legais.

Essa é boa, também http://paulbutler.org/archives/a-simple-diff-algorithm-in-php/

Resolver o problema não é tão simples quanto parece, e o problema me incomodou por cerca de um ano antes de eu descobrir. Consegui escrever meu algoritmo em PHP, em 18 linhas de código. Não é a maneira mais eficiente de fazer uma diferença, mas é provavelmente a mais fácil de entender.

Ele funciona encontrando a sequência mais longa de palavras comum a ambas as seqüências de caracteres e recursivamente localizando as seqüências mais longas dos demais remanescentes da sequência até que as subseqüências não tenham palavras em comum. Nesse ponto, ele adiciona as novas palavras restantes como uma inserção e as palavras antigas restantes como uma exclusão.

Você pode baixar a fonte aqui: PHP SimpleDiff ...

Aqui está uma função curta que você pode usar para diferenciar duas matrizes. Ele implementa o algoritmo LCS :

function computeDiff($from, $to)
{
    $diffValues = array();
    $diffMask = array();

    $dm = array();
    $n1 = count($from);
    $n2 = count($to);

    for ($j = -1; $j < $n2; $j++) $dm[-1][$j] = 0;
    for ($i = -1; $i < $n1; $i++) $dm[$i][-1] = 0;
    for ($i = 0; $i < $n1; $i++)
    {
        for ($j = 0; $j < $n2; $j++)
        {
            if ($from[$i] == $to[$j])
            {
                $ad = $dm[$i - 1][$j - 1];
                $dm[$i][$j] = $ad + 1;
            }
            else
            {
                $a1 = $dm[$i - 1][$j];
                $a2 = $dm[$i][$j - 1];
                $dm[$i][$j] = max($a1, $a2);
            }
        }
    }

    $i = $n1 - 1;
    $j = $n2 - 1;
    while (($i > -1) || ($j > -1))
    {
        if ($j > -1)
        {
            if ($dm[$i][$j - 1] == $dm[$i][$j])
            {
                $diffValues[] = $to[$j];
                $diffMask[] = 1;
                $j--;  
                continue;              
            }
        }
        if ($i > -1)
        {
            if ($dm[$i - 1][$j] == $dm[$i][$j])
            {
                $diffValues[] = $from[$i];
                $diffMask[] = -1;
                $i--;
                continue;              
            }
        }
        {
            $diffValues[] = $from[$i];
            $diffMask[] = 0;
            $i--;
            $j--;
        }
    }    

    $diffValues = array_reverse($diffValues);
    $diffMask = array_reverse($diffMask);

    return array('values' => $diffValues, 'mask' => $diffMask);
}

Ele gera duas matrizes:

• matriz de valores: uma lista de elementos como eles aparecem no diff.
• array de máscaras: contém números. 0: inalterado, -1: removido, 1: adicionado.

Se você preencher uma matriz com caracteres, ela poderá ser usada para calcular a diferença embutida. Agora, apenas um passo para destacar as diferenças:

function diffline($line1, $line2)
{
    $diff = computeDiff(str_split($line1), str_split($line2));
    $diffval = $diff['values'];
    $diffmask = $diff['mask'];

    $n = count($diffval);
    $pmc = 0;
    $result = '';
    for ($i = 0; $i < $n; $i++)
    {
        $mc = $diffmask[$i];
        if ($mc != $pmc)
        {
            switch ($pmc)
            {
                case -1: $result .= '</del>'; break;
                case 1: $result .= '</ins>'; break;
            }
            switch ($mc)
            {
                case -1: $result .= '<del>'; break;
                case 1: $result .= '<ins>'; break;
            }
        }
        $result .= $diffval[$i];

        $pmc = $mc;
    }
    switch ($pmc)
    {
        case -1: $result .= '</del>'; break;
        case 1: $result .= '</ins>'; break;
    }

    return $result;
}

Por exemplo.:

echo diffline('StackOverflow', 'ServerFault')

Saída:

S<del>tackO</del><ins>er</ins>ver<del>f</del><ins>Fau</ins>l<del>ow</del><ins>t</ins> 

StackOerverfFaulowt

Notas Adicionais:

• A matriz diff requer (m + 1) * (n + 1) elementos. Assim, você poderá encontrar erros de falta de memória se tentar diferenciar longas seqüências. Nesse caso, diferencie primeiro os pedaços maiores (por exemplo, linhas) e depois difira o conteúdo em uma segunda passagem.
• O algoritmo pode ser aprimorado se você aparar os elementos correspondentes do começo e do fim e executar o algoritmo apenas no meio diferente. Uma última versão (mais inchada) também contém essas modificações.

Há também uma extensão PECL para xdiff:

• http://php.net/manual/en/book.xdiff.php
• http://pecl.php.net/package/xdiff

Em particular:

• xdiff_string_diff - Crie um diff unificado de duas strings

Exemplo do manual do PHP:

<?php
$old_article = file_get_contents('./old_article.txt');
$new_article = $_POST['article'];

$diff = xdiff_string_diff($old_article, $new_article, 1);
if (is_string($diff)) {
    echo "Differences between two articles:\n";
    echo $diff;
}

Eu tive um problema terrível com as alternativas baseadas em PEAR e as mais simples mostradas. Então, aqui está uma solução que aproveita o comando diff do Unix (obviamente, você precisa estar em um sistema Unix ou ter um comando diff do Windows em funcionamento para que ele funcione). Escolha seu diretório temporário favorito e altere as exceções para retornar códigos, se você preferir.

/**
 * @brief Find the difference between two strings, lines assumed to be separated by "\n|
 * @param $new string The new string
 * @param $old string The old string
 * @return string Human-readable output as produced by the Unix diff command,
 * or "No changes" if the strings are the same.
 * @throws Exception
 */
public static function diff($new, $old) {
  $tempdir = '/var/somewhere/tmp'; // Your favourite temporary directory
  $oldfile = tempnam($tempdir,'OLD');
  $newfile = tempnam($tempdir,'NEW');
  if (!@file_put_contents($oldfile,$old)) {
    throw new Exception('diff failed to write temporary file: ' . 
         print_r(error_get_last(),true));
  }
  if (!@file_put_contents($newfile,$new)) {
    throw new Exception('diff failed to write temporary file: ' . 
         print_r(error_get_last(),true));
  }
  $answer = array();
  $cmd = "diff $newfile $oldfile";
  exec($cmd, $answer, $retcode);
  unlink($newfile);
  unlink($oldfile);
  if ($retcode != 1) {
    throw new Exception('diff failed with return code ' . $retcode);
  }
  if (empty($answer)) {
    return 'No changes';
  } else {
    return implode("\n", $answer);
  }
}

Este é o melhor que eu encontrei.

http://code.stephenmorley.org/php/diff-implementation/

O que você está procurando é um "algoritmo diff". Uma rápida pesquisa no Google me levou a esta solução . Não testei, mas talvez faça o que você precisa.

Uma porta php de Neil Frasers diff_match_patch (licença Apache 2.0)

Eu recomendaria olhar para essas funções impressionantes do núcleo do PHP:

similar_text - Calcula a similaridade entre duas strings

http://www.php.net/manual/en/function.similar-text.php

levenshtein - Calcule a distância de Levenshtein entre duas cordas

http://www.php.net/manual/en/function.levenshtein.php

soundex - Calcula a tecla soundex de uma string

http://www.php.net/manual/en/function.soundex.php

metafone - Calcule a chave de metafone de uma string

http://www.php.net/manual/en/function.metaphone.php

Me deparei com esta classe diff de PHP de Chris Boulton, baseada no Python difflib, que poderia ser uma boa solução:

PHP Diff Lib

Outra solução (para comparação lado a lado em oposição a uma exibição unificada): https://github.com/danmysak/side-by-side .