Learn Ruby The Hard Way

Front 1

Exercise 1

Terminal

Back 1

It is located in the Utilities folder within the Applications folder. When launched, it provides a line interface to control the underpinnings of the UNIX based operating system

Front 2

Exercise 1

How to run ruby

Back 2

ruby ex1.rb

You need to be in the same directory as the file you created. Make sure you use the cdcommand to go there first. For example, if you saved your file in lrthw/ex1.rb, then you would do cd lrthw/ before trying to run ruby ex1.rb. If you don't know what any of that means, then go through Appendix A.

Front 3

Exercise 1

puts

Back 3

puts prints out what you type on a new line.

Front 4

Exercise 2

How do you write a comment in ruby?

Back 4

# A comment, this is so you can read your program later.

Front 5

Exercise 2

What is a octothorpe

Back 5

It is the # character

Front 6

Exercise 3

What are the math symbols in ruby

Back 6

+ plus (addition)

- minus (subtraction)

/ slash (division)

* asterisk (multiplication)

% percent (modulus get the remainder of a division problem)

< less-than (comparison of two)

> greater-than (comparison of two)

<= less-than-equal (comparison of two or equal)

>= greater-than-equal (comparison of two or equal)

Front 7

Exercise 3

floating point number

Back 7

8.0

Front 8

Exercise 3

Integer

Back 8

9

Front 9

Exercise 4

variable

Back 9

a variable is nothing more than a name for something

Front 10

Exercise 4

What is the difference between = (single-equal) and == (double-equal)?

Back 10

The = (single-equal) assigns the value on the right to a variable on the left. The == (double-equal) tests if two things have the same value. You'll learn about this in Exercise 27.

Front 11

Exercise 5

string

Back 11

Every time you put " (double-quotes) around a piece of text you have been making a string. A string is how you make something that your program might give to a human. You print strings, save strings to files, send strings to web servers, and many other things.

Front 12

Exercise 5

How do you embed a variable inside a string

Back 12

You embed variables inside a string by using a special #{} sequence and then put the variable you want inside the {} characters. This tells Ruby, "Hey, this string needs to be formatted. Put these variables in there."

Front 13

Exercise 6

strings

Back 13

A string is usually a bit of text you want to display to someone, or "export" out of the program you are writing. Ruby knows you want something to be a string when you put either " (double-quotes) or '(single-quotes) around the text. You saw this many times with your use of puts when you put the text you want to go inside the string inside " after the puts to print the string.

Front 14

Exercise 6

strings

Back 14

Strings can contain any number of variables that are in your Ruby script. Remember that a variable is any line of code where you set a name = (equal) to a value. In the code for this exercise, types_of_people = 10 creates a variable named types_of_people and sets it = (equal) to 10. You can put that in any string with #{types_of_people}.

Front 15

Exercise 7

Can I use single-quotes or double-quotes to make a string or do they do different things?

Back 15

In Ruby the " (double-quote) tell Ruby to replace variables it finds with #{}, but the '(single-quote) tells Ruby to leave the string alone and ignore any variables inside it.

Front 16

Exercise 8

format string

Back 16

but rather than using variables, use values by their names.

Front 17

Exercise 8

Should I use %{} or #{} for formatting?

Back 17

You will almost always use #{} to format your strings, but there are times when you want to apply the same format to multiple values. That's when %{} comes in handy.

Front 18

Exercise 9

Multiple line string

Back 18

puts """There's something going on here.With the three double-quotes.We'll be able to type as much as we like.Even 4 lines if we want, or 5, or 6."""

Front 19

Exercise 10

string that goes across multiple lines

Back 19

In the first way, I put the characters \n (backslash n) between the names of the months. These two characters put a new line character into the string at that point.

Front 20

Exercise 10

\ backslash

Back 20

This \ (backslash) character encodes difficult-to-type characters into a string. There are various "escape sequences" available for different characters you might want to use.

Front 21

Exercise 10

escape single quote \' escape double \"

Back 21

An important escape sequence is to escape a single-quote ' or double-quote ". Imagine you have a string that uses double-quotes and you want to put a double-quote inside the string. If you write "I "understand" joe." then Ruby will get confused because it will think the " around "understand" actuallyends the string. You need a way to tell Ruby that the " inside the string isn't a real double-quote.

Front 22

Exercise 10

triple-quotes

Back 22

which is just """ and works like a string, but you also can put as many lines of text as you want until you type """ again.

Front 23

Exercise 10

Escape Sequences

Back 23

ESCAPEWHAT IT DOES.

\\ Backslash

\' Single-quote

\" Double-quote

\a ASCII bell (BEL)

\b ASCII backspace (BS)

