进程和块

下面的方法会输出 Hello两次 。

  1. def twice  # 使用yield关键词定义块方法，编译器可以识别到 
  2.   yield
  3.   yield
  4. end
  6. twice do
  7.   puts "Hello!"  # 块代码
  8. end
  10. # 更加直观的写法, 使用 &
  11. def twice(&block)
  12.   yield
  13.   yield
  14. end

调用块方法使用 do…end 或 {}, 两者一般情况下是等价的。

  1. twice() do
  2.   puts "Hello!"
  3. end
  5. twice do
  6.   puts "Hello!"
  7. end
  9. twice { puts "Hello!" }

区别在于 do…end使用left most模式， {}使用right most模式。

  1. foo bar do
  2.   something
  3. end
  5. # The above is the same as
  6. foo(bar) do
  7.   something
  8. end
  10. foo bar { something } # same as : foo(bar { something })
  12. # 多个参数 ， 实际传入的参数入量可以少于yield后面的参数数量
  13. def many
  14.   yield 1, 2, 3
  15. end
  17. many do |x, y, z|
  18.   puts x + y + z
  19. end
  21. # 单参数调用简写
  22. method do |argument|
  23.   argument.some_method
  24. end
  26. # 同上 
  27. method &.some_method
  28. method &.some_method(arg1, arg2)
  30. # 操作符也行。。。
  31. method &.+(2)
  32. method &.[index]
  34. # 类型限制
  35. def transform_int(start : Int32, &block : Int32 -> Int32)
  36.   result = yield start
  37.   result * 2
  38. end
  40. transform_int(3) { |x| x + 2 } #=> 10
  41. transform_int(3) { |x| "foo" } # Error: expected block to return Int32, not String
  43. # break ...略
  44. # next ...略
  45. # with...yield  ...略
  47. # 块参数展开, 块代码参数可以被小括号展开 
  48. array = [{1, "one"}, {2, "two"}]
  49. array.each do |(number, word)|
  50.   puts "#{number}: #{word}"
  51. end
  53. # 上面的等价代码   
  54. array = [{1, "one"}, {2, "two"}]
  55. array.each do |arg|
  56.   number = arg[0]
  57.   word = arg[1]
  58.   puts "#{number}: #{word}"
  59. end

捕获（生成）块

块代码可以转换成一个带有上下文的进程。必须把块当成一个方法的block参数并指定其输入输出的参数类型。

  1. def int_to_int(&block : Int32 -> Int32)
  2.   block
  3. end
  5. proc = int_to_int { |x| x + 1 }
  6. proc.call(1) #=> 2
  8. # 不指定返回类型，将没有返回 
  9. def some_proc(&block : Int32 ->)
  10.   block
  11. end
  13. proc = some_proc { |x| x + 1 }
  14. proc.call(1) # void
  16. # 使用下划线 返回任意类型值
  17. def some_proc(&block : Int32 -> _)
  18.   block
  19. end
  21. proc = some_proc { |x| x + 1 }
  22. proc.call(1) # 2
  24. proc = some_proc { |x| x.to_s }
  25. proc.call(1) # "1"

注: return和break不能使用在block中。

Proc字面量

  1. def some_proc(&block : Int32 -> Int32)
  2.   block
  3. end
  5. x = 0
  6. proc = ->(i : Int32) { x += i }  # 字面量
  7. proc = some_proc(&proc)
  8. proc.call(1)  #=> 1
  9. proc.call(10) #=> 11
  10. x #=> 11
  12. # 进程也可以从现有的方法创建 
  13. def add(x, y)
  14.   x + y
  15. end
  17. adder = ->add(Int32, Int32)
  18. adder.call(1, 2) #=> 3

块的转发执行

在yield可用的情况下，应避免使用闭包写法。并且break,next在捕获的闭包中无法使用。

  1. # 使用yield进行转发 
  2. def foo
  3.   yield 1
  4. end
  6. def wrap_foo
  7.   puts "Before foo"
  8.   foo do |x|
  9.     yield x
  10.   end
  11.   puts "After foo"
  12. end
  14. wrap_foo do |i|
  15.   puts i
  16. end
  18. # 使用闭包转发， 效率会降低
  19. def foo
  20.   yield 1
  21. end
  23. def wrap_foo(&block : Int32 -> _)
  24.   puts "Before foo"
  25.   foo(&block)
  26.   puts "After foo"
  27. end
  29. wrap_foo do |i|
  30.   puts i
  31. end

闭包

捕获块和proc字面量隔离self和本地变量形成闭包，下面的例子来说明

  1. x = 0
  2. proc = ->{ x += 1; x }
  3. proc.call #=> 1
  4. proc.call #=> 2
  5. x         #=> 2

也可以是在方法中返回一个进程

  1. def counter
  2.   x = 0
  3.   ->{ x += 1; x }
  4. end
  6. proc = counter
  7. proc.call #=> 1
  8. proc.call #=> 2
  9. # 上面的代码， x被proc字面量捕获并放置于堆中作为proc的上下文。一般情况下本地变量被放入栈中 并且在方法结束时被释放。

别名

使用别名可以给类型指定一个其它名字, 用于方便书写。

  1. alias PInt32 = Pointer(Int32)
  2. ptr = PInt32.malloc(1) # : Pointer(Int32)
  4. #
  5. alias RecArray = Array(Int32) | Array(RecArray)
  7. ary = [] of RecArray
  8. ary.push [1, 2, 3]
  9. ary.push ary
  10. ary #=> [[1, 2, 3], [...]]