#splat operator

[davidmcafee]

-27

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.

Also reviewed the uses of the splat operator in Ruby, and watched some videos on recursion.

[davidmcafee]

-59

Yesterday I reviewed the function of the splat operator, and I think I getting a much better grasp on it’s multiple uses, specifically, how it can be useful with passing multiple arguments in a function call. I’d already known it’s use when defining a method (i.e. def method_name(*argument_list), that is, for accepting different numbers of parameters for the method, which in turn would be accessed like an array from the method. But the part that I found particularly interesting was how it also can do the opposite: the splat operator in the above case was creating an array, but it can also flatten an array. How is that useful? If I have an array that I want to pass to another method, I can use the splat operator in my method call and that method will not receive the array as an array, but as separate arguments.

[turingwithgeorge-blog]

Random Tip: Fun with Splat Operators!

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

b = *”Hello” #=> [”Hello”]

[unqb]

Adam Sanderson with some cool tips and tricks on using Ruby's splat operator from 1.9 and on.