Bir dizi, tek bir eleman veya nil verildiğinde, bir dizi elde edin - son ikisi sırasıyla tek eleman dizisi ve boş bir dizidir.

Yanlışlıkla Ruby'nin şu şekilde çalışacağını düşündüm:

[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

Ama gerçekten aldığınız şey:

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

Bu yüzden bunu çözmek için ya başka bir yöntem kullanmam gerekiyor ya da kullanmayı düşündüğüm tüm sınıfların to_a yöntemini değiştirerek meta program yapabilirim - ki bu benim için bir seçenek değil.

Yani bir Yöntem:

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

Sorun şu ki, biraz karışıklık. Bunu yapmanın zarif bir yolu var mı? (Bu sorunu çözmek için Ruby'ye benzeyen yol buysa şaşırırdım)

Bunun hangi uygulamaları var? Neden bir diziye dönüştürülsün ki?

Rails'in ActiveRecord'unda, demek, user.postsbir dizi gönderi, tek bir gönderi veya sıfır döndürür. Bunun sonuçları üzerinde çalışan metotları yazarken, metodun sıfır, bir veya birçok eleman içeren bir dizi alacağını varsaymak en kolayıdır. Örnek yöntem:

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

[*foo]ya Array(foo)da çoğu zaman işe yarayacaktır, ancak bir hash gibi bazı durumlarda, işleri berbat eder.

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

Bunun bir hash için bile işe yaradığını düşünebilmemin tek yolu bir yöntem tanımlamaktır.

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 (Rails) ile: 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 kullanmıyorsanız, kendi yönteminizi ray kaynağına benzer şekilde tanımlayabilirsiniz .

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

En basit çözüm kullanmaktır [foo].flatten(1). Önerilen diğer çözümlerin aksine, (iç içe geçmiş) diziler, karmalar ve 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) hile yapmalı

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

ActiveSupport (Raylar)

ActiveSupport'un bunun için oldukça güzel bir yöntemi var. Rails ile dolu, bunu yapmanın en güzel yolu meydan okurcasına:

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

Uyarı (Yakut 1.9+)

Splat operatörü ( *) bir diziyi diziyi çözebilir, eğer yapabilir:

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

Elbette, bir dizi olmadan garip şeyler yapar ve "savurduğunuz" nesnelerin dizilere yerleştirilmesi gerekir. Biraz tuhaf ama şu anlama geliyor:

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

ActiveSupport'a sahip değilseniz, yöntemi tanımlayabilirsiniz:

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

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

Bununla birlikte, büyük dizilere ve daha az dizi olmayan şeylere sahip olmayı planlıyorsanız, onu değiştirmek isteyebilirsiniz - yukarıdaki yöntem büyük dizilerde yavaştır ve hatta Stack'inizin Taşmasına (omg so meta) neden olabilir. Her neyse, bunun yerine bunu yapmak isteyebilirsiniz:

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]

Ayrıca teneray operatörü olan ve olmayan bazı kriterlerim var .

Ne dersin

[].push(anything).flatten

Bariz olanı belirtme riskiyle ve bunun gezegende ve çevresindeki bölgelerde şimdiye kadar görülen en lezzetli sözdizimsel şeker olmadığını bilerek, bu kod tam olarak tanımladığınız şeyi yapıyor gibi görünüyor:

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

Object'in dizi yönteminin üzerine yazabilirsiniz

class Object
    def to_a
        [self]
    end
end

her şey Object'i miras alır, bu nedenle to_a şimdi güneşin altındaki her şey için tanımlanacak

Tüm cevapları okudum ve çoğunlukla Ruby 2+ ile çalışmıyorum

Ancak elado en zarif çözüme sahiptir.

ActiveSupport (Rails) ile: 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}]

Maalesef bu Ruby 2+ için de işe yaramıyor çünkü bir hata alacaksınız

undefined method `wrap' for Array:Class

Yani bunu düzeltmek için ihtiyacınız olan şey.

'active_support / kullanımdan kaldırma' gerektiriyor

"active_support / core_ext / array / wrap" gerektir

Yöntem #to_a, iki ana sorunlu sınıf ( Nilve Hash) için zaten mevcut olduğundan , geri kalanı için genişleterek bir yöntem tanımlamanız yeterlidir Object:

class Object
    def to_a
        [self]
    end
end

ve sonra bu yöntemi herhangi bir nesnede kolayca çağırabilirsiniz:

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