Ruby training day1

Introduction To Ruby
Programming

Bindesh Vijayan

Ruby as OOPs
● Ruby is a genuine Object
oriented programming
● Everything you manipulate is an
object
● And the results of the
manipulation is an object
● e.g. The number 4,if used, is an
object
Irb> 4.class Python : len()
Fixnum Ruby: obj.length

Setting up and installing ruby
● There are various ways of
installing ruby
● RailsInstaller for windows and osx
(http://railsinstaller.org)
● Compiling from source
● Using a package manager like
rvm..most popular

Ruby version
manager(rvm)
● In the ruby world, rvm is the most
popular method to install ruby and
rails
● Rvm is only available for mac os
x,linux and unix
● Rvm allows you to work with
multiple versions of ruby
● To install rvm you need to have
the curl program installed

Installing rvm(linux)
$ sudo apt-get install curl

$ curl -L https://get.rvm.io | bash -s stable –ruby

$ rvm requirements

$ rvm install 1.9.3

Standard types - numbers
● Numbers
● Ruby supports integers and floating point
numbers
● Integers within a certain range (normally
-230 to 230-1 or -262 to 262-1) are held
internally in binary form, and are objects
of class Fixnum
● Integers outside the above range are
stored in objects of class Bignum
● Ruby automatically manages the
conversion of Fixnum to Bignum and vice
versa
● Integers in ruby support several types
of iterators

Standard types- numbers
● e.g. Of iterators
● 3.times { print "X " }
● 1.upto(5) { |i| print i, " " }
● 99.downto(95) { |i| print i, " " }
● 50.step(80, 5) { |i| print i, " " }

Standard types - strings
● Strings in ruby are simply a sequence of
8-bit bytes
● In ruby strings can be assigned using
either a double quotes or a single quote
● a_string1 = 'hello world'
● a_string2 = “hello world”
● The difference comes
● when you want to use a special
character e.g. An apostrophe
● a_string1 = “Binn's world”
● a_string2 = 'Binn's world' # you need to
use an escape sequence here

Standard types - string
● Single quoted strings only
supports 2 escape sequences, viz.
● ' - single quote
● - single backslash
● Double quotes allows for many
more escape sequences
● They also allow you to embed
variables or ruby code commonly
called as interpolation
puts "Enter name"
name = gets.chomp
puts "Your name is #{name}"

Standard types - string
Common escape sequences available are :

● " – double quote
● – single backslash
● a – bell/alert
● b – backspace
● r – carriage return
● n – newline
● s – space
● t – tab
●

Working with strings
gsub Returns a copy of str with str.gsub( pattern,
all occurrences of pattern replacement )
replaced with either
replacement or the value of
the block.
chomp Returns a new String with str.chomp
the given record separator
removed from the end of str
(if present).
count Return the count of str.count
characters inside string
strip Removes leading and str.strip
trailing spaces from a
string
to_i Converts the string to a str.to_i
number(Fixnum)
upcase Upcases the content of the str.upcase
strings

http://www.ruby-doc.org/core-1.9.3/String.html#method-i-strip

Standard types - ranges
● A Range represents an interval—a set of
values with a start and an end
● In ruby, Ranges may be constructed using
the s..e and s...e literals, or with
Range::new
● ('a'..'e').to_a #=> ["a", "b", "c",
"d", "e"]
● ('a'...'e').to_a #=> ["a", "b", "c",
"d"]

Using ranges
● Comparison
● (0..2) == (0..2) #=>
true
● (0..2) == Range.new(0,2) #=>
true
● (0..2) == (0...2) #=>
false

Using ranges
● Using in iteration
(10..15).each do |n|
print n, ' '
end

Using ranges
● Checking for members
● ("a".."z").include?("g") # -> true
● ("a".."z").include?("A") # ->
false

Methods
● Methods are defined using the def
keyword
● By convention methods that act as a
query are often named in ruby with a
trailing '?'
● e.g. str.instance_of?
● Methods that might be
dangerous(causing an exception e.g.)
or modify the reciever are named with
a trailing '!'
● e.g. user.save!
● '?' and '!' are the only 2 special
characters allowed in method name

Defining methods
● Simple method:
def mymethod
end
● Methods with arguments:
def mymethod2(arg1, arg2)
end
● Methods with variable length arguments
def varargs(arg1, *rest)
"Got #{arg1} and #{rest.join(', ')}"
end

Methods
● In ruby, the last line of the
method statement is returned back
and there is no need to explicitly
use a return statement
def get_message(name)
“hello, #{name}”
end
.Calling a method :
get_message(“bin”)
● Calling a method without arguments
:
mymethod #calls the method

Methods with blocks
● When a method is called, it can be given
a random set of code to be executed
called as blocks
def takeBlock(p1)
if block_given?
yield(p1)
else
p1
end
end

Calling methods with
blocks
takeBlock("no block") #no block
provided
takeBlock("no block") { |s|
s.sub(/no /, '') }

Classes
● Classes in ruby are defined by
using the keyword 'class'
● By convention, ruby demands that
the class name should be capital
● An initialize method inside a
class acts as a constructor
● An instance variable can be
created using @

class
SimpleClass

end

//instantiate an
object

s1 =
SimpleClass.new

class Book

def intitialize(title,author)
@title = title
@author = author
end
end

//creating an object of the class

b1 = Book.new("programming ruby","David")

Making an attribute
accessible
● Like in any other object oriented
programming language, you will need
to manipulate the attributes
● Ruby makes this easy with the
keyword 'attr_reader' and
'attr_writer'
● This defines the getter and the
setter methods for the attributes

class Book

attr_reader :title, :author

def initialize(title,author)
@title = title
@author = author
end

end

#using getters
CompBook = Book.new(“A book”, “me”)
Puts CompBook.title

Symbols
● In ruby symbols can be declared using ':'
● e.g :name
● Symbols are a kind of strings
● The important difference is that they are immutable
unlike strings
● Mutable objects can be changed after assignment while
immutable objects can only be overwritten.
● puts "hello" << " world"
● puts :hello << :" world"

Making an attribute
writeable
class Book

attr_writer :title, :author
def initialize(title,author)
@title = title
@author = author
end

end
myBook = Book.new("A book",
"author")

myBook.title = "Some book"

Class variables
● Sometimes you might need to declare a
class variable in your class definition
● Class variables have a single copy for
all the class objects
● In ruby, you can define a class variable
using @@ symbol
● Class variables are private to the class
so in order to access them outside the
class you need to defined a getter or a
class method

Class Methods
● Class methods are defined using
the keyword self
● e.g.
– def self. myclass_method
end

Example
class SomeClass
@@instance = 0 #private
attr_reader :instance

def initialize
@@instance += 1
end

def self.instances
@@instance
end
end

s1 = SomeClass.new
s2 = SomeClass.new

puts "total instances #{SomeClass.instances}"

Access Control
● You can specify 3 types of
access control in ruby
● Private
● Protected
● Public
● By default, unless specified,
all methods are public

Access Control-Example
class Program

def get_sum
calculate_internal
end

private
def calculate_internal
end

end

Ruby training day1

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Ruby training day1 (20)

Recently uploaded (20)

Ruby training day1