多个退货单

我曾经听说过，过去人们为使方法具有单个出口点而奋斗。 我知道这是一种过时的方法，从未认为它特别值得注意。 但是最近，我与一些仍坚持该想法的开发人员进行了联系（最后一次是在这里 ），这让我开始思考。

因此，我第一次真正坐下来比较了这两种方法。

总览

文章的第一部分将针对多个return语句重复参数。 它还将确定干净代码在评估这些论点中的关键作用。 第二部分将对得益于早日返回的情况进行分类。

为了不总是写“带有多个return语句的方法”，我将这种方法称为通过模式构造方法的方法。 尽管这可能有些过头，但肯定会更简洁。

讨论

我正在讨论一个方法是否应该始终运行到最后一行，从那里返回结果，还是可以有多个return语句并“尽早返回”。

这当然不是新的讨论。 参见，例如Wikipedia ， Hacker Chick或StackOverflow 。

结构化程序设计

单个return语句是可取的想法源于1960年代开发的结构化编程范式。 关于子例程，它提倡它们具有单个入口和单个出口点。 尽管现代编程语言可以保证前者，但出于某些原因，后者有些过时了。

单个出口点解决的主要问题是内存或资源泄漏。 当方法内部某处的return语句阻止执行位于其末尾的某些清除代码时，就会发生这种情况。 如今，其中大部分由语言运行时处理（例如，垃圾回收），并且可以使用try-catch-finally编写显式清除块。 因此，现在的讨论主要围绕可读性。

可读性

坚持单个return语句可能导致嵌套增加，并需要其他变量（例如，中断循环）。 另一方面，使方法从多个点返回可能会导致其控制流程混乱，从而使其难以维护。 重要的是要注意，这两个方面在代码的整体质量方面有很大的不同。

考虑一种遵循简洁的编码准则的方法：它简短且具有明确的名称和意图揭示结构。 通过引入更多的嵌套和更多的变量，在可读性方面的相对损失非常明显，并且可能使干净的结构混乱。 但是由于该方法的简洁性和形式使其易于理解，因此忽略任何返回声明的风险不大。 因此，即使存在不止一个，控制流程仍然显而易见。

与较长的方法（可能是复杂或优化算法的一部分）进行对比。 现在情况逆转了。 该方法已经包含许多变量，并且可能包含一些嵌套级别。 引入更多内容在可读性方面几乎没有相对成本。 但是，忽视多个回报之一从而误解控制流程的风险是非常现实的。

因此，问题在于方法是否简短易读。 如果是这样，通常使用多个return语句是一种改进。 如果不是，则最好使用单个return语句。

其他因素

但是，可读性可能不是唯一的因素。

讨论的另一方面可以是日志记录。 如果要记录返回值但不求助于面向方面的编程，则必须在方法的出口点手动插入记录语句。 使用多个return语句执行此操作很繁琐，而忘记一个则很容易。

同样，如果要在从方法返回之前声明结果的某些属性，则可能希望使用单个退出点。

多个退货报表的情况

在几种情况下，一种方法可以从多个返回语句中获利。 我试图在这里对它们进行分类，但没有声称有完整的列表。 （如果您遇到另一种重复出现的情况，请发表评论，我将在此附上。）

每种情况都会附带一个代码示例。 请注意，缩短了这些内容可以使观点更清楚，并且可以通过多种方式进行改进。

由JDHancock在CC-BY 2.0下发布

警卫条款

保护子句位于方法的开头。 他们检查其参数，并在某些特殊情况下立即返回结果。

防范条款无效或空集合

private Set<T> intersection(Collection<T> first, Collection<T> second) {
	// intersection with an empty collection is empty
	if (isNullOrEmpty(first) || isNullOrEmpty(second))
		return new HashSet<>();

	return first.stream()
			.filter(second::contains)
			.collect(Collectors.toSet());
}

从一开始就排除边缘情况有几个优点：

• 它将特殊情况和常规情况的处理完全分开，从而提高了可读性
• 它提供了用于其他检查的默认位置，从而保持了可读性
• 这使得实施常规案例的错误更少
• 它可能会提高那些特殊情况下的性能（尽管这很少相关）

基本上，适用于该模式的所有方法都将从其使用中受益。

值得一提的是后卫条款的支持者是马丁·福勒（Martin Fowler），尽管我会在分支的边缘考虑他的例子 （见下文）。

分枝

某些方法的职责要求分支到几个通常专用的子例程之一。 通常最好将这些子例程本身实现为方法。 然后，原始方法仅负责评估某些条件并调用正确的例程。

