Tiếp tục meme "Các tính năng ẩn của ...", hãy chia sẻ các tính năng ít được biết đến nhưng hữu ích của ngôn ngữ lập trình Ruby.

Cố gắng hạn chế cuộc thảo luận này với Ruby cốt lõi, không có bất kỳ nội dung nào của Ruby on Rails.

Xem thêm:

• Các tính năng ẩn của C #
• Các tính năng ẩn của Java
• Các tính năng ẩn của JavaScript
• Các tính năng ẩn của Ruby on Rails
• Các tính năng ẩn của Python

(Xin vui lòng, chỉ một tính năng ẩn cho mỗi câu trả lời.)

Cảm ơn bạn

Từ Ruby 1.9 Proc # === là bí danh cho cuộc gọi Proc #, có nghĩa là các đối tượng Proc có thể được sử dụng trong các câu lệnh tình huống như vậy:

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 có một danh sách tốt các thủ thuật Ruby. Có lẽ yêu thích của anh ấy là cho phép liệt kê cả các mục đơn và bộ sưu tập. (Nghĩa là, coi một đối tượng không phải là bộ sưu tập là một bộ sưu tập chỉ chứa đối tượng đó.) Nó trông như thế này:

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

Không biết nó ẩn như thế nào, nhưng tôi thấy nó hữu ích khi cần tạo Hash từ mảng một chiều:

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

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

Một mẹo tôi thích là sử dụng bộ *mở rộng splat ( ) trên các đối tượng khác ngoài Mảng. Đây là một ví dụ về kết hợp biểu thức chính quy:

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

Các ví dụ khác bao gồm:

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

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

Wow, không ai đề cập đến toán tử flip flop:

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

Một trong những điều thú vị về ruby ​​là bạn có thể gọi các phương thức và chạy mã ở những nơi mà các ngôn ngữ khác sẽ nhăn mặt, chẳng hạn như trong các định nghĩa phương thức hoặc lớp.

Ví dụ, để tạo một lớp có siêu lớp chưa biết cho đến khi chạy, tức là ngẫu nhiên, bạn có thể làm như sau:

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

end

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

Điều này sử dụng Array#samplephương thức 1.9 (chỉ trong 1.8.7, xem Array#choice) và ví dụ này khá giả tạo nhưng bạn có thể thấy sức mạnh ở đây.

Một ví dụ thú vị khác là khả năng đặt các giá trị tham số mặc định không cố định (như các ngôn ngữ khác thường yêu cầu):

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

Tất nhiên vấn đề với ví dụ đầu tiên là nó được đánh giá ở thời gian xác định, không phải thời gian gọi. Vì vậy, một khi siêu lớp đã được chọn, nó sẽ giữ nguyên siêu lớp đó trong phần còn lại của chương trình.

Tuy nhiên, trong ví dụ thứ hai, mỗi lần bạn gọi do_something_at, atbiến sẽ là thời gian mà phương thức được gọi (tốt, rất gần với nó)

Một tính năng nhỏ khác - chuyển đổi a Fixnumthành bất kỳ cơ sở nào lên tới 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"

Và như Huw Walters đã nhận xét, chuyển đổi theo cách khác cũng đơn giản như sau:

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

Băm với giá trị mặc định! Một mảng trong trường hợp này.

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

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

Rất hữu ích trong siêu lập trình.

Tải xuống nguồn Ruby 1.9 và phát hành make golf, sau đó bạn có thể thực hiện những việc như sau:

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"

Đọc golf_prelude.cđể biết những điều gọn gàng hơn ẩn đi.

Một bổ sung thú vị khác trong chức năng 1.9 Proc là Proc # curry cho phép bạn biến Proc chấp nhận n đối số thành một chấp nhận n-1. Ở đây, nó được kết hợp với mẹo Proc # === tôi đã đề cập ở trên:

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

Toán tử Boolean trên các giá trị không boolean.

&& và ||

Cả hai trả về giá trị của biểu thức cuối cùng được đánh giá.

Đó là lý do tại sao ||=sẽ cập nhật biến với biểu thức trả về giá trị ở phía bên phải nếu biến không được xác định. Đây không phải là tài liệu rõ ràng, nhưng kiến ​​thức phổ biến.

Tuy nhiên, điều &&=này không được biết đến rộng rãi.

string &&= string + "suffix"

tương đương với

if string
  string = string + "suffix"
end

Nó rất thuận tiện cho các hoạt động phá hoại không nên tiến hành nếu biến không được xác định.

Hàm Symbol # to_proc mà Rails cung cấp thực sự rất tuyệt.

