blocks|key|728699|text|您可以使用nonzero?，如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|728700|def+compute_average(a,b,c,d,e)
++total+=+[a,b,c,d,e].sum.to_f
++average+=+[a,+2*b,+3*c,+4*d,+5*e].sum+/+(total.nonzero?+%7C%7C+1)
end|code-block|syntax|javascript|728701|更多的人会更熟悉使用三元运算符(total+==+0+?+1+:+total)，所以这是另一种可能性。|728702|entityMap^0|5|8|0|0|F|O|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

<p>You can use <code>nonzero?</code>, as in:</p>

<pre><code>def compute_average(a,b,c,d,e)
  total = [a,b,c,d,e].sum.to_f
  average = [a, 2*b, 3*c, 4*d, 5*e].sum / (total.nonzero? || 1)
end
</code></pre>

<p>More people would be more familiar with using the ternary operator <code>(total == 0 ? 1 : total)</code>, so that's another possibility.</p>


blocks|key|944839|text|def+compute_average(a,b,c,d,e)
++total+=+(a%2Bb%2Bc%2Bd%2Be).to_f
++total.zero?+?+0+:+((a+%2B+2*b+%2B+3*c+%2B+4*d+%2B+5*e)+/+total).round(2)
end|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|944840|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def compute_average(a,b,c,d,e)
  total = (a+b+c+d+e).to_f
  total.zero? ? 0 : ((a + 2*b + 3*c + 4*d + 5*e) / total).round(2)
end
</code></pre>


blocks|key|728755|text|我不太喜欢Ruby，但我会这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|728756|average+=+denominator.nonzero?+?+numerator/denominator+:+0|code-block|syntax|javascript|728757|可能有一个更好的答案，但这可能就足够了。|728758|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

<p>I'm not much of a Ruby-ist, but I'd do it like this:</p>

<pre><code>average = denominator.nonzero? ? numerator/denominator : 0
</code></pre>

<p>There is probably a better answer, but this might suffice.</p>


blocks|key|944901|text|如果要除法的数字或分母是浮点数，则/不会返回零除错误。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|944902|def+compute_average(a,b,c,d,e)
++total+=+[a,b,c,d,e].sum.to_f
++average+=+[a,+2*b,+3*c,+4*d,+5*e].sum+/+total
++average.finite?+?+average.round(2)+:+0.0
end|code-block|syntax|javascript|944903|更一般地说，在ruby1.9下，|944904|def+compute_average+*args
++average+=+args.to_enum.with_index.map{%7Cx,+w%7C+x+*+w}.sum+/+args.sum.to_f
++average.finite?+?+average.round(2)+:+0.0
end|944905|entityMap^0|H|1|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

<p><code>/</code> does not return a zero division error if either the number to be divided or the denominator is a float.</p>

<pre><code>def compute_average(a,b,c,d,e)
  total = [a,b,c,d,e].sum.to_f
  average = [a, 2*b, 3*c, 4*d, 5*e].sum / total
  average.finite? ? average.round(2) : 0.0
end
</code></pre>

<p>More generally, under ruby1.9,</p>

<pre><code>def compute_average *args
  average = args.to_enum.with_index.map{|x, w| x * w}.sum / args.sum.to_f
  average.finite? ? average.round(2) : 0.0
end
</code></pre>


blocks|key|728830|text|通常依赖rescue来捕获异常，然后返回默认值：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|728831|def+compute_average(a,+b,+c,+d,+e)
++total+=+[a,+b,+c,+d,+e].sum.to_f
++average+=+[+a,+2*b,+3*c,+4*d,+5*e+].sum+/+total
++average.round(2)
++rescue+ZeroDivisionError
++++0.0
end|code-block|syntax|javascript|728832|我还会写道：|728833|average+=+numerator+/+denominator+unless+denominator+==+0+then+0|728834|作为|728835|average+=+(denominator+==+0)+?+0+:+numerator+/+denominator|728836|entityMap^0|4|6|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|10|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|S|3|-4|5|6|7|12|8|@]|D|@]|E|$]]]|T|$]]

<p>It's common to rely on <code>rescue</code> to capture the exception, then to return the default value:</p>

