Étant donné un tableau, un seul élément ou nil, obtenez un tableau - les deux derniers étant respectivement un tableau d'élément unique et un tableau vide.

J'ai pensé à tort que Ruby fonctionnerait de cette façon:

[1,2,3].to_a  #= [1,2,3]     # Already an array, so no change
1.to_a        #= [1]         # Creates an array and adds element
nil.to_a      #= []          # Creates empty array

Mais ce que vous obtenez vraiment, c'est:

[1,2,3].to_a  #= [1,2,3]         # Hooray
1.to_a        #= NoMethodError   # Do not want
nil.to_a      #= []              # Hooray

Donc, pour résoudre cela, je dois soit utiliser une autre méthode, soit je pourrais utiliser un méta-programme en modifiant la méthode to_a de toutes les classes que j'ai l'intention d'utiliser - ce qui n'est pas une option pour moi.

Donc une méthode c'est:

result = nums.class == "Array".constantize ? nums : (nums.class == "NilClass".constantize ? [] : ([]<<nums))

Le problème est que c'est un peu le bordel. Y a-t-il une manière élégante de faire cela? (Je serais étonné si c'est la façon rubis de résoudre ce problème)

Quelles applications cela a-t-il? Pourquoi même convertir en un tableau?

Dans ActiveRecord de Rails, appeler par exemple user.postsrenverra un tableau de messages, un seul article ou nil. Lors de l'écriture de méthodes qui fonctionnent sur les résultats de ceci, il est plus facile de supposer que la méthode prendra un tableau, qui peut avoir zéro, un ou plusieurs éléments. Exemple de méthode:

current_user.posts.inject(true) {|result, element| result and (element.some_boolean_condition)}

[*foo]ou Array(foo)fonctionnera la plupart du temps, mais dans certains cas, comme un hachage, cela le gâche.

Array([1, 2, 3])    # => [1, 2, 3]
Array(1)            # => [1]
Array(nil)          # => []
Array({a: 1, b: 2}) # => [[:a, 1], [:b, 2]]

[*[1, 2, 3]]    # => [1, 2, 3]
[*1]            # => [1]
[*nil]          # => []
[*{a: 1, b: 2}] # => [[:a, 1], [:b, 2]]

La seule façon dont je peux penser que cela fonctionne même pour un hachage est de définir une méthode.

class Object; def ensure_array; [self] end end
class Array; def ensure_array; to_a end end
class NilClass; def ensure_array; to_a end end

[1, 2, 3].ensure_array    # => [1, 2, 3]
1.ensure_array            # => [1]
nil.ensure_array          # => []
{a: 1, b: 2}.ensure_array # => [{a: 1, b: 2}]

Avec ActiveSupport (Rails): Array.wrap

Array.wrap([1, 2, 3])     # => [1, 2, 3]
Array.wrap(1)             # => [1]
Array.wrap(nil)           # => []
Array.wrap({a: 1, b: 2})  # => [{:a=>1, :b=>2}]

Si vous n'utilisez pas de rails, vous pouvez définir votre propre méthode similaire à la source des rails .

class Array
  def self.wrap(object)
    if object.nil?
      []
    elsif object.respond_to?(:to_ary)
      object.to_ary || [object]
    else
      [object]
    end
  end
end

La solution la plus simple est d'utiliser [foo].flatten(1). Contrairement aux autres solutions proposées, cela fonctionnera bien pour les tableaux (imbriqués), les hachages et nil:

def wrap(foo)
  [foo].flatten(1)
end

wrap([1,2,3])         #= [1,2,3]
wrap([[1,2],[3,4]])   #= [[1,2],[3,4]]
wrap(1)               #= [1]
wrap(nil)             #= [nil]
wrap({key: 'value'})  #= [{key: 'value'}]

Array(whatever) devrait faire l'affaire

Array([1,2,3]) # [1,2,3]
Array(nil) # []
Array(1337)   # [1337]

ActiveSupport (rails)

ActiveSupport a une méthode assez intéressante pour cela. Il est chargé de Rails, donc la meilleure façon de le faire:

Array.wrap([1, 2, 3]) #=> [1, 2, 3]
Array.wrap(nil) #=> nil

Splat (Ruby 1.9+)

L'opérateur splat ( *) annule le tableau d'un tableau, s'il le peut:

*[1,2,3] #=> 1, 2, 3 (notice how this DOES not have braces)

Bien sûr, sans tableau, il fait des choses bizarres, et les objets que vous "splatez" doivent être placés dans des tableaux. C'est un peu bizarre, mais cela signifie:

[*[1,2,3]] #=> [1, 2, 3]
[*5] #=> [5]
[*nil] #=> []
[*{meh: "meh"}] #=> [[:meh, "meh"], [:meh2, "lol"]]

Si vous ne disposez pas d'ActiveSupport, vous pouvez définir la méthode:

class Array
    def self.wrap(object)
        [*object]
    end
end

Array.wrap([1, 2, 3]) #=> [1, 2, 3]
Array.wrap(nil) #=> nil

Bien que, si vous prévoyez d'avoir de grands tableaux et moins de choses non-tableau, vous voudrez peut-être le changer - la méthode ci-dessus est lente avec de grands tableaux et peut même provoquer un débordement de votre pile (omg so meta). Quoi qu'il en soit, vous voudrez peut-être faire ceci à la place:

class Array
    def self.wrap(object)
        object.is_a? Array ? object : [*object]
    end
end

Array.wrap([1, 2, 3]) #=> [1, 2, 3]
Array.wrap(nil) #=> [nil]

J'ai aussi quelques benchmarks avec et sans l'opérateur teneray.

Que diriez-vous

[].push(anything).flatten

Avec le risque de déclarer l'évidence, et sachant que ce n'est pas le sucre syntaxique le plus savoureux jamais vu sur la planète et les régions environnantes, ce code semble faire exactement ce que vous décrivez:

foo = foo.is_a?(Array) ? foo : foo.nil? ? [] : [foo]

vous pouvez écraser la méthode de tableau de Object

class Object
    def to_a
        [self]
    end
end

tout hérite de Object, donc to_a sera maintenant défini pour tout sous le soleil

J'ai parcouru toutes les réponses et la plupart du temps ne fonctionne pas dans ruby ​​2+

Mais elado a la solution la plus élégante à savoir

Avec ActiveSupport (Rails): Array.wrap

Array.wrap ([1, 2, 3]) # => [1, 2, 3]

Array.wrap (1) # => [1]

Array.wrap (nil) # => []

Array.wrap ({a: 1, b: 2}) # => [{: a => 1,: b => 2}]

Malheureusement, mais cela ne fonctionne pas non plus pour ruby ​​2+ car vous obtiendrez une erreur

undefined method `wrap' for Array:Class

Donc, pour résoudre ce problème, vous devez exiger.

nécessitent 'active_support / deprecation'

nécessitent 'active_support / core_ext / array / wrap'

Puisque la méthode #to_aexiste déjà pour les deux principales classes problématiques ( Nilet Hash), définissez simplement une méthode pour le reste en étendant Object:

class Object
    def to_a
        [self]
    end
end

et vous pouvez facilement appeler cette méthode sur n'importe quel objet:

"Hello world".to_a
# => ["Hello world"]
123.to_a
# => [123]
{a:1, b:2}.to_a
# => [[:a, 1], [:b, 2]] 
nil.to_a
# => []