Existe um oposto de incluir? para matrizes Ruby?

Eu tenho a seguinte lógica no meu código:

if !@players.include?(p.name)
  ...
end

@playersé uma matriz. Existe um método para que eu possa evitar o !?

Idealmente, esse snippet seria:

if @players.does_not_include?(p.name)
  ...
end

if @players.exclude?(p.name)
    ...
end

ActiveSupport adiciona o exclude?método para Array, Hash, e String. Isso não é puro Ruby, mas é usado por muitos rubiistas.

Fonte: Extensões principais do suporte ativo (guias de Rails)

Aqui está:

unless @players.include?(p.name)
  ...
end

Você pode dar uma olhada no Ruby Style Guide para obter mais informações sobre técnicas semelhantes.

Que tal o seguinte:

unless @players.include?(p.name)
  ....
end

Olhando apenas para Ruby:

TL; DR

Use none?passar um bloco com ==para a comparação:

[1, 2].include?(1)
  #=> true
[1, 2].none? { |n| 1 == n  }
  #=> false

Array#include?aceita um argumento e usa ==para verificar contra cada elemento na matriz:

player = [1, 2, 3]
player.include?(1)
 #=> true

Enumerable#none?também pode aceitar um argumento; nesse caso, ele é usado ===para a comparação. Para obter o comportamento oposto include?, omitimos o parâmetro e passamos um bloco ==para a comparação.

player.none? { |n| 7 == n }
 #=> true 
!player.include?(7)    #notice the '!'
 #=> true

No exemplo acima, podemos realmente usar:

player.none?(7)
 #=> true

Isso é porque Integer#==e Integer#===é equivalente. Mas considere:

player.include?(Integer)
 #=> false
player.none?(Integer)
 #=> false

none?retorna falseporque Integer === 1 #=> true. Mas realmente um notinclude?método legítimo deve retornar true. Assim como fizemos antes:

player.none? { |e| Integer == e  }
 #=> true

module Enumerable
  def does_not_include?(item)
    !include?(item)
  end
end

Ok, mas sério, a menos que funcione bem.

Use unless:

unless @players.include?(p.name) do
  ...
end

Você pode usar:

unless @players.include?(p.name) do
...
end

unlessé o oposto de if, ou você pode usar reject.

Você pode rejectos elementos não necessários:

@players.reject{|x| x==p.name}

após a obtenção dos resultados, você pode fazer sua implementação.

Usar unlessé bom para instruções com include?cláusulas únicas , mas, por exemplo, quando você precisa verificar a inclusão de algo em um, Arraymas não em outro, o uso de include?with exclude?é muito mais amigável.

if @players.include? && @spectators.exclude? do
  ....
end

Mas, como dizzy42 diz acima, o uso de exclude?requer ActiveSupport

Tente algo como isto:

@players.include?(p.name) ? false : true

Tente isso, é puro Ruby, portanto não há necessidade de adicionar estruturas periféricas

if @players.include?(p.name) == false do 
  ...
end

Eu estava lutando com uma lógica semelhante por alguns dias e, depois de verificar vários fóruns e quadros de perguntas e respostas com pouco proveito, a solução era realmente bastante simples.

Eu estava pesquisando por mim mesmo, encontrei isso e depois uma solução. As pessoas estão usando métodos confusos e alguns métodos que não funcionam em determinadas situações ou nem sequer funcionam.

Sei que agora é tarde demais, considerando que isso foi publicado há 6 anos, mas espero que futuros visitantes encontrem isso (e espero que possa limpar o código deles e o seu).

Solução simples:

if not @players.include?(p.name) do
  ....
end