Is there a way to conditionally add to an array in one line?

Question

I have str1 and str2. str1 may or not be an empty string, and I want to construct an array like:

str1 = ""
str2 = "bar"
["bar"]

or

str1 = "foo"
str2 = "bar"
["foo", "bar"]

I can only figure out a way to do this on two lines right now but I know there must be a way to do it one.

Answer 1

[str1, str2].reject {|x| x==''}
# ...or...
[str1, str2].reject &:empty?

Answer 2

In a way, I feel like there are 2 different questions being asked:

1. Is there a way to conditionally add to an array in one line?
2. How do I achieve this specific task.

Regarding question #1: Other people have already offered a lot of good options. One that I didn't see specifically mentioned though is that you can technically use a semicolon (;) as an inline statement separator and basically write whatever you want on a single line of code. For example:

array = []; if x; array << a; elsif y; array << b; else; array << c; end; array

Regarding question #2: Here's a fun option to to add to the list. Use the chomp(separator), split, and reverse methods.

str1 = ""
str2 = "bar"

"#{str2},#{str1}".chomp(",").split(",").reverse
#=>  ["bar"]

str1 = "foo"
str2 = "bar"

"#{str2},#{str1}".chomp(",").split(",").reverse
#=>  ["foo", "bar"]

string.chomp(substring) with and without reverse can be super handy ways to format string results that would otherwise need some conditional statements to handle the same operation somewhere else in the chain.

Answer 3

A more compact way to do this is using presence, which returns the object if present, or nil if not.

nil values can then be stripped with .compact:

[str1.presence, str2].compact

or even better, the magical * splat operator:

[*str1.presence, str2]

(And yes, pun was intended)

Answer 4

Note that sawa's proposed answer for Ruby 1.9 (currently the answer with the most votes) has issues when used with a hash - as follows;

> [*({foo: 1} if true), {foo: 2}]
[
    [0] [
        [0] :foo,
        [1] 1
    ],
    [1] {
        :foo => 2
    }
]

Note that the compact example works as you would expect;

[({foo: 1} if true), {foo: 2}].compact
[
    [0] {
        :foo => 1
    },
    [1] {
        :foo => 2
    }
]

Answer 5

You could monkey-patch Aray pr Enumerable and provide a conditional adding method.

module Array
 def add_if(object, condition=true)
   self << object if condition
   return self
 end
end

That way, it would be chainable, preserving most space in line. array = [].add(:class, is_given?).add(object, false) #etc

Answer 6

Perhaps a more concise version of Cyril's answer:

Array.new.tap do |array| if condition array << "foo" end end

Answer 7

Object#tap

[:starting_element].tap do |a|
  a << true if true
  a << false if false
  a << :for_sure
end
# => [:starting_element, true, :for_sure]

So in one line

[].tap { |a| [foo, bar].each { |thing| a << thing unless thing.blank? } }
[bar].tap { |a| a << bar unless foo.blank? }

Answer 8

Another way,

(str1.present? ? str1 : []) + [str2]

Answer 9

my_array = [str1, str2].find_all{|item| item != ""}

Answer 10

You can use delete_if:

['', 'hola'].delete_if(&:empty?)

If you're using Rails, you can replace empty? by blank?

['', 'hola'].delete_if(&:blank?)

or use a block:

['', 'hola'].delete_if{ |x| x == '' }

Answer 11

In ruby 1.9

[*(str1 unless str1.empty?), str2]

In ruby 1.8

[(str1 unless str1.empty?), str2].compact

Answer 12

You can use a ternary statement:

ary = (str1.empty?) ? [ str2 ] : [ str1, str2 ]

str1 = ''; str2 = 'bar'
(str1.empty?) ? [ str2 ] : [ str1, str2 ] #=> ["bar"]
str1 = 'foo'; str2 = 'bar'
(str1.empty?) ? [ str2 ] : [ str1, str2 ] #=> ["foo", "bar"]