\f ASCII formfeed (FF)

\n ASCII linefeed (LF)

\r ASCII Carriage Return (CR)

\t ASCII Horizontal Tab (TAB)

\uxxxx Character with 16-bit hex value xxxx (Unicode only)\vASCII vertical tab (VT)\oooCharacter with octal value ooo\xhhCharacter with hex value hh

Front 24

Exercise 11

Most of what software does is the following:

Back 24

Take some kind of input from a person.

Change it.

Print out something to show how it changed.

Front 25

Exercise 11

gets.chomp

Back 25

gets accepts a single line of data from the standard input - the keyboard in this case - and assigns the string typed by the user to city.

The standard input is a default stream supplied by many operating systems that relates to the standard way to accept input from the user.

In our case, the standard input is the keyboard.chomp is a string method and gets retrieves only strings from your keyboard.

You must have realised that gets returns a string and a '\n' character, while chomp removes this '\n'.

variable = gets.chomp

Front 26

Exercise 12

How do I get a number from someone so I can do math?

Back 26

That's a little advanced, but try gets.chomp.to_i which says, "Get a string from the user, chomp off the \n, and convert it to an integer."

Front 27

Exercise 12

What does .to_f do?

Back 27

It converts the number to a floating point. Or you can convert a number string into a floating point. Or you can convert an integer into a floating point number.

Front 28

Exercise 13

ARGV

Back 28

is the "argument variable," a very standard name in programming, that you will find used in many other languages. This variable holds the arguments you pass to your Ruby script when you run it.

Front 29

Exercise 13

first, second, third = ARGV

Back 29

Line 1 "unpacks" ARGV so that, rather than holding all the arguments, it gets assigned to four variables you can work with: first, second, and third. This may look strange, but "unpack" is probably the best word to describe what it does. It just says, "Take whatever is in ARGV, unpack it, and assign it to all of these variables on the left in order."

In the command line

ruby ex13.rb first 2nd 3rd

You can actually replace first, 2nd, and 3rd with any three things you want.

Front 30

Exercise 13

What's the difference between ARGV and gets.chomp?

Back 30

The different has to do with where the user is required to give input. If they give your script inputs on the command line, then you use ARGV. If you want them to input using the keyboard while the script is running, then use gets.chomp.

Front 31

Exercise 13

Are the command line arguments strings?

Back 31

Yes, they come in as strings, even if you typed numbers on the command line. Use .to_i to convert them just like with gets.chomp.to_i.

Front 32

Exercise 14

In this exercise we'll usegets.chomp slightly differently by having it print a simple > prompt. This is similar to a game like Zork or Adventure.

Back 32

user_name = ARGV.first

prompt = '> '

puts "Hi #{user_name}."puts "I'd like to ask you a few questions."

puts "Do you like me #{user_name}? ", promptlikes = $stdin.gets.chompputs "Where do you live #{user_name}? ", prompt

lives = $stdin.gets.chompputs "What kind of computer do you have? ", prompt

computer = $stdin.gets.chomp

puts """Alright, so you said #{likes} about liking me.You live in #{lives}. Not sure where that is.And you have a #{computer} computer. Nice."""

Front 33

Exercise 14

Variable prompt

Back 33

We make a variable prompt that is set to the prompt we want, and we give that to gets.chomp instead of typing it over and over. Now if we want to make the prompt something else, we just change it in this one spot and rerun the script.

Front 34

Exercise 15

Hard coding

Back 34

What we want to do is "open" that file in our script and print it out. However, we do not want to just "hard code" the name ex15_sample.txt into our script. "Hard coding" means putting some bit of information that should come from the user as a string directly in our source code. That's bad because we want it to load other files later. The solution is to use ARGV or gets.chomp to ask the user what file to open instead of "hard coding" the file's name.

Front 35

Exercise 15

CODE

Back 35

filename = ARGV.first

txt = open(filename)

puts "Here's your file #{filename}:"

print txt.read

print "Type the filename again: "

file_again = $stdin.gets.chomp

txt_again = open(file_again)

print txt_again.read

Front 36

Exercise 15

Break Down

Back 36

Lines 1-2 uses ARGV to get a filename. Next we have line 3 where we use a new command open. Right now, run ri open and read the instructions. Notice how like your own scripts and gets.chomp, it takes a parameter and returns a value you can set to your own variable.

Line 5 prints a little message, but on line 6 we have something very new and exciting. We call a function on txt named read. What you get back from open is a File, and it also has commands you can give it. You give a file a command by using the . (dot or period), the name of the command, and parameters. Just like with open and gets.chomp. The difference is that txt.read says, "Hey txt! Do your read command with no parameters!"

Front 37

Exercise 15

