it-swarm.com.de

Konvertieren eines Strings von snake_case nach CamelCase in Ruby

Ich versuche, einen Namen von Schlangenkasten zu Kamelkasten umzuwandeln. Gibt es eingebaute Methoden?

Z.B: "app_user" bis "AppUser"

(Ich habe eine Zeichenfolge "app_user" Ich möchte das in Modell AppUser konvertieren).

157
Lohith MV

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

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

Wenn Sie eine aktuelle Klasse erhalten möchten, sollten Sie zusätzlich String # constantize verwenden.

"app_user".camelize.constantize
228

Wie wäre es mit diesem?

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

Gefunden in den Kommentaren hier: Klassifiziere einen Ruby string

Siehe Kommentar von Wayne Conrad

109
user3869936

Verwenden Sie classify. Es behandelt Edge-Fälle gut.

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

Hinweis:

Diese Antwort ist spezifisch für die Beschreibung in der Frage (es ist nicht spezifisch für den Fragentitel). Wenn man versucht, eine Zeichenkette in einen Kamelkasten umzuwandeln, sollte man die Antwort von Sergio verwenden. Der Fragesteller gibt an, dass er app_user In AppUser konvertieren möchte (nicht App_user), Daher diese Antwort.

40
Harish Shetty

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

Zum Lernen:

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"
23
Mr. Black

Benchmark für reine Ruby Lösungen

Ich habe alle Möglichkeiten genutzt, die ich mir vorgestellt hatte, um es mit reinem Ruby Code zu tun. Hier sind sie:

  • kapitalisieren und gsub

    "app_user".capitalize.gsub(/_(\w)/){$1.upcase}
    
  • teilen und mappen mit & Kurzschrift (dank der Antwort von user3869936)

    "app_user".split('_').map(&:capitalize).join
    
  • teilen und zuordnen (dank der Antwort von Mr. Black)

    "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)
15
Ulysse BN

Ich bin auf der Suche nach der Umkehrung Ihrer Frage hierher gekommen und bin von einem Kamelkoffer zu einem Schlangenkoffer übergegangen. Verwenden Sie dazu nterstrich (nicht dekamelisieren):

AppUser.name.underscore # => "app_user"

oder, wenn Sie bereits eine Kamelhülle 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"

9
mike

Es ist mir ein wenig unangenehm, hier weitere Antworten hinzuzufügen. Beschlossen, den lesbarsten und reinsten Ruby) Ansatz zu wählen, wobei der Nice-Benchmark von @ ulysse-bn unberücksichtigt blieb. Während :class mode ist eine Kopie von @ user3869936, dem :method mode Ich sehe hier keine andere 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"
2
akostadinov

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

String erweitern, um Camelize hinzuzufügen

In pure Ruby könnten Sie die String-Klasse mit genau demselben Code erweitern wie in 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