J'essaye 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 que "app_user"je veux convertir en modèle AppUser).

Si vous utilisez Rails, String # 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 String # constantize en plus de cela.

"app_user".camelize.constantize

Celui-ci, ça va?

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

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

Voir le commentaire de Wayne Conrad

Si vous utilisez des rails, utilisez classify. Il gère bien les boîtiers 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 cas de chameau, il doit utiliser la réponse de Sergio . Le questionneur déclare qu'il veut se convertir app_useren AppUser(non App_user), d'où cette réponse.

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

À des fins d'apprentissage:

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"

Et pour 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"

Benchmark pour les solutions Ruby pures

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 la &sténographie (grâce à la réponse de user3869936)

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

• diviser et cartographier (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é 126080 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, passant de l'étui de chameau à l'étui de serpent. Utilisez un trait de soulignement pour cela (pas décaméliser):

AppUser.name.underscore # => "app_user"

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

"AppUser".underscore # => "app_user"

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

AppUser.name.tableize # => "app_users"

Je me sens un peu mal à l'aise d'ajouter plus de réponses ici. Décidé d'opter pour l'approche de rubis pur la plus lisible et la plus minimale, sans tenir compte de la belle référence de @ ulysse-bn. Alors que le :classmode est une copie de @ user3869936, le :methodmode que je ne vois dans aucune autre réponse ici.

  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 répertoriées ici sont spécifiques à Rails. Si vous voulez faire cela avec pur Ruby, voici la méthode la plus concise que j'ai trouvée (merci à @ ulysse-bn pour l'amélioration suggérée)

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

Étendre la chaîne pour ajouter du camelize

En Ruby pur, vous pouvez étendre la classe de chaînes en utilisant exactement le même code de Rails .camelize

class String
  def camelize(uppercase_first_letter = true)
    string = self
    if uppercase_first_letter
      string = string.sub(/^[a-z\d]*/) { |match| match.capitalize }
    else
      string = string.sub(/^(?:(?=\b|[A-Z_])|\w)/) { |match| match.downcase }
    end
    string.gsub(/(?:_|(\/))([a-z\d]*)/) { "#{$1}#{$2.capitalize}" }.gsub("/", "::")
  end
end