Biorąc pod uwagę tablicę, pojedynczy element lub nil, uzyskaj tablicę - dwie ostatnie są odpowiednio tablicą jednoelementową i pustą.

Pomyłkowo pomyślałem, że Ruby będzie działać w ten sposób:

[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

Ale tak naprawdę otrzymujesz:

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

Aby rozwiązać ten problem, muszę albo użyć innej metody, albo metaprogram, modyfikując metodę to_a wszystkich klas, których zamierzam użyć - co nie jest dla mnie opcją.

Oto metoda:

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

Problem w tym, że jest trochę bałaganu. Czy jest na to elegancki sposób? (Byłbym zdziwiony, gdyby to był Rubinowy sposób rozwiązania tego problemu)

Jakie to ma aplikacje? Po co w ogóle konwertować na tablicę?

W ActiveRecord Railsów, wywołanie say, user.postszwróci albo tablicę postów, pojedynczy post, albo zero. Pisząc metody, które działają na wynikach tego, najłatwiej jest założyć, że metoda przyjmie tablicę, która może mieć zero, jeden lub wiele elementów. Przykładowa metoda:

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

[*foo]lub Array(foo)będzie działać przez większość czasu, ale w niektórych przypadkach, takich jak hash, psuje.

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]]

Jedynym sposobem, w jaki mogę pomyśleć, że działa to nawet w przypadku skrótu, jest zdefiniowanie metody.

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}]

Z 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}]

Jeśli nie używasz Railsów, możesz zdefiniować własną metodę podobną do źródła railsów .

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

Najprostszym rozwiązaniem jest użycie [foo].flatten(1). W przeciwieństwie do innych proponowanych rozwiązań sprawdzi się dobrze w przypadku (zagnieżdżonych) tablic, skrótów i 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) powinien załatwić sprawę

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

ActiveSupport (szyny)

ActiveSupport ma na to całkiem niezłą metodę. Jest załadowany Railsami, więc zdecydowanie najładniejszy sposób na zrobienie tego:

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

Splat (Ruby 1.9+)

Operator splat ( *) usuwa tablice z tablicy, jeśli może:

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

Oczywiście bez tablicy robi dziwne rzeczy, a obiekty, które „splata” trzeba umieścić w tablicach. To trochę dziwne, ale oznacza:

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

Jeśli nie masz ActiveSupport, możesz zdefiniować metodę:

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

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

Chociaż, jeśli planujesz mieć duże tablice i mniej rzeczy niezwiązanych z tablicami, możesz chcieć to zmienić - powyższa metoda jest powolna w przypadku dużych tablic i może nawet spowodować przepełnienie stosu (omg, więc meta). W każdym razie możesz to zrobić zamiast tego:

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]

Mam też kilka testów z operatorem dzisiejszego dnia i bez niego.

Co powiesz na

[].push(anything).flatten

Ryzykując stwierdzenie oczywistego i wiedząc, że nie jest to najsmaczniejszy cukier syntaktyczny, jaki kiedykolwiek widziano na naszej planecie i otaczających ją obszarach, ten kod wydaje się robić dokładnie to, co opisujesz:

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

możesz nadpisać metodę tablicową Object

class Object
    def to_a
        [self]
    end
end

wszystko dziedziczy Object, dlatego to_a będzie teraz zdefiniowane dla wszystkiego pod słońcem

Przejrzałem wszystkie odpowiedzi i przeważnie nie działają w Ruby 2+

Ale elado ma najbardziej eleganckie rozwiązanie, tj

Z 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}]

Niestety, ale to również nie działa dla Ruby 2+, ponieważ pojawi się błąd

undefined method `wrap' for Array:Class

Aby to naprawić, musisz wymagać.

wymagaj „active_support / deprecation”

wymagają „active_support / core_ext / array / wrap”

Ponieważ metoda #to_ajuż istnieje dla dwóch głównych klas problematycznych ( Nili Hash), po prostu zdefiniuj metodę dla pozostałych, rozszerzając Object:

class Object
    def to_a
        [self]
    end
end

a następnie możesz łatwo wywołać tę metodę na dowolnym obiekcie:

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