txt = open(filename)

Back 37

where we use a new command open. Right now, run ri open and read the instructions. Notice how like your own scripts and gets.chomp, it takes a parameter and returns a value you can set to your own variable.

Front 38

Exercise 15

print txt.read

Back 38

We call a function on txt named read. What you get back from open is a File, and it also has commands you can give it. You give a file a command by using the . (dot or period), the name of the command, and parameters. Just like with open and gets.chomp. The difference is that txt.read says, "Hey txt! Do your read command with no parameters!"

Front 39

Exercise 15

Does txt = open(filename) return the contents of the file?

Back 39

No, it doesn't. It actually makes something called a "file object." You can think of a file like an old tape drive that you saw on mainframe computers in the 1950s, or even like a DVD player from today. You can move around inside them, and then "read" them, but the DVD player is not the DVD the same way the file object is not the file's contents.

Front 40

Exercise 15

Why is there no error when we open the file twice?

Back 40

Ruby will not restrict you from opening a file more than once and sometimes this is necessary.

Front 41

Exercise 16

Reading and Writing Files

Back 41

close -- Closes the file. Like File->Save.. in your editor

.read -- Reads the contents of the file. You can assign the result to a variable

.readline -- Reads just one line of a text file.

truncate -- Empties the file. Watch out if you care about the file

.write('stuff') -- Writes "stuff" to the file.

Front 42

Exercise 16

target = open(filename, 'w')

What does 'w' mean?

Back 42

It's really just a string with a character in it for the kind of mode for the file. If you use 'w'then you're saying "open this file in 'write' mode," thus the 'w' character. There's also 'r' for "read," 'a' for append, and modifiers on these.

Front 43

Exercise 17

CODE

Back 43

from_file, to_file = ARGV

puts "Copying from #{from_file} to #{to_file}"

in_file = open(from_file)

indata = in_file.read

puts "The input file is #{indata.length} bytes long"

puts "Does the output file exist? #{File.exist?(to_file)}"

puts "Ready, hit RETURN to continue, CTRL-C to abort."

$stdin.gets

out_file = open(to_file, 'w')out_file.write(indata)

puts "Alright, all done."

out_file.close

in_file.close

Front 44

Exercise 17

File.exist?(to_file)

Back 44

This can be broken down as, "File! I want you to use your exist? function to tell me if to_file exists on the disk." Yet another way to say this is, "Get the exist? function from File and call it with the variable to_file."

Front 45

Exercise 18

What does a function do?

Back 45

They name pieces of code the way variables name strings and numbers.

They take arguments the way your scripts take ARGV.

Using 1 and 2 they let you make your own "mini-scripts" or "tiny commands."

Front 46

Exercise 18

How do you create a function?

Back 46

You can create a function by using the word def in Ruby.

Front 47

Exercise 18

Function pattern

Back 47

def var(arg1, arg2)

puts "arg1: #{arg1}, arg2: #{arg2}"

end

var(input,input)

Front 48

Exercise 18

Function Checklist

Back 48

Did you start your function definition with def?

Does your function name have only characters and _ (underscore) characters?

