如何划分复杂条件,保持短路评估?

有时情况会变得非常复杂,所以为了可读性,我通常将它们分开,给每个组件一个有意义的名称。但是,这会使短路评估失败,从而造成问题。我想出了一个包装方法,但在我看来这太冗长了。

有人能想出一个很好的解决办法吗?

有关我的意思的示例,请参见下面的代码:

public class BooleanEvaluator {

    // problem: complex boolean expression, hard to read
    public static void main1(String[] args) {

        if (args != null && args.length == 2 && !args[0].equals(args[1])) {
            System.out.println("Args are ok");
        }
    }

    // solution: simplified by splitting up and using meaningful names
    // problem: no short circuit evaluation
    public static void main2(String[] args) {

        boolean argsNotNull = args != null;
        boolean argsLengthOk = args.length == 2;
        boolean argsAreNotEqual = !args[0].equals(args[1]);

        if (argsNotNull && argsLengthOk && argsAreNotEqual) {
            System.out.println("Args are ok");
        }
    }

    // solution: wrappers to delay the evaluation 
    // problem: verbose
    public static void main3(final String[] args) {

        abstract class BooleanExpression {
            abstract boolean eval();
        }

        BooleanExpression argsNotNull = new BooleanExpression() {
            boolean eval() {
                return args != null;
            }
        };

        BooleanExpression argsLengthIsOk = new BooleanExpression() {
            boolean eval() {
                return args.length == 2;
            }
        };

        BooleanExpression argsAreNotEqual = new BooleanExpression() {
            boolean eval() {
                return !args[0].equals(args[1]);
            }
        };

        if (argsNotNull.eval() && argsLengthIsOk.eval() && argsAreNotEqual.eval()) {
            System.out.println("Args are ok");
        }
    }
}

回答:

谢谢你的想法!目前提交了以下备选方案:

• 换行并添加注释
• 照原样离开
• 提取方法
• 早期收益
• 嵌套/拆分if's

换行并添加注释:

在Eclipse(ctrl+shift+f)中,只需在条件中添加换行符就可以被代码格式化程序撤消。内联注释有助于实现这一点,但每行上的空间很小,可能导致包装不美观。但在简单的情况下,这可能就足够了。

离开原样:

我给出的示例条件非常简单,因此在本例中可能不需要解决可读性问题。我想的是情况更复杂的情况,例如:

private boolean targetFound(String target, List<String> items,
        int position, int min, int max) {

    return ((position >= min && position < max && ((position % 2 == 0 && items
            .get(position).equals(target)) || (position % 2 == 1)
            && position > min && items.get(position - 1).equals(target)))
            || (position < min && items.get(0).equals(target)) || (position >= max && items
            .get(items.size() - 1).equals(target)));
}

我不建议把这个放在原处。

提取方法:

我考虑过提取方法,正如一些答案中所建议的那样。这样做的缺点是,这些方法通常具有非常低的粒度,它们本身可能没有什么意义,因此可能会使类变得混乱,例如:

private static boolean lengthOK(String[] args) {
    return args.length == 2;
}

在类级别上,这不应该是一个单独的方法。此外,还必须将所有相关参数传递给每个方法。如果只为评估非常复杂的条件而创建一个单独的类,那么这可能是一个不错的IMO解决方案。

我试图用BooleenExpression方法实现的是逻辑仍然是局部的。注意,即使booleanExpression的声明是本地的(我认为我以前从未遇到过本地类声明的用例!).

早期回报:

虽然我不喜欢这个成语,但早期返回的解决方案似乎足够了。替代符号:

public static boolean areArgsOk(String[] args) {

    check_args: {
        if (args == null) {
            break check_args;
        }
        if (args.length != 2) {
            break check_args;
        }
        if (args[0].equals(args[1])) {
            break check_args;
        }
        return true;
    }
    return false;
}

我意识到大多数人讨厌标签和分隔符,而且这种样式可能太不常见,以至于不能被认为是可读的。

嵌套/拆分条件:

它允许引入有意义的名称,并结合优化的评估。一个缺点是复杂的条件语句树会导致

摊牌

因此,为了了解我特别喜欢哪种方法,我将一些建议的解决方案应用到上面给出的复杂targetfound示例中。以下是我的结果:

嵌套/拆分if,带有有意义的名称 非常冗长、有意义的名称对可读性没有真正的帮助

private boolean targetFound1(String target, List<String> items,
        int position, int min, int max) {

    boolean result;
    boolean inWindow = position >= min && position < max;
    if (inWindow) {

        boolean foundInEvenPosition = position % 2 == 0
                && items.get(position).equals(target);
        if (foundInEvenPosition) {
            result = true;
        } else {
            boolean foundInOddPosition = (position % 2 == 1)
                    && position > min
                    && items.get(position - 1).equals(target);
            result = foundInOddPosition;
        }
    } else {
        boolean beforeWindow = position < min;
        if (beforeWindow) {

            boolean matchesFirstItem = items.get(0).equals(target);
            result = matchesFirstItem;
        } else {

            boolean afterWindow = position >= max;
            if (afterWindow) {

                boolean matchesLastItem = items.get(items.size() - 1)
                        .equals(target);
                result = matchesLastItem;
            } else {
                result = false;
            }
        }
    }
    return result;
}

