Ruby - test pour tableau

Quelle est la bonne façon de:

is_array("something") # => false         (or 1)

is_array(["something", "else"]) # => true  (or > 1)

ou pour obtenir le nombre d'éléments en elle?

Vous voulez probablement utiliser kind_of().

>> s = "something"
=> "something"
>> s.kind_of?(Array)
=> false
>> s = ["something", "else"]
=> ["something", "else"]
>> s.kind_of?(Array)
=> true

Êtes-vous sûr qu'il doit s'agir d'un tableau? Vous pourrez peut-être l'utiliser respond_to?(method)pour que votre code fonctionne pour des choses similaires qui ne sont pas nécessairement des tableaux (peut-être une autre chose numérotable). Si vous en avez réellement besoin array, le message décrivant la Array#kind\_of?méthode est le meilleur.

['hello'].respond_to?('each')

Au lieu de tester pour Array,simplement convertir tout ce que vous obtenez en un seul niveau Array,, votre code n'a besoin que de gérer le seul cas.

t = [*something]     # or...
t = Array(something) # or...
def f *x
    ...
end

Ruby a différentes façons d'harmoniser une API qui peut prendre un objet ou un tableau d'objets, donc, devinez pourquoi vous voulez savoir si quelque chose est un tableau, j'ai une suggestion.

L' opérateur splat contient beaucoup de magie que vous pouvez rechercher, ou vous pouvez simplement appeler Array(something)ce qui ajoutera un wrapper Array si nécessaire. C'est similaire à [*something]celui-ci.

def f x
  p Array(x).inspect
  p [*x].inspect
end
f 1         # => "[1]"
f [1]       # => "[1]"
f [1,2]     # => "[1, 2]"

Ou, vous pouvez utiliser le splat dans la déclaration de paramètres, puis .flattenvous donner un type de collecteur différent. (D'ailleurs, vous pouvez également appeler .flattenci - dessus.)

def f *x
  p x.flatten.inspect
end         # => nil
f 1         # => "[1]"
f 1,2       # => "[1, 2]"
f [1]       # => "[1]"
f [1,2]     # => "[1, 2]"
f [1,2],3,4 # => "[1, 2, 3, 4]"

Et, grâce à gregschlom , il est parfois plus rapide de simplement l'utiliser Array(x)parce que quand c'est déjà un, Arrayil n'a pas besoin de créer un nouvel objet.

[1,2,3].is_a? Array évalue à vrai.

Il semble que vous recherchiez quelque chose qui a un certain concept d'articles. Je recommanderais donc de voir si c'est le cas Enumerable. Cela garantit également l'existence de #count.

Par exemple,

[1,2,3].is_a? Enumerable
[1,2,3].count

notez que, tandis que size, lengthet counttous fonctionnent pour les tableaux, countest le bon sens ici - (par exemple, 'abc'.lengthet les 'abc'.sizedeux fonctionnent, mais 'abc'.countne fonctionnent pas comme ça).

Attention: une chaîne is_a? Enumerable, alors peut-être que ce n'est pas ce que vous voulez ... dépend de votre concept d'un objet de type tableau.

Essayer:

def is_array(a)
    a.class == Array
end

EDIT : L'autre réponse est bien meilleure que la mienne.

Pensez également à utiliser Array(). Extrait du Ruby Community Style Guide :

Utilisez Array () au lieu de la vérification explicite du tableau ou [* var], lorsque vous traitez une variable que vous souhaitez traiter comme un tableau, mais vous n'êtes pas certain qu'il s'agisse d'un tableau.

# bad
paths = [paths] unless paths.is_a? Array
paths.each { |path| do_something(path) }

# bad (always creates a new Array instance)
[*paths].each { |path| do_something(path) }

# good (and a bit more readable)
Array(paths).each { |path| do_something(path) }