before - string methods c#

La mejor forma de convertir el caso Pascal en una oración

Question

¿Cuál es la mejor forma de convertir el caso Pascal (caso Camel superior) a una oración?

Por ejemplo, comenzando por

"AwaitingFeedback"

y convertir eso a

"Awaiting feedback"

C # preferible, pero podría convertirlo de Java o similar.

Answer 1

Esto es como @SSTA, pero es más eficiente que llamar a TrimStart.

Regex.Replace("ThisIsMyCapsDelimitedString", "(//B[A-Z])", " $1")

Answer 2

Aquí hay una forma básica de hacerlo que se me ocurrió usar Regex

public static string CamelCaseToSentence(this string value)
{
    var sb = new StringBuilder();
    var firstWord = true;

    foreach (var match in Regex.Matches(value, "([A-Z][a-z]+)|[0-9]+"))
    {
        if (firstWord)
        {
            sb.Append(match.ToString());
            firstWord = false;
        }
        else
        {
            sb.Append(" ");
            sb.Append(match.ToString().ToLower());
        }
    }

    return sb.ToString();
}

También dividirá números que no especifiqué pero que serían útiles.

Answer 3

Aqui tienes...

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

namespace CamelCaseToString
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine(CamelCaseToString("ThisIsYourMasterCallingYou"));   
        }

        private static string CamelCaseToString(string str)
        {
            if (str == null || str.Length == 0)
                return null;

            StringBuilder retVal = new StringBuilder(32);

            retVal.Append(char.ToUpper(str[0]));
            for (int i = 1; i < str.Length; i++ )
            {
                if (char.IsLower(str[i]))
                {
                    retVal.Append(str[i]);
                }
                else
                {
                    retVal.Append(" ");
                    retVal.Append(char.ToLower(str[i]));
                }
            }

            return retVal.ToString();
        }
    }
}

Answer 4

Es fácil de hacer en JavaScript (o PHP, etc.) donde puede definir una función en la llamada de reemplazo:

var camel = "AwaitingFeedbackDearMaster";
var sentence = camel.replace(/([A-Z].)/g, function (c) { return '' '' + c.toLowerCase(); });
alert(sentence);

Aunque no he resuelto el problema del límite inicial ... :-)

Ahora, para la solución Java:

String ToSentence(String camel)
{
  if (camel == null) return ""; // Or null...
  String[] words = camel.split("(?=[A-Z])");
  if (words == null) return "";
  if (words.length == 1) return words[0];
  StringBuilder sentence = new StringBuilder(camel.length());
  if (words[0].length() > 0) // Just in case of camelCase instead of CamelCase
  {
    sentence.append(words[0] + " " + words[1].toLowerCase());
  }
  else
  {
    sentence.append(words[1]);
  }
  for (int i = 2; i < words.length; i++)
  {
    sentence.append(" " + words[i].toLowerCase());
  }
  return sentence.toString();
}

System.out.println(ToSentence("AwaitingAFeedbackDearMaster"));
System.out.println(ToSentence(null));
System.out.println(ToSentence(""));
System.out.println(ToSentence("A"));
System.out.println(ToSentence("Aaagh!"));
System.out.println(ToSentence(""));
System.out.println(ToSentence("disableGPS"));
System.out.println(ToSentence("Ahh89Boo"));
System.out.println(ToSentence("ABC"));

Tenga en cuenta el truco para dividir la oración sin perder ningún personaje ...

Answer 5

Pseudo-código:

NewString = "";
Loop through every char of the string (skip the first one)
   If char is upper-case (''A''-''Z'')
     NewString = NewString + '' '' + lowercase(char)
   Else
     NewString = NewString + char

Quizás se puedan hacer mejores cosas utilizando rutinas de regex o de reemplazo de cuerdas (reemplace ''X'' por ''x'')

Answer 6

Usaría una expresión regular, insertando un espacio antes de cada carácter en mayúscula y luego bajando toda la cuerda.

    string spacedString = System.Text.RegularExpressions.Regex.Replace(yourString, "/B([A-Z])", " /k");
    spacedString = spacedString.ToLower();

Answer 7

string camel = "MyCamelCaseString";
string s = Regex.Replace(camel, "([A-Z])", " $1").ToLower().Trim();
Console.WriteLine(s.Substring(0,1).ToUpper() + s.Substring(1));

Editar: no notó los requisitos de su carcasa, modificada en consecuencia. Podría usar un matchevaluator para hacer la carcasa, pero creo que una subcadena es más fácil. También podría envolverlo en una segunda regex reemplazar donde cambie el primer personaje

"^/w"

a la parte superior

/U (i think)

Answer 8

Esto funciona para mí:

Regex.Replace(strIn, "([A-Z]{1,2}|[0-9]+)", " $1").TrimStart()

Answer 9

Una solución xquery que funciona tanto para el caso UpperCamel como para el caso LowerCamel:

Para mostrar caso de oración (solo el primer carácter de la primera palabra está en mayúscula):

