以 Array 的 Initialize 为例，难道这样？

def param_pattern_match(pattern, params)
  return false if pattern.size != params.size
  match = true
  pattern.zip(params) do|type, param|
    unless type === param
      match = false
      break
    end
  end
  match
end
class Array
  def initialize(*variants)
    case
    when param_pattern_match([], variants)
      '[size=0, default=nil]'
    when param_pattern_match([Integer],variants)
      '[size, default=nil]'
    when param_pattern_match([Integer,Integer], variants)
      '[size, default]'
    when param_pattern_match([Array],variants)
      '[array]'
    else
      'no match'
    end
  end
end

搞不懂为什么这个例子要判断元素的类型，跟 Array 的 initialize 有什么关系？给个更有实际意义的例子吧。。。

写成多个方法，不然就要写更多的文档解释这个方法的用法。

是这样的，我学习 ruby 知道 ruby 不需要函数重载，但是在 ruby 里一个函数有多种参数列表比比皆是。我用 Arrary 的 new 函数只是举个例子，它不是可以有几种参数调用形式吗，Array.new(size=0,default=nil) Array.new(array) Array.new(size) {|index| block }, 我的 foo 函数就是照着这个写的，不是针对这个函数。我想既然标准库里都这样，应该是一种风格吧，难道 ruby 里不鼓励这样，一个函数最好就一种参数列表。

哦 好的

额。你把多个不同意义的参数封在了一个数组里，这个例子才会这么麻烦。如果是foo(arr: nil, size: nil, default: nil)就清晰多了，内部的判断也就变成了if arr。如果内部逻辑麻烦的话，我一般会拆成几个方法，再由 foo 提供统一接口 (如果需要有统一接口的话)

放屁脱裤子。。。

你真的需要这样一个函数吗？

@miao 我想 你是想知道因为没有同名异式 方法 如何利用引用参数来 达到同名异式的效果吧

参数引用优先顺序 是 一般数 hash block

def test(*args)
    a,*b=args  
   p a
   p b 
    if block_given? 
          b.each { |i|  yield i }
     end 
end 
def test1(a,b,c,&block)
       p a , b ,c
      block.call()
end 

def test2(a,b,c)
  p a,b,c
  yield 
end 

test( 1,2,3,a: 1,b:2,c:3)   {|i|   p i }  # 传入引数 [1,2,3,{a:1,b:2,c:3} ]
# a=1  b=[2,3,{a:1,b:2,c:3}]

def test1(argv)
   a=argv[:a]
   b=argv[:b]
end


test1(a:1 , b:2 ,c:3)  # 此时   参数被当做 1 个 Hash