blocks|key|2100526|text|据我所知，没有一个标准的方法可以做到这一点(假设find_all和reject相互引用，但find没有引用任何东西)。如果您经常需要它(特别是当拒绝太慢时)，您可以编写自己的代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2100527|module+Enumerable

++def+first_reject(&block)
++++find+{%7Ca%7C+not+(block.call(a))+}
++end

end|code-block|syntax|javascript|2100528|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|$]]

As far as I can tell there is not a standard method to do this (given that find_all and reject reference each other, but find does not reference anything). If you need it frequently (especially if the reject is too slow) you can write your own

<pre><code>module Enumerable

 def first_reject(&amp;block)
 find {|a| not (block.call(a)) }
 end

end
</code></pre>

blocks|key|2395983|text|这里有is+not，但是你也可以用一种干净的方式创建一个：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2395984|a+=+[0,2,1,0,3]

module+Enumerable
++def+first_not(&block)
++++find{+%7Cx%7C+!block[x]+}
++end
end

p+a.first_not(&:zero?)
#=>+2|code-block|syntax|javascript|2395985|...or这个非常有趣的黑客方式：|2395986|class+Proc
++def+!
++++proc{+%7Co,*a%7C+!self[o,*a]+}
++end
end

p+a.find(&!(:zero?.to_proc))
#=>+2|2395987|用简洁但非常危险的方式...or：|2395988|class+Symbol
++def+!
++++proc{+%7Co,*a%7C+!o.send(self,*a)+}
++end
end

p+a.find(&!:zero?)
#=>+2|2395989|但我主张跳过棘手的Symbol#to_proc用法，说出你想说的：|style|CODE|2395990|p+a.find{+%7Ci%7C+!i.zero?+}
#=>+2|2395991|entityMap|0|LINK|mutability|MUTABLE|url|http://ruby-doc.org/core/classes/Enumerable.html^0|3|6|0|0|0|0|0|0|0|9|E|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@]|9|@$A|15|B|16|1|17]]|C|$]]|$1|D|3|E|5|F|7|18|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|19|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|1A|8|@]|9|@]|C|$G|H]]|$1|M|3|N|5|6|7|1B|8|@]|9|@]|C|$]]|$1|O|3|P|5|F|7|1C|8|@]|9|@]|C|$G|H]]|$1|Q|3|R|5|6|7|1D|8|@$A|1E|B|1F|S|T]]|9|@]|C|$]]|$1|U|3|V|5|F|7|1G|8|@]|9|@]|C|$G|H]]|$1|W|3|-4|5|6|7|1H|8|@]|9|@]|C|$]]]|X|$Y|$5|Z|10|11|C|$12|13]]]]

There <a href="http://ruby-doc.org/core/classes/Enumerable.html">is not</a>, but you could create one either the clean-ish way:

<pre><code>a = [0,2,1,0,3]

module Enumerable
 def first_not(&amp;block)
 find{ |x| !block[x] }
 end
end

p a.first_not(&amp;:zero?)
#=&gt; 2
</code></pre>

...or the horribly-amusing hack way:

<pre><code>class Proc
 def !
 proc{ |o,*a| !self[o,*a] }
 end
end

p a.find(&amp;!(:zero?.to_proc))
#=&gt; 2
</code></pre>

...or the terse-but-terribly-dangerous way:

<pre><code>class Symbol
 def !
 proc{ |o,*a| !o.send(self,*a) }
 end
end

p a.find(&amp;!:zero?)
#=&gt; 2
</code></pre>

But I'd advocate just skipping the tricky <code>Symbol#to_proc</code> usage and saying what you want:

<pre><code>p a.find{ |i| !i.zero? }
#=&gt; 2
</code></pre>

blocks|key|4174638|text|如果您使用的是Ruby2.0，那么您可能能够执行lazy.reject(&:zero?).first，而不会因为遍历整个数组而造成性能损失。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|4174639|entityMap^0|O|Q|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

If you're using Ruby 2.0, you may be able to do <code>lazy.reject(&amp;:zero?).first</code> without the performance penalty of going through the full array.

<pre><code>a, b, c = 0, 1, 2
[a, b, c].find(&amp;:zero?) # =&gt; 0
</code></pre>

Is there any method that finds the first element for which the block returns false?

<pre><code>[a, b, c].the_method(&amp;:zero?) # =&gt; 1
</code></pre>

In other words, it would behave the same way as:

<pre><code>[a, b, c].reject(&amp;:zero?).first
</code></pre>

Is there a method in Ruby that does the opposite of find?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

a, b, c = 0, 1, 2[a, b, c].find(&:zero?) # => 0有没有什么方法可以找到块返回false的第一个元素？[a, b, c].the_method(&:zero?) # => 1换句话说，它的行为方式与：[a, b, c].reject(&:zero?).first

问在Ruby中有与find相反的方法吗？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中有与find相反的方法吗？EN