declare function content:sentenceCase($string)
{
let $firstCharacter := substring($string, 1, 1)
let $remainingCharacters := substring-after($string, $firstCharacter)
return
concat(upper-case($firstCharacter),lower-case(replace($remainingCharacters, ''([A-Z])'', '' $1'')))
};

Para mostrar el título del caso (primer carácter de cada palabra en mayúscula):

declare function content:titleCase($string)
{
let $firstCharacter := substring($string, 1, 1)
let $remainingCharacters := substring-after($string, $firstCharacter)
return
concat(upper-case($firstCharacter),replace($remainingCharacters, ''([A-Z])'', '' $1''))
};

Answer 10

Encontré esto en la fuente MvcContrib, no parece ser mencionado aquí todavía.

return Regex.Replace(input, "([A-Z])", " $1", RegexOptions.Compiled).Trim();

Answer 11

Me encontré haciendo algo similar, y aprecio tener un punto de partida con esta discusión. Esta es mi solución, colocada como un método de extensión para la clase de cadena en el contexto de una aplicación de consola.

using System;
using System.Text;

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            string piratese = "avastTharMatey";
            string ivyese = "CheerioPipPip";

            Console.WriteLine("{0}/n{1}/n", piratese.CamelCaseToString(), ivyese.CamelCaseToString());
            Console.WriteLine("For Pete/'s sake, man, hit ENTER!");
            string strExit = Console.ReadLine();
        }

    }

    public static class StringExtension
    {
        public static string CamelCaseToString(this string str)
        {
            StringBuilder retVal = new StringBuilder(32);

            if (!string.IsNullOrEmpty(str))
            {
                string strTrimmed = str.Trim();

                if (!string.IsNullOrEmpty(strTrimmed))
                {
                    retVal.Append(char.ToUpper(strTrimmed[0]));

                    if (strTrimmed.Length > 1)
                    {
                        for (int i = 1; i < strTrimmed.Length; i++)
                        {
                            if (char.IsUpper(strTrimmed[i])) retVal.Append(" ");

                            retVal.Append(char.ToLower(strTrimmed[i]));
                        }
                    }
                }
            }
            return retVal.ToString();
        }
    }
}

Answer 12

public static string ToSentenceCase(this string str)
{
    return Regex.Replace(str, "[a-z][A-Z]", m => m.Value[0] + " " + char.ToLower(m.Value[1]));
}

En las versiones de Visual Studio después de 2015, puedes hacer

public static string ToSentenceCase(this string str)
{
    return Regex.Replace(str, "[a-z][A-Z]", m => $"{m.Value[0]} {char.ToLower(m.Value[1])}");
}

Basado en: Convertir el caso de Pascal a oraciones con expresión regular

Answer 13

Prefiero usar Humanizer para esto. Humanizer es una biblioteca de clases portátil que satisface todas sus necesidades de .NET para manipular y mostrar cadenas, enumeraciones, fechas, horas, intervalos de tiempo, números y cantidades.

Respuesta corta

"AwaitingFeedback".Humanize() => Awaiting feedback

Respuesta larga y descriptiva

Humanizer puede hacer mucho más trabajo, otros ejemplos son:

"PascalCaseInputStringIsTurnedIntoSentence".Humanize() => "Pascal case input string is turned into sentence"
"Underscored_input_string_is_turned_into_sentence".Humanize() => "Underscored input string is turned into sentence"
"Can_return_title_Case".Humanize(LetterCasing.Title) => "Can Return Title Case"
"CanReturnLowerCase".Humanize(LetterCasing.LowerCase) => "can return lower case"

El código completo es:

using Humanizer;
using static System.Console;

namespace HumanizerConsoleApp
{
    class Program
    {
        static void Main(string[] args)
        {
            WriteLine("AwaitingFeedback".Humanize());
            WriteLine("PascalCaseInputStringIsTurnedIntoSentence".Humanize());
            WriteLine("Underscored_input_string_is_turned_into_sentence".Humanize());
            WriteLine("Can_return_title_Case".Humanize(LetterCasing.Title));
            WriteLine("CanReturnLowerCase".Humanize(LetterCasing.LowerCase));
        }
    }
}

Salida

En espera de retroalimentación

La cadena de entrada del caso Pascal se convierte en oración

La cadena de entrada de subrayado se convierte en oración. Puede devolver el título del caso

puede devolver minúsculas

Si prefiere escribir su propio código C #, puede lograrlo escribiendo algunas cosas del código C # como ya lo han respondido otros.

Answer 14

En su mayoría ya respondió aquí

Pequeño chage a la respuesta aceptada, para convertir la segunda y subsiguientes letras mayúsculas a minúsculas, así que cambie

if (char.IsUpper(text[i]))                
    newText.Append('' '');            
newText.Append(text[i]);

a

if (char.IsUpper(text[i]))                
{
    newText.Append('' '');            
    newText.Append(char.ToLower(text[i]));
}
else
   newText.Append(text[i]);