Saya mencoba mengubah nama dari case ular ke case unta. Apakah ada metode bawaan?

Misalnya: "app_user"untuk"AppUser"

(Saya punya string yang "app_user"ingin saya konversi menjadi model AppUser).

Jika Anda menggunakan Rails, String # camelize adalah yang Anda cari.

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

Jika Anda ingin mendapatkan kelas yang sebenarnya, Anda harus menggunakan String # constantize di atas itu.

"app_user".camelize.constantize

Bagaimana dengan yang ini?

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

Ditemukan dalam komentar di sini: Klasifikasi string Ruby

Lihat komentar Wayne Conrad

Jika Anda menggunakan Rails, Gunakan classify. Ini menangani kasus tepi dengan baik.

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

catatan:

Jawaban ini khusus untuk uraian yang diberikan dalam pertanyaan (tidak spesifik untuk judul pertanyaan). Jika seseorang mencoba mengkonversi string ke camel-case, mereka harus menggunakan jawaban Sergio . Penanya menyatakan bahwa ia ingin mengkonversi app_userke AppUser(tidak App_user), maka jawaban ini ..

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

Untuk tujuan belajar:

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"

Dan untuk varian 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 untuk solusi Ruby murni

Saya mengambil setiap kemungkinan yang ada dalam pikiran saya untuk melakukannya dengan kode ruby ​​murni, ini dia:

• bermodalkan dan gsub

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

• pisah dan petakan menggunakan &steno (terima kasih atas jawaban pengguna3869936)

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

• pisah dan petakan (terima kasih untuk jawaban Tuan Black)

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

Dan di sini adalah Tolok Ukur untuk semua ini, kita dapat melihat bahwa gsub sangat buruk untuk ini. Saya menggunakan 126 080 kata.

                              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)

Saya tiba di sini untuk mencari kebalikan dari pertanyaan Anda, dari kasus unta ke kasus ular. Gunakan garis bawah untuk itu (bukan decamelize):

AppUser.name.underscore # => "app_user"

atau, jika Anda sudah memiliki tali unta:

"AppUser".underscore # => "app_user"

atau, jika Anda ingin mendapatkan nama tabel, yang mungkin itulah mengapa Anda menginginkan kotak ular:

AppUser.name.tableize # => "app_users"

Saya merasa sedikit tidak enak untuk menambahkan lebih banyak jawaban di sini. Memutuskan untuk menggunakan pendekatan ruby ​​murni yang paling mudah dibaca dan minimal, mengabaikan tolok ukur yang bagus dari @ ulysse-bn. Meskipun :classmode adalah salinan dari @ user3869936, :methodmode yang tidak saya lihat di jawaban lain di sini.

  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

Hasilnya adalah:

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

Sebagian besar metode lain yang tercantum di sini adalah Rails khusus. Jika Anda ingin melakukan ini dengan Ruby murni, berikut ini adalah cara paling ringkas yang saya buat (terima kasih kepada @ ulysse-bn untuk perbaikan yang disarankan)

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

Perpanjang String untuk Menambahkan Camelize

Di Ruby murni Anda bisa memperluas kelas string menggunakan kode yang sama persis dari 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