[10-05-2015] [Prabhakaran S]
puts to print, gets to scan
ARGV is the array that contains arguments passed.
$0 is the file name, infact the first argument
$stdin, $stdout, $env all are there!
Normal math operations
Addition (+)
Subtract (-)
Division (/)
Multiplication (*)
Modulo (%) - No negative modulo
Exponent (**)
Boolean - The C way
(<=>) -1, 0, 1 locate smallest value
a, b, c = [1, 2, 3]
a, b, c = 1, 2, 3
# Both are same
Everying is an object in Ruby
1.next or 1.method('next').call
.respond_to?(method_name) tells if method exists for that object
self find where am I - Its an object again!
Object.class tell me the class name
Object.methods list all the methods
No need of brackets! Object.method1.method2...
obj.add(1, 2)
obj.add 1, 2
Method creating procedure, use snake_casing
def method_name(arg1, arg2)
# do whatever
end
The return specifies the object to be returned to the caller
when the method has done its work.
If no return, returns the object created by the last line in the method.
A method must always return exactly one object.
default values can be used in the arguments like C++, python
* - splat operator - converts parameters to array and array to paramaters
def add(a_number, another_number, options = {})
sum = a_number + another_number
sum = sum.abs if options[:absolute]
sum = sum.round(options[:precision]) if options[:round]
sum
end
puts add(1.0134, -5.568)
puts add(1.0134, -5.568, absolute: true)
puts add(1.0134, -5.568, absolute: true, round: true, precision: 2)
if cond
...
elsif cond
...
else
...
end
Ruby supports ternary operator
cond ? do_if_true : do_if_false
0 is true in Ruby!
loop do do_inside end <=> loop { do_inside }
Ruby iterates with a class called Enumerator
.times, .each, .each_with_index converts them to enumerators
(1..5).each do |counter| puts "iteration #{counter}" end
for i in Array
do_something
end
Some notable classes String Array Hash
a = "Hey" # Needs computation inside - String interpolation
b = "#{a}, How are you?" # This is interpolation
a = 'Hey'
By the way # is the comment
a, b are all of class String
Everything cannot be documented, but few examples.
String.split [delimiter] # convert String to Array
String1 << + .concat String2 # Concatenation
<< also works for Array
.sub regex replace # first occurence - regex "/pattern/"
.gsub regex replace # all occurences
.match regex starting # first occurence
[] or Array.new
Supports negative indexing
[start_index, length]
[start_index, end_index]
Array.map do |e| e+1 end # Transformation of array - .collect, .each
Array.select do |e| condition end # Filtering of array - .reject, .find
.find matches only the first
.inject has a variable retaining value for all the iteration.
similarly .reduce
Array.inject do |accumulator, element| do_something end
Similarly .delete, .delete_if
mehash = {'Monday' => 'First Day', 'Friday' => 'Fun Day' }
mehash = Hash['Monday', 'First Day', 'Friday', 'Fun Day']
mehash = Hash.new [default_value]
mehash.each do |key, value| do_something end
.class tell me the class name
.new creates an instance
$var is global variable @var is alive only within its block @@var is alive and visible to the whole class
def a=(a) # Setter method
@a=a
end
attr_writer :a
def a # Getter method
@a
end
attr_reader :a
Inheritance / Derives - @@var are visible for them
class Mom
end
class Son < Mom
end
self.method_name accessible by class name (no need of objects)
modules can be included or extended include - make it accessible for instances extend - make it accessible for classes
If module has modules inside, just define the rules for each module.
module ConcernExample
def self.[extended, included](base)
base.[extend, include](module_name)
# base.send(:[extend, include], module_name)
end
...
end
This is how you include/exclude a module
class Something
[extend, include] ConcernExample
end
Variables in the module should start with capital letter
:: is used to access class, methods, variables inside the modules
Function but without a name!
lambda do |a| p "Hey! #{a}" end.call 'Args passed here'
# Usual way
l = lambda do |a| p "Hey! #{a}" end
l.call "Args passed here"
def s(a)
yield(a)
end
s('Args passed here') do |a| puts "[#{a}]" end
mode = 'r+' # 'r', 'w', 'r+', 'w+'
file = File.open("list.txt", mode)
puts file.inspect
puts file.read # to read
file.puts "Hello" # to write
file.close