委托专门方法

public Offer makeOffer(Customer customer) {
	boolean isSucker = isSucker(customer);
	boolean canAffordLawSuit = customer.canAfford(
			legalDepartment.estimateLawSuitCost());

	if (isSucker) {
		if (canAffordLawSuit)
			return getBigBucksButStayLegal(customer);
		else
			return takeToTheCleaners(customer);
	} else {
		if (canAffordLawSuit)
			return getRid(customer);
		else
			return getSomeMoney(customer);
	}
}

（我知道我可以省略所有else行。有一天，我可能会写一篇帖子解释为什么在这种情况下我不这样做。）

与结果变量和单个返回相比，使用多个return语句具有多个优点：

• 该方法更清楚地表达了其打算跳转到子例程并仅返回其结果的意图
• 在任何理智的语言中，如果分支未涵盖所有可能性，则该方法不会编译（在Java中，如果未将变量初始化为默认值，也可以通过一次返回来实现）
• 结果没有额外的变量，几乎可以覆盖整个方法
• 被调用方法的结果在返回之前是无法操纵的（在Java中，如果变量是final并且其类是不可变的，也可以通过单次返回来实现；但是，这对于读者而言并不明显）
• 如果将switch语句用于具有穿透性的语言（例如Java），则立即返回语句可在每种情况下节省一行，因为不需要break ，这减少了样板并提高了可读性

此模式仅应应用于除分支以外无所作为的方法。 分支机构涵盖所有可能性尤其重要。 这意味着分支语句下没有代码。 如果有的话，将需要花费更多的精力来推理通过该方法的所有路径。 如果一种方法满足这些条件，那么它将很小且具有凝聚力，这很容易理解。

级联检查

有时，一种方法的行为主要由多个检查组成，其中每个检查的结果可能使进一步检查变得不必要。 在这种情况下，最好尽快返回（也许在每次检查之后）。

寻找锚定父级时进行级联检查

private Element getAnchorAncestor(Node node) {
	// if there is no node, there can be no anchor,
	// so return null
	if (node == null)
		return null;

	// only elements can be anchors,
	// so if the node is no element, recurse to its parent
	boolean nodeIsNoElement = !(node instanceof Element);
	if (nodeIsNoElement)
		return getAnchorAncestor(node.getParentNode());

	// since the node is an element, it might be an anchor
	Element element = (Element) node;
	boolean isAnchor = element.getTagName().equalsIgnoreCase("a");
	if (isAnchor)
		return element;

	// if the element is no anchor, recurse to its parent
	return getAnchorAncestor(element.getParentNode());
}

其他示例是Java中equals或compareTo的常规实现。 它们通常还包含一系列检查，其中每个检查都可以确定方法的结果。 如果是，则立即返回该值，否则该方法将继续进行下一个检查。

与单个return语句相比，此模式不需要您跳过箍以防止更深的缩进。 它还使直接添加新的检查和在检查并返回块之前放置注释成为可能。

与分支一样，多个return语句应仅应用于短而几乎没有其他作用的方法。 级联检查应该是它们的主要内容，或者更好的是它们的唯一内容（除了输入验证之外）。 如果检查或返回值的计算需要两到三行以上，则应将其重构为单独的方法。

正在搜寻

在存在数据结构的地方，可以找到具有特殊条件的项目。 搜索它们的方法通常看起来很相似。 如果这种方法遇到了要搜索的项目，则通常最容易立即返回它。

立即返回找到的元素

private <T> T findFirstIncreaseElement(Iterable<T> items, Comparator<? super T> comparator) {
	T lastItem = null;
	for (T currentItem : items) {
		boolean increase = increase(lastItem, currentItem, comparator);
		lastItem = currentItem;

		if (increase) {
			return currentItem;
		}
	}

	return null;
}

与单个return语句相比，这使我们免于寻找摆脱循环的方法。 这具有以下优点：

• 没有其他布尔变量可以打破循环
• 循环没有其他条件，它很容易被忽略（尤其是在for循环中），因此会引发错误
• 最后两点使循环更容易理解
• 结果很可能没有其他变量，几乎涵盖了整个方法

像大多数使用多个return语句的模式一样，这也需要干净的代码。 该方法应该很小，除了搜索外别无其他责任。 非平凡的检查和结果计算应具有自己的方法。

反射

我们已经看到了支持和反对多个return语句的参数，以及干净代码所起的关键作用。 分类应有助于识别重复出现的情况，在这种情况下，一种方法将从早期返回中受益。

翻译自: https://www.javacodegeeks.com/2015/01/multiple-return-statements.html