<pre><code>def compute_average(a, b, c, d, e)
  total = [a, b, c, d, e].sum.to_f
  average = [ a, 2*b, 3*c, 4*d, 5*e ].sum / total
  average.round(2)
  rescue ZeroDivisionError
    0.0
end
</code></pre>

<p>Also I'd write:</p>

<pre><code>average = numerator / denominator unless denominator == 0 then 0
</code></pre>

<p>as</p>

<pre><code>average = (denominator == 0) ? 0 : numerator / denominator
</code></pre>


blocks|key|945033|text|对我来说，最干净的方式是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|945034|numerator+/+denominator+rescue+0|code-block|syntax|javascript|945035|它还使您不必处理0+/+0。|offset|length|style|CODE|945036|正如@Andrew指出的，这只对整数有效。有关更多信息，请参阅此答案的注释。|945037|entityMap^0|0|0|8|5|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

<p>To me, the cleanest way is:</p>

<pre><code>numerator / denominator rescue 0
</code></pre>

<p>It also saves you from handling <code>0 / 0</code>.</p>

<p>As @Andrew points out, this is only valid for integers. See the comments to this answer for more info.</p>


blocks|key|728979|text|TL;DR:一种可能的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|728980|def+compute_average(*values)

++#+This+makes+sure+arrays+get+flattened+to+a+single+array.
++values.flatten!

++#+Throws+away+all+nil+values+passed+as+arguments.
++values.reject!(&:nil?)

++#+Throws+away+all+non-numeric+values.
++#+This+includes+trashing+strings+that+look+like+numbers,+like+"12".
++values.keep_if{+%7Cv%7C+v.is_a?+Numeric+}

++total+=+values.sum.to_f
++return+Float::NAN+if+total.zero?

++#+I'm+not+sure+what+this+business+is
++#+++average+=+[a,+2*b,+3*c,+4*d,+5*e].sum+/+total
++#+but+it+can+be+translated+to
++average+=+values.each_with_index.map{+%7Cv,i%7C+v*(i%2B1)+}.sum+/+total

++average.round(2)
end|code-block|syntax|javascript|728981|这可以防止所有情况：|728982|compute_average(1,2,3,4,5)
=>+3.67

compute_average(0,0,0,0,0)
=>+NaN

compute_average(1,2,nil,4,5)
=>+3.08

compute_average(1,2,"string",4,5)
=>+3.08

compute_average(1)
=>+1.0

compute_average([1,2,3,4,5])
=>+3.67

compute_average
=>+NaN|728983|原始函数：|728984|def+compute_average(a,b,c,d,e)
++total+=+[a,b,c,d,e].sum.to_f
++average+=+[a,+2*b,+3*c,+4*d,+5*e].sum+/+total
++average.round(2)
end|728985|考虑检查是否为零：|728986|def+compute_average(a,b,c,d,e)
++total+=+[a,b,c,d,e].sum.to_f
++return+if+total.zero?
++average+=+[a,+2*b,+3*c,+4*d,+5*e].sum+/+total
++average.round(2)
end|728987|此更改仅针对一种情况提供保护：|728988|compute_average(1,2,3,4,5)
#+=>+3.67

compute_average(0,0,0,0,0)
#+=>+nil

compute_average(1,2,nil,4,5)
#+=>+TypeError:+NilClass+can't+be+coerced+into+Fixnum

compute_average(1,2,"string",4,5)
#+=>+TypeError:+String+can't+be+coerced+into+Fixnum

compute_average(1)
#+=>+ArgumentError:+wrong+number+of+arguments+calling+`compute_average`+(1+for+5)

compute_average([1,2,3,4,5])
#+=>+ArgumentError:+wrong+number+of+arguments+calling+`compute_average`+(1+for+5)

compute_average
#+=>+ArgumentError:+wrong+number+of+arguments+calling+`compute_average`+(0+for+5)|728989|考虑使用内联rescue|offset|length|style|CODE|728990|def+compute_average(a,b,c,d,e)
++total+=+[a,b,c,d,e].sum.to_f
++average+=+[a,+2*b,+3*c,+4*d,+5*e].sum+/+total+rescue+0
++average.round(2)
end|728991|此更改仅针对一种情况提供保护，而且：|728992|compute_average(1,2,3,4,5)
#+=>+3.67

