blocks|key|1833708|text|不是的。好的Ruby风格通常只使用显式的返回值作为早期返回值。Ruby热衷于代码极简主义/隐含魔术。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1833709|也就是说，如果一个显式的返回值可以让事情变得更清楚，或者更容易阅读，那么它不会伤害任何东西。|1833710|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

No. Good Ruby style would generally only use an explicit returns for an early return. Ruby is big on code minimalism/implicit magic. 

That said, if an explicit return would make things clearer, or easier to read, it won't harm anything.

blocks|key|1833790|text|就像本说的。“ruby方法的返回值是函数体中最后一条语句的返回值”这一事实导致在大多数ruby方法中很少使用return关键字。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1833791|def+some_func_which_returns_a_list(+x,+y,+z)
++return+nil+if+failed_some_early_check


++#+function+code+

++@list+++++#+returns+the+list
end|code-block|syntax|javascript|1833792|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Like Ben said. The fact that 'the return value of a ruby method is the return value of the last statement in the function body' causes the return keyword to be rarely used in most ruby methods.

<pre><code>def some_func_which_returns_a_list( x, y, z)
 return nil if failed_some_early_check


 # function code 

 @list # returns the list
end
</code></pre>

blocks|key|1833906|text|这是一个在很大程度上你喜欢哪种风格的问题。如果您想要从方法中间的某个位置返回，则必须使用关键字return。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1833907|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It's a matter of which style you prefer for the most part. You do have to use the keyword return if you want to return from somewhere in the middle of a method.

blocks|key|2048163|text|我个人使用return关键字来区分我所说的函数式方法，即主要为了返回值而执行的方法和主要为了副作用而执行的过程性方法。因此，对于返回值很重要的方法，需要额外的return关键字来引起对返回值的注意。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2048164|我在调用方法时使用了同样的区别:函数方法得到圆括号，而过程方法没有。|2048165|最后但并非最不重要的一点是，我也将这种区别用于块:功能块使用花括号，过程块(即“做”某些事情的块)使用do/end。|2048166|但是，我尽量不对它信以为真:对于块，大括号和do/end具有不同的优先级，我只是切换到另一种样式，而不是添加显式的圆括号来消除表达式的歧义。同样的道理也适用于方法调用:如果在参数列表周围添加括号可以提高代码的可读性，那么我会这样做，即使所讨论的方法本质上是过程性的。|2048167|entityMap^0|5|6|27|6|0|0|1F|2|1I|3|0|M|2|P|3|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|S|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|Y|8|@$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|L|3|-4|5|6|7|13|8|@]|D|@]|E|$]]]|M|$]]

I personally use the <code>return</code> keyword to distinguish between what I call functional methods, i.e. methods that are executed primarily for their return value, and procedural methods that are executed primarily for their side-effects. So, methods in which the return value is important, get an extra <code>return</code> keyword to draw attention to the return value.

I use the same distinction when calling methods: functional methods get parentheses, procedural methods don't.

And last but not least, I also use that distinction with blocks: functional blocks get curly braces, procedural blocks (i.e. blocks that "do" something) get <code>do</code>/<code>end</code>.

However, I try not to be religious about it: with blocks, curly braces and <code>do</code>/<code>end</code> have different precedence, and rather than adding explicit parentheses to disambiguate an expression, I just switch to the other style. The same goes for method calling: if adding parentheses around the parameter list makes the code more readable, I do it, even if the method in question is procedural in nature.

blocks|key|2048334|text|老问题(和“回答”)，但我将抛出我的两分钱作为答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2048335|你不需要这样做，但在某些情况下，它可以让你的代码更清晰。|2048336|尽管不使用显式返回可能是“Ruby方式”，但对于使用不熟悉的代码或不熟悉Ruby的这一特性的程序员来说，这是令人困惑的。|2048337|这是一个有点做作的例子，但想象一下有一个小函数，像这样，它将传递的数字加1，并将其赋给一个实例变量。|2048338|def+plus_one_to_y(x)
++++@y+=+x+%2B+1
end|code-block|syntax|javascript|2048339|这是一个返回值的函数吗？很难说开发人员是什么意思，因为它既分配了实例变量，又返回了分配的值。|2048340|假设很久以后，另一位程序员(可能不太熟悉Ruby如何根据执行的最后一行代码进行返回)出现了，他想要输入一些打印语句来记录日志，然后函数变成这样……|2048341|def+plus_one_to_y(x)
++++@y+=+x+%2B+1
++++puts+"In+plus_one_to_y"
end|2048342|现在，如果有任何东西需要返回值，函数就会中断。如果没有任何东西需要返回值，那也没问题。显然，如果在代码链的更远的某个位置，某个调用它的东西期望返回一个值，那么它就会失败，因为它得不到它所期望的东西。|2048343|现在真正的问题是:是否真的需要返回值？这有没有破坏什么？它会在未来打破一些东西吗？谁知道呢！只有对所有调用进行完整的代码审查才能让您知道。|2048344|因此，至少对我来说，最好的实践方法是要么非常明确地表明，如果重要的话就返回它，或者当它不重要的时候什么都不返回。|2048345|因此，在我们的小演示函数的情况下，假设我们想让它返回一个值，它将写成这样……|2048346|def+plus_one_to_y(x)
++++@y+=+x+%2B+1
++++puts+"In+plus_one_to_y"
++++return+@y
end|2048347|对于任何程序员来说，它都很清楚它确实返回了一个值，而且他们很难在没有意识到的情况下破坏它。|2048348|或者，可以像这样编写，省略返回语句...|2048349|def+plus_one_to_y(x)
++++@y+=+x+%2B+1
++++puts+"In+plus_one_to_y"
++++@y
end|2048350|但是为什么要省略return这个词呢？为什么不把它放进去，让它100%25清楚地知道发生了什么？它不会对你的代码的执行能力产生任何影响。|2048351|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1C|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1D|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1E|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1F|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|1G|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1H|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1I|8|@]|9|@]|A|$]]|$1|Q|3|R|5|J|7|1J|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|1K|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1L|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1M|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1N|8|@]|9|@]|A|$]]|$1|10|3|11|5|J|7|1O|8|@]|9|@]|A|$K|L]]|$1|12|3|13|5|6|7|1P|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|16|3|17|5|J|7|1R|8|@]|9|@]|A|$K|L]]|$1|18|3|19|5|6|7|1S|8|@]|9|@]|A|$]]|$1|1A|3|-4|5|6|7|1T|8|@]|9|@]|A|$]]]|1B|$]]