Thay vì

Employee.collect { |emp| emp.name }

Bạn có thể viết:

Employee.collect(&:name)

Một cái cuối cùng - trong ruby, bạn có thể sử dụng bất kỳ ký tự nào bạn muốn phân định chuỗi. Lấy mã sau:

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

Nếu bạn không muốn thoát dấu ngoặc kép trong chuỗi, bạn chỉ cần sử dụng một dấu phân cách khác:

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

Ngoài việc tránh phải thoát các dấu phân cách, bạn có thể sử dụng các dấu phân cách này cho các chuỗi đa dòng đẹp hơn:

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

Tôi thấy việc sử dụng lệnh notify_method để tự động tạo ra các phương thức khá thú vị và không được biết đến nhiều. Ví dụ:

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

Đoạn mã trên sử dụng lệnh 'notify_method' để tự động tạo các phương thức "nhấn1" đến "nhấn9". Thay vào đó, sau đó gõ tất cả 10 phương thức mà thực chất chứa cùng một mã, lệnh phương thức xác định được sử dụng để tạo các phương thức này một cách nhanh chóng khi cần thiết.

Sử dụng một đối tượng Phạm vi như một danh sách lười biếng vô hạn:

Inf = 1.0 / 0

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

Thêm thông tin tại đây: http://banisterfiend.wordpress.com/2009/10/02/wtf-infinite-ranges-in-ruby/

mô-đun

Các phương thức mô-đun được khai báo là module_function sẽ tạo các bản sao của chính chúng như các phương thức cá thể riêng trong lớp bao gồm Mô-đun:

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>

Nếu bạn sử dụng module_function mà không có bất kỳ đối số nào, thì bất kỳ phương thức mô-đun nào xuất hiện sau câu lệnh module_feft sẽ tự động trở thành module_fifts.

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!'

Tiêm ngắn, như vậy:

Tổng phạm vi:

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

Cảnh báo: mục này đã được bình chọn là # Hack khủng khiếp nhất năm 2008 , vì vậy hãy cẩn thận khi sử dụng. Trên thực tế, tránh nó như bệnh dịch, nhưng nó chắc chắn là Hidden Ruby.

Superators Thêm toán tử mới vào Ruby

Bạn đã bao giờ muốn một toán tử bắt tay siêu bí mật cho một số hoạt động độc đáo trong mã của bạn chưa? Thích chơi golf mã? Hãy thử các toán tử như - ~ + ~ - hoặc <--- Cái cuối cùng được sử dụng trong các ví dụ để đảo ngược thứ tự của một mặt hàng.

Tôi không có gì để làm với Dự án Superators ngoài việc ngưỡng mộ nó.

Tôi đến bữa tiệc muộn, nhưng:

Bạn có thể dễ dàng lấy hai mảng có độ dài bằng nhau và biến chúng thành một hàm băm với một mảng cung cấp các khóa và các giá trị khác:

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

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

(Điều này hoạt động vì Array # zip "nén" các giá trị từ hai mảng:

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

Và Hash [] có thể chỉ cần một mảng như vậy. Tôi đã thấy mọi người cũng làm điều này:

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

Điều này mang lại kết quả tương tự, nhưng splat và flatten hoàn toàn không cần thiết - có lẽ chúng không có trong quá khứ?)

Băm tự động sinh động trong 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 } } }

Điều này chỉ có thể là tiện dụng chết tiệt.

Phá hủy một mảng

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

Ở đâu:

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

Sử dụng kỹ thuật này, chúng ta có thể sử dụng phép gán đơn giản để có được các giá trị chính xác mà chúng ta muốn từ mảng lồng nhau ở bất kỳ độ sâu nào.

Class.new()

Tạo một lớp mới trong thời gian chạy. Đối số có thể là một lớp để xuất phát và khối là phần thân của lớp. Bạn cũng có thể muốn xem xét const_set/const_get/const_defined?để đăng ký lớp mới của mình đúng cách, đểinspect in ra một tên thay vì một số.

Không phải thứ bạn cần mỗi ngày, nhưng khá tiện dụng khi bạn làm.

tạo một dãy các số liên tiếp:

x = [*0..5]

đặt x thành [0, 1, 2, 3, 4, 5]

Rất nhiều phép thuật bạn thấy trong Rubyland có liên quan đến siêu lập trình, đơn giản là viết mã viết mã cho bạn. Ruby attr_accessor, attr_readervà attr_writerđều là những lập trình meta đơn giản, ở chỗ chúng tạo ra hai phương pháp trong một dòng, sau một mô hình chuẩn. Rails thực hiện rất nhiều chương trình siêu dữ liệu với các phương thức quản lý mối quan hệ của họ như has_onevà belongs_to.

