Strings

In the numbers chapter, we learned how Ruby deals with numbers as Fixnum and Float objects.

For text, whether it be a single letter or a book, Ruby has the String class. This is an entirely different data object that won't mix with the data objects for numbers.

Text, words, characters

Strings are a sequence of characters denoted by single or double quotes. Here are some examples of strings:

• "a"
• "puts"
• "John's book"
• "12+100"
• 'To be or not to be, that is the question...'

A string can contain just a single character, a few words, or the entire works of Shakespeare.

In fact, they can contain numbers themselves:

"42"

And these quoted numbers may look like numbers, but they are not. Try adding these together:

"42" + 42
#=> TypeError: can't convert Fixnum into String
    

puts "Please treat these characters as a string and not a Ruby command"
#=> Please treat these characters as a string and not a Ruby command

puts Please treat these characters as a string and not a Ruby command
#=> NameError: undefined local variable or method `string' for #<Object:0x1001dd2a0>    

Either double or single quotes can be used to denote a string:

puts 100 + 10   #=>   110
puts "100 + 10"   #=>   100 + 10
puts "puts"      #=>   puts
puts puts      #   [a blank line] This is a double-called of the puts method, but no string was passed in to print out
      

Close your quotes

One of the most common show-stopping and confusing mistakes you'll make as a novice is not wrapping your strings in matching quotes. This is a very common typo to make early on.

If you start a string with a single quote ', you must end it with a single quote. If you start with ", end with ".

Here's the mistake in action; copy-and-paste this into irb to try it out:

puts "The following code is Dan's special math formula:
puts 42* 6+ 80 - 100^100*3.141
   

The programmer intends for the program to first print out a descriptive sentence and then output the result of a mathematical equation. But because he didn't close the string in the first line with a ", Ruby interprets the the second line is part of the initial string.

Try it out for yourself in irb. Until you put in that closing double-quote, the Ruby interpreter won't do anything no matter how many other characters you type in.

Students will sometimes miss the closing quote mark when copying code for practice. They then will complain their program doesn't do anything when they hit the Enter key. Without that closing quote, Ruby will interpret that Enter (carriage return/line break) character as just another part of the string, instead of an actual command.

This is another reason why we use a specialized text-editor such as TextWrangler or SciTE. For easy readability, these text editors color the content of the strings differently than the code:

String operations and methods

You can add strings together – this is sometimes referred to as concatenation. You can't subtract or multiply strings together:

puts "abc" + "def"   #=> "abcdef"
      

As I've mentioned in the numbers chapter, all the Ruby classes of data – such as Fixnum and Float – have a set of methods that can be called to do something, usually upon the object that invokes it.

As with numbers, we invoke a particular string's method with the dot operator .

puts (100.99).round 
#=> 101

puts "the quick brown fox jumps over the lazy dog".capitalize
#=> "The quick brown fox jumps over the lazy dog" 

Here are a few of the methods; the length method, which returns the number of characters in the string, will be one of the more frequently used String methods:

"abc".upcase   #=> "ABC"
"DEF".downcase   #=> "def"
"abcdef".reverse   #=> "fedcba"
"ABCdef".capitalize   #=> "Abcdef"
"dog park".length   #=> 8            
      

You can see a list of all String methods in the Ruby documentation.

Mixing datatypes

So a word wrapped in quotes is a String. What is a number wrapped in quotes? It is also a String.

What happens when you add together two numbers that have been wrapped in quotes?

puts 2 + 2   #   4
puts "2" + "2"   #   "22"
         

If this is confusing, your problem is that you are still thinking of "2" as a number. Ruby does not think that. It sees the quote marks and treats the "2" as it would treat any other quote-wrapped character:

puts "2" + "abc"   #   "2abc"
         

Adding a string to a number

Try adding a number to a String, like this:

"1" + 1

You should get an error. This is because the Ruby interpreter can't make sense of what you intend to do. Nor would a human being, if you asked her: "What's the sum of 42 and the letter D?"

We saw in the numbers chapter that Ruby can mix integers and decimals, even though they are technically different datatypes. But for some (actually, most) cases, Ruby won't allow you to mix objects of different classes.

"42".to_i + 42   #=> 84
"42" + 42.to_s   #=> "4242"
         

42.class   #   Fixnum
42.0.class   #   Float 
"42".class   #   String
String.class   #   Class         
Fixnum.class   #   Class
            

            
"hello".class + "world"   #=> [e.g. String + "world" – two different classes]
#=> TypeError: can't convert Class into String               
            

Combining strings with interpolation

Combining strings with non-strings using the plus sign + can be hard to read, and prone to error:

puts "The result of 7 + 7 is " + (7 + 7).to_s   
#=>   The result of 7 + 7 is 14

It's very easy to forget to miss a plus sign or closing quote when combining strings. Luckily, Ruby has a special notation that allows us to evaluate Ruby code and output the result into a String – within that String:

puts "The result of 7 + 7 is #{7+7}"   
#=>   The result of 7 + 7 is 14