compute_average(0,0,0,0,0)
#+=>+NaN

compute_average(1,2,nil,4,5)
#+=>+TypeError:+NilClass+can't+be+coerced+into+Fixnum

compute_average(1,2,"string",4,5)
#+=>+TypeError:+String+can't+be+coerced+into+Fixnum

compute_average(1)
#+=>+ArgumentError:+wrong+number+of+arguments+calling+`compute_average`+(1+for+5)

compute_average([1,2,3,4,5])
#+=>+ArgumentError:+wrong+number+of+arguments+calling+`compute_average`+(1+for+5)

compute_average
#+=>+ArgumentError:+wrong+number+of+arguments+calling+`compute_average`+(0+for+5)|728993|使用内联rescue还有另一个后果。考虑一下这个打字错误：|728994|def+compute_average(a,b,c,d,e)
++total+=+[a,b,c,d,e].sum.to_f
++average+=+[a,+2*b,+3*c,+4*d,+5*e].smu+/+total+rescue+0
++#+++++++++++++++++++++++++++++++++%5E%5E%5E
++average.round(2)
end

compute_average(1,2,3,4,5)
#+=>+0.0

compute_average(0,0,0,0,0)
#+=>+0.0|728995|考虑使用rescue|728996|def+compute_average(a,b,c,d,e)
++total+=+[a,b,c,d,e].sum.to_f
++average+=+[a,+2*b,+3*c,+4*d,+5*e].sum+/+total
++average.round(2)
rescue+ZeroDivisionError
++0.0
end|728997|这更好，因为它不会隐藏错误，但可以防止与上面的倾斜rescue相同的情况。|728998|另一个版本，我称之为正常平均计算|728999|顺便说一句，我熟悉的平均操作是使用total/count计算的，所以这里有一个版本可以做到这一点。|729000|def+compute_average(*values)

++#+This+makes+sure+arrays+get+flattened+to+a+single+array.
++values.flatten!

++#+Throws+away+all+nil+values+passed+as+arguments.
++values.reject!(&:nil?)

++#+Throws+away+all+non-numeric+values.
++#+This+includes+trashing+strings+that+look+like+numbers,+like+"12".
++values.keep_if{+%7Cv%7C+v.is_a?+Numeric+}

++total+=+values.sum.to_f
++count+=+values.count
++return+Float::NAN+if+count.zero?

++total+/+count
end|729001|729002|compute_average(1,2,3,4,5)
=>+3.0

compute_average(0,0,0,0,0)
=>+0.0

compute_average(1,2,nil,4,5)
=>+3.0

compute_average(1,2,"string",4,5)
=>+3.0

compute_average(1)
=>+1.0

compute_average([1,2,3,4,5])
=>+3.0

compute_average
=>+NaN|729003|entityMap^0|0|0|0|0|0|0|0|0|0|0|6|6|0|0|0|0|4|6|0|0|4|6|0|0|P|6|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1T|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|1U|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|1V|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|1W|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|1X|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|1Y|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|20|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|21|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|22|8|@]|9|@]|A|$E|F]]|$1|W|3|X|5|6|7|23|8|@$Y|24|Z|25|10|11]]|9|@]|A|$]]|$1|12|3|13|5|D|7|26|8|@]|9|@]|A|$E|F]]|$1|14|3|15|5|6|7|27|8|@]|9|@]|A|$]]|$1|16|3|17|5|D|7|28|8|@]|9|@]|A|$E|F]]|$1|18|3|19|5|6|7|29|8|@$Y|2A|Z|2B|10|11]]|9|@]|A|$]]|$1|1A|3|1B|5|D|7|2C|8|@]|9|@]|A|$E|F]]|$1|1C|3|1D|5|6|7|2D|8|@$Y|2E|Z|2F|10|11]]|9|@]|A|$]]|$1|1E|3|1F|5|D|7|2G|8|@]|9|@]|A|$E|F]]|$1|1G|3|1H|5|6|7|2H|8|@$Y|2I|Z|2J|10|11]]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|2K|8|@]|9|@]|A|$]]|$1|1K|3|1L|5|6|7|2L|8|@]|9|@]|A|$]]|$1|1M|3|1N|5|D|7|2M|8|@]|9|@]|A|$E|F]]|$1|1O|3|H|5|6|7|2N|8|@]|9|@]|A|$]]|$1|1P|3|1Q|5|D|7|2O|8|@]|9|@]|A|$E|F]]|$1|1R|3|-4|5|6|7|2P|8|@]|9|@]|A|$]]]|1S|$]]

