Ruby equivalent to grep -v - ruby

Question

This is what I've been doing instead:
my_array.reject { |elem| elem =~ /regex/ }.each { ... }
I feel like this is a little unwieldy, but I haven't found anything built in that would let me change it to my_array.grepv /regex/ { ... }
Is there such a function?

Answer 1

Ruby 2.3 implements an Enumerable#grep_v method that is exactly what you're after.
https://ruby-doc.org/core-2.3.0/Enumerable.html#method-i-grep_v

Answer 2

You know how Symbol#to_proc helps with chaining? You can do the same with regular expressions:
class Regexp
def to_proc
Proc.new {|string| string =~ self}
end
end
["Ruby", "perl", "Perl", "PERL"].reject(&/perl/i)
=> ["Ruby"]
But you probably shouldn't. Grep doesn't just work with regular expressions - you can use it like the following
[1,2, "three", 4].grep(Fixnum)
and if you wanted to grep -v that, you'd have to implement Class#to_proc, which sounds wrong.

Answer 3

How about this?
arr = ["abc", "def", "aaa", "def"]
arr - arr.grep(/a/) #=> ["def", "def"]
I deliberately included a dup to make sure all of them are returned.

Answer 4

What about inverting the regex?
["ab", "ac", "bd"].grep(/^[^a]/) # => ["bd"]

Answer 5

I don't believe there's anything built-in like this, but it's simple enough to add:
class Array
def grepv(regex, &block)
self.reject { |elem| elem =~ regex }.each(&block)
end
end
Note that you need to use parens around the regex when you call this function, otherwise you get a syntax error:
myarray.grepv(/regex/) { ... }

Answer 6

You can do:
my_array.reject{|e| e[/regex/]}.each { ... }
but really it's hard to be more concise and self-documenting. It could be written using grep(/.../) with some negative-lookahead pattern, but then I think it becomes harder to comprehend the overall action because the pattern itself is harder to understand.

Answer 7

You simply need to negate the result of the regexp match.
Enumerable.module_eval do
def grepv regexp
if block_given?
self.each do |item|
yield item if item !~ regexp
end
else
self.find_all do |item|
item !~ regexp
end
end
end
end

Answer 8

Thank you all for your comments. In the end, I did it this way:
module Enumerable
def grepv(condition)
non_matches = []
self.each do |item|
unless condition === item or condition === item.to_s
non_matches.push(item)
yield item if block_given?
end
end
return non_matches
end
end
Not sure if that's the best way because I'm just getting started with Ruby. It's a bit longer than other people's solutions here, but I like it because it's quite analogous to Enumerable's grep option - it works with anything that can handle the ===, just like grep, and it yields the items it finds if a block was given, and either way returns an Array of those that didn't match.
I added the or to_s part so that any integers, for instance, interspersed in the array could be matched with the same regex, though I could imagine this might jack things sometimes.

Answer 9

Try using Array#collect!
my_array.collect! do |elem|
if elem =~ /regex/
# do stuff
elem
end
end
EDIT: Sorry, then you would have to call Array#compact after. At least that would eliminate the second block. But it's more physical code. It depends on how much "stuff" you do.

Answer 10

Here's another shot at it, with a sprinkling of bltxd's and Hsiu's answers, and hopefully retaining as much of the spirit of the original grep as possible (even if it's wordy):
module Enumerable
def grepv(condition)
if block_given?
each do |item|
yield item if not condition === item
end
else
inject([]) do |memo, item|
memo << item if not condition === item
memo
end
end
end
end
If you supply a block, then everything is lazy like you would expect. If you don't supply a block, there is a little duplicate code. I really wish that Andrew Grimm's answer applied in the general case.
>> (%w(1 2 3) + [4]).cycle(3).grepv(Fixnum)
=> ["1", "2", "3", "1", "2", "3", "1", "2", "3"]
>> (%w(1 2 3) + [4]).cycle(3).grepv(/[12]/)
=> ["3", 4, "3", 4, "3", 4]
In neither case do you pay up to O(n^2) for item comparison, like you would in the worst case if you do array subtraction.