Yılan kasasından deve kasasına bir isim dönüştürmeye çalışıyorum. Yerleşik yöntemler var mı?

Ör: "app_user"hiç"AppUser"

(Bu "app_user"modele dönüştürmek istiyorum bir dize var AppUser).

Rails kullanıyorsanız, String # camelize aradığınız şeydir.

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

Gerçek bir sınıf almak istiyorsanız , bunun üstünde String # constantize kullanmalısınız .

"app_user".camelize.constantize

Buna ne dersin?

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

Buradaki yorumlarda bulundu: Bir Ruby dizesini sınıflandırın

Yoruma bakın Wayne Conrad

Rails kullanıyorsanız, kullanın classify. Kenar kasalarını iyi idare eder.

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

Not:

Bu cevap soruda verilen açıklamaya özgüdür (soru başlığına özgü değildir). Eğer bir ipi deveye çevirmeye çalışıyorsa Sergio'nun cevabını kullanmalıdırlar. O dönüştürmek istediği sorgulayıcı devletler app_useriçin AppUser(değil App_user), dolayısıyla bu cevabı ..

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

Öğrenme amacıyla:

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"

Ve lowerCase varyantı için:

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"

Saf Ruby çözümleri için karşılaştırma ölçütü

Saf yakut koduyla bunu yapmak için aklımdaki tüm olasılıkları aldım, işte bunlar:

• büyük harf ve büyük harf

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

• &steno kullanarak böl ve eşleştir (user3869936'un cevabı sayesinde)

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

• bölün ve haritalayın (Bay Black'in cevabı sayesinde)

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

İşte tüm bunlar için Benchmark, gsub'ın bunun için oldukça kötü olduğunu görebiliyoruz. 126 080 kelime kullandım.

                              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)

Buraya, sorunuzun tersini aramaya başladım, deve kasasından yılan kasasına. Bunun için alt çizgi kullanın (decamelize değil):

AppUser.name.underscore # => "app_user"

veya zaten bir deve kılıfı dizeniz varsa:

"AppUser".underscore # => "app_user"

veya tablo adını almak istiyorsanız, büyük olasılıkla yılan kasasını istersiniz:

AppUser.name.tableize # => "app_users"

Buraya daha fazla cevap eklemek biraz huzursuz hissediyorum. @ Ulysse-bn'den güzel ölçütü göz ardı ederek en okunabilir ve minimal saf yakut yaklaşımına karar verdi. İken :classmod @ user3869936 bir kopyasıdır, :methodmod burada başka yanıtında görmüyorum.

  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

Sonuç:

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

Burada listelenen diğer yöntemlerin çoğu Raylara özgüdür. Bunu saf Ruby ile yapmak istiyorsanız, aşağıda ortaya koyduğum en özlü yol (önerilen iyileştirme için @ ulysse-bn sayesinde)

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

Camelize Eklemek için Dizeyi Uzat

Pure Ruby'de, dize sınıfını Rails ile aynı kodu kullanarak genişletebilirsiniz .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