我正在尝试将名称从蛇案转换为骆驼案。有内置的方法吗？

例如："app_user"至"AppUser"

（我有一个"app_user"想要将其转换为model 的字符串AppUser）。

如果您使用的是Rails，则需要使用String＃camelize。

  "active_record".camelize                # => "ActiveRecord"
  "active_record".camelize(:lower)        # => "activeRecord"

如果要获取实际的类，则应在其上使用String＃constantize。

"app_user".camelize.constantize

这个怎么样？

"hello_world".split('_').collect(&:capitalize).join #=> "HelloWorld"

在此处的注释中找到： 分类Ruby字符串

参见Wayne Conrad的评论

如果您使用Rails，请使用classify。它可以很好地处理边缘情况。

"app_user".classify # => AppUser
"user_links".classify   # => UserLink

注意：

该答案特定于问题中给出的描述（并非特定于问题标题）。如果试图将字符串转换为驼峰式大小写，则应使用Sergio的答案。发问者说他想要转换app_user为AppUser（not App_user），因此此答案。

资料来源：http : //rubydoc.info/gems/extlib/0.9.15/String#camel_case-instance_method

出于学习目的：

class String
  def camel_case
    return self if self !~ /_/ && self =~ /[A-Z]+.*/
    split('_').map{|e| e.capitalize}.join
  end
end

"foo_bar".camel_case          #=> "FooBar"

对于lowerCase变体：

class String
  def camel_case_lower
    self.split('_').inject([]){ |buffer,e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
  end
end

"foo_bar".camel_case_lower          #=> "fooBar"

纯Ruby解决方案的基准

我考虑了使用纯红宝石代码实现的所有可能性，它们是：

• 大写和gsub

  'app_user'.capitalize.gsub(/_(\w)/){$1.upcase}

• 使用&简写方式进行拆分和映射（感谢user3869936的回答）

  'app_user'.split('_').map(&:capitalize).join

• 拆分并映射（感谢布莱克先生的回答）

  'app_user'.split('_').map{|e| e.capitalize}.join

这是所有这些的基准，我们可以看到gsub对此非常不利。我用了126080个单词。

                              user     system      total        real
capitalize and gsub  :      0.360000   0.000000   0.360000 (  0.357472)
split and map, with &:      0.190000   0.000000   0.190000 (  0.189493)
split and map        :      0.170000   0.000000   0.170000 (  0.171859)

我到这里来寻找您的问题的反面，从骆驼案到蛇案。为此，请使用下划线（不脱糖）：

AppUser.name.underscore # => "app_user"

或者，如果您已经有驼峰式的字符串：

"AppUser".underscore # => "app_user"

或者，如果要获取表名，这可能就是为什么要使用蛇形字母的原因：

AppUser.name.tableize # => "app_users"

在此处添加更多答案时，我感到有些不安。决定采用最易读和最小的纯红宝石方法，而忽略@ ulysse-bn的不错基准。虽然:classmode是@ user3869936的副本，但是:method我在这里的其他任何答案中都没有看到该模式。

  def snake_to_camel_case(str, mode: :class)
    case mode
    when :class
      str.split('_').map(&:capitalize).join
    when :method
      str.split('_').inject { |m, p| m + p.capitalize }
    else
      raise "unknown mode #{mode.inspect}"
    end
  end

结果是：

[28] pry(main)> snake_to_camel_case("asd_dsa_fds", mode: :class)
=> "AsdDsaFds"
[29] pry(main)> snake_to_camel_case("asd_dsa_fds", mode: :method)
=> "asdDsaFds"

此处列出的大多数其他方法都是特定于Rails的。如果您想使用纯Ruby做到这一点，以下是我想出的最简洁的方法（感谢@ ulysse-bn提出的改进建议）

x="this_should_be_camel_case"
x.gsub(/(?:_|^)(\w)/){$1.upcase}
    #=> "ThisShouldBeCamelCase"

扩展字符串以添加驼峰

在纯Ruby中，您可以使用Rails中完全相同的代码来扩展字符串类 .camelize

class String
  def camelize(uppercase_first_letter = true)
    string = self
    if uppercase_first_letter
      string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
    else
      string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
    end
    string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub("/", "::")
  end
end