Did you put an open parenthesis ( right after the function name?

Did you put your arguments after the parenthesis ( separated by commas?

Did you make each argument unique (meaning no duplicated names)?

Did you put a close parenthesis ) after the arguments?

Did you indent all lines of code you want in the function two spaces?

Did you end your function with end lined up with the def above?

Front 49

Exercise 18

When you run ("use" or "call") a function, check these things:

Back 49

Did you call/use/run this function by typing its name?

Did you put the ( character after the name to run it?

Did you put the values you want into the parenthesis separated by commas?

Did you end the function call with a ) character?

Functions that don't have parameters do not need the () after them, but would it be clearer if you wrote them anyway?

Front 50

Exercise 18

What's allowed for a function name?

Back 50

The same as variable names. Anything that doesn't start with a number, and is letters, numbers, and underscores will work.

Front 51

Exercise 18

What does the * in *args do?

Back 51

That tells Ruby to take all the arguments to the function and then put them in args as a list. It's like argv that you've been using, but for functions. It's not normally used too often unless specifically needed.

Front 52

Exercise 19

Are variable in your function connected to the variables in your script?

Back 52

The variables in your function are not connected to the variables in your script.

Front 53

Exercise 21

def add(a, b)

puts "ADDING #{a} + #{b}"

return a + b

end

age = add(30, 5)

Back 53

Our function is called with two arguments: a and b.We print out what our function is doing, in this case "ADDING."Then we tell Ruby to do something kind of backward: we return the addition of a + b. You might say this as, "I add a and b then return them."Ruby adds the two numbers. Then when the function ends, any line that runs it will be able to assign this a + b result to a variable.

Front 54

Exercise 27

The Truth Terms

Back 54

&& (and)

|| (or)

! (not)

!= (not equal)

== (equal)

>= (greater-than-equal)

<= (less-than-equal)

true

false

Front 55

Exercise 27

The Truth Tables (Not)

Back 55

NOT

!false == true

!true == false

Front 56

Exercise 27 The Truth Tables ( OR)

Back 56

OR (||)

true || false == true

true || true == true

false || true == true

false || false == false

Front 57

Exercise 27 The Truth Tables (And )

Back 57

AND (&&)

true && false == false

true && true == true

false && true == false

false && false == false

Front 58

Exercise 27 The Truth Tables (NOT OR)

Back 58

NOT OR

not (true || false) == false

not (true || true) == false

not (false || true) == false

not (false || false) == true

Front 59

Exercise 27 The Truth Tables ( NOT AND )

Back 59

NOT AND

!(true && false) == true

!(true && true) == false

!(false && true) == true

!(false && false) == true

Front 60

Exercise 27 The Truth Tables ( != )

Back 60

!=

1 != 0 == true

1 != 1 == false

0 != 1 == true

0 != 0 == false

Front 61

Exercise 27 The Truth Tables ( == )

Back 61

==

1 == 0 == false

1 == 1 == true

0 == 1 == false

0 == 0 == true

Front 62

Exercise 28: Boolean Practice

true && true

Back 62

true

Front 63

Exercise 28: Boolean Practice

false && true

Back 63

false

Front 64

Exercise 28: Boolean Practice

1 == 1 && 2 == 1

Back 64

false

Front 65

Exercise 28: Boolean Practice

"test" == "test"

Back 65

true?

Front 66

Exercise 28: Boolean Practice

1 == 1 || 2 != 1

Back 66

true

Front 67

Exercise 28: Boolean Practice

true && 1 == 1

Back 67

true

Front 68

Exercise 28: Boolean Practice

false && 0 != 0

Back 68

false?

Front 69

Exercise 28: Boolean Practice

true || 1 == 1

Back 69

true

Front 70

Exercise 28: Boolean Practice

"test" == "testing"

Back 70

false

Front 71

Exercise 28: Boolean Practice

1 != 0 && 2 == 1

Back 71

false

Front 72

Exercise 28: Boolean Practice

"test" != "testing"

Back 72

true

Front 73

Exercise 28: Boolean Practice

"test" == 1

Back 73

false

Front 74

Exercise 28: Boolean Practice

!(true && false)

Back 74

false

Front 75

Exercise 28: Boolean Practice

!(1 == 1 && 0 != 1)

Back 75

false?

Front 76

Exercise 28: Boolean Practice

!(10 == 1 || 1000 == 1000)

Back 76

true?

Front 77

Exercise 28: Boolean Practice

!(1 != 10 || 3 == 4)

Back 77

true?

Front 78

Exercise 28: Boolean Practice

!("testing" == "testing" && "Zed" == "Cool Guy")

Back 78

false?

Front 79

Exercise 28: Boolean Practice

1 == 1 && (!("testing" == 1 || 1 == 0))

Back 79

true?

Front 80

Exercise 28: Boolean Practice

"chunky" == "bacon" && (!(3 == 4 || 3 == 3))

Back 80

false?

Front 81

Exercise 28: Boolean Practice

3 == 3 && (!("testing" == "testing" || "Ruby" == "Fun"))

Back 81

false?

Front 82

Exercise 28: Boolean Practice (trick)

Back 82

Whenever you see these boolean logic statements, you can solve them easily by this simple process:

Find an equality test (== or !=) and replace it with its truth.

Find each &&/|| inside parentheses and solve those first.

Find each ! and invert it.

Find any remaining &&/|| and solve it.

When you are done you should have true or false.

Front 83

Exercise 28: equality operators

Back 83

Combined Operator

x += y == x = x + y

x -= y == x = x - y

x /= y == x = x / y

x *= y == x = x * y

x %= y == x = x % y

x **= y == x = x ** y

Front 84

Exercise 28: equality operators

Back 84

==Tests for equality.Returns true or false

.eql? Same as ==.

!= Tests for inequality. Returns true for inequality or false for equality

< Less than. Returns true if first operand is Less than second operand. Otherwise returns false.

> Greater than. Returns true if first operand is greater than second operand. Otherwise returns false.

>= Greater than or equal to. Returns true if first operand is greater than or equal to second operand. Otherwise returns false.

<= Less than or equal to. Returns true if first operand is less than or equal to second operand. Otherwise returns false.<=>Combined comparison operator. Returns 0 if first operand equals second, 1 if first operand is greater than the second and -1 if first operand is less than the second.

Front 85

Exercise 29: If statement

Back 85

people = 20

cats = 30

dogs = 15

if people < cats

puts "Too many cats! The world is doomed!"end

if people > cats

puts "Not many cats! The world is saved!"end

if people < dogs

puts "The world is drooled on!"

end

if people > dogs

puts "The world is dry!"

end

Front 86

Exercise 30 :

What do you think the if does to the code under it?

Back 86

An if-statement creates what is called a "branch" in the code. It's kind of like those choose your own adventure books where you are asked to turn to one page if you make one choice, and another if you go a different direction. The if-statement tells your script, "If this boolean expression is true, then run the code under it, otherwise skip it."

Front 87

Exercise 30 :

Why does the code under the if need to be indented two spaces?

Back 87

In Ruby you indent code under statements like if, else, and others so that other programmers know it is a "block" of code. Blocks can have other blocks in them and are ended with an end. There are other ways to make a block of code, but for if-statements this is the way.

Front 88

Exercise 30 :

What happens if you don't end it with end?

Back 88

If you don't then Ruby doesn't know where your if-statement ends and where others might begin, so it will give you a syntax error.

Front 89

Exercise 30 :

code

Back 89

people = 30

cars = 40

trucks = 15

if cars > people

puts "We should take the cars."

elsif cars < people

puts "We should not take the cars."

else

puts "We can't decide."

end

Front 90

Exercise 30 :

What happens if multiple elsif blocks are true?

Back 90

Ruby starts and the top runs the first block that is true, so it will run only the first one.

Front 91

Exercise 31 Making Decisions

Back 91

In the first half of this book you mostly just printed out things called functions, but everything was basically in a straight line. Your scripts ran starting at the top and went to the bottom where they ended. If you made a function you could run that function later, but it still didn't have the kind of branching you need to really make decisions. Now that you have if, else, and elsif you can start to make scripts that decide things.

Front 92

Exercise 31

Can you replace elsif with a sequence of if-else combinations?

Back 92

You can in some situations, but it depends on how each if/else is written. It also means that Ruby will check every if-else combination, rather than just the first false ones like it would with if-elsif-else. Try to make some of these to figure out the differences.

Front 93

Exercise 31

What if I wanted more options in the if-elsif-else blocks?

Back 93

Add more elsif blocks for each possible choice.

Front 94

Exercise 32

for-loop

Back 94

However, programs also need to do repetitive things very quickly

Front 95

Exercise 32

arrays

Back 95

Before you can use a for-loop, you need a way to store the results of loops somewhere. The best way to do this is with arrays. Arrays are exactly what their name says: a container of things that are organized in order from first to last. It's not complicated; you just have to learn a new syntax. First, there's how you make arrays:

Front 96

Exercise 32 First, there's how you make arrays:

Back 96

hairs = ['brown', 'blond', 'red']

eyes = ['brown', 'blue', 'green']

weights = [1, 2, 3, 4]

Front 97

Exercise 32 First, there's how you make arrays:

Back 97

You start the array with the [ (left bracket) which "opens" the array. Then you put each item you want in the array separated by commas, similar to function arguments. Lastly, end the array with a ] (right bracket) to indicate that it's over. Ruby then takes this array and all its contents and assigns them to the variable.

Front 98

Exercise 36

Rules for If-Statements

Back 98

Every if-statement must have an else.If this else should never run because it doesn't make sense, then you must use adie function in the else that prints out an error message and dies, just like we did in the last exercise. This will find many errors.Never nest if-statements more than two deep and always try to do them one deep.Treat if-statements like paragraphs, where each if-elsif-else grouping is like a set of sentences. Put blank lines before and after.Your boolean tests should be simple. If they are complex, move their calculations to variables earlier in your function and use a good name for the variable.

Front 99

Exercise 36

Rules for Loops

Back 99

Use a while-loop only to loop forever, and that means probably never. This only applies to Ruby; other languages are different.Use a for-loop for all other kinds of looping, especially if there is a fixed or limited number of things to loop over.

Front 100

Exercise 36

Tips for Debugging

Back 100

Do not use a "debugger." A debugger is like doing a full-body scan on a sick person. You do not get any specific useful information, and you find a whole lot of information that doesn't help and is just confusing.The best way to debug a program is to use put to print out the values of variables at points in the program to see where they go wrong.Make sure parts of your programs work as you work on them. Do not write massive files of code before you try to run them. Code a little, run a little, fix a little.

Front 101

Exercise 36

The best way to work on a piece of software is in small chunks like this:

Back 101

On a sheet of paper or an index card, write a list of tasks you need to complete to finish the software. This is your to do list.Pick the easiest thing you can do from your list.Write out English comments in your source file as a guide for how you would accmplish this task in your code.Write some of the code under the English comments.Quickly run your script so see if that code worked.Keep working in a cycle of writing some code, running it to test it, and fixing it until it works.Cross this task off your list, then pick your next easiest task and repeat.

This process will help you work on software in a methodical and consistent manner. As you work, update your list by removing tasks you don't really need and adding ones you do.

Front 102

Exercise 37: Symbol Review

BEGIN

Back 102

Run this block when the script starts.

BEGIN { puts "hi" }

Front 103

Exercise 37: Symbol Review

END

Back 103

Run this block when the script is done.

END { puts "hi" }

Front 104

Exercise 37: Symbol Review

alias

Back 104

Create another name for a function.

alias X Y

Front 105

Exercise 37: Symbol Review

and

Back 105

Logical and, but lower priority than &&

puts "Hello" and "Goodbye"

Front 106

Exercise 37: Symbol Review

begin

Back 106

Start a block, usually for exceptions.

begin end

Front 107

Exercise 37: Symbol Review

break

Back 107

Break out of a loop right now.

while true; break; end

Front 108

Exercise 37: Symbol Review

case

Back 108

Case style conditional, like an if.

case X; when Y; else; end

Front 109

Exercise 37: Symbol Review

class

Back 109

Define a new class.

class X; end

Front 110

Exercise 37: Symbol Review

def

Back 110

Define a new function.

def X(); end

Front 111

Exercise 37: Symbol Review

defined?

Back 111

Is this class/function/etc. defined already?

defined? Class == "constant"

Front 112

Exercise 37: Symbol Review

do

Back 112

Create a block that maybe takes a parameter.

(0..5).each do |x| puts x end

Front 113

Exercise 37: Symbol Review

else

Back 113

Else conditional.

if X; else; end

Front 114

Exercise 37: Symbol Review

elsif

Back 114

Else if conditional

if X; elsif Y; else; end

Front 115

Exercise 37: Symbol Review

end

Back 115

Ends blocks, functions, classes, everything.

begin end # many others

Front 116

Exercise 37: Symbol Review

ensure

Back 116

Run this code whether an exception happens or not.

begin ensure end

Front 117

Exercise 37: Symbol Review

for

Back 117

For loop syntax. The .each syntax is preferred.

for X in Y; end

Front 118

Exercise 37: Symbol Review

if

Back 118

If conditional.

if X; end

Front 119

Exercise 37: Symbol Review

in

Back 119

n part of for-loops.

for X in Y; end

Front 120

Exercise 37: Symbol Review

module

Back 120

Define a new module.

module X; end

Front 121

Exercise 37: Symbol Review

next

Back 121

Skip to the next element of a .each iterator.

(0..5).each {|y| next }

Front 122

Exercise 37: Symbol Review

not

Back 122

Logical not. But use ! instead.

not true == false

Front 123

Exercise 37: Symbol Review

or

Back 123

Logical or.

puts "Hello" or "Goodbye"

Front 124

Exercise 37: Symbol Review

redo

Back 124

Rerun a code block exactly the same.

(0..5).each {|i| redo if i > 2}

Front 125

Exercise 37: Symbol Review

rescue

Back 125

Run this code if an exception happens.

begin rescue X; end

Front 126

Exercise 37: Symbol Review

retry

Back 126

In a rescue clause, says to try the block again.

0..5).each {|i| retry if i > 2}