Nhưng thật đơn giản để tạo các thủ thuật siêu lập trình của riêng bạn bằng cách sử dụng class_evalđể thực thi mã được viết động.

Ví dụ sau đây cho phép một đối tượng trình bao bọc chuyển tiếp các phương thức nhất định cùng với một đối tượng bên trong:

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

Phương thức Wrapper.forwardslấy các ký hiệu cho tên của các phương thức và lưu trữ chúng trong methodsmảng. Sau đó, đối với mỗi người được đưa ra, chúng tôi sử dụngdefine_method để tạo một phương thức mới có nhiệm vụ gửi tin nhắn theo, bao gồm tất cả các đối số và khối.

Một nguồn tài nguyên tuyệt vời cho các vấn đề lập trình siêu dữ liệu là Tại sao "Nhìn thấy siêu lập trình rõ ràng" của Lucky Stiff .

sử dụng bất cứ điều gì đáp ứng ===(obj)cho các so sánh trường hợp:

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(và do đó Class) Regexp,Date , và nhiều lớp khác xác định một phương pháp dụ: === (khác), và tất cả có thể được sử dụng.

Cảm ơn Farrel vì lời nhắc nhở về Proc#callbí danh như Proc#===trong Ruby 1.9.

Nhị phân "ruby" (ít nhất là MRI) hỗ trợ rất nhiều công tắc làm cho perl one-liners trở nên khá phổ biến.

Những người quan trọng:

• -n Thiết lập một vòng lặp bên ngoài chỉ bằng "got" - hoạt động kỳ diệu với tên tệp hoặc STDIN đã cho, đặt từng dòng đọc thành $ _
• -p Tương tự như -n nhưng với một puts tự động ở cuối mỗi lần lặp
• -a Tự động gọi đến .split trên mỗi dòng đầu vào, được lưu trữ trong $ F
• -i Chỉnh sửa tập tin đầu vào tại chỗ
• -l Tự động gọi đến .chomp trên đầu vào
• -e Thực thi một đoạn mã
• -c Kiểm tra mã nguồn
• -w Với cảnh báo

Vài ví dụ:

# 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

Vui lòng google "ruby one-liners" và "perl one-liners" để biết thêm nhiều ví dụ thực tế và hữu dụng. Về cơ bản, nó cho phép bạn sử dụng ruby ​​như một sự thay thế khá mạnh mẽ cho awk và sed.

Phương thức send () là một phương thức có mục đích chung có thể được sử dụng trên bất kỳ Class hoặc Object nào trong Ruby. Nếu không bị ghi đè, send () chấp nhận một chuỗi và gọi tên của phương thức có chuỗi được truyền. Ví dụ: nếu người dùng nhấp vào nút Cl Cl Cl, thì chuỗi 'press_clear' sẽ được gửi đến phương thức send () và phương thức 'press_clear' sẽ được gọi. Phương thức send () cho phép một cách thú vị và năng động để gọi các hàm trong 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

Tôi nói thêm về tính năng này trong Blog blog: Ứng dụng Simple-Calc

Đánh lừa một số lớp hoặc mô-đun nói rằng nó đã yêu cầu một cái gì đó mà nó thực sự không yêu cầu:

$" << "something"

Ví dụ, điều này hữu ích khi yêu cầu A mà lần lượt yêu cầu B nhưng chúng tôi không cần B trong mã của chúng tôi (và A sẽ không sử dụng nó thông qua mã của chúng tôi):

Ví dụ: Backgroundrb's bdrb_test_helper requires 'test/spec', nhưng bạn hoàn toàn không sử dụng nó, vì vậy trong mã của bạn:

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

Fixnum#to_s(base)có thể thực sự hữu ích trong một số trường hợp. Một trường hợp như vậy là tạo ra các mã thông báo duy nhất ngẫu nhiên (giả) bằng cách chuyển đổi số ngẫu nhiên thành chuỗi bằng cơ sở 36.

Mã thông báo có độ dài 8:

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

Mã thông báo có độ dài 6:

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

Xác định một phương thức chấp nhận bất kỳ số lượng tham số nào và chỉ cần loại bỏ tất cả chúng

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

helloPhương thức trên chỉ cần puts "hello"trên màn hình và gọi super- nhưng vì siêu lớp helloxác định các tham số nên nó cũng phải - tuy nhiên vì nó không thực sự cần sử dụng chính các tham số - nên nó không phải đặt tên cho chúng.