嵌套/拆分if,带注释 不那么冗长,但仍然很难阅读,而且容易创建错误

private boolean targetFound2(String target, List<String> items,
        int position, int min, int max) {

    boolean result;
    if ((position >= min && position < max)) { // in window

        if ((position % 2 == 0 && items.get(position).equals(target))) {
            // even position
            result = true;
        } else { // odd position
            result = ((position % 2 == 1) && position > min && items.get(
                    position - 1).equals(target));
        }
    } else if ((position < min)) { // before window
        result = items.get(0).equals(target);
    } else if ((position >= max)) { // after window
        result = items.get(items.size() - 1).equals(target);
    } else {
        result = false;
    }
    return result;
}

早期收益 更紧凑,但条件树仍然同样复杂

private boolean targetFound3(String target, List<String> items,
        int position, int min, int max) {

    if ((position >= min && position < max)) { // in window

        if ((position % 2 == 0 && items.get(position).equals(target))) {
            return true; // even position
        } else {
            return (position % 2 == 1) && position > min && items.get(
                    position - 1).equals(target); // odd position
        }
    } else if ((position < min)) { // before window
        return items.get(0).equals(target);
    } else if ((position >= max)) { // after window
        return items.get(items.size() - 1).equals(target);
    } else {
        return false;
    }
}

提取方法 在你的课堂上产生了荒谬的方法 参数传递很烦人

private boolean targetFound4(String target, List<String> items,
        int position, int min, int max) {

    return (foundInWindow(target, items, position, min, max)
            || foundBefore(target, items, position, min) || foundAfter(
            target, items, position, max));
}

private boolean foundAfter(String target, List<String> items, int position,
        int max) {
    return (position >= max && items.get(items.size() - 1).equals(target));
}

private boolean foundBefore(String target, List<String> items,
        int position, int min) {
    return (position < min && items.get(0).equals(target));
}

private boolean foundInWindow(String target, List<String> items,
        int position, int min, int max) {
    return (position >= min && position < max && ((position % 2 == 0 && items
            .get(position).equals(target)) || (position % 2 == 1)
            && position > min && items.get(position - 1).equals(target)));
}

重新访问BooleenExpression包装纸 注意,方法参数必须声明为final 对于这个复杂的案件,我认为冗长是可以辩护的。 如果他们同意的话,关闭可能会使这变得更容易。(-

private boolean targetFound5(final String target, final List<String> items,
        final int position, final int min, final int max) {

    abstract class BooleanExpression {
        abstract boolean eval();
    }

    BooleanExpression foundInWindow = new BooleanExpression() {

        boolean eval() {
            return position >= min && position < max
                    && (foundAtEvenPosition() || foundAtOddPosition());
        }

        private boolean foundAtEvenPosition() {
            return position % 2 == 0 && items.get(position).equals(target);
        }

        private boolean foundAtOddPosition() {
            return position % 2 == 1 && position > min
                    && items.get(position - 1).equals(target);
        }
    };

    BooleanExpression foundBefore = new BooleanExpression() {
        boolean eval() {
            return position < min && items.get(0).equals(target);
        }
    };

    BooleanExpression foundAfter = new BooleanExpression() {
        boolean eval() {
            return position >= max
                    && items.get(items.size() - 1).equals(target);
        }
    };

    return foundInWindow.eval() || foundBefore.eval() || foundAfter.eval();
}

我想这真的取决于形势(一如既往)。对于非常复杂的条件,包装方法可能是可以防御的,尽管这是不常见的。

感谢您的所有意见!

编辑:事后诸葛亮。为复杂逻辑创建一个特定的类可能更好,例如:

import java.util.ArrayList;
import java.util.List;

public class IsTargetFoundExpression {

    private final String target;
    private final List<String> items;
    private final int position;
    private final int min;
    private final int max;

    public IsTargetFoundExpression(String target, List<String> items, int position, int min, int max) {
        this.target = target;
        this.items = new ArrayList(items);
        this.position = position;
        this.min = min;
        this.max = max;
    }

    public boolean evaluate() {
        return foundInWindow() || foundBefore() || foundAfter();
    }

    private boolean foundInWindow() {
        return position >= min && position < max && (foundAtEvenPosition() || foundAtOddPosition());
    }

    private boolean foundAtEvenPosition() {
        return position % 2 == 0 && items.get(position).equals(target);
    }

    private boolean foundAtOddPosition() {
        return position % 2 == 1 && position > min && items.get(position - 1).equals(target);
    }

    private boolean foundBefore() {
        return position < min && items.get(0).equals(target);
    }

    private boolean foundAfter() {
        return position >= max && items.get(items.size() - 1).equals(target);
    }
}

逻辑足够复杂,可以保证一个单独的类(和单元测试,yay!)。它将使使用此逻辑的代码更可读,并在其他地方需要此逻辑时促进重用。我认为这是一个很好的班级,因为它真正有一个单一的责任,只有最后的领域。