Comment comparer des caractères Unicode qui se "ressemblent" ?

Question

Je tombe dans un problème surprenant.

J'ai chargé un fichier texte dans mon application et j'ai une logique qui compare la valeur ayant µ.

Et j'ai réalisé que même si les textes sont identiques, la valeur de comparaison est fausse.

 Console.WriteLine("".Equals("µ")); // returns false
 Console.WriteLine("µ".Equals("µ")); // return true

Dans la ligne suivante, le caractère µ est copié-collé.

Cependant, ces personnages ne sont peut-être pas les seuls à être comme ça.

Existe-t-il un moyen en C# de comparer des caractères qui semblent identiques mais qui sont en fait différents ?

Answer 1

Parce qu'il s'agit de symboles vraiment différents, même s'ils se ressemblent, le premier est la lettre réelle et a des caractères. code = 956 (0x3BC) et le second est le micro signe et a 181 (0xB5) .

Références :

• Caractère Unicode "MAJUSCULES GRECQUES" (U+03BC)
• Caractère Unicode "MICRO SIGN" (U+00B5)

Ainsi, si vous souhaitez les comparer et qu'ils doivent être égaux, vous devez le faire manuellement, ou remplacer un caractère par un autre avant la comparaison. Ou bien utiliser le code suivant :

public void Main()
{
    var s1 = "";
    var s2 = "µ";

    Console.WriteLine(s1.Equals(s2));  // false
    Console.WriteLine(RemoveDiacritics(s1).Equals(RemoveDiacritics(s2))); // true 
}

static string RemoveDiacritics(string text) 
{
    var normalizedString = text.Normalize(NormalizationForm.FormKC);
    var stringBuilder = new StringBuilder();

    foreach (var c in normalizedString)
    {
        var unicodeCategory = CharUnicodeInfo.GetUnicodeCategory(c);
        if (unicodeCategory != UnicodeCategory.NonSpacingMark)
        {
            stringBuilder.Append(c);
        }
    }

    return stringBuilder.ToString().Normalize(NormalizationForm.FormC);
}

Et le Démo

Answer 2

Dans de nombreux cas, vous pouvez normaliser les deux caractères Unicode à une certaine forme de normalisation avant de les comparer, et ils devraient pouvoir correspondre. Bien entendu, la forme de normalisation que vous devez utiliser dépend des caractères eux-mêmes ; ce n'est pas parce qu'ils regardez de la même façon ne signifie pas nécessairement qu'ils représentent le même personnage. Vous devez également vous demander si cela est approprié pour votre cas d'utilisation - voir le commentaire de Jukka K. Korpela.

Pour cette situation particulière, si vous vous référez aux liens dans La réponse de Tony vous verrez que le tableau pour U+00B5 dit :

Décomposition <compat> PETIT LETTRE GREC MU (U+03BC)

Cela signifie que U+00B5, le deuxième caractère de votre comparaison originale, peut être décomposé en U+03BC, le premier caractère.

Vous normaliserez donc les caractères en utilisant la décomposition de la compatibilité totale, avec les formes de normalisation KC ou KD. Voici un exemple rapide que j'ai écrit pour démontrer :

using System;
using System.Text;

class Program
{
    static void Main(string[] args)
    {
        char first = '';
        char second = 'µ';

        // Technically you only need to normalize U+00B5 to obtain U+03BC, but
        // if you're unsure which character is which, you can safely normalize both
        string firstNormalized = first.ToString().Normalize(NormalizationForm.FormKD);
        string secondNormalized = second.ToString().Normalize(NormalizationForm.FormKD);

        Console.WriteLine(first.Equals(second));                     // False
        Console.WriteLine(firstNormalized.Equals(secondNormalized)); // True
    }
}

Pour plus de détails sur la normalisation d'Unicode et les différentes formes de normalisation, voir System.Text.NormalizationForm y la spécification Unicode .

Answer 3

Ils ont tous deux des codes de caractères différents : Consultez cette page pour plus de détails

Console.WriteLine((int)'');  //956
Console.WriteLine((int)'µ');  //181

Où, le premier est :

Display     Friendly Code   Decimal Code    Hex Code    Description
====================================================================
           μ            μ          μ     Lowercase Mu
µ           µ         µ          µ      micro sign Mu

Answer 4

Pour l'exemple spécifique de (mu) et µ (micro signe), ce dernier a un décomposition de la compatibilité au premier, afin que vous puissiez normaliser la chaîne de caractères à FormKC o FormKD pour convertir les signes micro en mus.

Cependant, il existe de nombreux ensembles de caractères qui se ressemblent mais qui ne sont équivalents sous aucune forme de normalisation Unicode. Par exemple, A (Latin), (grec), et (Cyrillique). Le site web d'Unicode propose une confusables.txt avec une liste de ces derniers, destinée à aider les développeurs à se prémunir contre les attaques par homographe . Si nécessaire, vous pourriez analyser ce fichier et construire un tableau pour la "normalisation visuelle" des chaînes de caractères.

Answer 5

Recherche les deux personnages dans un Base de données Unicode et voir le différence .

L'un est le Petite lettre grecque µ et l'autre est le Micro signe µ .

Name            : MICRO SIGN
Block           : Latin-1 Supplement
Category        : Letter, Lowercase [Ll]
Combine         : 0
BIDI            : Left-to-Right [L]
Decomposition   : <compat> GREEK SMALL LETTER MU (U+03BC)
Mirror          : N
Index entries   : MICRO SIGN
Upper case      : U+039C
Title case      : U+039C
Version         : Unicode 1.1.0 (June, 1993)

---

Name            : GREEK SMALL LETTER MU
Block           : Greek and Coptic
Category        : Letter, Lowercase [Ll]
Combine         : 0
BIDI            : Left-to-Right [L]
Mirror          : N
Upper case      : U+039C
Title case      : U+039C
See Also        : micro sign U+00B5
Version         : Unicode 1.1.0 (June, 1993)