Conversion de chaîne de snake_case en CamelCase en Ruby

J’essaie de convertir un nom de cas de serpent en cas de chameau. Existe-t-il des méthodes intégrées?

Par exemple: "app_user" à "AppUser"

(J’ai une chaîne "app_user" je veux convertir en modèle AppUser ).

Si vous utilisez Rails, Ssortingng # camelize est ce que vous recherchez.

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

Si vous voulez obtenir une classe réelle, vous devez utiliser Ssortingng # Constantize par-dessus.

 "app_user".camelize.constantize 

Celui-ci, ça va?

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

Trouvé dans les commentaires ici: Classer une chaîne Ruby

Voir le commentaire de Wayne Conrad

Utilisez classify . Il gère bien les cas de bord.

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

Remarque:

Cette réponse est spécifique à la description donnée dans la question (elle n’est pas spécifique au titre de la question). Si quelqu’un essaie de convertir une chaîne en camel-case, ils doivent utiliser la réponse de Sergio . Le questionneur déclare qu’il veut convertir app_user à AppUser (pas App_user ), d’où cette réponse ..

Source: http://rubydoc.info/gems/extlib/0.9.15/Ssortingng#camel_case-instance_method

Pour apprendre:

 class Ssortingng def camel_case return self if self !~ /_/ && self =~ /[AZ]+.*/ split('_').map{|e| e.capitalize}.join end end "foo_bar".camel_case #=> "FooBar" 

Et pour la variante LowerCase:

 class Ssortingng 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" 

Benchmark pour les solutions purement Ruby

J’ai pris toutes les possibilités que j’avais en tête pour le faire avec du code Ruby pur, les voici:

  • capitaliser et gsub

     "app_user".capitalize.gsub(/_(\w)/){$1.upcase} 
  • diviser et cartographier en utilisant & sténographie (grâce à la réponse de user3869936)

     "app_user".split('_').map(&:capitalize).join 
  • split et map (grâce à la réponse de M. Black)

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

Et voici le Benchmark pour tout cela, nous pouvons voir que gsub est assez mauvais pour cela. J’ai utilisé 126 080 mots.

  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) 

Je suis arrivé ici à la recherche de l’inverse de votre question, allant du cas du chameau au cas du serpent. Utilisez le soulignement pour cela (ne pas décélérer):

AppUser.name.underscore # => "app_user"

ou, si vous avez déjà une chaîne de cas camel:

"AppUser".underscore # => "app_user"

ou, si vous voulez obtenir le nom de la table, c’est probablement pourquoi vous voulez le cas du serpent:

AppUser.name.tableize # => "app_users"

Je me sens un peu mal à l’aise d’append plus de réponses ici. Décidé d’aller pour l’approche Ruby pure la plus lisible et minimale, sans tenir compte de la belle référence de @ ulysse-bn. Alors que :class mode :class est une copie de @ user3869936, le :method ne figure dans aucune autre réponse.

  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 

Le résultat est:

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

La plupart des autres méthodes listées ici sont spécifiques à Rails. Si vous voulez faire cela avec du Ruby pur, voici la manière la plus concise que je propose (merci à @ ulysse-bn pour l’amélioration suggérée)

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