equivalente a grep -v Rubí

Question

Esto es lo que he estado haciendo en su lugar:

my_array.reject { |elem| elem =~ /regex/ }.each { ... } 

siento que esto es un poco difícil de manejar, pero no he encontrado nada construido en el que me permitiera cambiarlo a my_array.grepv /regex/ { ... }

¿Existe tal función?

Answer 1

Trate de usar Array#collect!

my_array.collect! do |elem| 
    if elem =~ /regex/ 
    # do stuff 
    elem 
    end 
end 

EDIT: Lo sentimos, entonces usted tendría que llamar Array#compact después. Al menos eso eliminaría el segundo bloque. Pero es más código físico. Depende de la cantidad de "cosas" que hagas.

Answer 2

Usted puede hacer:

my_array.reject{|e| e[/regex/]}.each { ... } 

pero realmente es difícil ser más conciso y auto-documentado. Podría escribirse usando grep(/.../) con algún patrón de búsqueda negativa, pero luego creo que se hace más difícil comprender la acción general porque el patrón en sí es más difícil de entender.

Answer 3

No creo que haya nada incorporada como este, pero es lo suficientemente simple para agregar:

class Array 
    def grepv(regex, &block) 
    self.reject { |elem| elem =~ regex }.each(&block) 
    end 
end 

Tenga en cuenta que es necesario utilizar parens torno a la expresión regular cuando se llama a esta función, de lo contrario se obtiene un error de sintaxis:

myarray.grepv(/regex/) { ... } 

Answer 4

sólo hay que anular el resultado de la coincidencia de expresiones regulares.

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 5

¿Qué le parece esto?

 
arr = ["abc", "def", "aaa", "def"] 
arr - arr.grep(/a/) #=> ["def", "def"] 

Incluí deliberadamente un dup para asegurarme de que se devolvieran todos.

Answer 6

Gracias a todos por sus comentarios. Al final, lo hice de esta manera:

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 

No estoy seguro si esa es la mejor manera porque sólo estoy Primeros pasos con Ruby. Aquí es un poco más largo que las soluciones de otras personas, pero me gusta porque es bastante análogo a la opción grep de Enumerable: funciona con cualquier elemento que pueda manejar el ===, al igual que grep, y arroja los elementos que encuentra si un bloque era dado, y de cualquier manera devuelve una matriz de aquellos que no coinciden.

Agregué la parte or to_s para que cualquier número entero, por ejemplo, intercalado en la matriz pudiera coincidir con la misma expresión regular, aunque podría imaginar que esto podría cambiar las cosas a veces.

Answer 7

¿Sabes cómo Symbol#to_proc ayuda con el encadenamiento? Puede hacer lo mismo con expresiones regulares:

class Regexp 
    def to_proc 
    Proc.new {|string| string =~ self} 
    end 
end 

["Ruby", "perl", "Perl", "PERL"].reject(&/perl/i) 
=> ["Ruby"] 

Pero probablemente no debería.Grep no solo trabaja con expresiones regulares - se puede usar como el siguiente

[1,2, "three", 4].grep(Fixnum) 

y si quería a grep -v eso, se tendría que aplicar Class#to_proc, que suena mal.

Answer 8

¿Qué tal invertir la expresión regular?

["ab", "ac", "bd"].grep(/^[^a]/) # => ["bd"] 

Answer 9

Aquí hay otro tiro en él, con una rociada de bltxd 's y Hsiu' respuestas s, y es de esperar que conserva la mayor cantidad de espíritu del original grep como sea posible (incluso si es prolijo):

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 

Si proporciona un bloque, todo es flojo como cabría esperar. Si no proporciona un bloque, hay un pequeño código duplicado. Realmente deseo que la respuesta de Andrew Grimm se aplique en el caso general.

>> (%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] 

En ninguno de los casos hacen que paga hasta O(n^2) elemento de comparación, al igual que lo haría en el peor de los casos si lo hace matriz resta.

Answer 10

Ruby 2.3 implementa un método Enumerable#grep_v que es exactamente lo que buscas.

https://ruby-doc.org/core-2.3.0/Enumerable.html#method-i-grep_v