it-swarm.cn

Ruby的隐藏功能

继续“隐藏的......的特征”模因,让我们分享Ruby编程语言鲜为人知但有用的功能。

尝试用核心Ruby限制这个讨论,没有任何Ruby on Rails的东西。

也可以看看:

(请,每个答案只有one隐藏功能。)

谢谢

160
squadette

从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
80
Farrel

彼得库珀有一个 好的列表 Ruby技巧。也许我最喜欢的是允许枚举单个项目和集合。 (也就是说,将非集合对象视为仅包含该对象的集合。)它看起来像这样:

[*items].each do |item|
  # ...
end
76
James A. Rosen

不知道这是多么隐蔽,但我发现当需要从一维数组中创建哈希时它很有用:

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

Hash[*fruit]    
=> {"Apple"=>"red", "banana"=>"yellow"}
64
astronautism

我喜欢的一个技巧是在阵列以外的对象上使用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
54
tomafro

哇,没人提到触发器操作员:

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

关于Ruby的一个很酷的事情是你可以调用方法并在其他语言不喜欢的地方运行代码,例如在方法或类定义中。

例如,要创建一个具有未知超类的类,直到运行时,即是随机的,您可以执行以下操作:

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中,参见Array#choice),这个例子非常人为,但你可以看到这里的强大功能。

另一个很酷的例子是能够放置非固定的默认参数值(就像其他语言经常要求的那样):

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

当然,第一个例子的问题是它在定义时而不是通话时间进行评估。因此,一旦选择了超类,它就会保留该程序其余部分的超类。

但是,在第二个示例中,每次调用do_something_at时,at变量将是调用该方法的时间(嗯,非常非常接近它)

49
Bo Jeanes

另一个小功能 - 将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
47
tomafro

具有默认值的哈希值!在这种情况下的数组。

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

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

在元编程中非常有用。

40
August Lilleaas

下载Ruby 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以获取更多隐藏的东西。

39
manveru

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
38
Farrel

非布尔值的布尔运算符。

&&||

两者都返回最后一个表达式的值。

这就是为什么如果变量未定义,||=将使用右侧返回值的表达式更新变量。这没有明确记录,但是常识。

然而&&=并不是那么广为人知。

string &&= string + "suffix"

相当于

if string
  string = string + "suffix"
end

如果变量未定义,那么破坏性操作非常方便。

35
EmFi

Rails提供的Symbol#to_proc函数非常酷。

代替

Employee.collect { |emp| emp.name }

你可以写:

Employee.collect(&:name)
29
hoyhoy

最后一个 - 在Ruby中,您可以使用任何想要分隔字符串的字符。请使用以下代码:

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'
}
28
tomafro

我发现使用 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个特别包含相同代码的方法,define method命令用于根据需要动态生成这些方法。

26
CodingWithoutComments

使用Range对象作为无限延迟列表:

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/

26
horseyguy

module_function

声明为 module_function 的模块方法将在包含模块的类中创建自身的副本为 private instance方法:

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

短注射,如下:

范围总和:

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

警告:这个项目被选为#12008年最可怕的黑客,所以请谨慎使用。实际上,避免它像瘟疫一样,但它肯定是隐藏的红宝石。

Superators向Ruby添加新的运算符

有没有想要一个超级秘密握手操作符来代码中的一些独特操作?喜欢打码高尔夫?尝试像 - 〜+〜 - 或<---这样的运算符,在示例中使用最后一个来反转项目的顺序。

我与 Superators项目无关 超越欣赏它。

21
Captain Hammer

我迟到了,但是:

您可以轻松地将两个等长数组转换为哈希,其中一个数组提供键,另一个数组提供值:

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

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

(这是有效的,因为Array#Zip“拉开”来自两个数组的值:

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

而Hash []可以采用这样的数组。我见过人们这样做:

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

这产生了相同的结果,但是完全不需要splat和flatten - 也许它们不是在过去?)

19
Jordan Running

在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 } } }

这可能太方便了。

19
Trevoke

解构数组

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

