C'è un contrario di include? per Ruby Arrays?

Ho la seguente logica nel mio codice:

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

@playersè un array. Esiste un metodo per evitare il !?

Idealmente, questo frammento sarebbe:

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

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

ActiveSupport aggiunge il exclude?metodo Array, Hashe String. Questo non è puro rubino, ma è usato da MOLTI rubini.

Fonte: estensioni del nucleo di supporto attivo (guide di rotaie)

Ecco qui:

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

Potresti dare un'occhiata alla Ruby Style Guide per maggiori informazioni su tecniche simili.

Che ne dici di quanto segue:

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

Guardando solo Ruby:

TL; DR

Usa none?passandogli un blocco con ==per il confronto:

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

Array#include?accetta un argomento e utilizza ==per verificare ogni elemento dell'array:

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

Enumerable#none?può anche accettare un argomento nel qual caso utilizza ===per il confronto. Per ottenere il comportamento opposto include?omettiamo il parametro e passiamo un blocco usando ==per il confronto.

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

Nell'esempio sopra possiamo effettivamente usare:

player.none?(7)
 #=> true

Questo perché Integer#==e Integer#===sono equivalenti. Ma considera:

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

none?ritorna falseperché Integer === 1 #=> true. Ma in realtà notinclude?dovrebbe tornare un metodo legittimo true. Come abbiamo fatto prima:

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

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

Ok, ma sul serio, a meno che non funzioni bene.

Utilizzare unless:

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

Puoi usare:

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

unlessè l'opposto di if, o è possibile utilizzare reject.

È possibile rejectgli elementi non richiesti:

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

dopo aver ottenuto i risultati è possibile eseguire l'implementazione.

L'uso unlessva bene per le affermazioni con singole include?clausole ma, ad esempio, quando è necessario verificare l'inclusione di qualcosa in uno Arrayma non in un altro, l'uso di include?with exclude?è molto più amichevole.

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

Ma come dice dizzy42 sopra, l'uso di exclude?richiede ActiveSupport

Prova qualcosa del genere:

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

Prova questo, è puro Ruby, quindi non è necessario aggiungere alcun framework periferico

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

Ho lottato con una logica simile per alcuni giorni, e dopo aver controllato molti forum e schede di domande e risposte con scarso risultato, la soluzione era in realtà piuttosto semplice.

Stavo cercando su questo per me stesso, ho trovato questo e quindi una soluzione. Le persone usano metodi confusi e alcuni metodi che non funzionano in determinate situazioni o per niente.

So che è troppo tardi ora, considerando che questo è stato pubblicato 6 anni fa, ma spero che i futuri visitatori lo trovino (e si spera, può ripulire il loro e il tuo codice).

Soluzione semplice:

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