puts "#{10 * 10} is greater than #{9 * 11}"   
#=>   100 is greater than 99
   

Notice how the expressions inside the #{ } are evaluated before being included in the string.

Two requirements here:

• The string must be enclosed in double-quotes
• Use a pound sign # followed by curly braces {} to enclose the Ruby code.

Earlier in this chapter, I said anything within quotes is treated by Ruby as just text characters. But the #{} notation essentially creates a Ruby code-interpreting environment within the curly braces.

So yes, this means you can put strings inside a string:

puts "No interpolation here.upcase"   
#=> No interpolation here.upcase

puts "This is interpolation #{"here".upcase}"   
#=> This is interpolation HERE

puts "This is not useful interpolation #{"here.upcase"}"   
#=> This is not useful interpolation here.upcase

puts "This is an error #{here.upcase}"   
#=>   ERROR 
   

The last two puts statements didn't work quite as expected. Why?

In line 3, the "here.upcase" inside the curly brackets is just one String. A String, when evaluated, is just a String.

In line 4, Ruby sees here as the name of a Ruby object, but since here does not actually exist as such, we get an error.

puts "The answer to 12387 * 345 is: " + (12387 * 345).to_s + " Which is a " + "very".upcase + " big number! Even bigger than 42 * 98 * 12, which is: " + (42 * 98 * 12).to_s   

puts "The answer to 12387 * 345 is: #{12387 * 345} Which is a #{"very".upcase} big number! Even bigger than 42 * 98 * 12, which is: #{42 * 98 * 12}"
    
#=> The answer to 12387 * 345 is: 4273515 Which is a VERY big number! Even bigger than 42 * 98 * 12, which is: 49392     

"Escape" with backslash

If quote marks are special Ruby notation for starting and ending a String, what happens when we want regular quotation marks as part of the text?

In the context of a String, the backslash character \ tells Ruby that the character immediately following it is special. The backslash is frequently referred to as the escape character because it...escapes (I guess?) a character from being interpreted as normal.

"He asked Jeeves, \"Where is the local patisserie?\" To which Jeeves responded, \"Over hither.\""

So in the above example, the \ tells Ruby that the following " is not to be treated as a quotation mark typically are: as a symbol that denotes the beginning or end of a string. This means, then, that \" is treated just as any other character in a string. Thus, the quoted String continues on.

The newline character

Inside a string, the character n is just a literal n. However, prepending a backslash like so – \n – tells Ruby to insert a newline character there:

puts "Doe, a deer, a female deer.\nRay, a piece of the\nsun."

#=> Doe, a deer, a female deer.
#=> Ray, a piece of the
#=> sun.
   

Note that in the sequence "the\nsun", only the n has its meaning affected by the backslash. The characters preceding the backslash – the – and the characters following the n – i.e. sun – remain literal.

You'll use the backslash character so often that you'll quickly memorize this list of common uses:

\n

a newline

\t

a tab space

\"

a literal quotation mark

\'

a literal apostrophe

\\

a literal backslash

Stick with double quotation marks

As with string interpolation, Ruby will only interpret most of the above uses of backslashes inside strings with double quotes. Single-quoted strings will only make use of \\ and \'

So as you begin to learn Ruby, I recommend always using double-quoted strings, just so you avoid bugs in which you wrongly assume an escape sequence to work in a single-quoted string. There's a extremely slight performance uptick in using single-quoted strings because Ruby doesn't have to check for any interpolation or all the other backslash combinations. But it'll be awhile before you're writing a program where that fraction of a fraction of a second is noticeable.

String substitution

One of the most common String operations is replacing certain characters with others. The method for that is called sub, short for substitution.

Unlike the few methods we've learned so far, sub takes in two arguments.

"Arguments" is a kind-of-confusing-term for the values/operating parameters that a method needs to do its work. We'll cover this more in detail in the methods chapter. Just play along for now.

puts "The cat and the hat".sub("hat", "rat")   #=> The cat and the rat
puts "Another brick in the wall".sub("brick in the", "")   #=>   "Another wall"
      

The first argument is the character(s) to replace. The second argument is what to replace it with.

The sub method replaces only the first occurrence of the string to match. If you want to replace all occurrences of a given string, use gsub, which is short for global substitution:

puts "I own an iPad, iPhone and an iPod".gsub('i', 'my')
#=>   I own an myPad, myPhone and an myPod
      

Methods and regular expressions

Remember these replacement methods for later, because we'll use them more after we've formally covered methods.

After you learn about regular expressions, you'll find yourself using them rather than strings with gsub. I don't consider regular expressions a programming fundamental because you don't have to be a programmer to use them. But they're so important to any one who works with text (e.g. you, the reader) that I've written a separate chapter for them (skipping to it now isn't such a bad idea).

Moving on

If you're a data-enthusiast, strings will be one your most frequently-used types of data. Get used to using interpolation as it'll make your code more readable and less error-prone.