哪里:

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

使用这种技术,我们可以使用简单的赋值从任何深度的嵌套数组中获取我们想要的精确值。

16
horseyguy

Class.new()

在运行时创建一个新类。参数可以是派生的类,块是类体。您可能还需要查看const_set/const_get/const_defined?以正确注册新类,以便inspect输出名称而不是数字。

不是你每天都需要的东西,但是当你这样做时非常方便。

15
Justin Love

创建一个连续数字的数组:

x = [*0..5]

将x设置为[0,1,2,3,4,5]

13
horseyguy

您在Rubyland中看到的许多魔力与元编程有关,元编程只是编写为您编写代码的代码。 Ruby的attr_accessorattr_readerattr_writer都是简单的元编程,因为它们按照标准模式在一行中创建两个方法。 Rails使用他们的关系管理方法(如has_onebelongs_to)进行了大量的元编程。

但是使用class_eval创建自己的元编程技巧来执行动态编写的代码非常简单。

以下示例允许包装器对象将某些方法转发到内部对象:

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来创建一个新方法,该方法的作用是发送消息,包括所有参数和块。

元编程问题的一个重要资源是 为什么Lucky Stiff的“明确地看到元编程”

13
TALlama

使用任何响应===(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),RegexpDate和许多其他类定义了一个实例方法:===(其他),并且都可以使用。

感谢 Farrel 提醒Proc#call在Ruby 1.9中被别名为Proc#===

12
James A. Rosen

“Ruby”二进制文件(至少是MRI)支持许多使Perl单行程很受欢迎的开关。

重要的:

  • -n设置一个只有“gets”的外部循环 - 它与给定的文件名或STDIN神奇地一起工作,在$ _中设置每个读取行
  • -p与-n类似,但在每次循环迭代结束时使用自动puts
  • -a在每个输入行上自动调用.split,存储在$ F中
  • -i就地编辑输入文件
  • -l在输入上自动调用.chomp
  • -e执行一段代码
  • -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

随意谷歌“Ruby one-liners”和“Perl one-liners”获取更多可用和实用的例子。它本质上允许您使用Ruby作为awk和sed的相当强大的替代品。

11
minaguib

send() 方法是一种通用方法,可以在Ruby中的任何类或对象上使用。如果没有重写,send()接受一个字符串并调用传递其字符串的方法的名称。例如,如果用户单击“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

我在 Bloging Shoes:Simple-Calc应用程序中详细介绍了这个功能

10
CodingWithoutComments
private unless Rails.env == 'test'
# e.g. a bundle of methods you want to test directly

看起来很酷和(在某些情况下)Ruby的好/有用的黑客/功能。

9
Szymon Jeż

在某些情况下,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"
9
sickill

愚弄一些类或模块告诉它需要一些它真正不需要的东西:

$" << "something"

这很有用,例如当需要A反过来需要B但我们的代码中不需要B(并且A不会通过我们的代码使用它):

例如,Backgroundrb的bdrb_test_helper requires'test/spec',但你根本不使用它,所以在你的代码中:

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

定义一个接受任意数量参数的方法,只丢弃它们

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

上面的hello方法只需要puts"hello"在屏幕上并调用super - 但由于超类hello定义了它必须的参数 - 但是因为它实际上不需要使用参数本身 - 所以它不必给出他们的名字。

9
horseyguy

要将多个正则表达式与|组合,您可以使用

Regexp.union /Ruby\d/, /test/i, "cheat"

创建一个类似于的Regexp:

/(Ruby\d|[tT][eE][sS][tT]|cheat)/
8
J-_-L

我觉得这在一些脚本中很有用。它可以直接使用环境变量,例如Shell脚本和Makefile。环境变量用作未定义的Ruby常量的后备。

>> class <<Object
>>  alias :old_const_missing :const_missing
>>  def const_missing(sym)
>>   ENV[sym.to_s] || old_const_missing(sym)
>>  end
>> end
=> nil

>> puts Shell
/bin/zsh
=> nil
>> TERM == 'xterm'
=> true
8
Ropez

