Destaque la diferencia entre dos cadenas en PHP

¿Cuál es la forma más fácil de resaltar la diferencia entre dos cadenas en PHP?

Estoy pensando en la línea de la página del historial de edición de Desbordamiento de pila, donde el nuevo texto está en verde y el texto eliminado está en rojo. Si hay algunas funciones o clases previamente escritas disponibles, sería ideal.

Pudiste usar el paquete PHP Horde_Text_Diff.

Sin embargo, este paquete ya no está disponible.

Acabo de escribir una clase para calcular el número más pequeño (no para ser tomado literalmente) de ediciones para transformar una cadena en otra cadena:

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

Tiene una función estática para representar una versión HTML de la diferencia.

Es una primera versión, y es probable que se mejore, pero funciona bien ahora, por lo que la estoy lanzando por si alguien necesita generar un diferencial compacto de manera eficiente, como yo necesitaba.

Editar: ahora está en Github: https://github.com/gorhill/PHP-FineDiff

Si desea una biblioteca robusta, Text_Diff (un paquete PEAR) parece ser bastante bueno. Tiene algunas características geniales.

Este es bueno, también http://paulbutler.org/archives/a-simple-diff-algorithm-in-php/

Resolver el problema no es tan simple como parece, y el problema me molestó durante aproximadamente un año antes de resolverlo. Logré escribir mi algoritmo en PHP, en 18 líneas de código. No es la forma más eficiente de hacer una diferencia, pero es probablemente la más fácil de entender.

Funciona encontrando la secuencia más larga de palabras comunes a ambas cadenas y encontrando recursivamente las secuencias más largas de los restos de la cadena hasta que las subcadenas no tengan palabras en común. En este punto, agrega las palabras nuevas restantes como inserción y las palabras antiguas restantes como eliminación.

Puede descargar la fuente aquí: PHP SimpleDiff ...

Aquí hay una función corta que puede usar para diferenciar dos matrices. Implementa el 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);
}

Genera dos matrices:

• matriz de valores: una lista de elementos tal como aparecen en la diferencia.
• matriz de máscara: contiene números. 0: sin cambios, -1: eliminado, 1: agregado.

Si llena una matriz con caracteres, se puede usar para calcular la diferencia en línea. Ahora solo un paso para resaltar las diferencias:

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;
}

P.ej.:

echo diffline('StackOverflow', 'ServerFault')

Saldrá:

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

StackOerverFFaulAyt

Notas adicionales:

• La matriz de diferencias requiere elementos (m + 1) * (n + 1). Por lo tanto, puede encontrarse con errores de falta de memoria si intenta diferir secuencias largas. En este caso, difunda los trozos más grandes (por ejemplo, líneas) primero, luego diferencie su contenido en una segunda pasada.
• El algoritmo se puede mejorar si recorta los elementos coincidentes desde el principio y el final, luego ejecuta el algoritmo solo en el medio diferente. Una última versión (más hinchada) también contiene estas modificaciones.

También hay una extensión PECL para xdiff:

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

En particular:

• xdiff_string_diff - Crea un diff unificado de dos cadenas

Ejemplo del manual de 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;
}

Tuve problemas terribles con las alternativas basadas en PEAR y las más simples que se muestran. Entonces, aquí hay una solución que aprovecha el comando Unix diff (obviamente, debe estar en un sistema Unix o tener un comando diff de Windows que funcione para que funcione). Elija su directorio temporal favorito y cambie las excepciones a códigos de retorno si lo prefiere.

/**
 * @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 es el mejor que he encontrado.

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

Lo que está buscando es un "algoritmo diff". Una búsqueda rápida en Google me llevó a esta solución . No lo probé, pero tal vez haga lo que necesita.

Un puerto php de Neil Frasers diff_match_patch (Apache 2.0 con licencia)

Recomendaría mirar estas increíbles funciones desde el núcleo de PHP:

similar_text - Calcula la similitud entre dos cadenas

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

levenshtein - Calcular la distancia de Levenshtein entre dos cuerdas

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

soundex - Calcula la clave soundex de una cadena

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

metaphone - Calcule la tecla metaphone de una cadena

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

Encontré esta clase PHP diff de Chris Boulton basada en Python difflib, que podría ser una buena solución:

PHP Diff Lib

Otra solución (para la comparación lado a lado en lugar de una vista unificada): https://github.com/danmysak/side-by-side .