Próbuję przekonwertować nazwę z etui węża na etui na wielbłąda. Czy są jakieś wbudowane metody?

Np .: "app_user"do"AppUser"

(Mam ciąg, "app_user"który chcę przekonwertować na model AppUser).

Jeśli używasz Railsów, to String # camelize jest tym, czego szukasz.

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

Jeśli chcesz otrzymać aktualną klasę, powinieneś dodać do tego stałą String # .

"app_user".camelize.constantize

A co z tym?

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

Znalezione w komentarzach tutaj: Klasyfikuj łańcuch Ruby

Zobacz komentarz Wayne Conrad

Jeśli używasz Railsów, użyj classify. Dobrze radzi sobie z krawędziami.

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

Uwaga:

Ta odpowiedź jest specyficzna dla opisu podanego w pytaniu (nie jest specyficzna dla tytułu pytania). Jeśli ktoś próbuje zamienić sznurek na skrzynkę wielbłąda, powinien użyć odpowiedzi Sergio . Pytający stwierdza, że ​​chce przejść app_userna AppUser(nie App_user), stąd ta odpowiedź.

Źródło: http://rubydoc.info/gems/extlib/0.9.15/String#camel_case-instance_method

Do celów edukacyjnych:

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"

A dla wariantu lowCase:

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 dla czystych rozwiązań Ruby

Wykorzystałem wszystkie możliwości, jakie miałem na myśli, aby zrobić to za pomocą czystego kodu rubinowego, oto one:

• wielkie litery i gsub

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

• podziel i &mapuj używając skrótu (dzięki odpowiedzi użytkownika3869936)

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

• split i map (dzięki odpowiedzi pana Blacka)

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

A tutaj jest Benchmark dla wszystkich z nich, widzimy, że gsub jest do tego całkiem zły. Użyłem 126 080 słów.

                              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)

Przyszedłem tutaj, szukając odwrotności twojego pytania, przechodząc od przypadku wielbłąda do przypadku węża. Użyj do tego podkreślenia (nie dekamelizuj):

AppUser.name.underscore # => "app_user"

lub, jeśli masz już ciąg wielbłąda:

"AppUser".underscore # => "app_user"

lub, jeśli chcesz uzyskać nazwę stołu, prawdopodobnie dlatego chciałbyś mieć etui węża:

AppUser.name.tableize # => "app_users"

Czuję się trochę nieswojo, dodając tutaj więcej odpowiedzi. Zdecydowałem się na najbardziej czytelne i minimalne podejście do czystego rubinu, pomijając ładny wzorzec z @ ulysse-bn. Chociaż :classtryb jest kopią @ user3869936, :methodtryb, którego nie widzę w żadnej innej odpowiedzi tutaj.

  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

Wynik to:

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

Większość innych wymienionych tutaj metod jest specyficzna dla Railsów. Jeśli chcesz to zrobić z czystym Rubim, oto najbardziej zwięzły sposób, jaki wymyśliłem (dzięki @ ulysse-bn za sugerowane ulepszenie)

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

Przedłuż ciąg, aby dodać Camelize

W czystym Rubim możesz rozszerzyć klasę stringów używając dokładnie tego samego kodu z Railsów .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