Umwandlung des Kamelkastens in einen Unterstrich in Rubin

Gibt es eine Bereitschaftsfunktion, die Kamelfallstrings in durch Unterstriche getrennte Strings umwandelt?

Ich möchte so etwas:

"CamelCaseString".to_underscore      

um "camel_case_string" zurückzugeben.

...

ActiveSupport von Rails fügt dem String den folgenden Unterstrich hinzu:

class String
  def underscore
    self.gsub(/::/, '/').
    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
    gsub(/([a-z\d])([A-Z])/,'\1_\2').
    tr("-", "_").
    downcase
  end
end

Dann kannst du lustige Sachen machen:

"CamelCase".underscore
=> "camel_case"

Sie können verwenden

"CamelCasedName".tableize.singularize

Oder nur

"CamelCasedName".underscore

Beide Optionen ergeben sich "camel_cased_name". Weitere Details können Sie hier überprüfen .

Einzeilige Ruby-Implementierung:

class String
   # ruby mutation methods have the expectation to return self if a mutation occurred, nil otherwise. (see http://www.ruby-doc.org/core-1.9.3/String.html#method-i-gsub-21)
   def to_underscore!
     gsub!(/(.)([A-Z])/,'\1_\2')
     downcase!
   end

   def to_underscore
     dup.tap { |s| s.to_underscore! }
   end
end

So "SomeCamelCase".to_underscore # =>"some_camel_case"

Es gibt eine in Rails integrierte Methode namens "Unterstrich", die Sie für diesen Zweck verwenden können

"CamelCaseString".underscore #=> "camel_case_string" 

Die "Unterstrich" -Methode kann typischerweise als Umkehrung von "Kamelisierung" betrachtet werden.

So macht es Rails :

   def underscore(camel_cased_word)
     camel_cased_word.to_s.gsub(/::/, '/').
       gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
       gsub(/([a-z\d])([A-Z])/,'\1_\2').
       tr("-", "_").
       downcase
   end

Empfänger in Schlangenfall konvertiert: http://rubydoc.info/gems/extlib/0.9.15/String#snake_case-instance_method

Dies ist die Support-Bibliothek für DataMapper und Merb. ( http://rubygems.org/gems/extlib )

def snake_case
  return downcase if match(/\A[A-Z]+\z/)
  gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').
  gsub(/([a-z])([A-Z])/, '\1_\2').
  downcase
end

"FooBar".snake_case           #=> "foo_bar"
"HeadlineCNNNews".snake_case  #=> "headline_cnn_news"
"CNN".snake_case              #=> "cnn"

Schauen Sie sich den Schlangenkoffer von Ruby Facets an

Die folgenden Fälle werden wie folgt behandelt:

"SnakeCase".snakecase         #=> "snake_case"
"Snake-Case".snakecase        #=> "snake_case"
"Snake Case".snakecase        #=> "snake_case"
"Snake  -  Case".snakecase    #=> "snake_case"

Von: https://github.com/rubyworks/facets/blob/master/lib/core/facets/string/snakecase.rb

class String

  # Underscore a string such that camelcase, dashes and spaces are
  # replaced by underscores. This is the reverse of {#camelcase},
  # albeit not an exact inverse.
  #
  #   "SnakeCase".snakecase         #=> "snake_case"
  #   "Snake-Case".snakecase        #=> "snake_case"
  #   "Snake Case".snakecase        #=> "snake_case"
  #   "Snake  -  Case".snakecase    #=> "snake_case"
  #
  # Note, this method no longer converts `::` to `/`, in that case
  # use the {#pathize} method instead.

  def snakecase
    #gsub(/::/, '/').
    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
    gsub(/([a-z\d])([A-Z])/,'\1_\2').
    tr('-', '_').
    gsub(/\s/, '_').
    gsub(/__+/, '_').
    downcase
  end

  #
  alias_method :underscore, :snakecase

  # TODO: Add *separators to #snakecase, like camelcase.

end

Kurzer Oneliner für CamelCases, wenn auch Leerzeichen enthalten sind (funktioniert nicht richtig, wenn Sie ein Wort dazwischen mit einem kleinen Anfangsbuchstaben haben):

a = "Test String"
a.gsub(' ', '').underscore

  => "test_string"

Falls jemand nach einem Fall sucht, in dem er Unterstriche auf Zeichenfolgen mit Leerzeichen anwenden und diese auch in Unterstriche konvertieren möchte, können Sie so etwas verwenden

'your String will be converted To underscore'.parameterize.underscore
#your_string_will_be_converted_to_underscore

Oder verwenden Sie einfach .parameterize ('_'), aber denken Sie daran, dass dieses veraltet ist

'your String will be converted To underscore'.parameterize('_')
#your_string_will_be_converted_to_underscore

Das würde mir gefallen:

class String

  # \n returns the capture group of "n" index
  def snikize
    self.gsub(/::/, '/')
    .gsub(/([a-z\d])([A-Z])/, "\1_\2")
    .downcase
  end

  # or

  def snikize
    self.gsub(/::/, '/')
    .gsub(/([a-z\d])([A-Z])/) do
      "#{$1}_#{$2}"
    end
    .downcase
  end

end

Affenfeld der StringKlasse. Es gibt Klassen, die mit zwei oder mehr Buchstaben in Großbuchstaben beginnen.