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.classFixnum

Python : len()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.chompputs "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 stringsgsub Returns a copy of str with

all occurrences of pattern replaced with either replacement or the value of the block.

str.gsub( pattern, replacement )

chomp Returns a new String with the given record separator removed from the end of str (if present).

str.chomp

count Return the count of characters inside string

str.count

strip Removes leading and trailing spaces from a string

str.strip

to_i Converts the string to a number(Fixnum)

str.to_i

upcase Upcases the content of the strings

str.upcase

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 Book

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

end

//creating an object of the class

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

class SimpleClass

end

//instantiate an object

s1 = SimpleClass.new

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 gettersCompBook = 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_methodend

Exampleclass SomeClass

@@instance = 0 #privateattr_reader :instance

def initialize@@instance += 1

end

def self.instances @@instanceend

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

class Program

def get_sumcalculate_internal

end

private def calculate_internalend

end

Access Control-Example