Jaki jest elegancki sposób w Rubim, aby stwierdzić, czy zmienna jest hashem czy tablicą?

Aby sprawdzić, co @some_varjest, robię plik

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

Jestem pewien, że istnieje bardziej elegancki sposób sprawdzenia, czy @some_varjest a, Hashczy Array.

Możesz po prostu zrobić:

@some_var.class == Hash

lub też coś takiego:

@some_var.is_a?(Hash)

Warto zauważyć, że „is_a?” metoda jest prawdą, jeśli klasa znajduje się w dowolnym miejscu w drzewie przodków obiektów. na przykład:

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

powyższe jest prawdziwe, jeśli @some_var jest instancją skrótu lub innej klasy, która pochodzi z Object. Tak więc, jeśli chcesz ścisłego dopasowania do typu klasy, używając == lub instance_of? metoda jest prawdopodobnie tym, czego szukasz.

Przede wszystkim najlepszą odpowiedzią na dosłowne pytanie jest

Hash === @some_var

Ale na pytanie naprawdę należało odpowiedzieć, pokazując, jak tutaj pisać kaczkę. To zależy trochę od tego, jakiego rodzaju kaczki potrzebujesz.

@some_var.respond_to?(:each_pair)

lub

@some_var.respond_to?(:has_key?)

lub nawet

@some_var.respond_to?(:to_hash)

może mieć rację w zależności od aplikacji.

Zwykle w rubinowym, gdy szukasz „typu”, w rzeczywistości chcesz „typ kaczki” lub „czy to szarlatan jak kaczka?”. Zobaczysz, czy reaguje na określoną metodę:

@some_var.respond_to?(:each)

Możesz iterować po @some_var, ponieważ odpowiada na: each

Jeśli naprawdę chcesz znać typ i czy jest to Hash lub Array, możesz zrobić:

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

można tego również użyć z instrukcją case

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

Używam tego:

@var.respond_to?(:keys)

Działa dla Hash i ActiveSupport :: HashWithIndifferentAccess.

W praktyce często będziesz chciał zachowywać się inaczej w zależności od tego, czy zmienna jest tablicą, czy skrótem, a nie tylko zwykłym powiedzeniem. W tej sytuacji elegancki idiom jest następujący:

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

Pamiętaj, że nie wywołujesz .classmetody item.

Możesz użyć instance_of?

na przykład

@some_var.instance_of?(Hash)

Jeśli chcesz sprawdzić, czy obiekt jest ściśle lub rozszerza a Hash, użyj:

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

Ale aby zyskać wartość pisania kaczego Rubiego, możesz zrobić coś takiego:

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

Jest to przydatne, gdy chcesz uzyskać dostęp tylko do niektórych wartości za pomocą value[:key]składni.

Pamiętaj, że Array.new["key"]podniesie TypeError.

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