Ruby 检查块是否为零

Question

我用块调用方法；​​

method do
  "Hello"
end

方法定义为;

def method
  yield
end

以及在定义方法时；我想检查给定的块是否为空（nil），因为方法中的变量可能会像这样结束；

method do
  ""
end

所以在定义上，我想检查 yield 块是否为零。喜欢;

def method
  if yield ? yield : "Empty block? Seriously?"
end

我知道上述方法不起作用。但这正是我想要实现的目标。

还请记住，block_given? 将始终为“true”，因为即使它是 nil 或 空字符串，也会给出块.

更新：由于大多数 cmets/answers 表明问题不清楚；这是@ndn简化的问题：

我想检查执行块的结果是否为“空”（nil 或“”） 首先调用它。

Answer 1

不清楚你在问什么，因为块本身不能为空。因此，您可能有几个不同的意思：

1. 一个缺失的方块。您可以检查是否给出了块

   block_given?
   

2. 块空体（又名{} 或do end）。这并非不可能，但需要一些高级的 voodoo ruby​​ 元编程魔法。一般来说，如果这是您正在寻找的内容，那么您要么正在写一些非常有趣的东西，要么您的方法完全错误。

3. 您想在不先调用它的情况下检查执行块的结果是否为“空”。这是不可能的。例如，考虑以下块：

   { [nil, "", true].sample }
   

   显然，没有办法提前知道。

4. 您可以调用该块。然后您可以将结果分配给一个变量并对其进行检查：

   def some_method
     evaluation_result = yield if block_given?
     if evaluation_result.nil? or evaluation_result == ""
       # do something if the block was not given or the result is nil/empty
       puts "Empty block? Seriously?"
     else
       # do something if the block was given and the result is non nil/empty
       puts evaluation_result
     end
   end
   

   现在当你调用some_method:

   some_method { "something" } # => "something"
   some_method { 3 + 5 } # => 8
   some_method { nil } # => "Empty block? Seriously?"
   some_method { "" } # => "Empty block? Seriously?"
   some_method { } # => "Empty block? Seriously?"
   some_method # => "Empty block? Seriously?"
   

编辑： 案例 #3 的一种解决方法可能是创建两个 proc，一个是您想要在块为“空”时执行的操作，另一个是 - 如果不是，则将它们传递到您最终将调用该块的端点。这可能适用也可能不适用，具体取决于您的具体情况。

EDIT2： 另一种解决方法是为您的 proc 实例重新定义 Proc#call 方法。但是，这不适用于yield：

def secure(&block)
  insecure_call = block.method(:call)
  block.define_singleton_method(:call) do
    insecure_call_result = insecure_call.call
    if insecure_call_result.nil? or insecure_call_result == ""
      "<b>Bummer! Empty block...</b>"
    else
      insecure_call_result
    end
  end
end

x = proc { }
y = proc { "" }
z = proc { nil }
a = proc { 3 + 5 }
b = proc { "something" }
u = proc { [nil, "", true].sample }
[x, y, z, a, b, u].each { |block| secure &block }

# some method that uses the block
def user(&block)
  "What I got is #{block.call}!"
end


user &x # => "What I got is <b>Bummer! Empty block...</b>!"
user &y # => "What I got is <b>Bummer! Empty block...</b>!"
user &z # => "What I got is <b>Bummer! Empty block...</b>!"
user &a # => "What I got is 8!"
user &b # => "What I got is something!"
user &u # => Different each time

EDIT3：另一种选择，有点作弊，是将给定的 proc 包装在另一个 proc 中。这样，它也适用于yield。

def wrap(&block)
  proc do
    internal_proc_call_result = block.call
    if internal_proc_call_result.nil? or internal_proc_call_result == ""
      "<b>Bummer! Empty block...</b>"
    else
      internal_proc_call_result
    end
  end
end

现在使用wrap 的结果，会得到类似于secure 的行为。

Answer 2

如果我理解正确，您想静态确定块的运行时值是多少。这是由于停止问题的不可判定性而导致的许多已知的不可能问题之一。

换句话说：它做不到。

不是“不能在 Ruby 中完成”，也不是“很难”，它根本无法完成，句号。它可以（并且已经）在数学上证明它是不可能的。永远。

Answer 3

更新答案 我的last effort 根据 cmets 简化答案..

您可以使用block_given? 检查块是否为空，并且您需要显式检查yield 的输出是否为空，如下所示

def method(&block)

    # Below if condition is to prove that block can be accessed 
    if  block_given? 
        p block
        p block.yield
    end

    b = yield if block_given?
    (b.nil? || b.empty?) ? "Empty block? Seriously?" : b
end


p method {"Hello"} # inline block
result = method do 
      "World" 
    end
p result   
p method # No blocks provided
p method {""} # Block that returns empty string

程序的输出

"Hello"
"World"
"Empty block? Seriously?"
"Empty block? Seriously?"