Ruby

Ruby

Vladimir Bystrov

Goals

Learn Ruby basics, OOP and metaprogramming. Compare Ruby to other languages. Show Ruby pros and cons.

Contents

• Overview

• Statements

• OOP

• Metaprogramming

Ruby – Overview

• Object oriented

• Dynamic

• Untyped

• Non commercial

• Productive

Ruby – Overview

Ruby from other languages:

• Java

• Perl

• PHP

Ruby – Overview

Ruby libraries:

• Ruby/DBI

• Rails

• Ruby-IRC

• google image search

• Logging

Ruby – Overview

Advantages:

• OOP

• Dynamic

• Garbage collection

• Metaprogramming

• Exception handling

• Libraries (http://rubyforge.org/)

http://rubyforge.org/

Ruby – Overview

Disadvantages:

• You can’t control memory allocation process, unable to define data primitives.

• Unable to compile program

• Can’t protect sources

• Bad performance

Ruby – Statements

First programm:

puts “Hello World”

Ruby – Statements

Variables in Ruby always designate references to objects, not the objects themselves.

a = "abcdefg" => "abcdefg"

b = a => "abcdefg"

b => "abcdefg"

a[3] = 'R' => "R"

b => "abcRefg"

Ruby – Statements

Data types:

• number – 23• string – “hello”• boolean – true | false• array – [“str”, 3]• hash array – {“a”=>4, “b”=>56}• range – 0..5• symbol – :symb• proc and blocks – {|x| print x}

Ruby – Statements

Numbers:There are 2 types of numbers in Ruby: integers and

floats (or decimals). There are 2 classes of integer numbers in order to distinguish between their size. So, numbers between -2^62 and 2^62-1 or -2^30 and 2^30-1 belong to the class Fixnum and are stored internally in binary format. Numbers outside those ranges belong to the Bignum class. A numeric literal with a decimal point and/or an exponent is turned into a Float object, corresponding to the native architecture’s double data type.

Ruby – Statements

Numbers examples:

5 # integer number

-12 # negative integer number

4.5 # float number

076 # octal number

0b010 # binary number

0x89 # hexadecimal number

Ruby – Statements

Strings:

str = ‘String’

str = “Another string”

str = %q[String]

str = %Q[Another string]

str = <<EOF

Long long long

multiline text

EOF

Ruby – Statements

Boolean type:

• true• false

Any value evaluate to true, only nil evaluate to false.

Ruby – Statements

Arrays:

• dynamic• heterogeneous• iterators

Ruby – Statements

Ruby – Statements

Arrays examples:

a = [1, 3, 5, 7, 9]

b = [3.14159, "pie", 99]

s = %w[string array init]

r = (1..10).to_a

[1,3,5,7,9].each {|i| puts i}

[1,3,5,7,9].reverse_each {|i| puts i}

Ruby – Statements

Hash arrays:

Hashes (sometimes known as associative arrays, maps, or dictionaries) are similar to arrays in that they are indexed collections of object references. However, while you index arrays with integers, you can index a hash with objects of any type: strings, regular expressions, and so on.

Ruby – Statements

Hash array example:

{”hello” => ”world”,

234 => “mega number!”,

”ruby” => ”rocks”}

Ruby – Statements

Ranges:

Ranges occur everywhere: January to December, 0 to 9, lines 50 through 67, and so on. Ruby supports ranges and allows us to use ranges in a variety of ways:

• Sequences

• Conditions

• Intervals

Ruby – Statements

Ranges as sequences:

"a".."z"

"a"..."z" # equal to "a".."y"

1..100

1...100 # equal to 1..99

Ruby – Statements

Ranges as conditions:

score = 70

result = case score when 0..40: "Fail" when 41..60: "Pass" when 61..70: "Pass with Merit" when 71..100: "Pass with Distinction“ else "Invalid Score" end

puts result

Ruby – Statements

Ranges as intervals:

if ((1..10) === 5)

puts "5 lies in (1..10)"

end

if (('a'..'j') === 'c')

puts "c lies in ('a'..'j')"

end

Ruby – Statements

Symbols:

A symbol in Ruby is an instance of the class Symbol. A symbol is defined by prefixing a colon with an identifier. :name, :id, :user etc. are examples of symbols. Unlike strings, symbols of the same name are initialized and exist in memory only once during a session of ruby.

Ruby – Statements

Symbols usage:

• As keys in hashes

• In Metaprogramming

Ruby – Statements

Proc type:

Proc objects are blocks of code that have been bound to a set of local variables. Once bound, the code may be called in different contexts and still access those variables.

Ruby – Statements

Blocks:

A block does not live on its own - it prepares the code for when it will actually become alive, and only when it is bound and converted to a Proc, it starts living.

Ruby – Statements

Proc examples:

putser = Proc.new {|x| puts x}

putser = lambda {|x| puts x}

putser.call(“Hello”)

Ruby – Statements

Block usage example:

def three_times

yield

yield

yield

end

three_times {puts "Hello"}

Ruby – Statements

Control statements:

• if/unless• case• while/until/loop/for• times/upto/downto

Ruby – Statements

Operator if example:

if num > 0

print “num > 0”

elsif num < 0

print “num < 0”

else

print “num = 0”

end

Ruby – Statements

Operator unless example:

unless num == 0

print “num not equals 0”

else

print “num equals 0”

end

Ruby – Statements

Special if/unless usage example:

print “a < 2” if a < 2

print “num is positive” unless num < 0

Ruby – Statements

Operator case example:

case val

when 0: print “0”

when 1..10: print “from 1 to 10”

else print “more than 10”

end

Ruby – Statements

Operator while example:

num = 0

while num < 10

print num

num++

end

s = 2

s = s*s while s < 1000

Ruby – Statements

Operator until example:

num = 0

until num > 10

print num

num++

end

Ruby – Statements

Operator loop example:

loop do

print “Type something:”

line = gets

break if line =~ /q|Q/

puts line

end

Ruby – Statements

Operator for:

for i in 0..9

print i, “ ”

end

#=> 0 1 2 3 4 5 6 7 8 9

Ruby – Statements

Operators upto, downto and times:

1.upto(5) {|i| print i, “ ”}

#=> 1 2 3 4 5

5.downto(1) {|i| print i, “ ”}

#=> 5 4 3 2 1

10.times {|i| print i, “ ”}

#=> 0 1 2 3 4 5 6 7 8 9

Ruby – Statements

Exceptions handling:

begin

# ...

rescue RuntimeError => e

# handle concrete error

else

# handle unexpected error

ensure

# runs in any case

end

raise ArgumentError, “Incorrect argument", caller

# caller – returns stack trace

Ruby – OOP

• Methods

• Classes

• Singletons

• Inheritance

• Modules

• Encapsulation

Ruby – OOP

Methods:

def method

print “hello”

end

In Ruby you can override operators like methods.

def +(val)

@val + val

end

Ruby – OOP

Classes:

class Test

def initialize(val)

@val = val

end

def out_value

print @val

end

end

Ruby – OOP

Instance variables:

class Test

@name = “Easy Jet”

def name

@name

end

def name=(val)

@name = val

end

end

Ruby – OOP

In Ruby you can create getters and setters using methods:

• attr• attr_reader• attr_writer• attr_accessor

Ruby – OOP

Method attr:

class Test

attr :name, true

end

Ruby – OOP

Method attr_reader:

class Test

attr_reader :name, :phone

end

Ruby – OOP

Method attr_writer:

class Test

attr_writer :name, :phone

end

Ruby – OOP

Method attr_accessor:

class Test

attr_accessor :name, :phone

end

Ruby – OOP

Class variables and methods:

class Test

@@variable = “something”

Test.output

print “class method”

end

end

Ruby – OOP

Singleton:

Singleton classes, not to be confused with the singleton design pattern. The name itself is confusing, leading people to create alternative names such as: object-specific classes, anonymous classes, and virtual classes. Anonymous classes is one of the better names.

Ruby – OOP

Singleton example:

class Singleton

end

s = Singleton.new

class << s def s.handle

print “singleton method”

endend

Ruby – OOP

Inheritance:

class Base

def method

print “hello”

end

end

class Child < Base

attr_accessor :name

end

Ruby – OOP

Modules (Mixin):

module TestModule

def out

print “mixin”

end

end

class Test

include TestModule

end

Ruby – OOP

Encapsulation:

• private• protected• public

class Test

private

def priv_method

// do something

end

end

Ruby – Metaprogramming

Duck typing:

Duck typing is a style of dynamic typing in which an object's current set of methods and properties determines the valid semantics, rather than its inheritance from a particular class or implementation of a specific interface. The name of the concept refers to the duck test, attributed to James Whitcomb Riley, which may be phrased as follows: “If it walks like a duck and quacks like a duck, I would call it a duck”.


Metaprogramming is the writing of computer programs that write or manipulate other programs (or themselves) as their data, or that do part of the work at runtime that would otherwise be done at compile time. In many cases, this allows programmers to get more done in the same amount of time as they would take to write all the code manually, or it gives programs greater flexibility to efficiently handle new situations without recompilation.


Dynamic code interpretation:

• eval• class_eval, module_eval• instance_eval

Foo = Class.new

a = %q[def out() p "hello" end]

Foo.class_eval(a)

foo = Foo.new

foo.out #=> “hello”


Get and set instance variables:

class Tester

@name

end

x = Tester.new

p x.instance_variable_get("@name") #=> nil

x.instance_variable_set("@name", "hello")

p x.instance_variable_get("@name") #=> "hello"


Dynamic method definition:

class Tester

def new_method(name, &block)

self.class.send(:define_method, name, &block)

end

end

x = Tester.new

x.new_method(:out) {p "hello"}

x.out #=> “hello”


Remove definitions:

• undef_method• remove_method

class Array

remove_method :size

end

x = [1,2,3]

p x.size #=> Error


Get list of defined objects, class methods:

• constants• ancestors• class_variables• included_modules• public_instance_methods• private_instance_methods• protected_instance_methods• superclass


Get list of defined objects, instance methods:

• instance_variables• methods• public_methods• private_methods• protected_methods• singleton_methods


Get class information:

• class• object_id• kind_of?• instance_of?• respond_to?


View stack of calls:

def func1

puts caller[0]

end

def func2

func1

end

func2 #=> prints: somefile.rb:6:in “func2”


Iterate object space:

ObjectSpace.each_object do |obj|

p obj.class

end

You can provide parameter for each_object (class or module), to narrow output.


Handle missing methods calls:

In ruby, when you call a method that doesn't actually exist on that object, the object always invokes the method_missing method instead. This is one of ruby's cool metaprogramming features: it lets you decide yourself how to handle what would have otherwise been an error.


Handle missing methods calls:

class Tester

def method_missing(method, *args)

system(method.to_s, *args)

end

end

t = Tester.new

t.dir


Observe changes in objects or class definitions:

•inherited•included•method_added

class Test

def Test.method_added(method)

p "new method added [#{method}]"

end

end

Resources

http://www.ruby-lang.org/en/

http://www.ruby-lang.org/en/

Questions

Ruby

Education

Transcript of Ruby