Algorithm 一种算法；spacify“；骆驼套绳

非常基本，我只是好奇其他人如何实现这个算法，并想看看是否有任何聪明的技巧来优化算法…我只是为了我正在进行的一个项目实现了这个

在CamelCase中给定一个字符串，您将如何“指定”它

e、 g.给定FooBarGork我要foobar Gork回来

这是我的C#算法：

静态void Main（字符串[]参数）
{
Console.WriteLine（取消命名（“FooBarGork”）；
}
公共静态字符串取消命名（字符串str）
{
StringBuilder sb=新的StringBuilder（）；
对于（int i=0；i0）sb.追加（“”）；
某人追加（str[i]）；
}
使某人返回字符串（）；
}

---

因为你必须访问每个角色一次，我相信最好的例子是O（n）。你将如何实现这一点？

我已经能感觉到火焰，但我喜欢这种东西的正则表达式

publicstaticstringuncamelcase（stringstr）
{
返回正则表达式替换（str，“（[a-z]）（[a-z]）”，“$1$2”）；
}

（这可能不会比您的实现快，但对我来说更清楚。）

显然，这会更快（在运行时）

private static Regex _unCamelRegex=newregex（“（[a-z]）（[a-z]）”，RegexOptions.Compiled）；
公共静态字符串取消命名（字符串str）
{
返回(unCamelRegex.Replace)(str,"1美元2美元";；
}

这将处理Pete Kirkham提出的问题（就HTTPRequest这样的驼峰式字符串而言）：

private static Regex _unCamelRegex1=newregex（（[a-z]）（[a-z]）”，RegexOptions.Compiled）；
私有静态Regex_unCamelRegex2=newregex（（[A-Z]+）（[A-Z]）（[A-Z]）”，RegexOptions.Compiled）；
公共静态字符串取消命名（字符串str）
{
返回“unCamelRegex2.Replace”（“unCamelRegex1.Replace”（str，“$1$2”），“$1$2$3”）；
}

这个函数接受

HTTPRequestFOOBarGork

并返回

HTTP请求foobar Gork

---

因此，我使用OPs实现（使用“从1开始并跳过>0检查”更改）和我的第二个回复（使用静态编译的Regex对象的回复）对正则表达式方法测试了迭代方法。请注意，结果不包括正则表达式的编译时间。对于200万次呼叫（使用相同的FooBarGork输入）：

迭代：00:00:00.80
正则表达式：00:00:06.71

因此，很明显，迭代方法的效率要高得多。我已经包括了一个固定版本的OPs实现（由Jason Punyon编写，任何功劳都应该归他），它还考虑了一个null或空参数：

public静态字符串未命名字符串（string str）
{
if（String.IsNullOrEmpty（str））
返回str；
/*注意.ToString（）是必需的，否则char是隐式的
*已转换为整数，但使用了错误的重载构造函数*/
StringBuilder sb=新的StringBuilder（str[0].ToString（））；
对于（int i=1；i

看看你的代码，它似乎不知怎么被弄坏了（当你把它复制过来时）。除了修复for循环之外，我假设您只是缺少一个if语句，在

sb.Append（“”

位附近有一个char.IsUpper调用。否则当然没问题。对于泛型字符串，您不会得到比O（n）更好的结果

---

现在显然有一个单行RegEx-replace调用来完成这个任务，但实际上没有理由为这么简单的任务做这样的事情。出于可读性的考虑，尽可能避免使用正则表达式。

我可能会采用类似的方法，只是可能不使用stringbuilder：

str=str.replace(str[i], " "+str[i]);

我很确定你的方法最终会更有效率。

为什么不从1开始呢

您将取消&&i>0检查…

我将使用

public static string UnCamelCase(string str) {
    Regex reg = new Regex("([A-Z])");

    return reg.Replace(str, " $1").Trim();
}

---

一些正则表达式风格知道“\u”（大写）和“\u”（小写）字符类。它们可以取代这一点：

(?<=\U)(?=\u)

---

通常我的去融合方法要复杂一些，因为“HTTPRequest”应该变成“HTTP请求”而不是“HTTP请求”，不同的应用程序处理数字的方式也不同。

类似这样的事情（Python）

不是很刺激，但是：

    public static string UnCamelCase(string str)
    {
        StringBuilder sb = new StringBuilder();

        foreach (char c in str.ToCharArray())
        {
            if (System.Convert.ToInt32(c) <= 90) sb.Append(" ");
            sb.Append(c);
        }
        return sb.ToString().Trim();
    }


        //Console.WriteLine(System.Convert.ToInt32('a')); // 97
        //Console.WriteLine(System.Convert.ToInt32('z')); // 122
        //Console.WriteLine(System.Convert.ToInt32('A')); // 65
        //Console.WriteLine(System.Convert.ToInt32('Z')); // 90

publicstaticstringuncamelcase（stringstr）
{
StringBuilder sb=新的StringBuilder（）；
foreach（str.ToCharArray（）中的字符c）
{
if（System.Convert.ToInt32（c）以下是mootools javascript库的工作方式（尽管它们是“连字号”，但很容易将连字号替换为空格）

/*
Property: hyphenate
    Converts a camelCased string to a hyphen-ated string.

Example:
    >"ILikeCookies".hyphenate(); //"I-like-cookies"
*/

hyphenate: function(){
    return this.replace(/\w[A-Z]/g, function(match){
        return (match.charAt(0) + '-' + match.charAt(1).toLowerCase());
    });
},

下面是一个PHP示例

function spacify($str) {
  return preg_replace('/([a-z])([A-Z])/', "\1 \2", $str);
}

获取大写字母的索引

简短语法

Regex.Match("hello,World!", @"(\p{Lu})").Index

结果6

长例子

使用System.Text.RegularExpressions

namespace namespace.Helpers
{
    public static class Helper
    {
        public static int IndexOfUppercase(this string str, int startIndex = 0)
        {
            return str.IndexOfRegex(@"(\p{Lu})", startIndex);
        }

        public static int IndexOfRegex(this string str, string regex, int startIndex )
        {
            return str.Substring(startIndex).IndexOfRegex(regex);
        }

        public static int IndexOfRegex(this string str, string regex)
        {
            var match = Regex.Match(str, regex);
            if (match.Success)
            {
                return match.Index;
            }
            return -1;
        }
    }
}

使用多重匹配标志，确保Regex.Replace的默认值是替换所有发生的事件，因此不需要任何标志。我不应该使用此标志，因为这是一个有效的解决方案，但对于这样的任务，确实不需要使用Regex。值得一提的是，它值得发布，但我不建议在任何适当的代码中使用它。（我很不相信你怎么认为它更可读！）@ NoDulin——这可能不是每个人都能做到的，但唯一的替代方法是迭代方法，我认为这更简洁。通过查看正则表达式，我可以清楚地看到，我正在寻找一个小写字母，后面是大写字母，然后用它们自己和一个空格代替它们。我来这里是说ReGEX如何刺激我的心。很高兴再次发现诺多林令人沮丧。别担心，诺多林，开心点！好吧，你修复了代码，这正是我所期望的。你的实现非常好。完全支持Unicode可以通过以下方式实现：（？非常类似于+1-好的点。我已经
/*
Property: hyphenate
    Converts a camelCased string to a hyphen-ated string.

Example:
    >"ILikeCookies".hyphenate(); //"I-like-cookies"
*/

hyphenate: function(){
    return this.replace(/\w[A-Z]/g, function(match){
        return (match.charAt(0) + '-' + match.charAt(1).toLowerCase());
    });
},

function spacify($str) {
  return preg_replace('/([a-z])([A-Z])/', "\1 \2", $str);
}

echo "FooBarGork" | sed -r 's/([A-Z])/ \1/g;s/^ //'

Regex.Match("hello,World!", @"(\p{Lu})").Index

namespace namespace.Helpers
{
    public static class Helper
    {
        public static int IndexOfUppercase(this string str, int startIndex = 0)
        {
            return str.IndexOfRegex(@"(\p{Lu})", startIndex);
        }

        public static int IndexOfRegex(this string str, string regex, int startIndex )
        {
            return str.Substring(startIndex).IndexOfRegex(regex);
        }

        public static int IndexOfRegex(this string str, string regex)
        {
            var match = Regex.Match(str, regex);
            if (match.Success)
            {
                return match.Index;
            }
            return -1;
        }
    }
}