Booleans

Boolean data type - type of data, intended to represent the only 2 options: 'True' and 'False'. Mostly used inside the conditional statements.

true.class => TrueClass
false.class => FalseClass

'Ruby awesome' if true => "Ruby awesome"
'Ruby sucks' if false => nil
						

Try to guess

true    ? 'true' : 'false'
false   ? 'true' : 'false'
nil     ? 'true' : 'false'
1       ? 'true' : 'false'
0       ? 'true' : 'false'
'false' ? 'true' : 'false'
''      ? 'true' : 'false'
[]      ? 'true' : 'false'
						

Numbers

Integer

Integer numbers is simply a sequence of digits. Fixnum numbers are integers up to a certain limit. The limit is machine dependent. Bignum values hold integers outside the range of the Fixnum. If any operation on a Fixnum exceeds its range, the value is automatically converted to a Bignum.

0.zero? => true
7.next => 8
-5 + 7 => 2
5 / 2 => 2

1000.class => Fixnum
1_000_000_000_000.class => Bignum
						

Float

Floating point numbers represent real numbers. Complex, Big Decimal and Rational classes are not built-in to Ruby, but are distributet with Ruby as part of the standart library.

5.8.integer? => false
7.1 - 2 => 5.1
3 - 1.5 => 1.5
5.0 / 2 => 2.5

(5.0 / 2).class => Float
						

Duct Typing

In Ruby we don’t declare the types of variables or methods — everything is just some kind of object. In Ruby, the class isn't always the same as the type. Instead, the type of an object is defined more by what that object can do. It is called duck typing. If an object walks like a duck and talks like a duck, then the interpreter is happy to treat it as if it were a duck.

def save_name(name, target)
    target << name
end

array = []
string = ''

save_name('Vasyl', array) => ["Vasyl"]
save_name('Vasyl', string) => "Vasyl"
						

Expressions

One of the first differences with Ruby is that anything that can reasonably return a value does: just about everything is an expression. For example, the if and case statements both return the value of the last expression executed. Methods have the same behavior. In Ruby, many operators are actually method calls.

a = b = c = 0 => 0
(a.*(b)).+(c) <=> a * b + c
a, b, c = 1, 2, 3
a, b = b, a
a, b = 1, 2, 3, 4 => a=1, b=2
						

Assignment operators

Assignment operator is the operator used for assignment.

+=   -=   *=   /=   =   %=   &=   |=   ^=   <<=   >>= &&= ||= **=
						

No post- pre increment!

Arithmetic operators

Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value.

+ - * / % **
						

Comparison operators

Comparison operators are used in logical statements to determine equality or difference between variables or values.

== != > < <= >= <=> === .eql? .equal?
						

Logical operators

Logical operators are used to determine the logic between variables or values.

and or not && || !
						

Bitwise operators

Bitwise operator works on bits and perform bit by bit operation.

& | ^ ~ << >>
						

Precedence (high to low)

Explain the difference

result = true and false
result = true && false
						

Methods

Method is defined using the keyword def. Method names should begin with a lowercase letter or underscore, followed by letters, digits, and underscore. A method always returns a value and its name may end with one of ?, !, or =. Method definition:

def my_method(arg1, arg2='default') # 2 arguments, but 2nd already has a default value
    # Code for the method would be here
end
						

Method invoking:

1. my_method('first_param', 'second_param')
2. my_method('first_param')
						

Why do we need methods?

• They allow us to conceive of our program as a bunch of sub-steps. (Each sub-step can be its own method. When any program seems too hard, just break the overall program into sub-steps!);
• They allow us to reuse code instead of rewriting it;
• Methods allow us to keep our variable namespace clean (local variables only "live" as long as the methods does);
• Methods allow us to test small parts of our program in isolation from the rest. This is especially true in interpreted langaues, such as Ruby.

Steps to Writing a Method

• Understand the purpose of the method;
• Define the data that comes into the function from the caller (in the form of parameters);
• Define what data variables are needed inside the method to accomplish its goal;
• Decide on the set of steps that the program will use to accomplish this goal (the algorithm).

Recursion

Classic example

A recursive methos is a method that calls itself. It can be used to replace cycle.

def fact(n)
    return 1 if n.zero?
    n * fact(n-1)
end

fact(5) => 120