Markieren Sie den Unterschied zwischen zwei Zeichenfolgen in PHP

Was ist der einfachste Weg, um den Unterschied zwischen zwei Zeichenfolgen in PHP hervorzuheben?

Ich denke in Anlehnung an die Seite "Stapelüberlauf-Bearbeitungsverlauf", auf der neuer Text grün und entfernter Text rot angezeigt wird. Wenn vorab geschriebene Funktionen oder Klassen verfügbar sind, wäre dies ideal.

Sie konnten das PHP Horde_Text_Diff-Paket verwenden.

Dieses Paket ist jedoch nicht mehr verfügbar.

Ich habe gerade eine Klasse geschrieben, um die kleinste (nicht wörtlich zu nehmen) Anzahl von Änderungen zu berechnen, um eine Zeichenfolge in eine andere Zeichenfolge umzuwandeln:

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

Es hat eine statische Funktion zum Rendern einer HTML-Version des Diff.

Es ist eine erste Version, die wahrscheinlich verbessert wird, aber sie funktioniert ab sofort einwandfrei. Ich werfe sie also raus, falls jemand ein kompaktes Diff effizient generieren muss, wie ich es brauchte.

Bearbeiten: Es ist jetzt auf Github: https://github.com/gorhill/PHP-FineDiff

Wenn Sie eine robuste Bibliothek wünschen, sieht Text_Diff (ein PEAR-Paket) ziemlich gut aus. Es hat einige ziemlich coole Funktionen.

Dies ist eine schöne, auch http://paulbutler.org/archives/a-simple-diff-algorithm-in-php/

Das Problem zu lösen ist nicht so einfach, wie es scheint, und das Problem hat mich ungefähr ein Jahr lang gestört, bevor ich es herausgefunden habe. Ich habe es geschafft, meinen Algorithmus in PHP in 18 Codezeilen zu schreiben. Es ist nicht der effizienteste Weg, einen Diff zu machen, aber wahrscheinlich der am einfachsten zu verstehende.

Es funktioniert, indem die längste Folge von Wörtern gefunden wird, die beiden Zeichenfolgen gemeinsam sind, und rekursiv die längsten Folgen der verbleibenden Zeichenfolgen gefunden werden, bis die Teilzeichenfolgen keine gemeinsamen Wörter mehr haben. Zu diesem Zeitpunkt werden die verbleibenden neuen Wörter als Einfügung und die verbleibenden alten Wörter als Löschung hinzugefügt.

Sie können die Quelle hier herunterladen: PHP SimpleDiff ...

Hier ist eine kurze Funktion, mit der Sie zwei Arrays unterscheiden können. Es implementiert den LCS- Algorithmus:

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

Es werden zwei Arrays generiert:

• Werte-Array: Eine Liste von Elementen, wie sie im Diff erscheinen.
• Maskenarray: enthält Zahlen. 0: unverändert, -1: entfernt, 1: hinzugefügt.

Wenn Sie ein Array mit Zeichen füllen, können Sie damit die Inline-Differenz berechnen. Jetzt nur ein einziger Schritt, um die Unterschiede hervorzuheben:

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

Z.B.:

echo diffline('StackOverflow', 'ServerFault')

Wird ausgegeben:

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

S.TackOerverfFaulowt

Zusätzliche Bemerkungen:

• Die Diff-Matrix erfordert (m + 1) * (n + 1) Elemente. Wenn Sie versuchen, lange Sequenzen zu unterscheiden, können daher Speicherfehler auftreten. In diesem Fall werden zuerst größere Teile (z. B. Linien) und dann in einem zweiten Durchgang deren Inhalt unterschieden.
• Der Algorithmus kann verbessert werden, wenn Sie die übereinstimmenden Elemente von Anfang bis Ende kürzen und den Algorithmus dann nur in der unterschiedlichen Mitte ausführen. Eine letztere (aufgeblähte) Version enthält auch diese Modifikationen.

Es gibt auch eine PECL-Erweiterung für xdiff:

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

Bestimmtes:

• xdiff_string_diff - Erstellt einen einheitlichen Unterschied zwischen zwei Zeichenfolgen

Beispiel aus dem PHP-Handbuch:

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

Ich hatte schreckliche Probleme mit den PEAR-basierten und den einfacheren Alternativen. Hier ist also eine Lösung, die den Unix-Diff-Befehl nutzt (offensichtlich müssen Sie sich auf einem Unix-System befinden oder über einen funktionierenden Windows-Diff-Befehl verfügen, damit er funktioniert). Wählen Sie Ihr temporäres Lieblingsverzeichnis und ändern Sie die Ausnahmen in Rückkehrcodes, wenn Sie dies bevorzugen.

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

Dies ist das beste, das ich gefunden habe.

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

Was Sie suchen, ist ein "Diff-Algorithmus". Eine schnelle Google-Suche führte mich zu dieser Lösung . Ich habe es nicht getestet, aber vielleicht macht es das, was Sie brauchen.

Ein PHP-Port von Neil Frasers diff_match_patch (Apache 2.0 lizenziert)

Ich würde empfehlen, sich diese fantastischen Funktionen aus dem PHP-Kern anzusehen:

like_text - Berechnet die Ähnlichkeit zwischen zwei Zeichenfolgen

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

levenshtein - Berechnet den Levenshtein-Abstand zwischen zwei Saiten

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

Soundex - Berechnet den Soundex-Schlüssel einer Zeichenfolge

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

Metaphon - Berechnet den Metaphonschlüssel einer Zeichenfolge

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

Ich bin auf diese PHP-Diff-Klasse von Chris Boulton gestoßen, die auf Python-Difflib basiert und eine gute Lösung sein könnte:

PHP Diff Lib

Eine andere Lösung (zum direkten Vergleich im Gegensatz zu einer einheitlichen Ansicht): https://github.com/danmysak/side-by-side .