Old (and "answered") question, but I'll toss in my two cents as an answer.

TL;DR - You don't have to, but it can make your code a lot more clear in some cases.

Though not using an explicit return may be "the Ruby way", it's confusing to programmers working with unfamiliar code, or unfamiliar with this feature of Ruby.

It's a somewhat contrived example, but imagine having a little function like this, which adds one to the number passed, and assigns it to an instance variable. 

<pre><code>def plus_one_to_y(x)
 @y = x + 1
end
</code></pre>

Was this meant to be a function that returned a value, or not? It's really hard to say what the developer meant, as it both assigns the instance variable, AND returns the value assigned as well.

Suppose much later, another programmer (perhaps not that familiar with how Ruby does returns based on last line of code executed) comes along and wants to put in some print statements for logging, and the function becomes this...

<pre><code>def plus_one_to_y(x)
 @y = x + 1
 puts "In plus_one_to_y"
end
</code></pre>

Now the function is broken if anything expects a returned value. If nothing expects a returned value, it's fine. Clearly if somewhere further down the code chain, something calling this is expecting a returned value, it's going to fail as it's not getting back what it expects.

The real question now is this: did anything really expect a returned value? Did this break something or not? Will it break something in the future? Who knows! Only a full code review of all calls will let you know.

So for me at least, the best practice approach is to either be very explicit that you are returning something if it matters, or return nothing at all when it doesn't.

So in the case of our little demo function, assuming we wanted it to return a value, it would be written like this...

<pre><code>def plus_one_to_y(x)
 @y = x + 1
 puts "In plus_one_to_y"
 return @y
end
</code></pre>

And it would be very clear to any programmer that it does return a value, and much harder for them to break it without realizing it.

Alternatively, one could write it like this and leave out the return statement...

<pre><code>def plus_one_to_y(x)
 @y = x + 1
 puts "In plus_one_to_y"
 @y
end
</code></pre>

But why bother leaving out the word return? Why not just put it in there and make it 100% clear what's happening? It will literally have no impact on your code's ability to perform.

blocks|key|2048435|text|我同意Ben+Hughes的观点，但不同意Tim+Holt的观点，因为这个问题提到了Python的明确方式，并询问Ruby是否有类似的标准。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2048436|It+does.|offset|length|2048437|这是该语言的一个众所周知的特性，任何希望在ruby中调试问题的人都应该知道这一点。|2048438|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/bbatsov/ruby-style-guide#no-explicit-return^0|0|0|8|0|0|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Q|8|@]|9|@$D|R|E|S|1|T]]|A|$]]|$1|F|3|G|5|6|7|U|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|V|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]]]

I agree with Ben Hughes and disagree with Tim Holt, because the question mentions the definitive way Python does it and asks if Ruby has a similar standard. 

<a href="https://github.com/bbatsov/ruby-style-guide#no-explicit-return" rel="nofollow">It does.</a>

This is such a well-known feature of the language that anyone expected to debug a problem in ruby should reasonably be expected to know about it.

Coming from a Python background, where there is always a "right way to do it" (a "Pythonic" way) when it comes to style, I'm wondering if the same exists for Ruby. I've been using my own style guidelines but I'm thinking about releasing my source code, and I'd like it to adhere to any unwritten rules that might exist.

Is it "The Ruby Way" to explicitly type out <code>return</code> in methods? I've seen it done with and without, but is there a right way to do it? Is there maybe a right time to do it? For example:

<pre><code>def some_func(arg1, arg2, etc)
 # Do some stuff...
 return value # &lt;-- Is the 'return' needed here?
end
</code></pre>

Is it good style to explicitly return in Ruby?

我来自Python背景，当涉及到风格时，总是有一种“正确的方式”(一种"Pythonic“方式)，我想知道Ruby是否也存在同样的情况。我一直在使用我自己的风格指南，但我正在考虑发布我的源代码，我希望它遵守任何可能存在的不成文规则。在方法中显式键入return是“Ruby方式”吗？我看过使用和不使用的情况，但是有正确的...

问在Ruby中显式返回是一种好的风格吗？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中显式返回是一种好的风格吗？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中显式返回是一种好的风格吗？
EN