将Pascal Case转换为句子的最佳方式

时间：2008-11-27 09:30:35

标签： c# string

将Pascal Case（上层Camel Case）转换为句子的最佳方法是什么。

例如从

开始 
"AwaitingFeedback"

并将其转换为

"Awaiting feedback"

C＃更受欢迎，但我可以从Java或类似的转换它。

16 个答案:

答案 0 :(得分：64)

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

在2015年之后的visual studio版本中，你可以做到

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

基于：Converting Pascal case to sentences using regular expression

答案 1 :(得分：15)

你去...... 

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

答案 2 :(得分：15)

这对我有用： 

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

答案 3 :(得分：9)

我更愿意使用Humanizer。 Humanizer是一个可移植类库，可满足您操作和显示字符串，枚举，日期，时间，时间跨度，数字和数量的所有.NET需求。

简答 

"AwaitingFeedback".Humanize() => Awaiting feedback

冗长且具有描述性的答案

Humanizer可以做更多的工作，其他例子是：

"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"

完整的代码是：

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

<强>输出

  

等待反馈

     

Pascal案例输入字符串变为句子

     

将突出显示的输入字符串转换为句子可以返回标题大小写

     

可以返回小写

如果您更喜欢编写自己的C＃代码，可以通过编写其他人已经回答过的C＃代码来实现这一目标。

答案 4 :(得分：8)

这就像@SSTA，但比调用TrimStart更有效。 

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

答案 5 :(得分：8)

在MvcContrib源代码中找到此内容，此处似乎尚未提及。

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

答案 6 :(得分：4)

这是我使用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();
}

它也会拆分我没有指定但会有用的数字。

答案 7 :(得分：2)

我使用正则表达式，在每个大写字符前插入一个空格，然后降低所有字符串。

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

答案 8 :(得分：2)

在JavaScript（或PHP等）中很容易做到，你可以在replace调用中定义一个函数：

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

虽然我还没有解决最初的上限问题......： - ）

现在，对于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("stackoverflow"));
System.out.println(ToSentence("disableGPS"));
System.out.println(ToSentence("Ahh89Boo"));
System.out.println(ToSentence("ABC"));

注意分割句子而不丢失任何字符的技巧......

答案 9 :(得分：2)

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

编辑：未注意到您的套管要求，因此进行了修改。您可以使用matchevaluator来做套管，但我认为子串更容易。您也可以将它包装在第二个正则表达式替换中，您可以在其中更改第一个字符

"^\w"

到上面

\U (i think)

答案 10 :(得分：1)

的伪代码：

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

使用正则表达式或字符串替换例程（将'X'替换为'x'）也可以采用更好的方法

答案 11 :(得分：1)

适用于UpperCamel和lowerCamel案例的xquery解决方案：

输出句子大小写（只有第一个单词的第一个字符大写）：

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

输出标题大小写（每个单词的首字母大写）：

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

答案 12 :(得分：1)

发现自己做了类似的事情，我很欣赏这个讨论的出发点。这是我的解决方案，作为控制台应用程序上下文中的字符串类的扩展方法。

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

答案 13 :(得分：1)

仅因为每个人都在使用Regex（this guy除外），所以在我的测试中，这是StringBuilder的一种实现方式，它快了 5倍。还包括检查数字。

"SomeBunchOfCamelCase2".FromCamelCaseToSentence == "Some Bunch Of Camel Case 2"

public static string FromCamelCaseToSentence(this string input) {
    if(string.IsNullOrEmpty(input)) return input;

    var sb = new StringBuilder();
    // start with the first character -- consistent camelcase and pascal case
    sb.Append(char.ToUpper(input[0]));

    // march through the rest of it
    for(var i = 1; i < input.Length; i++) {
        // any time we hit an uppercase OR number, it's a new word
        if(char.IsUpper(input[i]) || char.IsDigit(input[i])) sb.Append(' ');
        // add regularly
        sb.Append(input[i]);
    }

    return sb.ToString();
}

答案 14 :(得分：0)

主要是already answered here

对接受的答案进行小的更改，将第二个及后续的大写字母转换为小写字母，因此请更改

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

到

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

答案 15 :(得分：0)

前面的大多数答案都将缩写词和数字分开，并在每个字符前添加一个空格。我希望缩写词和数字保持在一起，所以我有一个简单的状态机，每次输入从一种状态转换到另一种状态时，该状态机都会发出一个空格。

    /// <summary>
    /// Add a space before any capitalized letter (but not for a run of capitals or numbers)
    /// </summary>
    internal static string FromCamelCaseToSentence(string input)
    {
        if (string.IsNullOrEmpty(input)) return String.Empty;

        var sb = new StringBuilder();
        bool upper = true;

        for (var i = 0; i < input.Length; i++)
        {
            bool isUpperOrDigit = char.IsUpper(input[i]) || char.IsDigit(input[i]);
            // any time we transition to upper or digits, it's a new word
            if (!upper && isUpperOrDigit)
            {
                sb.Append(' ');
            }
            sb.Append(input[i]);
            upper = isUpperOrDigit;
        }

        return sb.ToString();
    }

这是一些测试：

    [TestCase(null, ExpectedResult = "")]
    [TestCase("", ExpectedResult = "")]
    [TestCase("ABC", ExpectedResult = "ABC")]
    [TestCase("abc", ExpectedResult = "abc")]
    [TestCase("camelCase", ExpectedResult = "camel Case")]
    [TestCase("PascalCase", ExpectedResult = "Pascal Case")]
    [TestCase("Pascal123", ExpectedResult = "Pascal 123")]
    [TestCase("CustomerID", ExpectedResult = "Customer ID")]
    [TestCase("CustomABC123", ExpectedResult = "Custom ABC123")]
    public string CanSplitCamelCase(string input)
    {
        return FromCamelCaseToSentence(input);
    }
相关问题
最新问题