Quelle est la manière élégante dans Ruby de dire si une variable est un hachage ou un tableau?

Pour vérifier ce que @some_varc'est, je fais un

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

Je suis sûr qu'il existe un moyen plus élégant de vérifier si @some_varest un Hashou un Array.

Vous pouvez simplement faire:

@some_var.class == Hash

ou aussi quelque chose comme:

@some_var.is_a?(Hash)

Il convient de noter que le "is_a?" La méthode est vraie si la classe est n'importe où dans l'arborescence d'ascendance des objets. par exemple:

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

ce qui précède est vrai si @some_var est une instance d'un hachage ou d'une autre classe qui provient d'Object. Donc, si vous voulez une correspondance stricte sur le type de classe, utilisez le == ou instance_of? La méthode est probablement ce que vous recherchez.

Tout d'abord, la meilleure réponse à la question littérale est

Hash === @some_var

Mais la question aurait vraiment dû être répondue en montrant comment faire du typage canard ici. Cela dépend un peu du type de canard dont vous avez besoin.

@some_var.respond_to?(:each_pair)

ou

@some_var.respond_to?(:has_key?)

ou même

@some_var.respond_to?(:to_hash)

peut avoir raison selon l'application.

Habituellement, en rubis, lorsque vous recherchez «type», vous voulez en fait le «type canard» ou «est-ce que charlatan est comme un canard? Vous verriez s'il répond à une certaine méthode:

@some_var.respond_to?(:each)

Vous pouvez parcourir @some_var car il répond à: each

Si vous voulez vraiment connaître le type et s'il s'agit de Hash ou Array, vous pouvez faire:

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

cela peut également être utilisé avec l'instruction case

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

J'utilise ceci:

@var.respond_to?(:keys)

Cela fonctionne pour Hash et ActiveSupport :: HashWithIndifferentAccess.

En pratique, vous voudrez souvent agir différemment selon que la variable est un tableau ou un hachage, et pas seulement un simple tell. Dans cette situation, un idiome élégant est le suivant:

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

Notez que vous n'appelez pas la .classméthode item.

Vous pouvez utiliser instance_of?

par exemple

@some_var.instance_of?(Hash)

Si vous voulez tester si un objet est strictement ou étend a Hash, utilisez:

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

Mais pour valoriser le typage du canard de Ruby, vous pouvez faire quelque chose comme:

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

C'est utile lorsque vous ne souhaitez accéder qu'à une valeur en utilisant la value[:key]syntaxe.

Veuillez noter que Array.new["key"]cela augmentera un TypeError.

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