Interpolation Super Power

Objectives

  1. Interpolate arbitrary code into a string
  2. Interpolate elements of an array into a single string

Overview

We've talked about string interpolation, but let's review quickly. String interpolation allows us to evaluate Ruby code, and inject the return value into the middle of a string. Normally, we see something like this:

name = "Bob"

puts "Hello, #{name}"

# => "Hello, Bob"

We're not just limited to injecting simple variables, though. We can do slightly fancier things if we just think of the pound sign/curly braces (#{}) as delimiters that allow us to run arbitrary code in the middle of a string. For example, there is nothing preventing us from doing something like this:

puts "1 plus 1 is #{1 + 1}!"

# => "1 plus 1 is 2!"

Almost anything is fair game here. In fact, we're not even limited to just one interpolation per string. It's perfectly acceptable for me to do the following:

three = 2 + 1
name  = "Bob"

puts "1 plus 1 is #{1 + 1} and 1 plus 2 is #{three} and 2 times 2 is
#{2 * 2}. Oh, hey #{name}!"

# => "1 plus 1 is 2 and 1 plus 2 is 3 and 2 times 2 is 4. Oh, hey Bob!"

This means we can do some pretty awesome stuff! Let's say we wanted to print out a business card for our friend, Bob. We want it to look like this:

# => "Name: Bob, Age: 46, Occupation: Juggler"

At first blush, it might make sense to do something like this:

name       = "Bob"
age        = 46
occupation = "Juggler"

puts "Name: #{name}, Age: #{age}, Occupation: #{occupation}"

# => "Name: Bob, Age: 46, Occupation: Juggler"

But what if, now, we also want to print a business card for Stefani? With this pattern, we'd need to start creating a whole bunch of variables:

bob_name           = "Bob"
bob_age            = 46
bob_occupation     = "Juggler"
stefani_name       = "Stefani"
stefani_age        = 49
stefani_occupation = "Firefighter"

puts "Name: #{bob_name}, Age: #{bob_age}, Occupation: #{bob_occupation}"

# => "Name: Bob, Age: 46, Occupation: Juggler"

puts "Name: #{stefani_name}, Age: #{stefani_age}, Occupation:
#{stefani_occupation}"

# => "Name: Stefani, Age: 49, Occupation: Firefighter"

Three variables per person is going to get really, really messy once we want to print 5, 10, or 100 business cards. We can clean this up quite a bit by considering that name, age, and occupation really just comprise a list of attributes about a person. We have a really great data structure for representing lists in Ruby...an array!

With that in mind, let's represent our data as an array:

bob     = ["Bob", 46, "Juggler"]
stefani = ["Stefani", 49, "Firefighter"]

If we wanted to print out Bob's name, we'd do it like this:

name = bob[0]

puts name

# => "Bob"

There's an extra step there, though! As we know, we can run whatever Ruby code we want inside the #{} in a string. So we can just access the first element in the array directly within the string:

puts "#{bob[0]}"

# => "Bob"

This is going to clean up our business card printer quite a bit!

bob     = ["Bob", 46, "Juggler"]
stefani = ["Stefani", 49, "Firefighter"]

puts "Name: #{bob[0]}, Age: #{bob[1]}, Occupation: #{bob[2]}"

# => "Name: Bob, Age: 46, Occupation: Juggler"

puts "Name: #{stefani[0]}, Age: #{stefani[1]}, Occupation: #{stefani[2]}"

# => "Name: Stefani, Age: 49, Occupation: Firefighter"

Nice! But even this is a bit much. The fact that we have to repeat so much code is a pretty good sign that we need a printer method.

So let's do that! Let's make a method, #print_business_card, that accepts an array representing a person, and then prints out their business card. First, we'll create the basic method signature:

def print_business_card(person)
end

Now, let's re-use the code we've already written to print out the passed-in person's details:

def print_business_card(person)
  puts "Name: #{person[0]}, Age: #{person[1]}, Occupation: #{person[2]}"
end

Something is missing, though. Our people need a phone number. Let's change our people arrays to look like this:

bob = ["Bob", 46, "Juggler", "555-555-5555"]

And in our #print_business_card method, let's print that out on a second line:

def print_business_card(person)
  puts "Name: #{person[0]}, Age: #{person[1]}, Occupation: #{person[2]}"
  puts "Contact: #{person[3]}"
end

Now, let's use this! Let's print out business cards for Bob and Stefani:

bob     = ["Bob", 46, "Juggler", "555-555-5555"]
stefani = ["Stefani", 49, "Firefighter", "555-111-1111"]

print_business_card(bob)

# => "Name: Bob, Age: 46, Occupation: Juggler"
# => "Contact: 555-555-5555"

print_business_card(stefani)

# => "Name: Stefani, Age: 49, Occupation: Firefighter"
# => "Contact: 555-111-1111"

String interpolation is basically a super power. And like any good super power, mastery comes with practice! (That's how Superman got so good at flying, right?) Your turn!

Instructions

  1. Define a method, #display_rainbow, in lib/display_rainbow.rb.
  2. #display_rainbow must accept an argument, an array of colors. The tests call #display_rainbow with the following invocation: display_rainbow(['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']).
  3. #display_rainbow should print out the colors of the rainbow in the following format: "R: red, O: orange, Y: yellow, G: green, B: blue, I: indigo, V: violet" by reading from the array passed in as an argument. (For this lab it is OK to hardcode the uppercase letters.)
  4. It should accept an array containing the colors as an argument.
  5. Run learn locally until you pass.
  6. Submit the lab.

colors will be passed in as: ['red', 'orange', 'yellow', 'green', 'blue', 'indigo', 'violet']

You must read from the colors argument and you should hardcode the order. Do not use #each or any loop. For example, given letters = ["b","a","c"] to print them in alphabetical order without iteration you should:

letters = ["b","a","c"]
puts "The first letter in the alphabet is: #{letters[1]}"
puts "The second letter in the alphabet is: #{letters[0]}"
puts "The third letter in the alphabet is: #{letters[2]}"

View Interpolation Super Power on Learn.co and start learning to code for free.

Unlock your future in tech
Learn to code.

Learn about Flatiron School's Mission

With a new take on education that falls somewhere between self-taught prodigy and four-year computer science degree, the Flatiron School promises to turn students with little programming experience into developers.

In the six months since the Manhattan coding school was acquired by WeWork, it has spawned locations in Washington, D.C., Brooklyn, and London. Now, WeWork is opening a fourth Flatiron School location, this time in Houston.

Adam Enbar, Flatiron School's cofounder, believes now is the time to grow. "How the world is changing has impacted working and learning in very similar ways. We think education fundamentally is about one thing: enabling people to pursue a better life."

Learn. Love. Code.
Students come to Flatiron School to change their lives. Join our driven community of career-changers and master the skills you need to become a software engineer or a data scientist.
Find Us