Normalisation des chaînes

Question

J'écris un code qui doit normaliser les chaînes. Je veux transformer une chaîne donnée en une représentation camel-case (du moins, au mieux, au moins). Exemple:

"the quick brown fox" => "TheQuickBrownFox"
"the_quick_brown_fox" => "TheQuickBrownFox"
"123The_quIck bROWN FOX" => "TheQuickBrownFox"
"the_quick brown fox 123" => "TheQuickBrownFox123"
"thequickbrownfox" => "Thequickbrownfox"

Je pense que vous devriez pouvoir vous faire une idée à partir de ces exemples. Je souhaite supprimer tous les caractères spéciaux (', ",!, @,., Etc.), mettre en majuscule chaque mot (les mots sont définis par un espace, _ ou -) et tout les chiffres principaux ont été supprimés (les caractères finaux / internes sont corrects, mais cette exigence n'est pas essentielle, cela dépend vraiment de la difficulté).

J'essaie de déterminer quel serait le meilleur moyen d'y parvenir. Ma première hypothèse serait avec une expression régulière, mais mes compétences de regex sont au mieux mauvaises, donc je ne saurais pas vraiment par où commencer.

Mon autre idée serait de boucler et d'analyser les données, de les décomposer en mots , de les analyser, puis de reconstruire la chaîne de cette façon.

Ou y a-t-il un autre moyen de s'y prendre?

Answer 1

Que diriez-vous d’une solution simple utilisant Strings.StrConv dans l'espace de noms Microsoft.VisualBasic? (N'oubliez pas d'ajouter une référence de projet à Microsoft.VisualBasic):

using System;
using VB = Microsoft.VisualBasic;


namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(VB.Strings.StrConv("QUICK BROWN", VB.VbStrConv.ProperCase, 0));
            Console.ReadLine();
        }
    }
}

Answer 2

Cette regex correspond à tous les mots. Ensuite, nous les Agrégons avec une méthode qui capitalise les premiers caractères, et ToLower correspond au reste de la chaîne.

Regex regex = new Regex(@"[a-zA-Z]*", RegexOptions.Compiled);

private string CamelCase(string str)
{
    return regex.Matches(str).OfType<Match>().Aggregate("", (s, match) => s + CamelWord(match.Value));
}

private string CamelWord(string word)
{
    if (string.IsNullOrEmpty(word))
        return "";

    return char.ToUpper(word[0]) + word.Substring(1).ToLower();
}

Au fait, cette méthode ignore les nombres. Pour les ajouter, vous pouvez modifier l'expression régulière en @ "[a-zA-Z] * | [0-9] *" , je suppose - mais je ne l'ai pas testée.

Answer 3

Toute solution impliquant la correspondance de caractères particuliers peut ne pas fonctionner correctement avec certains codages de caractères, en particulier si une représentation Unicode est utilisée, qui comporte des dizaines de caractères espace, des milliers de "symboles", des milliers de caractères de ponctuation, des milliers de "lettres". , etc. Il serait préférable, dans la mesure du possible, d’utiliser des fonctions intégrées prenant en charge Unicode. En ce qui concerne ce qui est un "caractère spécial", vous pourriez décider en fonction de Unicode catégories . Par exemple, cela inclurait la "ponctuation" mais les "symboles"?

ToLower (), IsLetter (), etc. devraient convenir et prendre en compte toutes les lettres possibles en Unicode. La correspondance avec les tirets et les barres obliques devrait probablement prendre en compte des dizaines d'espaces et de tirets dans Unicode.

Answer 4

Vous pouvez porter des pantoufles de rubis pour travailler :)

def camelize str
  str.gsub(/^[^a-zA-z]*/, '').split(/[^a-zA-Z0-9]/).map(&:capitalize).join
end

Answer 5

pensais que ce serait amusant d'essayer, voici ce que j'ai trouvé:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace ConsoleApplication2
{
    class Program
    {
        static void Main(string[] args)
        {
            StringBuilder sb = new StringBuilder();
            string sentence = "123The_quIck bROWN FOX1234";

            sentence = sentence.ToLower();

            char[] s = sentence.ToCharArray();

            bool atStart = true;
            char pChar = ' ';

            char[] spaces = { ' ', '_', '-' };
            char a;
            foreach (char c in s)
            {
                if (atStart && char.IsDigit(c)) continue;

                if (char.IsLetter(c))
                {
                    a = c;
                    if (spaces.Contains(pChar))
                        a = char.ToUpper(a);
                    sb.Append(a);
                    atStart = false;
                }
                else if(char.IsDigit(c))
                {
                    sb.Append(c);
                }
                pChar = c;
            }

            Console.WriteLine(sb.ToString());
            Console.ReadLine();
        }
    }
}