Convertir el caso en camello para subrayar caso de rubí

Question

¿Hay alguna función de lista, lo que convierte las cadenas de casos en camello por cadena separada subrayado?

Quiero algo como esto:

"CamelCaseString".to_underscore      

para volver "camel_case_string".

...

Answer 1

carril ActiveSupport agrega subrayar a la cadena utilizando la siguiente:

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

A continuación, puede hacer cosas divertidas:

"CamelCase".underscore
=> "camel_case"

Answer 2

Puede utilizar

"CamelCasedName".tableize.singularize

O simplemente

"CamelCasedName".underscore

Ambas opciones maneras producirán "camel_cased_name". Usted puede comprobar más detalles que aquí .

Answer 3

One-liner aplicación Ruby:

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

Así "SomeCamelCase".to_underscore # =>"some_camel_case"

Answer 4

Hay un método incorporado rieles llamado 'guión' que se puede utilizar para este propósito

"CamelCaseString".underscore #=> "camel_case_string" 

El método 'subrayado' típicamente se puede considerar como inversa de 'camelize'

Answer 5

Así es como Rieles lo hace :

   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

Answer 6

Receptor convierte en caso serpiente: http://rubydoc.info/ gemas / extlib / 0.9.15 / cadena # snake_case-instance_method

Esta es la biblioteca de soporte para DataMapper y 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"

Answer 7

Salida snakecase Rubí Facetas

Los siguientes casos son manejados, como se ve a continuación:

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

De: https: // github. com / rubyworks / facetas / burbuja / maestro / lib / core / facetas / cadena / 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

Answer 8

Cortos un trazador de líneas de camello casos cuando haya espacios también se incluye (no funciona correctamente si usted tiene una palabra entre medio con una pequeña partida letras):

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

  => "test_string"

Answer 9

Me gustaría que esta:

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

parche Monkey de clase String. Hay clases que comienzan con dos o más letras en mayúsculas.