Support Forums

Full Version: Ruby Basic Tutorial
You're currently viewing a stripped down version of our content. View the full version with proper formatting.
Pages: 1 2
Ruby Basic Tutorial



Hello World

This is the simplest possible Ruby program, hello.rb. As you'd expect, it prints "Hello World" on the screen. Be sure to set it executable.

Code:
#!/usr/bin/ruby
print "Hello World\n"

Although this program works as expected, it goes against the philosophy of Ruby because it's not object oriented. But as a proof of concept that Ruby's working on your computer, it's just fine.

Besides print, there's also a puts keyword. The difference is that puts automatically inserts a newline at the end of the string being printed, whereas print does not. In other words, puts is more convenient, but print is necessary if separate statements print to the same line. Througout this tutorial we'll use both print and puts.

Loops

Let's count to 10...

Code:
#!/usr/bin/ruby
for ss in 1...10
    print ss, " Hello\n";
end

The elipses (...) indicate the range through which to loop. The for is terminated by an end. You don't need braces for a loop. Whew!

The following is the output:

Code:
[slitt@mydesk slitt]$ ./loop.rb
1 hello
2 hello
3 hello
4 hello
5 hello
6 hello
7 hello
8 hello
9 hello
[slitt@mydesk slitt]$

Now lets list the presidents backwards by calculating the array's subscript as the array's length minus the counter, minus one. Ugly, but it gets the job done:

Code:
#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
for ss in 0...presidents.length
    print ss, ": ", presidents[presidents.length - ss - 1], "\n";
end

The preceding program produces the following output:

Code:
[slitt@mydesk slitt]$ ./hello.rb
0: Bush2
1: Clinton
2: Bush1
3: Reagan
4: Carter
5: Ford
[slitt@mydesk slitt]$

Ruby has a much nicer way of iterating backwards through a list: Negative subscripts. The following iterates backward through the array, using the fact that array[-1] is the last item, array[-2] is the second to last, etc:

Code:
#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
for ss in 0...presidents.length
    print ss, ": ", presidents[-ss -1], "\n";
end

If you're familiar with C, Pascal or Perl, you're probably dissappointed you couldn't just use presidents.length...0. Backwards iteration doesn't work in Ruby -- it must iterate up.

Iterators and Blocks

Another way to loop through an array is to use an iterator (in red in the following code) and a block (in blue in the following code:

Code:
#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
presidents.each {|prez| puts prez}

In the preceding code, the block argument (prez) contains the current array element, and everything else until the closing brace contains code to operate on the block argument. The block argument is always enclosed in vertical lines (pipe symbols). The following is the output of the preceding code:

Code:
[slitt@mydesk slitt]$ ./hello.rb
Ford
Carter
Reagan
Bush1
Clinton
Bush2
[slitt@mydesk slitt]$

The block needn't be on one line:
Code:
#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
presidents.each {
    |prez|
    puts prez
}



As shown in the previous examples, you can define the block by enclosing it in curly braces. You can also define it by enclosing it in a do and an end, where the do replaces the opening brace, and the end replaces the closing brace:
Code:
#!/usr/bin/ruby
presidents = ["Ford", "Carter", "Reagan", "Bush1", "Clinton", "Bush2"]
presidents.each do
    |prez|
    puts prez
end


Personally, I greatly prefer the do/end syntax for multiline blocks, because as a Perl/C/C++ guy I have a very different perception of braces than their limited use in Ruby, and also because of all the brace placement religious wars I've endured (I'm a Whitesmith type guy myself). However, on short single line blocks, using the braces saves valuable line space. From what I understand, the methods are interchangeable in features and performance, with one small exception...

Speaking of performance, if you declare the block argument outside the block (in other words, make it a local variable), performance improves because Ruby needn't recreate a variable every iteration. HOWEVER, the loop messes with the value of the variable, so it's best to use a specific variable for that purpose, and do not use it for other purposes within the subroutine. Here's an example of using a local variable as a block argument:
Code:
#!/usr/bin/ruby
i = -99
puts "Before: " + i.to_s
(1..10).each{|i| puts i}
puts "After : " + i.to_s
[slitt@mydesk slitt]$ ./loop.rb          
Before: -99
1
2
3
4
5
6
7
8
9
10
After : 10
[slitt@mydesk slitt]$


If you use a local variable for a block argument, do so only in loops with huge numbers of iterations, and use only variables that are specifically intended to serve as block arguuments and nothing else.


I pulled this crap from here , so don't flame!
Great tutorial, thanks for the share. No need to flame, you can pull it from other sites, just be sure to cite your sources. If you don't give credit where it is due you will find your stay on this forum to be relatively short.
What can I say , I'm happy that you didn't flame.
Very nice, I understood all of it clearly.
Thanks! It cleared up a few things for me.
Good tutorial dude, keep it up Smile
so in every program We should
start With
Code:
#!/usr/bin/ruby

hmm?
(04-07-2010, 09:36 AM)Mr.Kewl Wrote: [ -> ]so in every program We should
start With
Code:
#!/usr/bin/ruby

hmm?

If ruby is anything like python than no, your right, you should use:
Code:
#!/usr/bin/env ruby
In case the person doesn't have ruby installed on that directory, it uses the ruby environment variable(not sure if that is exactly correct but that's how it works for python)
(04-07-2010, 05:03 PM)uber1337 Wrote: [ -> ]<SNIP>
Code:
#!/usr/bin/env ruby
<SNIP>

Yes that right Tongue
Great TUT
5/5 Great Job
Great TuT dude.Very usefull.
Well done Oui
Pages: 1 2