Qual è un modo elegante in Ruby per dire se una variabile è un hash o una matrice?

Per controllare cos'è @some_var, sto facendo un

if @some_var.class.to_s == 'Hash' 

Sono sicuro che esiste un modo più elegante per verificare se @some_varè un Hasho un Array.

Puoi semplicemente fare:

@some_var.class == Hash

o anche qualcosa di simile:

@some_var.is_a?(Hash)

Vale la pena notare che "is_a?" Il metodo è vero se la classe si trova in qualsiasi punto dell'albero degli antenati degli oggetti. per esempio:

@some_var.is_a?(Object)  # => true

quanto sopra è vero se @some_var è un'istanza di un hash o di un'altra classe che deriva da Object. Quindi, se vuoi una corrispondenza rigorosa sul tipo di classe, usando == o istanza_di? il metodo è probabilmente quello che stai cercando.

Prima di tutto, la migliore risposta per la domanda letterale è

Hash === @some_var

Ma alla domanda avrebbe davvero dovuto dare una risposta mostrando come eseguire la digitazione delle anatre qui. Dipende un po 'dal tipo di anatra di cui hai bisogno.

@some_var.respond_to?(:each_pair)

o

@some_var.respond_to?(:has_key?)

o anche

@some_var.respond_to?(:to_hash)

potrebbe essere giusto a seconda dell'applicazione.

Di solito in rubino quando stai cercando "tipo" in realtà stai cercando il "tipo di anatra" o "fa ciarlatano come un'anatra?". Vedresti se risponde a un certo metodo:

@some_var.respond_to?(:each)

Puoi iterare su @some_var perché risponde a: ciascuno

Se vuoi davvero conoscere il tipo e se è Hash o Array, puoi fare:

["Hash", "Array"].include?(@some_var.class)  #=> check both through instance class
@some_var.kind_of?(Hash)    #=> to check each at once
@some_var.is_a?(Array)   #=> same as kind_of

Hash === @some_var #=> return Boolean

questo può anche essere usato con case case

case @some_var
when Hash
   ...
when Array
   ...
end

Io lo uso questo:

@var.respond_to?(:keys)

Funziona con Hash e ActiveSupport :: HashWithIndifferentAccess.

In pratica, spesso vorrai agire in modo diverso a seconda che una variabile sia un array o un hash, non solo una semplice spiegazione. In questa situazione, un elegante linguaggio è il seguente:

case item
  when Array
   #do something
  when Hash
   #do something else
end

Si noti che non si chiama il .classmetodo item.

Puoi usare instance_of?

per esempio

@some_var.instance_of?(Hash)

Se si desidera verificare se un oggetto è strettamente o esteso a Hash, utilizzare:

value = {}
value.is_a?(Hash) || value.is_a?(Array) #=> true

Ma per valutare la digitazione dell'anatra di Ruby, potresti fare qualcosa del tipo:

value = {}
value.respond_to?(:[]) #=> true

È utile quando si desidera accedere ad alcuni valori utilizzando la value[:key]sintassi.

Si noti che Array.new["key"]aumenterà a TypeError.

irb(main):005:0> {}.class
=> Hash
irb(main):006:0> [].class
=> Array