Ich versuche, einen Namen vom Schlangenfall in den Kamelfall umzuwandeln. Gibt es eingebaute Methoden?

ZB: "app_user"zu"AppUser"

(Ich habe eine Zeichenfolge, die "app_user"ich in ein Modell konvertieren möchte AppUser).

Wenn Sie Rails verwenden, ist String # camelize genau das, wonach Sie suchen.

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

Wenn Sie eine tatsächliche Klasse erhalten möchten, sollten Sie darüber hinaus String # constize verwenden .

"app_user".camelize.constantize

Wie wäre es mit diesem?

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

In den Kommentaren hier zu finden: Klassifizieren Sie eine Ruby-Zeichenfolge

Siehe Kommentar von Wayne Conrad

Wenn Sie Rails verwenden, verwenden Sie classify. Es handhabt Randfälle gut.

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

Hinweis:

Diese Antwort ist spezifisch für die Beschreibung in der Frage (sie ist nicht spezifisch für den Fragentitel). Wenn man versucht, einen String in einen Kamelkasten umzuwandeln, sollte man Sergios Antwort verwenden. Der Fragesteller gibt an, dass er app_userzu AppUser(nicht App_user) konvertieren möchte , daher diese Antwort.

Quelle: http://rubydoc.info/gems/extlib/0.9.15/String#camel_case-instance_method

Zu Lernzwecken:

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"

Und für die LowerCase-Variante:

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"

Benchmark für reine Ruby-Lösungen

Ich habe alle Möglichkeiten genutzt, um dies mit reinem Ruby-Code zu tun. Hier sind sie:

• kapitalisieren und gsub

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

• &Teilen und Zuordnen mit Kurzschrift (dank der Antwort von user3869936)

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

• Split und Map (dank Mr. Blacks Antwort)

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

Und hier ist der Benchmark für all dies. Wir können sehen, dass gsub dafür ziemlich schlecht ist. Ich habe 126 080 Wörter verwendet.

                              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)

Ich bin hierher gekommen, um die Umkehrung Ihrer Frage zu suchen, von Kamelfall zu Schlangenfall. Verwenden Sie dazu einen Unterstrich (nicht dekamellisieren):

AppUser.name.underscore # => "app_user"

oder, wenn Sie bereits eine Kamelfallschnur haben:

"AppUser".underscore # => "app_user"

oder, wenn Sie den Tabellennamen erhalten möchten, weshalb Sie wahrscheinlich den Schlangenfall möchten:

AppUser.name.tableize # => "app_users"

Es ist mir etwas unangenehm, hier weitere Antworten hinzuzufügen. Beschlossen, den lesbarsten und minimalsten reinen Rubin-Ansatz zu wählen, ohne den netten Benchmark von @ ulysse-bn zu berücksichtigen. Während der :classModus eine Kopie von @ user3869936 ist, sehe :methodich den Modus hier in keiner anderen Antwort.

  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

Ergebnis ist:

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

Die meisten anderen hier aufgeführten Methoden sind Rails-spezifisch. Wenn Sie dies mit reinem Ruby tun möchten, ist das Folgende die prägnanteste Methode, die ich mir ausgedacht habe (danke an @ ulysse-bn für die vorgeschlagene Verbesserung).

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

Erweitern Sie den String, um Camelize hinzuzufügen

In reinem Ruby können Sie die Zeichenfolgenklasse mit genau demselben Code aus Rails erweitern .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