ดำเนินการต่อ "meme คุณสมบัติที่ซ่อนอยู่ของ ... " มาแบ่งปันคุณสมบัติที่รู้จักกันน้อย แต่มีประโยชน์ของภาษาการเขียนโปรแกรม Ruby

พยายาม จำกัด การสนทนานี้ด้วย Core Ruby โดยไม่มี Ruby on Rails

ดูสิ่งนี้ด้วย:

• คุณสมบัติที่ซ่อนของ C #
• คุณสมบัติที่ซ่อนของ Java
• คุณสมบัติที่ซ่อนของ JavaScript
• คุณสมบัติที่ซ่อนของ Ruby on Rails
• คุณสมบัติที่ซ่อนของ Python

(โปรดเพียงหนึ่งคุณสมบัติที่ซ่อนอยู่ต่อคำตอบ)

ขอบคุณ

จาก Ruby 1.9 Proc # === เป็นนามแฝงถึง Proc # call ซึ่งหมายความว่าวัตถุ Proc สามารถใช้ในคำสั่ง case เช่น:

def multiple_of(factor)
  Proc.new{|product| product.modulo(factor).zero?}
end

case number
  when multiple_of(3)
    puts "Multiple of 3"
  when multiple_of(7)
    puts "Multiple of 7"
end

Peter Cooper มีรายการเคล็ดลับ Ruby ที่ดี บางทีสิ่งที่ฉันโปรดปรานของเขาคืออนุญาตให้แจกแจงรายการและคอลเลกชันเดี่ยว (นั่นคือถือว่าวัตถุที่ไม่ใช่คอลเลกชันเป็นคอลเลกชันที่มีเพียงวัตถุนั้น) มันมีลักษณะเช่นนี้:

[*items].each do |item|
  # ...
end

ไม่ทราบว่าซ่อนไว้อย่างไร แต่ฉันพบว่ามีประโยชน์เมื่อต้องการทำให้แฮชเป็นอาร์เรย์หนึ่งมิติ:

fruit = ["apple","red","banana","yellow"]
=> ["apple", "red", "banana", "yellow"]

Hash[*fruit]    
=> {"apple"=>"red", "banana"=>"yellow"}

หนึ่งในเคล็ดลับที่ฉันชอบคือการใช้*ตัวขยายsplat ( ) บนวัตถุอื่นที่ไม่ใช่อาร์เรย์ นี่คือตัวอย่างของการจับคู่นิพจน์ทั่วไป:

match, text, number = *"Something 981".match(/([A-z]*) ([0-9]*)/)

ตัวอย่างอื่น ๆ ได้แก่ :

a, b, c = *('A'..'Z')

Job = Struct.new(:name, :occupation)
tom = Job.new("Tom", "Developer")
name, occupation = *tom

ว้าวไม่มีใครพูดถึงตัวดำเนินการของฟล็อปฟล็อป:

1.upto(100) do |i|
  puts i if (i == 3)..(i == 15)
end

หนึ่งในสิ่งที่ยอดเยี่ยมเกี่ยวกับทับทิมคือคุณสามารถเรียกใช้เมธอดและเรียกใช้โค้ดในที่ ๆ ภาษาอื่น ๆ จะขมวดคิ้วเช่นในเมธอดหรือนิยามคลาส

ตัวอย่างเช่นในการสร้างคลาสที่มีซูเปอร์คลาสที่ไม่รู้จักจนกระทั่งถึงเวลาใช้งานนั่นคือสุ่มคุณสามารถทำสิ่งต่อไปนี้:

class RandomSubclass < [Array, Hash, String, Fixnum, Float, TrueClass].sample

end

RandomSubclass.superclass # could output one of 6 different classes.

สิ่งนี้ใช้ 1.9 Array#sampleวิธี (ใน 1.8.7-only, see Array#choice) และตัวอย่างนั้นถูกออกแบบมาอย่างสวยงาม แต่คุณสามารถเห็นพลังได้ที่นี่

