web-dev-qa-db-fra.com

Trouvez la différence entre deux cordes dans JavaScript

J'ai besoin de trouver la différence entre deux chaînes.

const string1 = 'lebronjames';
const string2 = 'lebronnjames';

La sortie attendue consiste à trouver le N et à le journaler à la console.

Y a-t-il un moyen de le faire en JavaScript?

javascriptstringalgorithmdifference
7
Elvis S.

Une autre option, pour une vérification plus sophistiquée de différence, consiste à utiliser l'algorithme de patience. J'ai porté cet algorithme à JavaScript à ...

https://github.com/jontrent/patianendeiff

... qui, bien que l'algorithme soit généralement utilisé pour la comparaison des lignes lignées du texte (tels que les programmes informatiques), il peut toujours être utilisé pour la comparaison du caractère-caractère. Par exemple, pour comparer deux cordes, vous pouvez faire ce qui suit ...

let a = "thelebronnjamist";
let b = "the lebron james";

let difference = patienceDiff( a.split(""), b.split("") );

...avec difference.lines étant réglé sur un tableau avec les résultats de la comparaison ...

difference.lines: Array(19)

0: {line: "t", aIndex: 0, bIndex: 0}
1: {line: "h", aIndex: 1, bIndex: 1}
2: {line: "e", aIndex: 2, bIndex: 2}
3: {line: " ", aIndex: -1, bIndex: 3}
4: {line: "l", aIndex: 3, bIndex: 4}
5: {line: "e", aIndex: 4, bIndex: 5}
6: {line: "b", aIndex: 5, bIndex: 6}
7: {line: "r", aIndex: 6, bIndex: 7}
8: {line: "o", aIndex: 7, bIndex: 8}
9: {line: "n", aIndex: 8, bIndex: 9}
10: {line: "n", aIndex: 9, bIndex: -1}
11: {line: " ", aIndex: -1, bIndex: 10}
12: {line: "j", aIndex: 10, bIndex: 11}
13: {line: "a", aIndex: 11, bIndex: 12}
14: {line: "m", aIndex: 12, bIndex: 13}
15: {line: "i", aIndex: 13, bIndex: -1}
16: {line: "e", aIndex: -1, bIndex: 14}
17: {line: "s", aIndex: 14, bIndex: 15}
18: {line: "t", aIndex: 15, bIndex: -1}

Partout où aIndex === -1 ou alors bIndex === -1 est une indication d'une différence entre les deux chaînes. Spécifiquement...

  • L'élément 3 indique que le caractère "" a été trouvé dans b en position 3.
  • L'élément 10 indique que le caractère "n" a été trouvé dans a en position 9.
  • L'élément 11 indique que le caractère "" a été trouvé dans b en position 10.
  • L'élément 15 indique que le caractère "i" a été trouvé dans a en position 13.
  • L'élément 16 indique que le caractère "E" a été trouvé dans b en position 14.
  • L'élément 18 indique que le caractère "T" a été trouvé dans a en position 15.

Notez que l'algorithme PatianFFIFF est utile pour comparer deux blocs de texte ou de chaînes similaires. Cela ne vous dira pas si les modifications de base ont eu lieu. Par exemple, les suivants ...

let a = "james lebron";
let b = "lebron james";

let difference = patienceDiff( a.split(""), b.split("") );

...Retour difference.lines contenant ...

difference.lines: Array(18)

0: {line: "j", aIndex: 0, bIndex: -1}
1: {line: "a", aIndex: 1, bIndex: -1}
2: {line: "m", aIndex: 2, bIndex: -1}
3: {line: "e", aIndex: 3, bIndex: -1}
4: {line: "s", aIndex: 4, bIndex: -1}
5: {line: " ", aIndex: 5, bIndex: -1}
6: {line: "l", aIndex: 6, bIndex: 0}
7: {line: "e", aIndex: 7, bIndex: 1}
8: {line: "b", aIndex: 8, bIndex: 2}
9: {line: "r", aIndex: 9, bIndex: 3}
10: {line: "o", aIndex: 10, bIndex: 4}
11: {line: "n", aIndex: 11, bIndex: 5}
12: {line: " ", aIndex: -1, bIndex: 6}
13: {line: "j", aIndex: -1, bIndex: 7}
14: {line: "a", aIndex: -1, bIndex: 8}
15: {line: "m", aIndex: -1, bIndex: 9}
16: {line: "e", aIndex: -1, bIndex: 10}
17: {line: "s", aIndex: -1, bIndex: 11}

