Javascript或c#中的局部短路布尔值计算

Question

在JavaScript或c#中，是否有一种方法可以确定逻辑表达式的结果所有变量的值已检索?

或者换句话说;是否可以对表达式进行评估，使其返回"true"，"false"或"maybe"?其中"maybe"表示需要更多的数据。

解释:我有一个过程，其中需要一些时间从数据库后端检索数据，我想看看如果没有必要，我们是否可以跳过检索某些数据。但逻辑表达式是预先确定的，不能更改或拆开。

例如，考虑以下表达式:

((a = 1) and (b = 2)) or (c = 3)

有几种可能性:如果a和b已被检索，但c尚未被检索:

• 如果a=1和b=2，那么表达式将始终返回true，我可以跳过检索c的值
• 如果a=0和b=2，那么第一部分将为假，我需要检索c的值，以便能够确定结果

如果c已经被检索到，而a和b还没有被检索到。

• 如果c=3那么表达式将始终返回true，我可以跳过检索a和b的值。
• 如果c=2，那么第一部分将为假，我需要检索a和b的值，以便能够确定结果

在这些情况下，只要知道结果已经确定，或者需要更多的数据，就可以大大加快进程。

有谁有主意吗?一个过程，函数，算法?

Answer 1

因此，为了覆盖您的特定代码，您可以简单地使用以下代码:

if(CHasValue())
    return (c == 3) or ((a == 1) and (b == 2))
else
    return ((a == 1) and (b == 2)) or (c == 3)

短路操作人员将负责其余部分。

对于更复杂的表达式，这不是很好地扩展。为了真正覆盖任意的布尔表达式，你需要创建自己的新类型和相应的布尔运算符。

我们将从定义一个布尔值的接口开始，该接口可能还没有计算出它的值:

public interface IComputableBoolean
{
    public bool Value { get; }
    public bool ValueComputed { get; }
}

第一个实现是简单的;它是一个可计算的布尔值，表示一个我们已知的值:

public class ComputedBoolean : IComputableBoolean
{
    public ComputedBoolean(bool value)
    {
        Value = value;
    }
    public bool Value { get; private set; }
    public bool ValueComputed { get { return true; } }
}

然后是稍微复杂一点的情况，基于函数生成的布尔值(可能是可能长时间运行的东西，或者有副作用)。它将接受一个计算表达式的委托，在第一次请求值时对其求值，并从那时起返回一个缓存的值(并指示它已经计算了它的值)。

public class DeferredBoolean : IComputableBoolean
{
    private Func<bool> generator;
    private bool? value = null;
    public DeferredBoolean(Func<bool> generator)
    {
        this.generator = generator;
    }
    public bool Value
    {
        get
        {
            if (value != null)
                return value.Value;
            else
            {
                value = generator();
                return value.Value;
            }
        }
    }
    public bool ValueComputed { get { return value != null; } }
}

现在我们只需要创建应用于该接口的And、Or和Not方法。它们应该首先检查是否计算了足够的值以允许它短路，如果没有，它们应该创建一个延迟的布尔值来表示值的计算。这种延迟值的传播很重要，因为它允许组合复杂的布尔表达式，并且仍然可以用最少的计算量适当地短路。

public static IComputableBoolean And(
    this IComputableBoolean first,
    IComputableBoolean second)
{
    if (first.ValueComputed && !first.Value ||
        second.ValueComputed && !second.Value)
        return new ComputedBoolean(false);
    else
        return new DeferredBoolean(() => first.Value && second.Value);
}
public static IComputableBoolean Or(
    this IComputableBoolean first,
    IComputableBoolean second)
{
    if (first.ValueComputed && first.Value ||
        second.ValueComputed && second.Value)
        return new ComputedBoolean(true);
    else
        return new DeferredBoolean(() => first.Value && second.Value);
}

Not操作有点不同，因为它根本不能短路，但它仍然很重要，因为它继续延迟给定布尔表达式的求值，因为它可能最终不需要。

public static IComputableBoolean Not(
    this IComputableBoolean boolean)
{
    if (boolean.ValueComputed)
        return new ComputedBoolean(boolean.Value);
    else
        return new DeferredBoolean(() => boolean.Value);
}

我们现在可以像这样表示表达式(根据需要使用实际的长时间运行的操作来计算a, b和/或c):

var a = new DeferredBoolean(() => false);
var b = new DeferredBoolean(() => true);
var c = new DeferredBoolean(() => false);
var expression = a.And(b).Or(c);
bool result = expression.Value;

Answer 2

假设a、b、c在加载后为真，而在加载前为假(或者a、b、c包含一个可以检查的"loaded"属性):

var isValid = false;
if (a && b) {
  if (a == 1 && b == 2) {
    isValid = true;
  }
}
if (!isValid && c) {
  if (c == 3) {
    isValid = true;
  }
}