Come restituire vero se solo una chiave specifica in un hash ha un vero valore (tutti gli altri valori sono false)

Question

Per esempio:

options = { fight: true, 
use_item: false, 
run_away: false, 
save_game: false } 

Voglio un espressione booleana che restituisce true se e solo se solo :fight è true e il resto sono false (come illustrato sopra).

Posso incidere questo insieme, ma sto cercando di allenarmi a scrivere più elegante rubino. Grazie!

EDIT: L'essere mod:

(options[:fight] == true && options.delete(:fight).values.all {|x| !x})

Answer 1

Ispirato dalla risposta di Vitaliy:

options[:flight] && options.values.one? 

Answer 2

options.find_all{|k,v| v } == [[:fight, true]] 

o

options.values.count(true) == 1 && options[:fight] 

Answer 3

Assumendo tutti i valori sono rigorosamente booleano, è semplice come:

options == {fight: true, use_item: false, run_away: false, save_game: false} 

See documentation for the == method

Answer 4

Penso che il tuo trucco non sia male. Esso può essere semplificato un po 'però:

options.delete(:flight) && options.values.none? 

Answer 5

ne dite:

options.all? {|k,v| k == :fight ? v : !v} 

Per un approccio più generale:

def is_action?(options, action) 
    options.all? {|k,v| k == action ? v : !v} 
end 

is_action? options, :fight 
# => true 

Answer 6

Questo è indipendente dal numero di chiave/elems in l'hash.

options[:fight] && options.find_all{|arr| !arr[1]}.size == options.size-1 

Anche Solo un consiglio, in Ruby, non è necessario scrivere qualcosa come:

options[:fight] == true 

Answer 7

options.select{ |k, v| v } == [[:fight, true]] 

Answer 8

Se controlli il contenuto dell'hash, ed è relativamente piccolo, vorrei usare qualcosa di simile in un metodo privato come soluzione generica.

def exclusively_true?(hash, key) 
    return false unless hash.delete(key) == true 
    !hash.has_value? true 
end 

require 'test/unit' 
class TestExclusive < Test::Unit::TestCase 
    def setup 
    @test_hash = {foo: true, bar: false, hoge: false} 
    end 
    def test_exclusive 
    assert_equal(true, exclusively_true?(@test_hash, :foo)) 
    end 
    def test_inexclusive 
    @test_hash[:bar] = true 
    assert_equal(false, exclusively_true?(@test_hash, :foo)) 
    end 
end 

require 'benchmark' 

h = {foo: true} 
999.times {|i| h["a#{i}"] = false} 
Benchmark.bmbm(30) do |x| 
    x.report('exclusively_true') do 
    1000.times do 
     exclusively_true?(h, :foo) 
    end 
    end 
end 

benchmark artificiosa: (OS X 10.8.3/3 GHz/8 GB)

ruby -v: ruby 2.0.0p0 (2013-02-24 revision 39474) [x86_64-darwin12.3.0] 
Rehearsal ------------------------------------------------------------------ 
exclusively_true     0.000000 0.000000 0.000000 ( 0.000412) 
--------------------------------------------------------- total: 0.000000sec 

            user  system  total  real 
exclusively_true     0.000000 0.000000 0.000000 ( 0.000331)