Notez que le patiantiff ne signale pas l'échange du prénom et de la prénom, mais il fournit plutôt un résultat montrant quels caractères ont été supprimés de a et quels caractères ont été ajoutés à b pour vous retrouver avec le résultat de b.

Modifier: Ajout d'un nouvel algorithme DUBBED Patiandeffplus.

Après avoir brioué sur le dernier exemple prévu ci-dessus qui a montré une limitation de la patience de la patience dans les lignes d'identification susceptibles de bouger, il s'est levé sur moi qu'il existait un moyen élégant d'utiliser l'algorithme de patience pour déterminer si des lignes avaient probablement été déplacée plutôt que de montrer que Suppression et ajouts.

En bref, j'ai ajouté l'algorithme patienceDiffPlus (au répéteur GitHub identifié ci-dessus) au bas du fichier PatianNefIFF.js. L'algorithme patienceDiffPlus prend les alines supprimées [] et ajouté des blins [] à partir de l'algorithme initial patienceDiff et les exécute à nouveau sur l'algorithme patienceDiff. IE, patienceDiffPlus cherche la recherche courante la plus longue des lignes susceptibles de déplacer, après quoi elle enregistre cela dans les résultats d'origine patienceDiff. L'algorithme patienceDiffPlus continue cela jusqu'à ce que plus aucune ligne déplacée soit trouvée.

Maintenant, en utilisant patienceDiffPlus, la comparaison suivante ...

let a = "james lebron";
let b = "lebron james";

let difference = patienceDiffPlus( a.split(""), b.split("") );

...Retour difference.lines contenant ...

difference.lines: Array(18)

0: {line: "j", aIndex: 0, bIndex: -1, moved: true}
1: {line: "a", aIndex: 1, bIndex: -1, moved: true}
2: {line: "m", aIndex: 2, bIndex: -1, moved: true}
3: {line: "e", aIndex: 3, bIndex: -1, moved: true}
4: {line: "s", aIndex: 4, bIndex: -1, moved: true}
5: {line: " ", aIndex: 5, bIndex: -1, moved: true}
6: {line: "l", aIndex: 6, bIndex: 0}
7: {line: "e", aIndex: 7, bIndex: 1}
8: {line: "b", aIndex: 8, bIndex: 2}
9: {line: "r", aIndex: 9, bIndex: 3}
10: {line: "o", aIndex: 10, bIndex: 4}
11: {line: "n", aIndex: 11, bIndex: 5}
12: {line: " ", aIndex: 5, bIndex: 6, moved: true}
13: {line: "j", aIndex: 0, bIndex: 7, moved: true}
14: {line: "a", aIndex: 1, bIndex: 8, moved: true}
15: {line: "m", aIndex: 2, bIndex: 9, moved: true}
16: {line: "e", aIndex: 3, bIndex: 10, moved: true}
17: {line: "s", aIndex: 4, bIndex: 11, moved: true}

Notez l'ajout de l'attribut moved, qui identifie si une ligne (ou un caractère dans ce cas) était probablement déplacée. Encore une fois, patienceDiffPlus correspond simplement aux alignes supprimées [] et a ajouté Blines [], il n'ya donc aucune garantie que les lignes ont été effectivement déplacées, mais il y a une forte probabilité qu'ils aient été effectivement déplacés.

1
Jon Trent
    function getDifference(a, b)
    {
        var i = 0;
        var j = 0;
        var result = "";

        while (j < b.length)
        {
         if (a[i] != b[j] || i == a.length)
             result += b[j];
         else
             i++;
         j++;
        }
        return result;
    }
    console.log(getDifference("lebronjames", "lebronnjames"));
2
Nero

cela retournera la première différence entre deux chaînes

Comme pour lebronjames et lebronnjames est n

const string1 = 'lebronjames';
const string2 = 'lebronnjabes';


const findFirstDiff = (srt1, str2) =>
  str2[[...string1].findIndex((el, index) => el !== string2[index])];


// equivalent of 

const findFirstDiff2 = function(srt1, str2) {
  return str2[[...string1].findIndex(function(el, index) {
    return el !== string2[index]
  })];
}



console.log(findFirstDiff2(string1, string2));
console.log(findFirstDiff(string1, string2));
0
G.aziz