如何基于ARGV [0]打开文件?

readfile.rb:

$<.each_line{|l| puts l}

Ruby readfile.rb testfile.txt

这是编写一次性脚本的一个很好的捷径。大多数人都不知道有大量预先定义的变量。明智地使用它们(阅读:不要乱丢你打算用它们维护的代码库,它可能会变得混乱)。

8
Scott Holden

我是粉丝:

%w{An Array of strings} #=> ["An", "Array", "of", "Strings"]

这有点太有趣了。

5
Judson

多个返回值

def getCostAndMpg
    cost = 30000  # some fancy db calls go here
    mpg = 30
    return cost,mpg
end
AltimaCost, AltimaMpg = getCostAndMpg
puts "AltimaCost = #{AltimaCost}, AltimaMpg = #{AltimaMpg}"

并行分配

i = 0
j = 1
puts "i = #{i}, j=#{j}"
i,j = j,i
puts "i = #{i}, j=#{j}"

虚拟属性

class Employee < Person
  def initialize(fname, lname, position)
    super(fname,lname)
    @position = position
  end
  def to_s
     super + ", #@position"
  end
  attr_writer :position
  def etype
     if @position == "CEO" || @position == "CFO"
         "executive"
     else
         "staff"
     end
  end
end
employee = Employee.new("Augustus","Bondi","CFO")
employee.position = "CEO"
puts employee.etype    =>  executive
employee.position = "Engineer"
puts employee.etype    =>  staff

method_missing - 一个很棒的主意

(在大多数语言中,当找不到方法并且抛出错误并且程序停止时。在Ruby中你实际上可以捕获这些错误并且可能根据情况做一些聪明的事情)

class MathWiz
  def add(a,b) 
    return a+b
  end
  def method_missing(name, *args)
    puts "I don't know the method #{name}"
  end
end
mathwiz = MathWiz.new
puts mathwiz.add(1,4)
puts mathwiz.subtract(4,2)

我不知道减法的方法

5
Ramiz Uddin

James A. Rosen的提示很酷([* items] .each),但我发现它会破坏哈希:

irb(main):001:0> h = {:name => "Bob"}
=> {:name=>"Bob"}
irb(main):002:0> [*h]
=> [[:name, "Bob"]]

当我接受要处理的事物列表但我很宽松并允许调用者提供一个时,我更喜欢这种处理案例的方式:

irb(main):003:0> h = {:name => "Bob"}
=> {:name=>"Bob"}
irb(main):004:0> [h].flatten
=> [{:name=>"Bob"}]

这可以很好地结合方法签名:

def process(*entries)
  [entries].flatten.each do |e|
    # do something with e
  end
end
4
minaguib

我只是内联关键字 救援 像这样:
编辑示例:

@user #=> nil (but I did't know)
@user.name rescue "Unknown"
link_to( d.user.name, url_user( d.user.id, d.user.name)) rescue 'Account removed'

这可以避免破坏我的应用程序并且比Rails .try()中发布的功能更好 /

4
Fabiano Soriani

调用继承链中任何位置定义的方法,即使被覆盖也是如此

ActiveSupport的对象有时会伪装成内置对象。

要求'active_support'
天= 5.days 
 days.class#=> Fixnum 
 days.is_a?(Fixnum)#=> true [._____ 。] Fixnum === days#=> false(嗯?你到底是什么?)[。_____。] Object.instance_method(:class).bind(days).call#=> ActiveSupport :: Duration(aha!) 
 ActiveSupport :: Duration === days#=> true 

当然,上面的内容依赖于active_support不会重新定义Object#instance_method这一事实,在这种情况下我们真的会成为一条小溪。然后,我们总是可以在加载任何第三方库之前保存Object.instance_method(:class)的返回值。

Object.instance_method(...)返回一个UnboundMethod,然后您可以将其绑定到该类的实例。在这种情况下,您可以将它绑定到Object的任何实例(包括的子类)。

如果对象的类包含模块,您还可以使用这些模块中的UnboundMethod。

