To summarize Ruby 0.3 from codeschool:

"Exclamation Points. Methods may have exclamation points in their name, which just means to impact the current data, rather than making a copy. No big deal.

Square Brackets. With these, you can target and find things. You can even replace them if necessary.

Chaining methods lets you get a lot more done in a single command. Break up a poem, reverse it"

chain the .join onto it to put it all back together

By using { } you can create an empty hash, which is also called a dictionary.

 "Hashes store related information by giving reusable labels to pieces of our data."

Creating Hashes works like > Sandwiches = { } So we'll now have an empty hash that we can call with "Sandwiches". If we want to start filling our hash or dictionary we can do that by using "Sandwiches = ["Ham"] = :Delicious".

If we attempt to just type > Sandwiches = ["Ham"] we'll get an output of nil.

Something else we did was use the : colon.

"When you place a colon in front of a simple word, you get a Ruby symbol. Symbols are much cheaper than strings (in terms of computer memory.) If you need to use a word over and over in your program itself, use a symbol. Rather than having thousands of copies of that word in memory, the computer will store a symbol only once, and refer to it over and over."

If you want, instead of typing out each symbol you're going to use to describe sandwiches such as :delicious, :tastes_good, or tastes_bad you can assign the symbol to a variable using > del = :delicious I'm not sure about best practices when it comes to this but, if you try to do > Sandwiches["Rueben"] = del then call Sandwiches your output will be => {"Rueben" => :delicious}. If you want to know how many items are in your hash then you can type > Sandwiches.length and it'll return the number of items. In my example if I tried it, I would get => 2. The method name #length will work for strings, lists, arrays, and hashes. 

What if we can't remember if we've already entered something for "Ham". We can check with > Sandwiches.keys and our output will be => ["Ham", "Rueben"].

What we've done is create an empty hash and given it a name. In this instance we did Sandwiches by doing > Sandwiches {}. After we created our empty hash we then began to fill it with keys and values. We created keys by using the > Sandwiches["Ham'] = :Delicious. First we called which hash we wanted to use by declaring Sandwiches, after the square brackets and quotes targeted what key we were using, then the equal assigned a value to our key. The key in this case was the symbol ":Delicious". If we try to give a hash a key without a value we're given the output of nil as I stated earlier.

The next example codeschool gives you is to create another empty hash using a different command. It seems the end result may be the same (an empty hash) but how it interacts with our other example will be different.

=> ratings = Hash.new(0)

> { }

if it succeeds then we'll have created a new empty hash called ratings.

The next command we're asked to enter is:

=> books.values.each { |rate| ratings[rate] += 1 }

The excerpt from codeschool describes this as:

(That | in the code is called the pipe character. It's probably located right above the Enter key on your keyboard.)

This code will turn all your unique values in books...into keys within the new ratings hash. Crazy, right? Then, as it looks at each rating you originally gave in books, it will increase the count value for that rating in ratings

After you've built your new hash of count values, type ratings again to see the full tally. This new hash will show you a rating followed by the number of times you've given that rating.

The output of our last line of code (if you were following my examples and used sandwich instead of the codeschool book example):

> [:Delicious]

So what it did was as they explained above, took the values in the hash we created and turned those into keys under the new ratings hash. If you're wondering what values were assigned, were the total times each value was used in the original hash. So for our sandwich example if you were to call the hash ratings, the output will be;

=> {:Delicious=>2}

If we were to analyze the last line more, we can see that we're calling our hash, then using the method .values.each The first method #values created a new array from the values in our hash. The #each (this is taken from the ruby-doc.org):

"Calls block once for each key in hsh, passing the key-value pair as parameters.

If no block is given, an enumerator is returned instead.

h = { "a" => 100, "b" => 200 }

h.each {|key, value| puts "#{key} is #{value}" }

In summary of Ruby 0.2:

"Errors. If you try to reverse a number or do anything fishy, Ruby will skip the prompt and tell you to straighten up.

Arrays are lists of stored information.

Variables are a place to save stuff you might need again, as well as give that stuff a name. You used the equals sign to do this, in a process called assignment."

To demonstrate a way to dynamically change a string of text I'll show an example from codeschool:

There was a saved string of text named "poem". To call the poem you would use the command "print poem" the output yielded the results:

"My toast has flown out of my hand 

And my toast has gone to the moon.

But when I saw it on television,

Planting our flag on Haley's comet,

More still did I want to eat it."

Now, lets say using the word toast wasn't silly enough, we wanted to change the word toast in the poem to honeydew. We could change this by using the command: poem['toast'] = 'honeydew'.

While I'm not entirely sure if this is the process of how it works, I'm postulating that what you're doing is calling the array that you created of the string called poem. In that array you're using the equal sign to say that in the array poem you want to assign 'honeydew' to the character of 'toast' so now all instances of 'toast' are 'honeydew'

When you call "print poem" a second time you'll see that your output is now:

"My honeydew has flown out of my hand

And my toast has gone to the moon.

But when I saw it on television,

Planting our flag on Haley's comet,

More still did I want to eat it."

So looking at the output, I notice that you did not change toast in all instances but instead only on the first line of text did it change.

Fundamentally though, the bracket operator stated, "I am looking for ____ somewhere in here." In this scenario we were looking for the word toast to replace with honeydew.

the .reverse modifier still is able to be used for multiple lines of strings. In this case though, not only will the lines be moved in reverse, the order will reverse too. So the first line will become the last and the last line will become the first.

If we didn't want the words to become reverse such as: "dnah ym fo tuo nwolf sah wedyenoh yM", but still were looking to change the line order we can use the command: "poem.lines.to_a.reverse" This will maintain the word/letter order so our first line will still read as "My honeydew has flown out of my hand", but now it will be our last line instead of the first.

If we look at the command further we can see that it uses a new operand .lines, but we've seen the other two before .to_a and .reverse. The first part "poem" is calling our poem. Then the .lines is deciding on how we're going to handle our string. .lines is deciding to split it by each new line. The next part to_a (to_a[rray]) is converting each single string line into an array. Then lastly we're using .reverse to change the order of our array's. Now you may think when we had the array [47, 15, 33] it changed the order to [33, 15, 47]. So why didn't it change the order of each line array much like the first example of poem.reverse? If you think of it as [first array, second array, third array, fourth array, fifth array] then you can see how .reverse would change it to [fifth array, fourth array, ] and so on. using .line and .to_a changed each string into a single element in our array. This is at least how it seems to work while I'm working through it.

if we were to print this poem though, using just the command print poem.lines.to_a.reverse our output will be

["More still did I want to eat it.\

", "Planting our flag on Haley's comet,\

", "But when I saw it on television,\

", "And my toast has gone to the moon.\

", "My honeydew has flown out of my hand\

"]

to_s will convert values to strings

to_i will convert values to integers

to_a will convert values to arrays

Arrays are a form of lists, stored as sequences.

[ ] is an example of an empty array.

similar to sets in mathematics, when creating an array like [47, 15, 33] the numbers need to be separated by a comma.

Using the point operator you can find the max value in an array by typing ".max" at the end of an array like [47, 15, 33].max

the output would give you, 47

If you've used C you can also create named variables for an array.

number = [47, 15, 33]

now "number" has been declared and initialized with the value of your array

when you input "number" your output will be the array you assigned to it [47, 15, 33]

now instead of typing out the array to find the max value you could just use "number.max" and it'll give you the same output as above, 47

another function that can be called is .sort

inputing number.sort will yeild [15, 33, 47]

lowest value to highest value

by adding a .reverse operand to it will reverse the order to [47, 33, 15]

A note on using the operands on a declared variable.