Konwertowanie ciągu znaków ze snake_case na CamelCase w Ruby

Question

Próbuję przekształcić nazwę ze sprawy węża na wielbłądzie. Czy są jakieś wbudowane metody?

Np "app_user" do "AppUser"

(mam ciąg "app_user" chcę przekonwertować do modelowania AppUser).

Answer 1

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

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

Jeśli chcesz uzyskać aktualną klasę, powinieneś dodatkowo użyć String#constantize.

"app_user".camelize.constantize 

Answer 2

Użyj classify. Dobrze radzi sobie z przypadkami na krawędziach.

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

Uwaga:

Ta odpowiedź jest specyficzne z opisem podanym w pytaniu (to nie jest specyficzne dla tytule zapytania). Jeśli próbujesz przekonwertować ciąg na wielbłądzie, powinni użyć odpowiedzi: Sergio. Pytający stwierdza, że ​​chce przekształcić app_user do AppUser (nie App_user), stąd ta odpowiedź ..

Answer 3

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

do nauki celu:

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 małymi literami:

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

Poszukałem odwrotności twojego pytania, przechodząc od przypadku wielbłąda do s sprawa nake. Użyj underscore na to (nie decamelize):

AppUser.name.underscore # => "app_user"

lub, jeśli masz już camel sprawa ciąg:

"AppUser".underscore # => "app_user"

lub, jeśli chcesz uzyskać nazwę tabeli, która prawdopodobnie dlatego, że chcesz sprawę snake:

AppUser.name.tableize # => "app_users"

Answer 5

Większość innych wymienionych tutaj metod jest specyficznych dla Rails. Jeśli chcesz rób tego z czystej Ruby, następujące jest najbardziej zwięzły sposób mam wymyślić (dzięki @ Ulysse-bn dla sugerowanej poprawy)

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

Answer 6

Jak o tym?

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

Znaleziono tu komentarze: Classify a Ruby string

Zobacz komentarz Wayne Conrad

Answer 7

Benchmark dla czystych rozwiązań Ruby

wziąłem co możliwości miałem na myśli to zrobić z czystego kodu Ruby , tutaj są to:

• wykorzystać i gsub

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

• Split i mapę przy użyciu & skrótów (dzięki odpowiedzi user3869936'S)

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

• dzielenie i map (dzięki pana Blacka odpowiedź)

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

I tutaj jest Benchmark dla wszystkich z nich, my widać, że gsub jest na to 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) 

Answer 8

Czuję się trochę nieswojo, aby dodać więcej odpowiedzi tutaj. Postanowili przejść do najbardziej czytelnego i minimalnego podejścia z czystym rubinem, pomijając ładny benchmark z @ ulysse-bn. Podczas gdy tryb :class jest kopią trybu @ user3869936, :method, nie widzę tutaj żadnej innej odpowiedzi.

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 jest:

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