ruby中定义一个方法时，各种参数的定义方式

# 位置参数
def add_values(a, b)
   a + b
end

# 默认位置参数
def add_values2(a = 1, b = 2, c)
   a + b + c
end

def add_values3(a = 1, b = a) # 参数值总是从左到右被计算的
   a + b
end

def add_values4(a = b, b = 1) # 除非定义了一个名字为b的方法，否则在默认参数执行时会报错
   a + b
end

p add_values4 # raise an error

# 数组参数
def my_method((a, b))
   p a: a, b: b
end

my_method([1, 2])

# 嵌套数组参数
def my_method2((a, *b))
   p a: a, b: b   # {:a=>1, :b=>2}
end

my_method2([1, 2, 3, 4]) # {:a=>1, :b=>[2, 3, 4]}

def my_method3((a, (b, c), d)) # 如果传入的参数不为数组，则会把参数赋给第一个参数，而余下参数赋值为nil
   p a: a, b: b, c: c, d: d
end


my_method3(1)              # {:a=>1, :b=>nil, :c=>nil, :d=>nil}
my_method3([1, [1, 2], 4]) # {:a=>1, :b=>1, :c=>2, :d=>4}
my_method3([1, 2, 3])      # {:a=>1, :b=>2, :c=>nil, :d=>3}

def my_method4(((a, b), c))
   p a: a, b: b, c: c
end

my_method4([[1, 2], 3]) # {:a=>1, :b=>2, :c=>3}

def gather_arguments(*arg) # 数组参数， 数组参数必须出现在所有关键字参数前面
   p arg
end

gather_arguments(1, x: 20) # [1, {:x=>20}] 数组参数将捕获一个哈希作为最后一条记录，如果一个哈希被传递到所有位置参数的后面。


def gather_arguments2(first_arg, *arg, last_arg)
   p [first_arg, arg, last_arg]
end

def gather_arguments_keyword(*positional, keyword: nil)
   p positional: positional, keyword: keyword
end
gather_arguments_keyword(1, 2, three: 3) # error unknown keyword: :three (ArgumentError) three关键字并不存在

def ignore_arguments(*) # 忽略所有参数，即使在调用时传入了参数
   p "none"
end

ignore_arguments(1, 2, 3) # none

#关键字参数
def add_values(first: 1, second: 2)
   p first + second
end

add_values(first: 3, second: 4) # 7

def gather_arguments3(first: nil, **rest)
   p first, rest
end

gather_arguments3(first: 1, second: 3, three: 4) # 1, {:second=>3, :three=>4} rest被解析为哈希值


def add_values5(first:, second: ) # 不带默认值的关键字参数
   p first + second
end

add_values5 # error missing keywords: :first, :second (ArgumentError)
add_values5(first: 1, second: 2) # 3

def add_values6(first, second: ) # 所有位置参数必须在关键字参数前面
   p [first, second]
end

add_values6(1, second: 2) #[1, 2]

def ignore_keywords(**) # 忽略任何关键字参数
   ###
end

def no_keywords(**nil)
   ###
end

no_keywords(1, 2, 3) # error, 必须传入关键字参数

def my_method5(**keywords)
   p keywords
end
my_method5(x: 1, y: 2) # {:x=>1, :y=>2}
my_method5({x: 3, y: 4}) # 产生警告 {:x=>3, :y=>4}

def my_method6(hash = nil, **keywords)
   p [hash, keywords]
end

my_method6 10, x: 1, y: 2 # [10, {:x=>1, :y=>2}]

def my_method7(hash, **keywords)
   p [hash, keywords]
end
my_method7(1, x: 1, y: 2) # [1, {:x=>1, :y=>2}]

my_method7(x: 2) # [{:x=>2}, {}] 如果一个方法缺少了必要位置参数，那么关键字参数会被作为位置参数的值
my_method7({x: 2}) # [{:x=>2}, {}] same as above

my_method7({}) # [{}, {}] 空的关键字作为必要参数的值

def my_method8(hash = 3, a: 4)
   p [hash, a]
end
my_method8(a: 1, 'a' => 2)       # 这种情况下，非符号键值对将赋值给位置参数hash，符号键值对则解析为关键字参数，因此a的值1，[{"a"=>2}, 1]
my_method8({a: 1, 'a' => 2}) # [{"a"=>2}, 1] # 同上

# 块参数
def my_method9(&block)
   block.call(self)
end
my_method9 { |var| p var } # main


def my_method10(&block)
   return [1, 2, 3].each(&block) # 将块参数传递给each方法
end

my_method10 { |var| p var } # 1 2 3

def my_method11 # 与上面相同
   yield self
end
my_method11 { |var| p var } # main

# 方法中的异常处理
def my_method12
   begin
      raise "bad"
   rescue
      puts "bad thing happend"
   end
end

my_method12 # bad thing happend

def my_method13
   raise "good"
rescue
   puts "good thing happened"
end
my_method13 # good thing happened 与上面相同

def my_method14
   raise "again"
ensure
   puts "again happend"
end

my_method14 # 先执行ensure的代码，再触发一个异常

def my_method15
   raise "again again"
rescue
   puts "again again happend"
else                    # 没有异常则触发
   puts "no exception"
ensure
   puts "always execute!"
end
my_method15

def my_method16
   puts "again again"
rescue
   puts "again again happend"
else                       # 没有异常则触发
   puts "no exception"
ensure                     # 无论是否有异常都执行
   puts "always execute!"
end