Front 127

Exercise 37: Symbol Review

return

Back 127

Returns a value from a function. Mostly optional.

return X

Front 128

Exercise 37: Symbol Review

self

Back 128

The current object, class, or module.

defined? self == "self"

Front 129

Exercise 37: Symbol Review

super

Back 129

The parent class of this class.

super

Front 130

Exercise 37: Symbol Review

then

Back 130

Can be used with if optionally.

if true then puts "hi" end

Front 131

Exercise 37: Symbol Review

undef

Back 131

Remove a function definition from a class.

undef X

Front 132

Exercise 37: Symbol Review

unless

Back 132

nverse of if.

unless false then puts "not" end

Front 133

Exercise 37: Symbol Review

until

Back 133

qInverse of while, execute block as long as false.

until false; end

Front 134

Exercise 37: Symbol Review

when

Back 134

Part of case conditionals.

case X; when Y; else; end

Front 135

Exercise 37: Symbol Review

while

Back 135

While loop.

while true; end

Front 136

Exercise 37: Symbol Review

yield

Back 136

Pause and transfer control to the code block.

yield

Front 137

Exercise 37: Symbol Review

Data Types

true

Back 137

True boolean value.

true or false == true

Front 138

Exercise 37: Symbol Review Data Types

false

Back 138