<h2>TL;DR: One possible solution</h2>

<pre><code>def compute_average(*values)

  # This makes sure arrays get flattened to a single array.
  values.flatten!

  # Throws away all nil values passed as arguments.
  values.reject!(&amp;:nil?)

  # Throws away all non-numeric values.
  # This includes trashing strings that look like numbers, like "12".
  values.keep_if{ |v| v.is_a? Numeric }

  total = values.sum.to_f
  return Float::NAN if total.zero?

  # I'm not sure what this business is
  #   average = [a, 2*b, 3*c, 4*d, 5*e].sum / total
  # but it can be translated to
  average = values.each_with_index.map{ |v,i| v*(i+1) }.sum / total

  average.round(2)
end
</code></pre>

<p>This protects against all cases:</p>

<pre><code>compute_average(1,2,3,4,5)
=&gt; 3.67

compute_average(0,0,0,0,0)
=&gt; NaN

compute_average(1,2,nil,4,5)
=&gt; 3.08

compute_average(1,2,"string",4,5)
=&gt; 3.08

compute_average(1)
=&gt; 1.0

compute_average([1,2,3,4,5])
=&gt; 3.67

compute_average
=&gt; NaN
</code></pre>

<h2>Original function:</h2>

<pre><code>def compute_average(a,b,c,d,e)
  total = [a,b,c,d,e].sum.to_f
  average = [a, 2*b, 3*c, 4*d, 5*e].sum / total
  average.round(2)
end
</code></pre>

<h2>Consider checking for zero:</h2>

<pre><code>def compute_average(a,b,c,d,e)
  total = [a,b,c,d,e].sum.to_f
  return if total.zero?
  average = [a, 2*b, 3*c, 4*d, 5*e].sum / total
  average.round(2)
end
</code></pre>

<p>This change only protects against one case:</p>

<pre><code>compute_average(1,2,3,4,5)
# =&gt; 3.67

compute_average(0,0,0,0,0)
# =&gt; nil

compute_average(1,2,nil,4,5)
# =&gt; TypeError: NilClass can't be coerced into Fixnum

compute_average(1,2,"string",4,5)
# =&gt; TypeError: String can't be coerced into Fixnum

compute_average(1)
# =&gt; ArgumentError: wrong number of arguments calling `compute_average` (1 for 5)

compute_average([1,2,3,4,5])
# =&gt; ArgumentError: wrong number of arguments calling `compute_average` (1 for 5)

compute_average
# =&gt; ArgumentError: wrong number of arguments calling `compute_average` (0 for 5)
</code></pre>

<h2>Consider using an inline <code>rescue</code></h2>

<pre><code>def compute_average(a,b,c,d,e)
  total = [a,b,c,d,e].sum.to_f
  average = [a, 2*b, 3*c, 4*d, 5*e].sum / total rescue 0
  average.round(2)
end
</code></pre>

<p>This change only protects against one case, also:</p>

<pre><code>compute_average(1,2,3,4,5)
# =&gt; 3.67

compute_average(0,0,0,0,0)
# =&gt; NaN

compute_average(1,2,nil,4,5)
# =&gt; TypeError: NilClass can't be coerced into Fixnum

compute_average(1,2,"string",4,5)
# =&gt; TypeError: String can't be coerced into Fixnum

compute_average(1)
# =&gt; ArgumentError: wrong number of arguments calling `compute_average` (1 for 5)

compute_average([1,2,3,4,5])
# =&gt; ArgumentError: wrong number of arguments calling `compute_average` (1 for 5)

