Head First Ruby

Chapter 1. More with Less: Code the Way You Want

You’re wondering what this crazy Ruby language is all about, and if it’s right for you. Let us ask you this: Do you like being productive? Do you feel like all those extra compilers and libraries and class files and keystrokes in your other language bring you closer to a finished product, admiring coworkers, and happy customers? Would you like a language that takes care of the details for you? If you sometimes wish you could stop maintaining boilerplate code and get to work on your problem, then Ruby is for you. Ruby lets you get more done with less code.

The Ruby philosophy

Back in the 1990s in Japan, a programmer named Yukihiro Matsumoto (“Matz” for short) was dreaming about his ideal programming language. He wanted something that:

• Was easy to learn and use

• Was flexible enough to handle any programming task

• Let the programmer concentrate on the problem they were trying to solve

• Gave the programmer less stress

• Was object-oriented

He looked at the languages that were available, but felt that none of them was exactly what he wanted. So he set out to make his own. He called it Ruby.

After tinkering around with Ruby for his own work for a while, Matz released it to the public in 1995. Since then, the Ruby community has done some amazing things:

• Built out a vast collection of Ruby libraries that can help you do anything from reading CSV (comma-separated value) files to controlling objects over a network

• Written alternate interpreters that can run your Ruby code faster or integrate it with other languages

• Created Ruby on Rails, a hugely popular framework for web applications

This explosion of creativity and productivity was enabled by the Ruby language itself. Flexibility and ease of use are core principles of the language, meaning you can use Ruby to accomplish any programming task, in fewer lines of code than other languages.

Once you’ve got the basics down, you’ll agree: Ruby is a joy to use!

Flexibility and ease of use are core principles of Ruby.

Get Ruby

First things first: you can write Ruby code all day, but it won’t do you much good if you can’t run it. Let’s make sure you have a working Ruby interpreter installed. We want version 2.0 or later. Open up a new terminal window (also known as a command-line prompt) and type:

ruby -v

When you type ruby -v at a prompt, if you see a response like this, you’re in business:

Do this!

If you don’t have Ruby 2.0 or later, visit www.ruby-lang.org and download a copy for your favorite OS.

By the way, if you accidentally type ruby by itself (without the -v), Ruby will wait for you to enter some code. To exit this mode, just hold the Control key and press the C key on your keyboard. You can do this any time you need Ruby to exit immediately.

Use Ruby

Ruby source files that you can execute are referred to as scripts, but they’re really just plain-text files. To run a Ruby script, you simply save your Ruby code in a file, and run that file with the Ruby interpreter.