False boolean value.

false and true == false

Front 139

Exercise 37: Symbol Review Data Types

nil

Back 139

Represents "nothing" or "no value".

x = nil

Front 140

Exercise 37: Symbol Review Data Types

strings

Back 140

Stores textual information.

x = "hello"

Front 141

Exercise 37: Symbol Review Data Typesnumbers

Back 141

Stores integers.

i = 100

Front 142

Exercise 37: Symbol Review Data Types

floats

Back 142

Stores decimals.

i = 10.389

Front 143

Exercise 37: Symbol Review Data Types

arrays

Back 143

Stores a list of things.

j = [1,2,3,4]

Front 144

Exercise 37: Symbol Review Data Types

hashes

Back 144

Stores a key=value mapping of things.

e = {'x' => 1, 'y' => 2}

Front 145

Exercise 37: Symbol Review

String Escape Sequences

\\

Back 145

Backslash

Front 146

Exercise 37: Symbol Review String Escape Sequences

\'

Back 146

Single-quote

Front 147

Exercise 37: Symbol Review String Escape Sequences

\"

Back 147

Double-quote

Front 148

Exercise 37: Symbol Review String Escape Sequences

\a

Back 148

Bell

Front 149

Exercise 37: Symbol Review String Escape Sequences

\b

Back 149