อีกตัวอย่างที่ยอดเยี่ยมคือความสามารถในการใส่ค่าพารามิเตอร์เริ่มต้นที่ไม่คงที่ (เช่นภาษาอื่นมักต้องการ):

def do_something_at(something, at = Time.now)
   # ...
end

แน่นอนปัญหากับตัวอย่างแรกก็คือมันจะถูกประเมินตามเวลาที่กำหนดไม่ใช่เวลาโทร ดังนั้นเมื่อเลือกซูเปอร์คลาสแล้วจะยังคงเป็นซูเปอร์คลาสนั้นตลอดเวลาที่เหลือของโปรแกรม

อย่างไรก็ตามในตัวอย่างที่สองทุกครั้งที่คุณโทรหาdo_something_atที่atตัวแปรจะเป็นเวลาที่วิธีการที่เรียกว่า (ดีมากใกล้เคียงกับมัน)

อีกคุณสมบัติเล็ก ๆ - แปลงเป็นFixnumฐานได้สูงสุด 36:

>> 1234567890.to_s(2)
=> "1001001100101100000001011010010"

>> 1234567890.to_s(8)
=> "11145401322"

>> 1234567890.to_s(16)
=> "499602d2"

>> 1234567890.to_s(24)
=> "6b1230i"

>> 1234567890.to_s(36)
=> "kf12oi"

และอย่างที่ Huw Walters ได้แสดงความคิดเห็นการแปลงวิธีอื่นนั้นเรียบง่าย:

>> "kf12oi".to_i(36)
=> 1234567890

แฮชที่มีค่าเริ่มต้น! อาร์เรย์ในกรณีนี้

parties = Hash.new {|hash, key| hash[key] = [] }
parties["Summer party"]
# => []

parties["Summer party"] << "Joe"
parties["Other party"] << "Jane"

มีประโยชน์มากใน metaprogramming

ดาวน์โหลดแหล่งทับทิม 1.9 และปัญหาmake golfจากนั้นคุณสามารถทำสิ่งนี้:

make golf

./goruby -e 'h'
# => Hello, world!

./goruby -e 'p St'
# => StandardError

./goruby -e 'p 1.tf'
# => 1.0

./goruby19 -e 'p Fil.exp(".")'
"/home/manveru/pkgbuilds/ruby-svn/src/trunk"

อ่านgolf_prelude.cสิ่งที่ซ่อนเร้นมากขึ้น

การเพิ่มความสนุกใน 1.9 Proc อีกอย่างคือ Proc # curry ซึ่งช่วยให้คุณเปลี่ยน Proc ที่รับอาร์กิวเมนต์ n เป็นหนึ่งการยอมรับ n-1 นี่คือมันรวมกับเคล็ดลับ Proc # === ฉันกล่าวถึงข้างต้น:

it_is_day_of_week = lambda{ |day_of_week, date| date.wday == day_of_week }
it_is_saturday = it_is_day_of_week.curry[6]
it_is_sunday = it_is_day_of_week.curry[0]

case Time.now
when it_is_saturday
  puts "Saturday!"
when it_is_sunday
  puts "Sunday!"
else
  puts "Not the weekend"
end

ตัวดำเนินการบูลีนบนค่าที่ไม่ใช่บูลีน

&& และ ||

ทั้งสองคืนค่าของนิพจน์สุดท้ายที่ประเมิน

ซึ่งเป็นสาเหตุที่||=จะอัปเดตตัวแปรพร้อมกับนิพจน์ที่ส่งคืนค่าทางด้านขวาหากตัวแปรนั้นไม่ได้กำหนด นี่ไม่ใช่เอกสารอย่างชัดเจน แต่เป็นความรู้ทั่วไป

อย่างไรก็ตามเรื่อง&&=นี้ไม่ค่อยเป็นที่รู้จักอย่างกว้างขวางนัก

string &&= string + "suffix"

เทียบเท่ากับ

if string
  string = string + "suffix"
end

มันมีประโยชน์มากสำหรับการทำลายที่ไม่ควรดำเนินการหากตัวแปรไม่ได้กำหนด

