# 位置参数
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
ruby中定义一个方法时,各种参数的定义方式
最新推荐文章于 2021-11-24 01:02:43 发布