ruby on rails - rails - Conversión de cadena de snake_case a CamelCase en Ruby

ruby on rails tutorial

Question

Estoy tratando de convertir un nombre de serpiente en camello. ¿Hay algún método incorporado?

Por ejemplo: "app_user" a "AppUser"

(Tengo una cadena "app_user" Quiero convertir eso al AppUser modelo).

Answer 1

Benchmark para soluciones de Ruby puro

Tomé todas las posibilidades que tenía en mente para hacerlo con código de rubí puro, aquí están:

• capitalizar y gsub

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

• dividir y mapa usando & taquigrafía (gracias a la respuesta del usuario3869936)

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

• división y mapa (gracias a la respuesta del Sr. Black)

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

Y aquí está el punto de referencia para todos estos, podemos ver que gsub es bastante malo para esto. Usé 126 080 palabras.

 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)

Answer 2

¿Que tal este?

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

Se encuentra en los comentarios aquí: Clasificar una cadena de Ruby

Ver el comentario de Wayne Conrad

Answer 3

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

Para el propósito de aprendizaje:

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"

Y para la variante lowerCase:

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"

Answer 4

La mayoría de los otros métodos enumerados aquí son específicos de Rails. Si quieres hacer esto con Ruby puro, la siguiente es la forma más concisa que he encontrado (gracias a @ ulysse-bn por la mejora sugerida)

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

Answer 5

Llegué aquí buscando el inverso de tu pregunta, pasando de la caja de camello al caso de la serpiente. Use un underscore para eso (no decamelize):

AppUser.name.underscore # => "app_user"

o, si ya tienes una cadena de camello:

"AppUser".underscore # => "app_user"

o, si desea obtener el nombre de la tabla, que es probablemente la razón por la que desea el caso de la serpiente:

AppUser.name.tableize # => "app_users"

Answer 6

Me siento un poco incómodo para agregar más respuestas aquí. Decidió optar por el enfoque ruby ​​puro más legible y mínimo, sin tener en cuenta el buen punto de referencia de @ ulysse-bn. Mientras :class modo de :class es una copia de @ user3869936, el modo de :method no aparece en ninguna otra respuesta aquí.

 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

El resultado es:

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

Answer 7

Si está utilizando Rails, String#camelize es lo que está buscando.

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

Si desea obtener una clase real, debe usar String#constantize además de eso.

"app_user".camelize.constantize

Answer 8

Usa classify Maneja bien las cajas de borde.

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

Nota:

Esta respuesta es específica a la descripción dada en la pregunta (no es específica del título de la pregunta). Si uno trata de convertir una cuerda en camel-case, debería usar la respuesta de Sergio . El interlocutor declara que quiere convertir app_user en AppUser (no App_user ), de ahí esta respuesta.