Backspace

Front 150

Exercise 37: Symbol Review String Escape Sequences

\f

Back 150

Formfeed

Front 151

Exercise 37: Symbol Review String Escape Sequences

\n

Back 151

Newline

Front 152

Exercise 37: Symbol Review String Escape Sequences

\r

Back 152

Carriage

Front 153

Exercise 37: Symbol Review String Escape Sequences

\t

Back 153

Tab

Front 154

Exercise 37: Symbol Review String Escape Sequences

\v

Back 154

Vertical tab

Front 155

Exercise 37: Symbol Review

Operators

+

Back 155

Add

2 + 4 == 6

Front 156

Exercise 37: Symbol Review Operators

-

Back 156

Subtract

2 - 4 == 2

Front 157

Exercise 37: Symbol Review Operators

*

Back 157

Multiply

2 * 4 == 8

Front 158

Exercise 37: Symbol Review Operators

**

Back 158

Power of

2 ** 4 == 16

Front 159

Exercise 37: Symbol Review Operators

/

Back 159

Divide

2 / 4.0 == 0.5

Front 160

Exercise 37: Symbol Review Operators

%

Back 160

Modulus

2 % 4 == 2

Front 161

Exercise 37: Symbol Review Operators

>

Back 161

Greater than

Front 162

Exercise 37: Symbol Review Operators

.

Back 162

Dot access

"1".to_i == 1

Front 163

Exercise 37: Symbol Review Operators

::

Back 163

Colon access

Module::Class

Front 164

Exercise 37: Symbol Review Operators

[]

Back 164

List brackets

[1,2,3,4]

Front 165

Exercise 37: Symbol Review Operators

!

Back 165

Not

!true == false

Front 166

Exercise 37: Symbol Review Operators

<

Back 166

Less than

Front 167

Exercise 37: Symbol Review Operators

>=

Back 167

Greater than equal

Front 168

Exercise 37: Symbol Review Operators

<=

Back 168

Less than equal

Front 169

Exercise 37: Symbol Review Operators

<=>

Back 169

Comparison

Front 170

Exercise 37: Symbol Review Operators

==

Back 170

Equal

Front 171

Exercise 37: Symbol Review Operators

===

Back 171

Equality

Front 172

Exercise 37: Symbol Review Operators

!=

Back 172

Not equal

Front 173

Exercise 37: Symbol Review Operators

&&

Back 173

Logical and (higher precedence)

Front 174

Exercise 37: Symbol Review Operators

||

Back 174

Logical or (higher precedence)

Front 175

Exercise 37: Symbol Review Operators

..

Back 175

Range inclusive

(0..3).to_a == [0, 1, 2, 3]

Front 176

Exercise 37: Symbol Review Operators

...

Back 176

Range non-inclusive

(0...3).to_a == [0, 1, 2]

Front 177

Exercise 37: Symbol Review Operators

@

Back 177

Object scope

@var ; @@classvar

Front 178

Exercise 37: Symbol Review Operators

@@

Back 178

Class scope

@var ; @@classvar

Front 179

Exercise 37: Symbol Review Operators

$

Back 179

Global scope

$stdin

Front 180

Exercise 37: Symbol Review

Reading Code

Back 180

