logchi (SuKong)

lambda 接 block 参数的问题

logchi — Fri, 07 Mar 2014 11:19:21 +0800

接着我昨天的问题，下面是我在实际项目中的代码，不确定这样写行不行。

def lines_array(*coordinate)
  count = LineInfo.where(player: self.to_pointer).count
  if count == 0
    return []
  else
    lines = LineInfo.where(player: self.to_pointer).execute
    first = true
    path = []
    construct_path = ->(*coordinate, &operation) {
      if lines.empty?
        return path
      elsif lines.size == 1
        operation.call lines
        return path
      else
        target_index = 0
        if first
          target_index = -1 
          first = false
        end
        base_x, base_y = transform_coordinate coordinate
        lines.sort_by! do |line|
          x, y = transform_coordinate( line.pointArray[-1].split(':') )
          (base_x - x)**2 + (base_y - y)**2
        end
        the_line = operation.call lines
        x, y = the_line.pointArray[target_index].split ':'
        construct_path.call(x, y) do |lines|
          the_line = lines.shift
          path << {
            color: the_line.color,
            style: the_line.style,
            pointArray: converse_coordinates(the_line.pointArray)
          }
          the_line
        end
      end
    }
    construct_path.call(*coordinate) do |lines|
      the_line = lines.shift
      path << {
        color: the_line.color,
        style: the_line.style,
        pointArray: converse_coordinates(the_line.pointArray)
      }
      the_line
    end
  end
end

def transform_coordinate(coordinate)
  [coordinate[0].to_i, coordinate[1].to_i]
end

def converse_coordinates(ary)
  if ary.nil?
    []
  else
    ary.map do |coordinate|
      x, y = coordinate.split ':'
      "{#{x}, #{y}}"
    end
  end
end

最后的调用像这个样子

player.lines_array( '123', '456' )

其中 line 的 pointArray 是一个 [ "123:456", "789:123" , ... ] 这样的坐标字串数组。 coordinate 是一个点的坐标 x ,y 字串数组，像这个样子 [ '123', '456' ]

lambda 的问题

logchi — Thu, 06 Mar 2014 19:41:02 +0800

我在解决实际问题的时候，遇到了关于 lambda 的问题，不清楚 Ruby 中的 lambda 是否能像下面这样用。

lambda 的递归是像下面这样吗？

lambda_x = ->(x) {
  if x == 0
    return
  else
    puts "Some Operaions..."
    lambda_x[ x-1 ]
  end
}

lambda_x[10]

lambda 可以像方法那样接收其他的 lambda 作参数吗？

lambda_x = ->(x) {
  puts "Some Operations..."
}

base = 10
lambda_y = ->(another_lambda) {
  if base == 0
    return
  else
    puts 'Some Operations...'
    another_lambda[ base**2 ]
    base -= 1
    lambda_y[ another_lambda ]
  end
}

lambda_y[ lambda_x ]

或者作为闭包直接引用另一个 lambda ?

lambda_x = ->(x) {
  puts "Some Operations..."
}

base = 10
lambda_y = ->{
  if base == 0
    return
  else
    puts 'Some Operations...'
    lambda_x[ base**2 ]
    base -= 1
    lambda_y.call
  end
}

lambda_y.call

可以像上面这样用吗？

One Question about Method Lookup Process

logchi — Sat, 11 Jan 2014 15:32:24 +0800

我正在看《Metaprogramming Ruby》, Chapter3 中 Flattening the Scope 这一小节有这样一段代码：

my_var = "Success"

MyClass = Class.new do
  puts "#{my_var} in the class definition!"

  define_method :my_method do
    puts "#{my_var} in the method!"
  end
end

MyClass.new.my_method

在 Class.new 后连接的 Block 中，这里 self 是 Class 对象，这时调用 define_method 方法，我想问的是当 define_method 方法被调用时的查找过程

我目前知道的是，Class 作为一个对象，首先它会寻找自己是否有这个方法

Class.methods false   # => []

发现没有之后会跑到自己所属的类中的实例方法里寻找

Class.class   # => Class
Class.instance_methods false            # => [:allocate, :new, :superclass]
Class.private_instance_methods false   # => [:inherited, :initialize]

因为 Class 的类是自己，所以还是没找到，之后就沿着祖先链继续向上寻找

Class.ancestors   # => [Class, Module, Object, PP::ObjectMixin, Kernel, BasicObject]

终于在 Module 中找到了 define_method 这个实例方法

Module.private_instance_methods(false).grep /define_method/   # => [:define_method]

这个查找过程是正确的吗？如果不是，应该是怎样的？