¿Cuál es una manera elegante en Ruby para saber si una variable es un Hash o una matriz?

Para comprobar qué @some_vares, estoy haciendo un

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

Estoy seguro de que hay una forma más elegante de verificar si @some_vares una Hasho una Array.

Solo puedes hacer:

@some_var.class == Hash

o también algo como:

@some_var.is_a?(Hash)

Vale la pena señalar que el "is_a?" El método es verdadero si la clase está en cualquier parte del árbol de ascendencia de los objetos. por ejemplo:

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

lo anterior es cierto si @some_var es una instancia de un hash u otra clase que se deriva de Object. Entonces, si desea una coincidencia estricta en el tipo de clase, utilizando == o instancia_de? El método es probablemente lo que estás buscando.

En primer lugar, la mejor respuesta para la pregunta literal es

Hash === @some_var

Pero la pregunta realmente debería haberse respondido mostrando cómo hacer tipear patos aquí. Eso depende un poco del tipo de pato que necesites.

@some_var.respond_to?(:each_pair)

o

@some_var.respond_to?(:has_key?)

o incluso

@some_var.respond_to?(:to_hash)

puede ser correcto dependiendo de la aplicación.

Por lo general, en rubí cuando buscas "tipo", en realidad quieres el "tipo pato" o "¿grazna como un pato?". Vería si responde a cierto método:

@some_var.respond_to?(:each)

Puede iterar sobre @some_var porque responde a: cada

Si realmente quiere saber el tipo y si es Hash o Array, puede hacer lo siguiente:

["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

esto también se puede usar con declaración de caso

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

Yo uso esto:

@var.respond_to?(:keys)

Funciona para Hash y ActiveSupport :: HashWithIndifferentAccess.

En la práctica, a menudo querrá actuar de manera diferente dependiendo de si una variable es una matriz o un hash, no solo una simple indicación. En esta situación, un idioma elegante es el siguiente:

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

Tenga en cuenta que no llama al .classmétodo item.

Puedes usar instance_of?

p.ej

@some_var.instance_of?(Hash)

Si desea probar si un objeto es estrictamente o extiende a Hash, use:

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

Pero para valorar la escritura del pato de Ruby, podría hacer algo como:

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

Es útil cuando solo desea acceder a algún valor utilizando la value[:key]sintaxis.

Tenga en cuenta que Array.new["key"]elevará a TypeError.

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