ฟังก์ชั่น Symbol # to_proc ที่ Rails มีนั้นยอดเยี่ยมจริงๆ

แทน

Employee.collect { |emp| emp.name }

คุณสามารถเขียน:

Employee.collect(&:name)

หนึ่งตัวสุดท้าย - ในทับทิมคุณสามารถใช้อักขระใด ๆ ที่คุณต้องการคั่นสตริง ใช้รหัสต่อไปนี้:

message = "My message"
contrived_example = "<div id=\"contrived\">#{message}</div>"

หากคุณไม่ต้องการหนีเครื่องหมายคำพูดคู่ภายในสตริงคุณสามารถใช้ตัวคั่นอื่น:

contrived_example = %{<div id="contrived-example">#{message}</div>}
contrived_example = %[<div id="contrived-example">#{message}</div>]

เช่นเดียวกับการหลีกเลี่ยงการหลีกเลี่ยงตัวคั่นคุณสามารถใช้ตัวคั่นเหล่านี้สำหรับสตริงที่ดีกว่า:

sql = %{
    SELECT strings 
    FROM complicated_table
    WHERE complicated_condition = '1'
}

ฉันพบว่าการใช้คำสั่งdefine_methodเพื่อสร้างวิธีการแบบไดนามิกค่อนข้างน่าสนใจและไม่เป็นที่รู้จักกันดี ตัวอย่างเช่น:

((0..9).each do |n|
    define_method "press_#{n}" do
      @number = @number.to_i * 10 + n
    end
  end

รหัสด้านบนใช้คำสั่ง 'define_method' เพื่อสร้างวิธีการแบบไดนามิก "press1" ถึง "press9" แทนที่จะพิมพ์ทั้ง 10 วิธีซึ่ง essentailly มีรหัสเดียวกันคำสั่ง define method จะใช้ในการสร้างวิธีการเหล่านี้ได้ทันทีตามต้องการ

ใช้วัตถุ Range เป็นรายการ lazy ที่ไม่มีที่สิ้นสุด:

Inf = 1.0 / 0

(1..Inf).take(5) #=> [1, 2, 3, 4, 5]

ข้อมูลเพิ่มเติมที่นี่: http://banisterfiend.wordpress.com/2009/10/02/wtf-infinite-ranges-in-ruby/

module_function

เมธอดโมดูลที่ประกาศเป็นmodule_functionจะสร้างสำเนาของตัวเองเป็นเมธอดอินสแตนซ์ส่วนตัวในคลาสที่มีโมดูล:

module M
  def not!
    'not!'
  end
  module_function :not!
end

class C
  include M

  def fun
    not!
  end
end

M.not!     # => 'not!
C.new.fun  # => 'not!'
C.new.not! # => NoMethodError: private method `not!' called for #<C:0x1261a00>

หากคุณใช้module_functionโดยไม่มีข้อโต้แย้งใด ๆ แล้ววิธีการโมดูลใด ๆ ที่มาหลังจากคำสั่ง module_function จะกลายเป็น module_functions ตัวเองโดยอัตโนมัติ

module M
  module_function

  def not!
    'not!'
  end

  def yea!
    'yea!'
  end
end


class C
  include M

  def fun
    not! + ' ' + yea!
  end
end
M.not!     # => 'not!'
M.yea!     # => 'yea!'
C.new.fun  # => 'not! yea!'

ฉีดสั้น ๆ เช่น:

ผลรวมของช่วง:

(1..10).inject(:+)
=> 55

คำเตือน: ไอเท็มนี้ได้รับการโหวต # 1 แฮ็คที่น่ากลัวที่สุดในปี 2008ดังนั้นควรใช้ด้วยความระมัดระวัง ที่จริงแล้วหลีกเลี่ยงมันเหมือนกับโรคระบาด แต่เป็นทับทิมซ่อนแน่นอนที่สุด

Superators เพิ่มตัวดำเนินการใหม่ไปยัง Ruby

เคยต้องการตัวดำเนินการจับมือลับสุดยอดสำหรับการดำเนินการที่ไม่ซ้ำกันในรหัสของคุณหรือไม่ ชอบเล่นรหัสกอล์ฟไหม? ลองใช้โอเปอเรเตอร์เช่น - ~ + ~ - หรือ <--- อันสุดท้ายถูกใช้ในตัวอย่างสำหรับการกลับคำสั่งของรายการ

ฉันไม่มีอะไรเกี่ยวข้องกับโครงการ Superatorsเกินกว่าจะชื่นชมมัน

ฉันไปงานปาร์ตี้สาย แต่:

คุณสามารถใช้อาร์เรย์ที่มีความยาวเท่ากันสองชุดได้อย่างง่ายดายและเปลี่ยนเป็นแฮชโดยมีหนึ่งอาร์เรย์ที่จัดหาคีย์และค่าอื่น ๆ :

a = [:x, :y, :z]
b = [123, 456, 789]

Hash[a.zip(b)]
# => { :x => 123, :y => 456, :z => 789 }

(ใช้งานได้เนื่องจาก Array # zip "zips" ค่าสูงสุดจากสองอาร์เรย์:

a.zip(b)  # => [[:x, 123], [:y, 456], [:z, 789]]

และ Hash [] สามารถรับอาร์เรย์ได้ ฉันเคยเห็นคนทำเช่นนี้:

Hash[*a.zip(b).flatten]  # unnecessary!

ซึ่งให้ผลเหมือนกัน แต่แผ่นสีและแบนไม่จำเป็นทั้งหมด - บางทีพวกเขาไม่ได้เป็นในอดีต?)

แฮชอัตโนมัติใน Ruby

def cnh # silly name "create nested hash"
  Hash.new {|h,k| h[k] = Hash.new(&h.default_proc)}
end
my_hash = cnh
my_hash[1][2][3] = 4
my_hash # => { 1 => { 2 => { 3 =>4 } } }

สิ่งนี้สามารถเป็นประโยชน์ได้

การทำลายอาร์เรย์

(a, b), c, d = [ [:a, :b ], :c, [:d1, :d2] ]

ที่ไหน:

a #=> :a
b #=> :b
c #=> :c
d #=> [:d1, :d2]

การใช้เทคนิคนี้เราสามารถใช้การมอบหมายอย่างง่าย ๆ เพื่อรับค่าที่แน่นอนที่เราต้องการจากอาร์เรย์ที่มีความลึกหลายระดับ

Class.new()

สร้างคลาสใหม่ ณ เวลาทำงาน อาร์กิวเมนต์สามารถเป็นคลาสที่ได้มาจากและบล็อกเป็นคลาสของร่างกาย คุณอาจต้องการดูconst_set/const_get/const_defined?การลงทะเบียนคลาสใหม่ของคุณอย่างถูกต้องเพื่อinspectพิมพ์ชื่อแทนหมายเลข

ไม่ใช่สิ่งที่คุณต้องการทุกวัน แต่มีประโยชน์เมื่อคุณทำ

สร้างอาร์เรย์ของตัวเลขที่ต่อเนื่องกัน:

x = [*0..5]

ตั้งค่า x เป็น [0, 1, 2, 3, 4, 5]

ความมหัศจรรย์มากมายที่คุณเห็นใน Rubyland เกี่ยวข้องกับ metaprogramming ซึ่งเป็นการเขียนโค้ดที่เขียนโค้ดให้คุณ Ruby's attr_accessor,, attr_readerและattr_writermetaprogramming ทั้งหมดนั้นพวกเขาสร้างสองวิธีในหนึ่งบรรทัดตามรูปแบบมาตรฐาน Rails ใช้เมตาโพรไฟล์โปรแกรมจำนวนมากด้วยวิธีการจัดการความสัมพันธ์เช่นhas_oneและbelongs_toและ

แต่มันค่อนข้างง่ายที่จะสร้างเทคนิคการ metaprogramming ของคุณเองโดยใช้class_evalเพื่อรันโค้ดที่เขียนขึ้นแบบไดนามิก

ตัวอย่างต่อไปนี้อนุญาตให้วัตถุ wrapper ส่งต่อวิธีการบางอย่างพร้อมกับวัตถุภายใน:

class Wrapper
  attr_accessor :internal

  def self.forwards(*methods)
    methods.each do |method|
      define_method method do |*arguments, &block|
        internal.send method, *arguments, &block
      end
    end
  end

  forwards :to_i, :length, :split
end

w = Wrapper.new
w.internal = "12 13 14"
w.to_i        # => 12
w.length      # => 8
w.split('1')  # => ["", "2 ", "3 ", "4"]

วิธีการWrapper.forwardsใช้สัญลักษณ์สำหรับชื่อของวิธีการและเก็บไว้ในmethodsอาร์เรย์ จากนั้นสำหรับแต่ละคนเราได้รับdefine_methodเพื่อสร้างวิธีการใหม่ที่มีหน้าที่ส่งข้อความรวมถึงอาร์กิวเมนต์และบล็อกทั้งหมด

แหล่งข้อมูลที่ดีสำหรับปัญหา metaprogramming คือทำไมโชคดีแข็งของ "เห็น metaprogramming เห็นได้ชัด"

ใช้อะไรก็ได้ที่ตอบสนองต่อการ===(obj)เปรียบเทียบกรณีและปัญหา:

case foo
when /baz/
  do_something_with_the_string_matching_baz
when 12..15
  do_something_with_the_integer_between_12_and_15
when lambda { |x| x % 5 == 0 }
  # only works in Ruby 1.9 or if you alias Proc#call as Proc#===
  do_something_with_the_integer_that_is_a_multiple_of_5
when Bar
  do_something_with_the_instance_of_Bar
when some_object
  do_something_with_the_thing_that_matches_some_object
end

Module(และClass) Regexp, Dateและชั้นเรียนอื่น ๆ อีกมากมายกำหนดวิธีการเช่นนี้: === (อื่น ๆ ) และทั้งหมดสามารถนำมาใช้

ขอบคุณFarrelสำหรับคำเตือนProc#callว่ามีนามแฝงเหมือนProc#===ใน Ruby 1.9

ไบนารี "ruby" (อย่างน้อย MRI) สนับสนุนสวิตช์จำนวนมากที่ทำให้ Perl หนึ่ง liners ได้รับความนิยมมาก

คนสำคัญ:

• -n ตั้งค่าวงนอกด้วยเพียงแค่ "รับ" - ซึ่งทำงานได้อย่างน่าอัศจรรย์กับชื่อไฟล์ที่กำหนดหรือ STDIN การตั้งค่าแต่ละบรรทัดอ่านใน $ _
• -p คล้ายกับ -n แต่มีputs อัตโนมัติที่ตอนท้ายของการวนซ้ำแต่ละรอบ
• - เรียกอัตโนมัติเพื่อ. แยกในแต่ละบรรทัดอินพุตเก็บไว้ใน $ F
• -i ในสถานที่แก้ไขไฟล์อินพุต
• -l อัตโนมัติโทรไปยัง. chomp ที่อินพุต
• - ดำเนินการชิ้นส่วนของรหัส
• -c ตรวจสอบซอร์สโค้ด
• -w ด้วยคำเตือน

ตัวอย่างบางส่วน:

# Print each line with its number:
ruby -ne 'print($., ": ", $_)' < /etc/irbrc

# Print each line reversed:
ruby -lne 'puts $_.reverse' < /etc/irbrc

# Print the second column from an input CSV (dumb - no balanced quote support etc):
ruby -F, -ane 'puts $F[1]' < /etc/irbrc

# Print lines that contain "eat"
ruby -ne 'puts $_ if /eat/i' < /etc/irbrc

# Same as above:
ruby -pe 'next unless /eat/i' < /etc/irbrc

# Pass-through (like cat, but with possible line-end munging):
ruby -p -e '' < /etc/irbrc

# Uppercase all input:
ruby -p -e '$_.upcase!' < /etc/irbrc

# Same as above, but actually write to the input file, and make a backup first with extension .bak - Notice that inplace edit REQUIRES input files, not an input STDIN:
ruby -i.bak -p -e '$_.upcase!' /etc/irbrc

อย่าลังเลที่จะ google "ruby one-liners" และ "perl one-liners" สำหรับตัวอย่างที่ใช้งานได้จริงและใช้งานได้จริง มันช่วยให้คุณสามารถใช้ทับทิมเป็นสิ่งทดแทนที่ทรงพลังพอสมควร

วิธีการส่ง ()เป็นวิธีการทั่วไปที่สามารถใช้กับ Class หรือ Object ใดก็ได้ใน Ruby หากไม่แทนที่จะส่ง () ยอมรับสตริงและเรียกชื่อของเมธอดที่ส่งผ่านสตริง ตัวอย่างเช่นหากผู้ใช้คลิกปุ่ม“ Clr” สตริง 'press_clear' จะถูกส่งไปที่เมธอด send () และเมธอด 'press_clear' จะถูกเรียก เมธอด send () ช่วยให้สามารถเรียกใช้ฟังก์ชันใน Ruby ได้อย่างสนุกสนานและมีชีวิตชีวา

 %w(7 8 9 / 4 5 6 * 1 2 3 - 0 Clr = +).each do |btn|
    button btn, :width => 46, :height => 46 do
      method = case btn
        when /[0-9]/: 'press_'+btn
        when 'Clr': 'press_clear'
        when '=': 'press_equals'
        when '+': 'press_add'
        when '-': 'press_sub'
        when '*': 'press_times'
        when '/': 'press_div'
      end

      number.send(method)
      number_field.replace strong(number)
    end
  end

ฉันพูดคุยเกี่ยวกับคุณสมบัตินี้ในบล็อกของรองเท้า: แอปพลิเคชัน Simple-Calc

หลอกคลาสหรือโมดูลที่บอกว่าต้องการบางสิ่งที่ไม่จำเป็นต้องใช้:

$" << "something"

สิ่งนี้มีประโยชน์เช่นเมื่อต้องการ A ที่ผลัดกันต้องใช้ B แต่เราไม่ต้องการ B ในรหัสของเรา (และ A จะไม่ใช้ B ผ่านรหัสของเรา):

ตัวอย่างเช่น Backgroundrb's bdrb_test_helper requires 'test/spec'แต่คุณไม่ได้ใช้เลยในรหัสของคุณ:

$" << "test/spec"
require File.join(File.dirname(__FILE__) + "/../bdrb_test_helper")

Fixnum#to_s(base)อาจมีประโยชน์จริงๆในบางกรณี หนึ่งกรณีดังกล่าวกำลังสร้างโทเค็นที่ไม่ซ้ำกัน (หลอก) โดยการแปลงหมายเลขสุ่มเป็นสตริงโดยใช้ฐาน 36

เหรียญที่มีความยาว 8:

rand(36**8).to_s(36) => "fmhpjfao"
rand(36**8).to_s(36) => "gcer9ecu"
rand(36**8).to_s(36) => "krpm0h9r"

เหรียญที่มีความยาว 6:

rand(36**6).to_s(36) => "bvhl8d"
rand(36**6).to_s(36) => "lb7tis"
rand(36**6).to_s(36) => "ibwgeh"

การกำหนดวิธีการที่ยอมรับพารามิเตอร์จำนวนเท่าใดก็ได้และละทิ้งพวกเขาทั้งหมด

def hello(*)
    super
    puts "hello!"
end

helloวิธีการข้างต้นจำเป็นต้องputs "hello"อยู่บนหน้าจอและการโทรsuperเท่านั้น - แต่เนื่องจากซูเปอร์คลาสhelloกำหนดพารามิเตอร์มันก็ต้องมีเช่นกัน - อย่างไรก็ตามเนื่องจากมันไม่จำเป็นต้องใช้พารามิเตอร์เอง - มันไม่จำเป็นต้องตั้งชื่อให้กับพวกเขา