给定一个数组，则单个元素或nil获得一个数组-后两个分别为单个元素数组和一个空数组。

我错误地认为Ruby可以这样工作：

[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

但是，您真正得到的是：

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

因此，要解决此问题，我要么需要使用另一种方法，要么可以通过修改我打算使用的所有类的to_a方法来元程序-这对我来说不是一个选择。

所以一个方法是：

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

问题是，这有点混乱。是否有一种优雅的方法？（如果这是解决该问题的类似Ruby的方法，我会感到惊讶）

这有什么应用程序？为什么还要转换为数组？

在Rails的ActiveRecord中，调用say user.posts会返回一组帖子，单个帖子或nil。当编写根据此结果工作的方法时，最容易假设该方法将采用一个数组，该数组可能具有零个，一个或多个元素。示例方法：

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

[*foo]或Array(foo)将在大多数情况下有效，但是对于某些情况（例如哈希），它会搞砸。

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

我认为即使是哈希也可以使用的唯一方法是定义方法。

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

使用ActiveSupport（导轨）： 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}]

如果您不使用Rails，则可以定义自己的方法，类似于rails source。

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

最简单的解决方案是使用[foo].flatten(1)。与其他建议的解决方案不同，它适用于（嵌套）数组，哈希和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) 应该可以

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

ActiveSupport（导轨）

ActiveSupport为此提供了一种非常不错的方法。它装有Rails，因此绝对是实现此目的的最佳方法：

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

Splat（Ruby 1.9+）

*如果可以，splat运算符（）取消数组的数组：

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

当然，如果没有数组，它会做一些奇怪的事情，并且您需要“散布”的对象需要放在数组中。这有点怪异，但这意味着：

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

如果没有ActiveSupport，则可以定义方法：

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

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

虽然，如果您打算使用大型数组，而较少使用非数组的东西，则可能需要更改它-上面的方法对于大型数组很慢，甚至可能导致堆栈溢出（omg meta meta）。无论如何，您可能要这样做：

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]

无论有没有Teneray运算符，我都有一些基准。

怎么样

[].push(anything).flatten

冒着陈述明显的风险，并知道这不是在地球和周边地区见过的最美味的语法糖，此代码似乎完全符合您的描述：

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

您可以覆盖Object的数组方法

class Object
    def to_a
        [self]
    end
end

一切都继承了Object，因此to_a现在将为阳光下的所有事物定义

我已经仔细研究了所有的答案，但大多数情况下都无法在ruby中工作2+

但是elado有最优雅的解决方案，即

使用ActiveSupport（导轨）：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}]

可悲的是，但这对于Ruby 2+也不起作用，因为您会得到一个错误

undefined method `wrap' for Array:Class

因此，为了解决此问题，您需要进行修复。

需要'active_support / deprecation'

需要'active_support / core_ext / array / wrap'

由于该方法#to_a已经存在于两个主要有问题的类（Nil和Hash），因此只需扩展Object以下内容即可定义其余方法：

class Object
    def to_a
        [self]
    end
end

然后您可以轻松地在任何对象上调用该方法：

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