normalização de Cordas

Question

Estou a escrever algum código que precisa fazer normalização corda, eu quero transformar uma determinada cadeia em uma representação camel-case (bem, para o melhor palpite, pelo menos). Exemplo:

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

Eu acho que você deve ser capaz de ficar com a ideia de que esses exemplos. Quero retirar tudo especial caracteres (',",, @, etc!)., Capitalizar cada palavra (palavras são definidas por um espaço, _ ou -) e qualquer líder números caiu (arrastando / interno são ok, mas este requisito não é vital, dependendo da dificuldade realmente).

Eu estou tentando descobrir qual seria a melhor maneira de conseguir isso. Meu primeiro palpite seria com uma expressão regular, mas minhas habilidades regex são ruins na melhor das hipóteses, então eu realmente não sei por onde começar.

A minha outra idéia seria a de loop e analisar os dados, dizem dividi-la em palavras , analisar cada um, e reconstruiu a cadeia que forma.

Ou existe outra maneira em que eu poderia ir sobre ele?

Answer 1

Como sobre uma solução simples usando Strings.StrConv no namespace Microsoft.VisualBasic? (Não se esqueça de adicionar uma referência de projeto para 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

Este regex corresponde a todas as palavras. Então, nós Aggregate-los com um método que capitaliza os primeiros caracteres, e ToLowers o resto do string.

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

Este método ignora números, pelo caminho. Adicioná-los, você pode alterar o regex para @"[a-zA-Z]*|[0-9]*", suponho -. Mas eu não testei

Answer 3

Qualquer solução que envolve a correspondência de caracteres específicos podem não funcionar bem com alguns codificação de caracteres, particularmente se a representação Unicode está sendo usado, que tem dezenas de caracteres de espaço, milhares de 'símbolos', milhares de caracteres de pontuação, milhares de 'letras' , etc. seria melhor onde quer possível usar built-in funções Unicode-aware. Em termos do que é um 'caráter especial', assim você pode decidir com base em Unicode categorias . Por exemplo, incluiria 'pontuação', mas será que incluem 'Símbolos'?

ToLower (), IsLetter (), etc deve estar bem, e ter em conta todas as letras possíveis em Unicode. A comparação com traços e barras provavelmente deve ter em conta algumas das dezenas de espaço e de traço caracteres em Unicode.

Answer 4

Você poderia desgaste rubi chinelos ao trabalho :)

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

Answer 5

pensei que seria divertido tentar, aqui está o que eu vim acima com:

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