You may be used to other languages (like C++, C#, or Java) where you have to manually compile your code to a binary format that a CPU or virtual machine can understand. In these languages, your code can’t be executed before you compile it.

Other languages:

With Ruby, you skip that step. Ruby instantly and automatically compiles the source code in your script. This means less time between writing your code and trying it out!

The Ruby way:

Type your source code. Save as: hello.rb

Run your source code with the Ruby interpreter.

Use Ruby—interactively

There’s another big benefit to using a language like Ruby. Not only do you not have to run a compiler each time you want to try out your code, but you don’t even have to put it in a script first.

Ruby comes with a separate program, called irb (for Interactive Ruby). The irb shell lets you type any Ruby expression, which it will then immediately evaluate and show you the results. It’s a great way to learn the language, because you get immediate feedback. But even Ruby professionals use irb to try out new ideas.

Throughout the book, we’ll be writing lots of scripts to be run via the Ruby interpreter. But any time you’re testing out a new concept, it’s a great idea to launch irb and experiment a bit.

So what are we waiting for? Let’s get into irb now and play around with some Ruby expressions.

Using the irb shell

Open a terminal window, and type irb. This will launch the interactive Ruby interpreter. (You’ll know it’s running because the prompt will change, although it may not match exactly what you see here.)

From there, you can type any expression you want, followed by the Enter/Return key. Ruby will instantly evaluate it and show you the result.

When you’re done with irb, type exit at the prompt, and you’ll be returned to your OS’s prompt.

Your first Ruby expressions

Now that you know how to launch irb, let’s try out a few expressions and see what results we get!

Type the following at the prompt, then press Return: 1 + 2

You’ll be shown the result:

Math operations and comparisons

Ruby’s basic math operators work just like they do in most other languages. The + symbol is for addition, - for subtraction, * for multiplication, / for division, and ** for exponentiation.

You can use < and > to compare two values and see if one is less than or greater than another. You can also use == (that’s two equals signs) to see if two values are equal.

Strings

A string is a series of text characters. You can use strings to hold names, email addresses, phone numbers, and a million other things. Ruby’s strings are special because even very large strings are highly efficient to work with (this isn’t true in many other languages).

The easiest way to specify a string is to surround it either with double quotes (") or single quotes ('). The two types of quotes work a little differently; we’ll cover that later in the chapter.

Variables

Ruby lets us create variables—names that refer to values.

You don’t have to declare variables in Ruby; assigning to them creates them. You assign to a variable with the = symbol (that’s a single equals sign).

A variable name starts with a lowercase letter, and can contain letters, numbers, and underscores.

Once you’ve assigned to variables, you can access their values whenever you need, in any context where you might use the original value.

Variables don’t have types in Ruby; they can hold any value you want. You can assign a string to a variable, then immediately assign a floating-point number to the same variable, and it’s perfectly legal.

The += operator lets you add on to the existing value of a variable.

Conventional Wisdom

Use all lowercase letters in variable names. Avoid numbers; they’re rarely used. Separate words with underscores.

my_rank = 1

This style is sometimes called “snake case,” because the underscores make the name look like it’s crawling on the ground.

Everything is an object!

Ruby is an object-oriented language. That means your data has useful methods (fragments of code that you can execute on demand) attached directly to it.

In modern languages, it’s pretty common for something like a string to be a full-fledged object, so of course strings have methods to call:

What’s cool about Ruby, though, is that everything is an object. Even something as simple as a number is an object. That means numbers have useful methods, too.

Calling a method on an object

When you make a call like this, the object you’re calling the method on is known as the method receiver. It’s whatever is to the left of the dot operator. You can think of calling a method on an object as passing it a message—like a note saying, “Hey, can you send me back an uppercase version of yourself ?” or “Can I have your absolute value?”

Exercise

Open a new terminal window, type irb, and hit the Enter/Return key. For each of the Ruby expressions below, write your guess for what the result will be on the line below it. Then try typing the expression into irb, and hit Enter. See if your guess matches what irb returns!

Exercise Solution

Open a new terminal window, type irb, and hit the Enter/Return key. For each of the Ruby expressions below, write your guess for what the result will be on the line below it. Then try typing the expression into irb, and hit Enter. See if your guess matches what irb returns!

Let’s build a game

In this first chapter, we’re going to build a simple game. If that sounds daunting, don’t worry; it’s easy when you’re using Ruby!

Let’s look at what we’ll need to do:

	Prompt the player to enter their name. Use their name to print a greeting.
	Generate a random number from 1 to 100, and store it as a target number for the player to guess.
	Keep track of how many guesses the player has made. Before each guess, let them know how many guesses (out of 10) they have left.
	Prompt the player to make a guess as to what the target number is.
	If the player’s guess is less than the target number, say, “Oops. Your guess was LOW.” If the player’s guess is greater than the target number, say, “Oops. Your guess was HIGH.”
	If the player’s guess is equal to the target number, tell them, “Good job, [name]! You guessed my number in [number of guesses] guesses!”
	If the player runs out of turns without guessing correctly, say, “Sorry. You didn’t get my number. My number was [target].”
	Keep allowing the player to guess until they get it right or run out of turns.

Gary Richardott Game Designer

Input, storage, and output

Our first requirement is to greet the user by name. To accomplish that, we’ll need to write a script that gets input from the user, stores that input, and then uses that stored value to create some output.

We can do all this in just a few lines of Ruby code:

We’ll go into detail on each component of this script over the next few pages. But first, let’s give it a try!

Running scripts

We’ve written a simple script that fulfills our first requirement: to greet the player by name. Now, you’ll learn how to execute the script so you can see what you’ve created.

Do this!

Step One:

Open a new document in your favorite text editor, and type in the following code.

Step Two:

Save the file as get_number.rb.

Step Three:

Open up a terminal window and change into the directory where you saved your program.

Step Four:

Run the program by typing ruby get_number.rb.

Step Five:

You’ll see a greeting and a prompt. Type your name and hit the Enter/Return key. You’ll then see a message that welcomes you by name.

Let’s take a few pages to look at each part of this code in more detail.

Comments

Our source file starts out with a couple of comments. Ruby ignores everything from a hash mark (#) up until the end of the line, so that you can leave instructions or notes for yourself and your fellow developers.

If you place a # in your code, then everything from that point until the end of the line will be treated as a comment. This works just like the double-slash (//) marker in Java or JavaScript.

i_am = "executed" # I'm not.
# Me neither.

“puts” and “print”

The actual code starts with a call to the puts method (“puts” is short for “put string”), which displays text on standard output (usually the terminal). We pass puts a string containing the text to display.

We pass another string to the print method on the following line, to ask the user their name. The print method works just like puts, except that puts adds a newline character at the end of the string (if it doesn’t already have one) to skip to the following line, whereas print doesn’t. For cosmetic reasons, we end the string that we pass to print with a space, so that our text doesn’t run up against the area where the user types their name.

Sometimes you don’t have to specify a receiver for method calls.

The puts and print methods are so important, and so commonly used, that they’re among a select few methods that have been included in Ruby’s top-level execution environment. Methods defined in the top-level environment are available for you to call anywhere in your Ruby code, without specifying a receiver. You’ll see how to define methods like this at the start of Chapter 2.

Method arguments

The puts method takes a string and prints it to standard output (your terminal window).

puts "first line"

The string passed to the puts method is known as the method argument.

The puts method can take more than one argument; just separate the arguments with commas. Each argument gets printed on its own line.

puts "second line", "third line", "fourth line"

“gets”

The gets method (short for “get string”) reads a line from standard input (characters typed in the terminal window). When you call gets, it causes the program to halt until the user types their name and presses the Enter key. It returns the user’s text to the program as another string.

As with puts and print, you can call the gets method from anywhere in your code without specifying a receiver.

Parentheses are optional on method calls

Method arguments can be surrounded with parentheses in Ruby:

puts("one", "two")

But the parentheses are optional, and in the case of puts, most Rubyists prefer to leave them off.

puts "one", "two"

As noted above, the gets method reads a line from standard input. It doesn’t (usually) need any arguments:

gets

Rubyists are adamant that parentheses not be used if a method takes no arguments. So please, don’t do this, even though it’s valid code:

Conventional Wisdom

Leave parentheses off of a method call if there are no arguments. You can leave them off for method calls where there are arguments as well, but this can make some code more difficult to read. When in doubt, use parentheses!

String interpolation

The last thing our script does is to call puts with one more string. This one is special because we interpolate (substitute) the value in the name variable into the string. Whenever you include the #{...} notation inside a double-quoted string, Ruby uses the value in the curly braces to “fill in the blank.” The #{...} markers can occur anywhere in the string: the beginning, end, or somewhere in the middle.

You’re not limited to using variables within the #{...} marker—you can use any Ruby expression.

Note that Ruby applies interpolation only in double-quoted strings. If you include a #{...} marker in a single-quoted string, it will be taken literally.

There are No Dumb Questions

Q:	Q: Where are the semicolons?
A:	A: In Ruby, you can use semicolons to separate statements, but you generally shouldn’t. (It’s harder to read.) Ruby treats separate lines as separate statements, making semicolons unnecessary. puts "Hello" puts "World"
Q:	Q: My other language would require me to put this script in a class with a “main” method. Doesn’t Ruby?
A:	A: No! That’s one of the great things about Ruby—it doesn’t require a bunch of ceremony for simple programs. Just write a few statements, and you’re done!

Ruby doesn’t require a bunch of ceremony for simple programs.

What’s in that string?

Well, that’s easy enough to add. Let’s throw an exclamation point on the end of the greeting string, after the interpolated value.

But if we try running the program again, we’ll see that rather than appearing immediately after the user’s name, the exclamation point jumps down to the next line!

Why is this happening? Maybe there’s something going on within that input variable...

Printing it via the puts method doesn’t reveal anything special about it, though. If we append this line to the code above, we’d see this output:

Inspecting objects with the “inspect” and “p” methods

Now let’s try again, using a method meant especially for troubleshooting Ruby programs. The inspect method is available on any Ruby object. It converts the object to a string representation that’s suitable for debugging. That is, it will reveal aspects of the object that don’t normally show up in program output.

Here’s the result of calling inspect on our string:

What’s that \n at the end of the string? We’ll solve that mystery on the next page...

Printing the result of inspect is so common that Ruby offers another shortcut: the p method. It works just like puts, except that it calls inspect on each argument before printing it.

This call to p is effectively identical to the previous code:

Remember the p method; we’ll be using it in later chapters to help debug Ruby code!

The “inspect” method reveals information about an object that doesn’t normally show up in program output.

Escape sequences in strings

Our use of the p method has revealed some unexpected data at the end of the user’s input:

These two characters, the backslash (\) and the n that follows it, actually represent a single character: a newline character. (The newline character is named thus because it makes terminal output jump down to a new line.) There’s a newline at the end of the user input because when the user hits the Return key to indicate their entry is done, that gets recorded as an extra character. That newline is then included in the return value of the gets method.

Commonly used escape sequences

If you include this in a double-quoted string...	...you get this character...
\n	newline
\t	tab
\"	double-quotes
\'	single-quote
\\	backslash

The backslash character (\) and the n that follows it are an escape sequence—a portion of a string that represents characters that can’t normally be represented in source code.

The most commonly used escape sequences are \n (newline, as we’ve seen) and \t (a tab character, for indentation).

Normally, when you try to include a double-quotation mark (") in a double-quoted string, it gets treated as the end of the string, leading to errors:

If you escape the double-quotation marks by placing a backslash before each, you can place them in the middle of a double-quoted string without causing an error.

Lastly, because \ marks the start of an escape sequence, we also need a way to represent a backlash character that isn’t part of an escape sequence. Using \\ will give us a literal backslash.

Bear in mind that most of these escape sequences apply only in double-quoted strings. In single-quoted strings, most escape sequences are treated literally.

Calling “chomp” on the string object

We can use the chomp method to remove the newline character.

If the last character of a string is a newline, the chomp method will remove it. It’s great for things like cleaning up strings returned from gets.

The chomp method is more specialized than print, puts, and gets, so it’s available only on individual string objects. That means we need to specify that the string referenced by the input variable is the receiver of the chomp method. We need to use the dot operator on input.

The chomp method returns the same string, but without the newline character at the end. We store this in a new variable, name, which we then print as part of our welcome message.

If we try running the program again, we’ll see that our new, emphatic greeting is working properly now!

What methods are available on an object?

You can’t call just any method on just any object. If you try something like this, you’ll get an error:

Which, if you think about it, isn’t so wrong. After all, it doesn’t make a lot of sense to capitalize a number, does it?

But, then, what methods can you call on a number? That question can be answered with a method called methods:

If you call methods on a string, you’ll get a different list: puts "hello".methods

Why the difference? It has to do with the object’s class. A class is a blueprint for making new objects, and it decides, among other things, what methods you can call on the object.

There’s another method that lets objects tell us what their class is. It’s called, sensibly enough, class. Let’s try it out on a few objects.

We’ll be talking more about classes in the next chapter, so stay tuned!

Prompt the player to enter their name. Use their name to print a greeting.

There are No Dumb Questions

Q:	Q: How do I find out what all these methods do?
A:	A: We cover how to look up documentation on a class’s methods in Chapter 11. But for right now, you don’t need to know about the majority of these methods. (And you may never need to.) Don’t worry: if a method is important, we’ll go over how to use it!

That’s all the code for our first requirement. You can check it off the list!

Generating a random number

Our player greeting is done. Let’s look at our next requirement.

	Prompt the player to enter their name. Use their name to print a greeting.
	Generate a random number from 1 to 100, and store it as a target number for the player to guess.

The rand method will generate a random number within a given range. It should be able to create a target number for us.

We need to pass an argument to rand with the number that will be at the upper end of our range (100). Let’s try it out a couple of times:

Looks good, but there’s one problem: rand generates numbers between zero and just below the maximum value you specify. That means we’ll be getting random numbers in the range 0–99, not 1–100 like we need.

That’s easy to fix, though. We’ll just add 1 to whatever value we get back from rand. That will put us back in the range of 1–100!

rand(100) + 1

We’ll store the result in a new variable, named target.

Converting to strings

That’s another requirement down! Let’s look at the next one...

	Generate a random number from 1 to 100, and store it as a target number for the player to guess.
	Keep track of how many guesses the player has made. Before each guess, let them know how many guesses (out of 10) they have left.

“Keep track of how many guesses the player has made...” Looks like we’ll need a variable for the number of guesses. Obviously, when the player first starts, they haven’t made any guesses, so we’ll create a variable named num_guesses that’s set to 0 initially.

num_guesses = 0

Now, the first thing you might attempt to do in order to display the number of guesses remaining is to concatenate (join) the strings together using the plus sign (+), as many other languages do. Something like this won’t work, however:

The + operator is used to add numbers as well as to concatenate strings, and since remaining_guesses contains a number, this plus sign looks like an attempt to add numbers.

What’s the solution? You need to convert the number to a string. Almost all Ruby objects have a to_s method you can call to do this conversion; let’s try that now.

That works! Converting the number to a string first makes it clear to Ruby that you’re doing concatenation, not addition.

Ruby provides an easier way to handle this, though. Read on...

Ruby makes working with strings easy

Instead of calling to_s, we could save ourselves the effort of explicitly converting a number to a string by using string interpolation. As you saw in our code to greet the user, when you include #{...} in a double-quoted string, code within the curly braces is evaluated, converted to a string if necessary, and interpolated (substituted) into the longer string.

The automatic string conversion means we can get rid of the to_s call.

Ruby lets us do operations directly within the curly braces, so we can also get rid of the remaining_guesses variable.

The #{...} can occur anywhere within the string, so it’s easy to make the output a little more user-friendly, too.

Now the player will know how many guesses they have left. We can check another requirement off our list!

Converting strings to numbers

	Keep track of how many guesses the player has made. Before each guess, let them know how many guesses (out of 10) they have left.
	Prompt the player to make a guess as to what the target number is.

Our next requirement is to prompt the player to guess the target number. So we need to print a prompt, then record the user’s input as their guess. The gets method, as you may recall, retrieves input from the user. (We already used it to get the player’s name.) Unfortunately, we can’t just use gets by itself to get a number from the user, because it returns a string. The problem will arise later, when we try to compare the player’s guess with the target number using the > and < operators.

We need to convert the string returned from the gets method to a number so that we can compare the guess to our target number. No problem! Strings have a to_i method to do the conversion for us.

Common conversions

If you call this method on an object...	...you get this kind of object back.
to_s	string
to_i	integer
to_f	floating-point number

This code will call to_i on the string returned from gets. We don’t even need to put the string in a variable first; we’ll just use the dot operator to call the method directly on the return value.

guess = gets.to_i

When you call to_i on a string, it ignores any non-numeric characters that follow the number. So we don’t even need to remove the newline character left by gets.

If we want to test our changes, we can print out the result of a comparison.

Much better—we have a guess that we can compare to the target. That’s another requirement done!

Conditionals

Two more requirements for our game down, four to go! Let’s look at the next batch.

	Prompt the player to make a guess as to what the target number is.
	If the player’s guess is less than the target number, say, “Oops. Your guess was LOW.” If the player’s guess is greater than the target number, say, “Oops. Your guess was HIGH.”
	If the player’s guess is equal to the target number, tell them, “Good job, [name]! You guessed my number in [number of guesses] guesses!”
	If the player runs out of turns without guessing correctly, say, “Sorry. You didn’t get my number. My number was [target].”

Now, we need to compare the player’s guess with the target. If it’s too high, we print a message saying so. Otherwise, if it’s too low, we print a message to that effect, and so on... Looks like we need the ability to execute portions of our code only under certain conditions.

Like most languages, Ruby has conditional statements: statements that cause code to be executed only if a condition is met. An expression is evaluated, and if its result is true, the code in the conditional body is executed. If not, it’s skipped.

As with most other languages, Ruby supports multiple branches in the condition. These statements take the form if/elsif/else.

Conditionals rely on a Boolean expression (one with a true or false value) to decide whether the code they contain should be executed. Ruby has constants representing the two Boolean values, true and false.

if true puts "I'll be printed!" end

if false puts "I won't!" end

Ruby also has all the comparison operators you’re used to.

It has the Boolean negation operator, !, which lets you take a true value and make it false, or a false value and make it true. It also has the more-readable keyword not, which does basically the same thing.

if ! true puts "I won't be printed!" end if ! false puts "I will!" end

if not true puts "I won't be printed!" end if not false puts "I will!" end

If you need to ensure that two conditions are both true, you can use the && (“and”) operator. If you need to ensure that either of two conditions is true, you can use the || (“or”) operator.

if true && true puts "I'll be printed!" end if true && false puts "I won't!" end

if false || true puts "I'll be printed!" end if false || false puts "I won't!" end

No, Ruby doesn’t treat indentation as significant to the meaning of the program (unlike some other languages, such as Python).

But indenting code within if statements, loops, methods, classes, and the like is just good coding style. It helps make the structure of your code clear to your fellow developers (and even to yourself).

We need to compare the player’s guess to the random target number. Let’s use everything we’ve learned about conditionals to implement this batch of requirements.

The opposite of “if” is “unless”

This statement works, but it’s a little awkward to read:

if not guessed_it
  puts "Sorry. You didn't get my number. (It was #{target}.)"
end

Conventional Wisdom

It’s valid to use else and elsif together with unless in Ruby:

But it’s very hard to read. If you need an else clause, use if for the main clause instead!

In most respects, Ruby’s conditional statements are just like most other languages. Ruby has an additional keyword, though: unless.

Code within an if statement executes only if a condition is true, but code within an unless statement executes only if the condition is false.

unless true puts "I won't be printed!" end

unless false puts "I will!" end

The unless keyword is an example of how Ruby works hard to make your code a little easier to read. You can use unless in situations where a negation operator would be awkward. So instead of this:

if ! (light == "red")
  puts "Go!"
end

You can write this:

unless light == "red"
  puts "Go!"
end

We can use unless to clean up that last conditional.

unless guessed_it
  puts "Sorry. You didn't get my number. (It was #{target}.)"
end

Much more legible! And our conditional statements are working great!

Note

You’ll see something like this if you run get_number.rb now...

As it stands right now, though, the player gets only one guess—they’re supposed to get 10. We’ll fix that next...

Loops

Great work so far! We have just one more requirement to go for our guessing game!

	If the player’s guess is less than the target number, say, “Oops. Your guess was LOW.” If the player’s guess is greater than the target number, say, “Oops. Your guess was HIGH.”
	If the player’s guess is equal to the target number, tell them, “Good job, [name]! You guessed my number in [number of guesses] guesses!”
	If the player runs out of turns without guessing correctly, say, “Sorry. You didn’t get my number. My number was [target].”
	Keep allowing the player to guess until they get it right or run out of turns.

Currently, the player gets one guess. Since there’s 100 possible target numbers, those don’t seem like very fair odds. We need to keep asking the player 10 times, or until they get the right answer, whichever comes first.

The code to prompt for a guess is already in place, so we just need to run it more than once. We can use a loop to execute a segment of code repeatedly. You’ve probably encountered loops in other languages. When you need one or more statements to be executed over and over, you place them inside a loop.

A while loop consists of the word while, a Boolean expression (just like in if or unless statements), the code you want to repeat, and the word end. The code within the loop body repeats while the condition is true.

Here’s a simple example that uses a loop for counting.

Just as unless is the counterpart to if, Ruby offers an until loop as a counterpart to while. An until loop repeats until the condition is true (that is, it loops while it’s false).

Here’s a similar example, using until.

Here’s our conditional code again, updated to run within a while loop:

There’s one more readability improvement we can make. As with the if statement that we replaced with an unless, we can make this while loop read more clearly by replacing it with an until.

Before:

while num_guesses  <  10 && guessed_it == false
  ...
end

After:

until num_guesses == 10 || guessed_it
  ...
end

Here’s our complete code listing.

Let’s try running our game!

Our loop is in place—that’s the last requirement! Let’s open a terminal window and try running the program!

Keep allowing the player to guess until they get it right or run out of turns.

Using variables, strings, method calls, conditionals, and loops, you’ve written a complete game in Ruby! Better yet, it took fewer than 30 lines of code! Pour yourself a cold drink—you’ve earned it!

Your Ruby Toolbox

You’ve got Chapter 1 under your belt and now you’ve added method calls, conditionals, and loops to your toolbox.

Bullet Points

• Ruby is an interpreted language. You don’t have to compile Ruby code before executing it.

• You don’t need to declare variables before assigning to them. You also don’t have to specify a type.

• Ruby treats everything from a # to the end of the line as a comment—and ignores it.

• Text within quotation marks is treated as a string—a series of characters.

• If you include #{...} in a Ruby string, the expression within the braces is interpolated into the string.

• Method calls may need one or more arguments, separated by commas.

• Parentheses are optional around method arguments. Leave them off if you’re not passing any arguments.

• Use the inspect and p methods to view debug output for Ruby objects.

• You can include special characters within double-quoted strings by using escape sequences like \n and \t.

• You can use the interactive Ruby interpreter, or irb, to quickly test out the result of Ruby expressions.

• Call to_s on almost any object to convert it to a string. Call to_i on a string to convert it to an integer.

• unless is the opposite of if; its code won’t execute unless a statement is false.

• until is the opposite of while; it executes repeatedly until a condition is true.

Statements

Conditional statements execute the code they enclose if a condition is met.

Loops execute the code they enclose repeatedly. They exit when a condition is met.

Up Next...

All your code is in one big lump right now. In the next chapter, you’ll learn how to break your code into easily maintainable chunks, using classes and methods.