模块Mod 
 def var_add(更多); @ VAR +以上;结束
结束
类Cla 
包括Mod 
 def initialize(var); @ VAR = VAR;结束
#覆盖
 def var_add(更多); @ VAR +更多+多;结束
结束
 cla = Cla.new('abcdef')[。_____。] cla.var_add('ghi')#=>“abcdefghighi”
 Mod.instance_method( :var_add).bind(cla).call('ghi')#=>“abcdefghi”

这甚至适用于覆盖对象所属类的实例方法的单例方法。

类Foo 
 def mymethod; '原版的';结束
结束
 foo = Foo.new 
 foo.mymethod#=>'original'
 def foo.mymethod; “单”;结束
 foo.mymethod#=>'singleton'
 Foo.instance_method(:mymethod).bind(foo).call#=>'original'
 
 #你也可以在单例类上调用#instance方法:[。_____。] class << foo;自; end.instance_method(:mymethod).bind(foo).call#=>'singleton'
4
Kelvin

人们应该知道符号文字的某些方面。通过特殊符号文字解决的一种情况是,当您需要创建一个符号时,其名称会因某种原因导致语法错误,并使用正常的符号文字语法:

:'class'

您也可以进行符号插值。在访问者的上下文中,例如:

define_method :"#{name}=" do |value|
  instance_variable_set :"@#{name}", value
end
3
Tom

each_with_index 任何可以对象的对象(数组,哈希等)的方法也许?

myarray = ["la", "li", "lu"]
myarray.each_with_index{|v,idx| puts "#{idx} -> #{v}"}

#result:
#0 -> la
#1 -> li
#2 -> lu

也许它比其他答案更为人所知,但并非所有Ruby程序员都知道:)

3
mhd
class A

  private

  def my_private_method
    puts 'private method called'
  end
end

a = A.new
a.my_private_method # Raises exception saying private method was called
a.send :my_private_method # Calls my_private_method and prints private method called'
2
Chirantan

Ruby有一个 call/cc 机制,允许一个人在堆栈中自由跳跃。

简单的例子如下。这当然不是人们如何在Ruby中乘以序列,但它演示了如何使用call/cc来达到堆栈以使算法短路。在这种情况下,我们递归地乘以一个数字列表,直到我们看到每个数字或我们看到零(我们知道答案的两个情况)。在零的情况下,我们可以在列表中任意深入并终止。

#!/usr/bin/env Ruby

def rprod(k, rv, current, *nums)
  puts "#{rv} * #{current}"
  k.call(0) if current == 0 || rv == 0
  nums.empty? ? (rv * current) : rprod(k, rv * current, *nums)
end

def prod(first, *rest)
  callcc { |k| rprod(k, first, *rest) }
end

puts "Seq 1:  #{prod(1, 2, 3, 4, 5, 6)}"
puts ""
puts "Seq 2:  #{prod(1, 2, 0, 3, 4, 5, 6)}"

你可以在这里看到输出:

http://codepad.org/Oh8ddh9e

对于一个更复杂的例子,其中连续性在堆栈上移动另一个方向,请将源读取到 Generator

2
Dustin

我只是阅读了所有的答案...一个值得注意的遗漏是解构分配:

> (a,b),c = [[1,2],3]
=> [[1,2],3]
> a
=> 1

它也适用于块参数。当你有嵌套数组时,这很有用,每个数组都代表一些不同的东西。您可以在一行代码中打破嵌套数组并为每个元素提供描述性名称,而不是像“array [0] [1]”那样编写代码。

2
Alex D
@user #=> nil (but I did't know)
@user.name rescue "Unknown"
2
haoqi

Sprintf快捷方式

我最喜欢的Ruby功能。语法是format_string % argument

"%04d"  % 1         # => "0001"
"%0.2f" % Math::PI  # => "3.14"

适用于数组(format_string % array_of_arguments

"%.2f %.3f %.4f" % ([Math::PI]*3) 
# => "3.14 3.142 3.1416"
1
iblue