compute_average
# =&gt; ArgumentError: wrong number of arguments calling `compute_average` (0 for 5)
</code></pre>

<p>Using an inline <code>rescue</code> has another consequence. Consider this typo:</p>

<pre><code>def compute_average(a,b,c,d,e)
  total = [a,b,c,d,e].sum.to_f
  average = [a, 2*b, 3*c, 4*d, 5*e].smu / total rescue 0
  #                                 ^^^
  average.round(2)
end

compute_average(1,2,3,4,5)
# =&gt; 0.0

compute_average(0,0,0,0,0)
# =&gt; 0.0
</code></pre>

<h2>Consider using a <code>rescue</code></h2>

<pre><code>def compute_average(a,b,c,d,e)
  total = [a,b,c,d,e].sum.to_f
  average = [a, 2*b, 3*c, 4*d, 5*e].sum / total
  average.round(2)
rescue ZeroDivisionError
  0.0
end
</code></pre>

<p>This is better, as it does not hide errors, but protects against the same scenario as the incline <code>rescue</code> above.</p>

<h2>Another version with what I would call a normal average calculation</h2>

<p>As a side note, the average operation I am familiar with is calculated using total/count, so here is a version that does that.</p>

<pre><code>def compute_average(*values)

  # This makes sure arrays get flattened to a single array.
  values.flatten!

  # Throws away all nil values passed as arguments.
  values.reject!(&amp;:nil?)

  # Throws away all non-numeric values.
  # This includes trashing strings that look like numbers, like "12".
  values.keep_if{ |v| v.is_a? Numeric }

  total = values.sum.to_f
  count = values.count
  return Float::NAN if count.zero?

  total / count
end
</code></pre>

<p>This protects against all cases:</p>

<pre><code>compute_average(1,2,3,4,5)
=&gt; 3.0

compute_average(0,0,0,0,0)
=&gt; 0.0

compute_average(1,2,nil,4,5)
=&gt; 3.0

compute_average(1,2,"string",4,5)
=&gt; 3.0

compute_average(1)
=&gt; 1.0

compute_average([1,2,3,4,5])
=&gt; 3.0

compute_average
=&gt; NaN
</code></pre>


blocks|key|729053|text|虽然这是一个过时的帖子，但我想我应该加入一个简单的线条，你可以使用……|type|unstyled|depth|inlineStyleRanges|entityRanges|data|729054|@average+=+variable1+/+variable2+rescue+0|code-block|syntax|javascript|729055|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|$]]

<p>While this is an outdated thread I thought I would chime in with a simple one liner you can use... </p>

<pre><code>@average = variable1 / variable2 rescue 0
</code></pre>


<p>I have the following method to compute an average:</p>

<pre><code>def compute_average(a,b,c,d,e)
  total = [a,b,c,d,e].sum.to_f
  average = [a, 2*b, 3*c, 4*d, 5*e].sum / total
  average.round(2)
end
</code></pre>

<p>It's nothing special, but it has a problem that I expect all average equations have: it might divide by zero if inputs are all zero.</p>

<p>So, I thought of doing this:</p>

<pre><code>def compute_average(a,b,c,d,e)
  total = [a,b,c,d,e].sum.to_f
  if total==0
    average = 0.00
  else
    average = [a, 2*b, 3*c, 4*d, 5*e].sum / total
    average.round(2)
  end
end
</code></pre>

<p>... and that works, but it feels kludgy to me. Is there a more elegant, "Ruby Way" to avoid this division by zero problem?</p>

<p>What I'm wishing I had was an "unless then" operator, like...</p>

<pre><code>average = numerator / denominator unless denominator == 0 then 0
</code></pre>

<p>Any suggestions?</p>


Ruby way: catch division by zero

我有以下方法来计算平均值：def compute_average(a,b,c,d,e)  total = [a,b,c,d,e].sum.to_f  average = [a, 2*b, 3*c, 4*d, 5*e].sum / total  average.round(2)end这没什么特别的，但它有一个我认为所有平...

问Ruby方式:捕获除法为零
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby方式:捕获除法为零EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Ruby方式:捕获除法为零
EN