ฉันพยายามแปลงชื่อจากเคสงูเป็นเคสอูฐ มีวิธีการในตัวหรือไม่?

เช่น: "app_user"ถึง"AppUser"

(ฉันมีสตริง"app_user"ฉันต้องการแปลงให้เป็นรุ่นAppUser)

หากคุณใช้ Rails String # camelizeคือสิ่งที่คุณกำลังมองหา

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

หากคุณต้องการได้คลาสจริงคุณควรใช้String # constantizeด้านบน

"app_user".camelize.constantize

แล้วอันนี้ละ?

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

พบได้ในความคิดเห็นที่นี่: จัดประเภทสตริง Ruby

ดูความคิดเห็นโดยWayne Conrad

classifyถ้าคุณใช้ทางรถไฟใช้ มันจัดการกรณีขอบได้ดี

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

บันทึก:

คำตอบนี้เฉพาะเจาะจงกับคำอธิบายที่ให้ไว้ในคำถาม (ไม่เฉพาะเจาะจงกับชื่อคำถาม) หากพยายามแปลงสตริงเป็นอูฐก็ควรใช้คำตอบของSergio ผู้ถามระบุว่าเขาต้องการแปลงapp_userเป็นAppUser(ไม่ใช่App_user) ดังนั้นคำตอบนี้ ..

ที่มา: http://rubydoc.info/gems/extlib/0.9.15/String#camel_case-instance_method

เพื่อการเรียนรู้:

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"

และสำหรับตัวแปร 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"

เกณฑ์มาตรฐานสำหรับโซลูชันทับทิมบริสุทธิ์

ฉันใช้ความเป็นไปได้ทุกอย่างที่ฉันมีในใจที่จะทำด้วยรหัสทับทิมบริสุทธิ์นี่คือ:

• ใช้ประโยชน์และ gsub

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

• แยกและแผนที่โดยใช้&ชวเลข (ขอบคุณคำตอบของผู้ใช้ 3869936)

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

• แยกและแผนที่ (ขอบคุณคำตอบของ Mr. Black)

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

และนี่คือเกณฑ์มาตรฐานสำหรับสิ่งเหล่านี้เราจะเห็นได้ว่า gsub นั้นค่อนข้างแย่สำหรับเรื่องนี้ ฉันใช้ 126 080 คำ

                              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)

ฉันมาที่นี่เพื่อค้นหาสิ่งที่ตรงกันข้ามกับคำถามของคุณเริ่มจากอูฐเคสไปจนถึงเคสงู ใช้ขีดเส้นใต้สำหรับสิ่งนั้น (ไม่ใช่ decamelize):

AppUser.name.underscore # => "app_user"

หรือถ้าคุณมีสตริงตัวอูฐอยู่แล้ว:

"AppUser".underscore # => "app_user"

หรือถ้าคุณต้องการได้รับชื่อตารางซึ่งอาจเป็นสาเหตุที่คุณต้องการกรณีงู:

AppUser.name.tableize # => "app_users"

ฉันรู้สึกอึดอัดเล็กน้อยที่จะเพิ่มคำตอบเพิ่มเติมที่นี่ ตัดสินใจที่จะใช้วิธีการทับทิมบริสุทธิ์ที่อ่านง่ายและน้อยที่สุดโดยไม่คำนึงถึงมาตรฐานที่ดีจาก @ ulysse-bn ในขณะที่:classโหมดเป็นสำเนาของ @ user3869936 :methodโหมดที่ฉันไม่เห็นในคำตอบอื่น ๆ ที่นี่

  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

ผลลัพธ์คือ:

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

วิธีอื่น ๆ ส่วนใหญ่ที่ระบุไว้ที่นี่เป็นวิธีเฉพาะของ Rails หากคุณต้องการทำสิ่งนี้ด้วย Ruby บริสุทธิ์ต่อไปนี้เป็นวิธีที่กระชับที่สุดที่ฉันคิดขึ้นมาด้วย (ขอบคุณ @ ulysse-bn สำหรับการปรับปรุงที่แนะนำ)

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

ขยายสตริงเพื่อเพิ่ม Camelize

ใน Ruby บริสุทธิ์คุณสามารถขยายคลาสสตริงโดยใช้โค้ดเดียวกันจาก 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