#splat operator

Today ended my wife’s summer break, and so begins my next several weeks of very intense preparation before I begin App Academy.

I started off by working quickly through the App Academy curriculum on github. I always learn best by being exposed to material several times, over time, so I figured it would be best to start looking ahead as much as possible. Since there is several weeks of material, I don’t plan to do all the exercises, and I plan to work fast (part of being able to work in an intense and fast-paced environment is practice, so I figured I should begin practicing just that). I figure it’s best to place myself into a timed, fast-paced context on my own, because a huge part of learning is learning to learn.

Today involved going over the basics once more, including coding style and debugging. I was very surprised to learn that Byebug can be used as a conditional debugger—super helpful if a method is called several times in your program, and you need to see which call is causing a problem.

Normally when you see the “*” character, you associate it with the multiplication function. However, if you see it before a variable name, it can have interesting purposes depending on the state of that variable. 

If you find it before an argument collection variable in a method:

def method(*args)

  #stuff

end

then it takes in all arguments into an array, so that if you call on the method:

method(1, 2, 3, 4, 5)

then args would be a local variable within that method equalling [1, 2, 3, 4, 5]. 

You can separate out multiple arguments accepted for the method and have the splat operator absorb any arguments that are left over after the other arguments have been assigned, if any (it wold be an empty array if there are not enough arguments passed for it to take in any after the other arguments are collected). 

Here’s the (slightly) tricky part. The splat operator can take in all of the arguments at the end, the beginning, or even from the middle! Here are three examples. 

def method(a, b, *c)

  [a, b, c]

end

method (1, 2, 3, 4, 5) #=> [1, 2, [3, 4, 5]]

_______________________________________________________________________

def method(*a, b, c)

    [a, b, c]

end

method (1, 2, 3, 4, 5) #=> [[1, 2, 3], 4, 5]

_______________________________________________________________________

def method(a, *b, c)

  [a, b, c]

end

method (1, 2, 3, 4, 5) #=> [1, [2, 3, 4], 5]

_______________________________________________________________________

The double splat “**” is similar, except it converts arguments passed in as key value pairs into a hash and can only be at the end of the argument collection for a method:

def method(a, b, **c)

  [a, b, c]

end

method (1, 2, a: 3, b: 4, c: 5) #=> [1, 2, {3, 4, 5}]

Once a key value pair is passed, then it only expects the rest of the arguments passed to be key value pairs and raises an error message if this format is not adhered to. 

Splat operators can also be used in deconstructing their respective arrays and hashes into their individual elements/key-value pair. So, if you had an array:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

calling method with 

method(*numbers)

would be synonymous with

method(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

and the same for the double splat hash

nums = {a: 1, b: 2, c: 3}

method(nums) #=> method(a: 1, b: 2, c: 3)

which probably wouldn’t work very well unless you had a double splat operator to catch those key value pairs!

You can also use the splat operator to do some quick variable assignments. Just like with :

a, b = 1, 2 #=> a = 1, b = 2

a, *b, c = 1, 2, 3, 4, 5  #=> a = 1, b = [2, 3, 4], c = 5

The last thing I will mention about the splat operator is that you can use it to coerce into array format things that normally can’t be converted into an array:

a = “Hello”.to_a #=> NoMethodError: undefined method `to_a' for "Hello":String