Conversione di una custodia color cammello in una sottolineatura in rubino

Esiste una funzione pronta che converte le stringhe della custodia del cammello in una stringa separata di sottolineatura?

Voglio qualcosa del genere:

"CamelCaseString".to_underscore      

per restituire "camel_case_string".

...

ActiveSupport di Rails aggiunge il carattere di sottolineatura alla stringa usando quanto segue:

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

Quindi puoi fare cose divertenti:

"CamelCase".underscore
=> "camel_case"

Puoi usare

"CamelCasedName".tableize.singularize

O semplicemente

"CamelCasedName".underscore

Entrambe le opzioni verranno rese "camel_cased_name". Puoi controllare maggiori dettagli qui .

Implementazione Ruby con una sola riga:

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

Così "SomeCamelCase".to_underscore # =>"some_camel_case"

Esiste un metodo integrato di Rails chiamato 'underscore' che puoi usare a questo scopo

"CamelCaseString".underscore #=> "camel_case_string" 

Il metodo "underscore" può essere generalmente considerato come inverso di "camelize"

Ecco come 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

Ricevitore convertito in custodia per serpenti: http://rubydoc.info/gems/extlib/0.9.15/String#snake_case-instance_method

Questa è la libreria di supporto per DataMapper e 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"

Dai un'occhiata a snakecase da Ruby Facets

Vengono gestiti i seguenti casi, come illustrato di seguito:

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

Da: 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

Short oneliner per CamelCases anche con spazi inclusi (non funziona correttamente se hai una parola in mezzo con una piccola lettera iniziale):

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

  => "test_string"

Nel caso in cui qualcuno cerchi un caso in cui deve applicare il carattere di sottolineatura alla stringa con spazi e desidera convertirli in caratteri di sottolineatura, puoi usare qualcosa di simile

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

O semplicemente usa .parameterize ('_') ma tieni presente che questo è deprecato

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

Mi piacerebbe questo:

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

Toppa di scimmia di Stringclasse. Ci sono classi che iniziano con due o più lettere maiuscole.