First, print out the code you want to understand. Yes, print it out, because your eyes and brain are more used to reading paper than computer screens. Make sure you print a few pages at a time.

Front 181

Exercise 37: Symbol Review Reading Code

Second, go through your printout and take notes of the following:

Back 181

Functions and what they do.Where each variable is first given a value.Any variables with the same names in different parts of the program. These may be trouble later.Any if-statements without else clauses. Are they right?Any while-loops that might not end.Any parts of code that you can't understand for whatever reason.

Front 182

Exercise 37: Symbol Review Reading Code

Third

Back 182

Third, once you have all of this marked up, try to explain it to yourself by writing comments as you go. Explain the functions, how they are used, what variables are involved and anything you can to figure this code out.

Front 183

Exercise 37: Symbol Review Reading Code

Last

Back 183

Lastly, on all of the difficult parts, trace the values of each variable line by line, function by function. In fact, do another printout and write in the margin the value of each variable that you need to "trace."

Front 184

Exercise 37: Symbol Review Reading Code

last 2

Back 184

Once you have a good idea of what the code does, go back to the computer and read it again to see if you find new things. Keep finding more code and doing this until you do not need the printouts anymore.

Front 185

Exercise 37: Symbol Review Reading Code

Find out what a "flow chart"

Back 185

Front 186

Exercise 38: Doing Things to Arrays

When you write mystuff.push('hello') you are actually setting off a chain of events inside Ruby to cause something to happen to the mystuff array. Here's how it works:

Back 186

Ruby sees you mentioned mystuff and looks up that variable. It might have to look backward to see if you created with =, if it is a function argument, or if it's a global variable. Either way it has to find the mystuff first.Once it finds mystuff it reads the . (period) operator and starts to look at variablesthat are a part of mystuff. Since mystuff is an array, it knows that mystuff has a bunch of functions.It then hits push and compares the name to all the names that mystuff says it owns. If push is in there (it is) then Ruby grabs that to use.Next Ruby sees the ( (parenthesis) and realizes, "Oh hey, this should be a function." At this point it calls (runs, executes) the function just like normally, but instead it calls the function with an extra argument.That extra argument is ... mystuff! I know, weird, right? But that's how Ruby works so it's best to just remember it and assume that's the result. What happens, at the end of all this, is a function call that looks like: push(mystuff, 'hello') instead of what you read which is mystuff.append('hello').

Front 187

Exercise 38: Doing Things to Arrays

Data Structure

Back 187

Let's say you want to create a computer game based on Go Fish. If you don't know what Go Fish is, take the time now to go read up on it on the internet. To do this you would need to have some way of taking the concept of a "deck of cards" and put it into your Ruby program. You then have to write Ruby code that knows how to work this imaginary version of a deck of cards so that a person playing your game thinks that it's real, even if it isn't. What you need is a "deck of cards" structure, and programmers call this kind of thing a "data structure".

Front 188

Exercise 38: Doing Things to Arrays

What's a data structure?

Back 188

If you think about it, a "data structure" is just a formal way to structure(organize) some data (facts). It really is that simple, even though some data structures can get insanely complex, all they are is just a way to store facts inside a program so you can access them in different ways. They structure data.

Front 189

Exercise 38: Doing Things to Arrays

I'll be getting into this more in the next exercise, but arrays are one of the most common data structures programmers use. They are simply ordered lists of facts you want to store and access randomly or linearly by an index. What?! Remember what I said though, just because a programmer said "array is a list" doesn't mean that it's any more complex than what an array already is in the real world. Let's look at the deck of cards as an example of an array:

Back 189

You have a bunch of cards with values.Those cards are in a stack, list, or array from the top card to the bottom card.You can take cards off the top, the bottom, the middle at random.If you want to find a specific card, you have to grab the deck and go through it one at a time.

Front 190

Exercise 38: Doing Things to Arrays

Let's look at what I said:

Back 190

"An ordered array"Yes, deck of cards is in order with a first, and a last."of things you want to store"Yes, cards are things I want to store."and access randomly"Yes, I can grab a card from anywhere in the deck."or linearly"Yes, if I want to find a specific card I can start at the beginning and go in order."by an index"Almost, since with a deck of cards if I told you to get the card at index 19 you'd have to count until you found that one. In our Ruby arrays the computer can just jump right to any index you give it.

Front 191

Exercise 38: Doing Things to Arrays

When to Use Arrays

Back 191

ou use an array whenever you have something that matches the array data structure's useful features:If you need to maintain order. Remember, this is listed order, not sorted order. Arrays do not sort for you.If you need to access the contents randomly by a number. Remember, this is usingcardinal numbers starting at 0.If you need to go through the contents linearly (first to last). Remember, that's whatfor-loops are for.