Comment ne pas inclure des sauts de ligne lors de la comparaison de deux chaînes

Question

Je compare des mises à jour à deux chaînes. j'ai fait un:

string1 != string2 

et ils s'avèrent différents. Je les ai mis dans le « Ajouter Watch » et je vois la seule différence est qu'on a des sauts de ligne et l'autre ne marche pas » .:

string1 = "This is a test. \nThis is a test"; 
string2 = "This is a test. This is a test"; 

je veux essentiellement à faire comparer mais ne comprennent les sauts de ligne. Donc, si le saut de ligne est la seule différence, considérez-les comme égaux.

Answer 1

Une façon rapide et sale, lorsque les performances ne sont pas vraiment un problème:

string1.Replace("\n", "") != string2.Replace("\n", "") 

Answer 2

string1.replace('\n','') != string2.replace('\n','') 

Answer 3

Vous pouvez simplement supprimer les sauts de ligne avant de comparer les chaînes?

E.g. (Pseudocode) ...

string1.replace('\n','') != string2.replace('\n','') 

Answer 4

Je vous suggère regex de réduire tous les space, tab, \r, \n à un seul espace:

Regex.Replace(string1, @"\s+", " ") != Regex.Replace(string2, @"\s+", " ") 

Answer 5

en supposant que:

1. Le type de comparaison directe des valeurs de char-value-for-char de! = Et == est ce qui est voulu ici, sauf pour les nouvelles lignes.
2. Les chaînes sont, ou peuvent, être assez grandes ou comparées assez souvent pour remplacer simplement "\n" par une chaîne vide trop inefficace.

Puis:

public bool LinelessEquals(string x, string y) 
{ 
    //deal with quickly handlable cases quickly. 
    if(ReferenceEquals(x, y))//same instance 
     return true;   // - generally happens often in real code, 
          //and is a fast check, so always worth doing first. 
    //We already know they aren't both null as 
    //ReferenceEquals(null, null) returns true. 
    if(x == null || y == null) 
     return false; 
    IEnumerator<char> eX = x.Where(c => c != '\n').GetEnumerator(); 
    IEnumerator<char> eY = y.Where(c => c != '\n').GetEnumerator(); 
    while(eX.MoveNext()) 
    { 
     if(!eY.MoveNext()) //y is shorter 
      return false; 
     if(ex.Current != ey.Current) 
      return false; 
    } 
    return !ey.MoveNext(); //check if y was longer. 
} 

Il se définit comme l'égalité plutôt que l'inégalité, donc vous pouvez facilement l'adapter à être une mise en œuvre de IEqualityComparer<string>.Equals. Votre question pour une linebreak-moins string1 != string2 devient: !LinelessEquals(string1, string2)

Answer 6

Une approche plus propre serait d'utiliser:

string1.Replace(Environment.NewLine, String.Empty) != string2.Replace(Environment.NewLine, String.Empty); 

Answer 7

Ceci est une version généralisée et testée de réponse Jon Hannas.

/// <summary> 
/// Compares two character enumerables one character at a time, ignoring those specified. 
/// </summary> 
/// <param name="x"></param> 
/// <param name="y"></param> 
/// <param name="ignoreThese"> If not specified, the default is to ignore linefeed and newline: {'\r', '\n'} </param> 
/// <returns></returns> 
public static bool EqualsIgnoreSome(this IEnumerable<char> x, IEnumerable<char> y, params char[] ignoreThese) 
{ 
    // First deal with quickly handlable cases quickly: 
    // Same instance - generally happens often in real code, and is a fast check, so always worth doing first. 
    if (ReferenceEquals(x, y)) 
     return true;   // 
    // We already know they aren't both null as ReferenceEquals(null, null) returns true. 
    if (x == null || y == null) 
     return false; 
    // Default ignore is newlines: 
    if (ignoreThese == null || ignoreThese.Length == 0) 
     ignoreThese = new char[] { '\r', '\n' }; 
    // Filters by specifying enumerator. 
    IEnumerator<char> eX = x.Where(c => !ignoreThese.Contains(c)).GetEnumerator(); 
    IEnumerator<char> eY = y.Where(c => !ignoreThese.Contains(c)).GetEnumerator(); 
    // Compares. 
    while (eX.MoveNext()) 
    { 
     if (!eY.MoveNext()) //y is shorter 
      return false; 
     if (eX.Current != eY.Current) 
      return false; 
    } 
    return !eY.MoveNext(); //check if y was longer. 
} 

Answer 8

Voici un comparateur d'égalité pour les chaînes qui ne tient pas compte de certains caractères, tels que \r et \n.

Cette implémentation n'alloue aucune mémoire de segment pendant l'exécution, ce qui améliore ses performances. Il évite également les appels virtuels à travers IEnumerable et IEnumerator.

public sealed class SelectiveStringComparer : IEqualityComparer<string> 
{ 
    private readonly string _ignoreChars; 

    public SelectiveStringComparer(string ignoreChars = "\r\n") 
    { 
     _ignoreChars = ignoreChars; 
    } 

    public bool Equals(string x, string y) 
    { 
     if (ReferenceEquals(x, y)) 
      return true; 
     if (x == null || y == null) 
      return false; 
     var ix = 0; 
     var iy = 0; 
     while (true) 
     { 
      while (ix < x.Length && _ignoreChars.IndexOf(x[ix]) != -1) 
       ix++; 
      while (iy < y.Length && _ignoreChars.IndexOf(y[iy]) != -1) 
       iy++; 
      if (ix >= x.Length) 
       return iy >= y.Length; 
      if (iy >= y.Length) 
       return false; 
      if (x[ix] != y[iy]) 
       return false; 
      ix++; 
      iy++; 
     } 
    } 

    public int GetHashCode(string obj) 
    { 
     throw new NotSupportedException(); 
    } 
} 

Answer 9

Voici une version en VB.net basé sur Drew Noakes répondre

Dim g_sIgnore As String = vbSpace & vbNewLine & vbTab 'String.Format("\n\r\t ") 

Public Function StringCompareIgnoringWhitespace(s1 As String, s2 As String) As Boolean 
    Dim i1 As Integer = 0 
    Dim i2 As Integer = 0 
    Dim s1l As Integer = s1.Length 
    Dim s2l As Integer = s2.Length 

    Do 
     While i1 < s1l AndAlso g_sIgnore.IndexOf(s1(i1)) <> -1 
      i1 += 1 
     End While 
     While i2 < s2l AndAlso g_sIgnore.IndexOf(s2(i2)) <> -1 
      i2 += 1 
     End While 
     If i1 = s1l And i2 = s2l Then 
      Return True 
     Else 
      If i1 < s1l AndAlso i2 < s2l AndAlso s1(i1) = s2(i2) Then 
       i1 += 1 
       i2 += 1 
      Else 
       Return False 
      End If 
     End If 
    Loop 
    Return False 
End Function 

J'ai aussi testé avec

Try 
    Debug.Assert(Not StringCompareIgnoringWhitespace("a", "z")) 
    Debug.Assert(Not StringCompareIgnoringWhitespace("aa", "zz")) 
    Debug.Assert(StringCompareIgnoringWhitespace("", "")) 
    Debug.Assert(StringCompareIgnoringWhitespace(" ", "")) 
    Debug.Assert(StringCompareIgnoringWhitespace("", " ")) 
    Debug.Assert(StringCompareIgnoringWhitespace(" a", "a ")) 
    Debug.Assert(StringCompareIgnoringWhitespace(" aa", "aa ")) 
    Debug.Assert(StringCompareIgnoringWhitespace(" aa ", " aa ")) 
    Debug.Assert(StringCompareIgnoringWhitespace(" aa a", " aa a")) 
    Debug.Assert(Not StringCompareIgnoringWhitespace("a", "")) 
    Debug.Assert(Not StringCompareIgnoringWhitespace("", "a")) 
    Debug.Assert(Not StringCompareIgnoringWhitespace("ccc", "")) 
    Debug.Assert(Not StringCompareIgnoringWhitespace("", "ccc")) 
Catch ex As Exception 
    Console.WriteLine(ex.ToString) 
End Try