Kernel, IO, Dir or File. Kernel module. Methods of the Kernel are available to all objects in Ruby. #!/usr/bin/rubyThe
print "Apple "
print "Apple\n"
puts "Orange"
puts "Orange"
print and puts methods produce textual output on the console. The difference between the two is that the latter adds a new line character. print "Apple "The print method prints two consecutive "Apple" strings to the terminal. If we want to create a new line, we must explicitly include the newline character. The newline character is '\n'. Behind the scenes. the
print "Apple\n"
print method actually calls the to_s method of the object being printed. puts "Orange"The
puts "Orange"
puts method prints two strings to the console. They are on a separate line. The method includes automatically the newline character. $ ./printing.rbOutput of the printing.rb script file.
Apple Apple
Orange
Orange
print method is an equivalent to the $stdout.print. The $stdout is a global variable which holds the standard output stream. #!/usr/bin/rubyWe print two lines using the
$stdout.print "Ruby language\n"
$stdout.puts "Python language"
$stdout variable. #!/usr/bin/rubyIn the example, we present
p "Lemon"
p "Lemon"
printf "There are %d apples\n", 3
putc 'K'
putc 0xA
p, printf and putc methods. p "Lemon"The
p calls the inspect method upon the object being printed. The method is useful for debugging. printf "There are %d apples\n", 3The
printf method is well known from the C programming language. It enables string formatting. putc 'K'The
putc 0xA
putc method prints one character to the console. The second line prints a newline. The 0xA is a hexadecimal code for the newline character. $ ./printing3.rbOutput of the example.
"Lemon"
"Lemon"
There are 3 apples
K
ios = IO.new STDOUT.filenoIn the example, we open a standard output stream and write a string into it.
ios.write "ZetCode\n"
ios.close
ios = IO.new STDOUT.filenoThe
new method returns a stream to which we can write data. The method takes a numeric file descriptor. The STDOUT.fileno gives us the file descriptor for the standard output stream. We could also simply write 2. ios.write "ZetCode\n"We write a string to the opened stream.
ios.closeThe input stream is closed.
#!/usr/bin/rubyA small example in which we write to a /dev/tty file. This only works on Unix.
fd = IO.sysopen "/dev/tty", "w"
ios = IO.new(fd, "w")
ios.puts "ZetCode"
ios.close
fd = IO.sysopen "/dev/tty", "w"The
sysopen method opens the given path, returning the underlying file descriptor number. ios = IO.new(fd, "w")The file descriptor number is used to open a stream.
ios.puts "ZetCode"We write a string to the stream and close it.
ios.close
$stdin is a global variable that holds a stream for the standard input. It can be used to read input from the console. #!/usr/bin/rubyIn the above code, we use the
inp = $stdin.read
puts inp
read method to read input from the console. inp = $stdin.readThe
read method reads data from the standard input, until it reaches the end of the file. The EOF is produced by pressing Ctrl + D on Unix or Ctrl + Z on Windows. $ ./reading.rbWhen we launch a program without a parameter, the script reads data from the user. It reads until we press Ctrl + D or Ctrl + Z.
Ruby language
Ruby language
$ echo "ZetCode" | ./reading.rbThe script can read data from another program or a file, if we do some redirections.
ZetCode
$ ./input.rb < stones
Garnet
Topaz
Opal
Amethyst
Ruby
Jasper
Pyrite
Malachite
Quartz
gets method. #!/usr/bin/rubyWe use the
print "Enter your name: "
name = gets
puts "Hello #{name}"
gets method to read a line from the user. name = getsThe
gets method reads a line from the standard input. The data is assigned to the name variable. puts "Hello #{name}"
The data that we have read is printed to the console. We use interpolation to include the variable in the string. $ ./readline.rbSample output.
Enter your name: Jan
Hello Jan
chompmethod. It is a string method. It removes white spaces from the end of the string, if present. It is useful when doing input operations. The method name and usage comes from the Perl language. #!/usr/bin/rubyWe read a string from a user and calculate the length of the input string.
print "Enter a string: "
inp = gets
puts "The string has #{inp.size} characters"
$ ./nochomp.rbThe message says that the string has 5 characters. It is because it counts the newline as well.
Enter a string: Ruby
The string has 5 characters
chomp method. #!/usr/bin/rubyThis time we use we cut the newline character with the
print "Enter a string: "
inp = gets.chomp
puts "The string has #{inp.size} characters"
chompmethod. $ ./chomp.rbThe Ruby string has indeed 4 characters.
Enter a string: Ruby
The string has 4 characters
IO class is the basis for all input and output in Ruby. The File class is the only subclass of the IO class. The two classes are closely related. #!/usr/bin/rubyIn the first example, we open a file and write some data to it.
f = File.open('output.txt', 'w')
f.puts "The Ruby tutorial"
f.close
f = File.open('output.txt', 'w')
We open a file 'output.txt' in a write mode. The open method returns an io stream. f.puts "The Ruby tutorial"We used the above opened stream to write some data. The
puts method can be used to write data to a file as well. f.closeAt the end the stream is closed.
$ ./simplewrite.rbWe execute the script and show the contents of the output.txt file.
$ cat output.txt
The Ruby tutorial
#!/usr/bin/rubyIf there is a block after the
File.open('langs', 'w') do |f|
f.puts "Ruby"
f.write "Java\n"
f << "Python\n"
end
open method, then Ruby passes the opened stream to this block. At the end of the block, the file is automatically closed. f.puts "Ruby"We use three different methods to write to a file.
f.write "Java\n"
f << "Python\n"
$ ./simplewrite2.rbWe execute the script and check the contents of the langs file.
$ cat langs
Ruby
Java
Python
File class. #!/usr/bin/rubyThe example creates a new file named 'tempfile' and calls some methods.
puts File.exists? 'tempfile'
f = File.new 'tempfile', 'w'
puts File.mtime 'tempfile'
puts f.size
File.rename 'tempfile', 'tempfile2'
f.close
puts File.exists? 'tempfile'The
exists? method checks, if a file with a given name already exists. The line returns false, because we have not yet created the file. f = File.new 'tempfile', 'w'The file is created.
puts File.mtime 'tempfile'The
mtime method gives us the last modification time of the file. puts f.sizeWe determine the file size. The method returns 0, since we have not written to the file.
File.rename 'tempfile', 'tempfile2'Finally, we rename the file using the
rename method. $ ./testfile.rbSample output.
false
2011-11-05 16:19:36 +0100
0
#!/usr/bin/rubyThis is a simple script, that will open a file called stones and print it contents line by line to the terminal.
f = File.open("stones")
while line = f.gets do
puts line
end
f.close
f = File.open("stones")
We open a 'stones' file. The default mode is a read mode. The 'stones' file contains nine names of valued stones; each on a separate line. while line = f.gets doThe
puts line
end
gets method reads a line from the I/O stream. The while block ends when we reach the end of file. $ ./readlines2.rbOutput of the example.
Garnet
Topaz
Opal
Amethyst
Ruby
Jasper
Pyrite
Malachite
Quartz
#!/usr/bin/rubyThis script is another way, how we can read contents of a file. The code example will print its own code to the terminal.
fname = 'alllines.rb'
File.readlines(fname).each do |line|
puts line
end
File.readlines(fname).each do |line|The
puts line
end
readlines reads all lines from the specified file and returns them in the form of an array. We go through the array with the each method and print the lines to the terminal. $ ./alllines.rbOutput of the example.
#!/usr/bin/ruby
fname = 'alllines.rb'
File.readlines(fname).each do |line|
puts line
end
Dir class to work with directories in Ruby. #!/usr/bin/rubyIn the script we use four methods of the
Dir.mkdir "tmp"
puts Dir.exists? "tmp"
puts Dir.pwd
Dir.chdir "tmp"
puts Dir.pwd
Dir.chdir '..'
puts Dir.pwd
Dir.rmdir "tmp"
puts Dir.exists? "tmp"
Dir class. Dir.mkdir "tmp"The
mkdir method makes a new directory called 'tmp'. puts Dir.exists? "tmp"With the
exists? method, we check if a directory with a given name exists in the filesystem. puts Dir.pwdThe
pwd method prints a current working directory. It is a directory, where we have launched the script. Dir.chdir '..'The
chdir method changes to another directory. The '..' directory is the parent directory of the current working directory. Dir.rmdir "tmp"Finally, we remove a directory with the
puts Dir.exists? "tmp"
rmdir method. This time the exists? method returns false. $ ./dirs.rbOutput of the example.
true
/home/vronskij/programming/ruby/io
/home/vronskij/programming/ruby/io/tmp
/home/vronskij/programming/ruby/io
false
#!/usr/bin/rubyThe
fls = Dir.entries '.'
puts fls.inspect
entries method returns all entries of a given diretory. fls = Dir.entries '.'We get the array of files and directories of a current directory. The '.' character stands for the current working directory in this constext. The
puts fls.inspect
inspect method gives us a more readable representation of the array. $ ./allfiles.rbIn the output we can see an array of files and directories.
["putc.rb", "simplewrite.rb", "readlines2.rb", "fileexists.rb~" ...
#!/usr/bin/rubyThe script prints two home directories.
puts Dir.home
puts Dir.home 'root'
puts Dir.homeIf we do not specify the user name, then a home directory of a current user is returned. The current user is the owner of the script file. Someone, who has launched the script.
puts Dir.home 'root'Here we print the home directory of a specific user. In our case the superuser.
$ ./homedir.rbSample output.
/home/vronskij
/root
#!/usr/bin/rubyWe call a
data = system 'ls'
puts data
ls command, which lists directory contents. data = system 'ls'The
system command executes an external program in a subshell. The method belongs to the Kernel Ruby module. $ ./system.rbA sample output.
allfiles.rb characters.rb fileexists.rb homedir.rb~ ...
#!/usr/bin/rubyTo run external programs we can use backticks `` or %x[] characters.
out = `pwd`
puts out
out = %x[uptime]
puts out
out = %x[ls | grep 'readline']
puts out
out = `pwd`Here we execute the
pwd command using backticks. The command returns the current working directory. out = %x[uptime]Here we get the output of the
uptime command, which tells how long a system is running. out = %x[ls | grep 'readline']We can use also a combination of commands.
$ ./system2.rbSample output.
/home/vronskij/programming/ruby/io
22:50:50 up 5:32, 1 user, load average: 0.46, 0.44, 0.45
readline.rb
readline.rb~
readlines2.rb
readlines2.rb~
open method. The method belongs to the Kernel module. It creates an IO object connected to the given stream, file, or subprocess. If we want to connect to a subprocess, we start the path of the open with a pipe character (|). #!/usr/bin/rubyIn the example, we print the outcome of the
f = open("|ls -l |head -3")
out = f.read
puts out
f.close
puts $?.success?
ls -l | head -3commands. The combination of these two commands return the first three lines of the ls -l command. We also check the status of the child subprocess. f = open("|ls -l |head -3")
We connect to a subprocess, created by these two commands. out = f.readWe read and print data from the subprocess.
puts out
f.closeWe close the file handler.
puts $?.success?The
$? is a special Ruby variable, which obtains the status of the last executed child process. The success?method returns true, if the child process ended OK, false otherwise. $ ./system3.rbSample output.
total 148
-rwxr-xr-x 1 vronskij vronskij 57 2011-10-30 23:33 allfiles.rb
-rwxr-xr-x 1 vronskij vronskij 58 2011-10-30 23:33 allfiles.rb~
true
$stdout is the name of the variable for the standard output. #!/usr/bin/rubyIn the above example, we redirect a standard output to the output.log file.
$stdout = File.open "output.log", "a"
puts "Ruby"
puts "Java"
$stdout.close
$stdout = STDOUT
puts "Python"
$stdout = File.open "output.log", "a"This line creates a new standard ouput. The standard output will now flow to the ouput.log file. The file is opened in an append mode. If the file does not exist yet, it is created. Otherwise it is opened and the data is written at the end of the file.
puts "Ruby"We print two strings. The strings will not be shown in the terminal as usual, they will be appended to the output.log file.
puts "Java"
$stdout.closeWe close the handler.
$stdout = STDOUTWe use a predefined standard constant
puts "Python"
STDOUT to recreate the normal standard ouput. The "Python" string is printed to a console. | . | Matches any single character. |
| * | Matches the preceding element zero or more times. |
| [ ] | Bracket expression. Matches a character within the brackets. |
| [^ ] | Matches a single character, that is not contained within the brackets. |
| ^ | Matches the starting position within the string. |
| $ | Matches the ending position within the string. |
| | | Alternation operator. |
Regexp class is used to develop regular expressions. There are also two shorthand ways to create regular expressions. The following example will show them. #!/usr/bin/rubyIn the first example, we show three ways of applying regular expressions on a string.
re = Regexp.new 'Jane'
p "Jane is hot".match re
p "Jane is hot" =~ /Jane/
p "Jane is hot".match %r{Jane}
re = Regexp.new 'Jane'In the above two lines, we create a
p "Jane is hot".match re
Regexp object cointaining a simple regular expression text. Using the match method, we apply this regular expression object on the "Jane is hot" sentence. We check, if the word 'Jane' is inside the sentence. p "Jane is hot" =~ /Jane/These two lines do the same. Two forward slashes // and the %r{} characters are shorthands for the more verbose first way. In this tutorial, we will use the forward slashes. This is a de facto standard in many languages.
p "Jane is hot".match %r{Jane}
$ ./regex.rbIn all three cases there is a match. The
#<MatchData "Jane">
0
#<MatchData "Jane">
match method returns a matched data, or nil if there is no match. The =~ operator returns the first character of the matched text, or nil otherwise. #!/usr/bin/rubyIn the first example, we will use the
p "Seven".match /.even/
p "even".match /.even/
p "eleven".match /.even/
p "proven".match /.even/
match method to apply regular expression on strings. The match method returns the matched data on success or nil otherwise. p "Seven".match /.even/The "Seven" is the string on which we call the
match method. The parameter of the method is the pattern. The /.even/ regular pattern looks for a text that starts with an arbitrary character followed by the 'even' characters. $ ./dot.rbFrom the output we can see which strings did match and which did not.
#<MatchData "Seven">
nil
#<MatchData "leven">
nil
#!/usr/bin/rubyThe script uses the ? repetition character.
p "seven".match /.even/
p "even".match /.even/
p "even".match /.?even/
p "even".match /.even/This line prints
nil since the regular expression expects one character before the 'even' string. p "even".match /.?even/Here we have slightly modified the regular expression. The '.?' stands for no character or one arbitrary character. This time there is a match.
$ ./dot2.rbExample output.
#<MatchData "seven">
nil
#<MatchData "even">
match method to work with regular expressions. There are other methods where we can apply regular expressions. #!/usr/bin/rubyThe example shows some methods that can work with regular expressions.
puts "motherboard" =~ /board/
puts "12, 911, 12, 111"[/\d{3}/]
puts "motherboard".gsub /board/, "land"
p "meet big deep nil need".scan /.[e][e]./
p "This is Sparta!".split(/\s/)
puts "motherboard" =~ /board/The =~ is an operator that applies the regular expression on the right to the string on the left.
puts "12, 911, 12, 111"[/\d{3}/]
Regular expressions can be placed between the square brackets following the string. This line prints the first string which has three digits. puts "motherboard".gsub /board/, "land"With the
gsub method we replace a 'board' string with a 'land' string. p "meet big deep nil need".scan /.[e][e]./The
scan method looks for matches in the string. It looks for all occurences, not just the first one. The line prints all strings that match the pattern. p "This is Sparta!".split(/\s/)The
split method splits a string using a given regular expression as a separator. The \s character type stands for any whitespace character. $ ./apply.rbOutput of the apply.rb script.
6
911
motherland
["meet", "deep", "need"]
["This", "is", "Sparta!"]
#!/usr/bin/rubyThe example shows three special variables.
puts "Her name is Jane" =~ /name/
p $`
p $&
p $'
puts "Her name is Jane" =~ /name/In this line we have a simple regular expression matching. We look for a 'name' string inside the 'Her name is Jane' sentence. We use the =~ operator. This operator also sets three special variables. The line returns number 4, which is the position on which the match starts.
p $`The $` special variable contains the text before the last match.
p $&The $& has the matched text.
p $'And the $' variable contains the text after the last match.
$ ./svars.rbOutput of the example.
4
"Her "
"name"
" is Jane"
#!/usr/bin/rubyIn the first example, we work with the ^ and the $ anchoring characters.
sen1 = "Everywhere I look I see Jane"
sen2 = "Jane is the best thing that happened to me"
p sen1.match /^Jane/
p sen2.match /^Jane/
p sen1.match /Jane$/
p sen2.match /Jane$/
sen1 = "Everywhere I look I see Jane"We have two sentences. The word 'Jane' is located at the beginning of the first one and at the end of the second one.
sen2 = "Jane is the best thing that happened to me"
p sen1.match /^Jane/Here we look if the word 'Jane' is at the beginning of the two sentences.
p sen2.match /^Jane/
p sen1.match /Jane$/Here we look for a match of a text at the end of the sentences.
p sen2.match /Jane$/
$ ./anchors.rbThese are the results.
nil
#<MatchData "Jane">
#<MatchData "Jane">
nil
#!/usr/bin/rubyWe have a sentence. And within this sentence, we look for a string cat. With the help of the
text = "The cat also known as the domestic cat is a small,
usually furry, domesticated, carnivorous mammal."
p text.scan /cat/
p $`
p $&
p $'
scan method, we look for all 'cat' strings in the sentence. Not just the first occurence. text = "The cat also known as the domestic cat is a small,The problem is that inside the text there are three 'cat' strings. In addition to the 'cat' referring to the mammal there is also a match inside the word 'domesticated'. Which is not what we are looking for in this case.
usually furry, domesticated, carnivorous mammal."
$ ./boudaries.rbRunnning the example shows three matches. And the special variables show the text before and after the match in the 'domesticated' adjective. This is not what we want. In the next example, we will improve our regular expression to look only for whole word matches.
["cat", "cat", "cat"]
"The cat also known as the domestic cat is a small, \nusually furry, domesti"
"cat"
"ed, carnivorous mammal."
\b character is used to set boundaries to the words we are looking for. #!/usr/bin/rubyThe example is improved by including the \b metacharacter.
text = "The cat also known as the domestic cat is a small,
usually furry, domesticated, carnivorous mammal."
p text.scan /\bcat\b/
p $`
p $&
p $'
p text.scan /\bcat\b/With the above regular expression, we look for 'cat' strings as whole words. We do not count subwords.
$ ./boudaries2.rbThis time there are two matches. And the special variables show correctly the text before and after the last match.
["cat", "cat"]
"The cat also known as the domestic "
"cat"
" is a small, \nusually furry, domesticated, carnivorous mammal."
#!/usr/bin/rubyWe have an array of six three letter words. We apply a regular expression on the strings of the array with a specific character set.
words = %w/ sit MIT fit fat lot pad /
pattern = /[fs]it/
words.each do |word|
if word.match pattern
puts "#{word} matches the pattern"
else
puts "#{word} does not match the pattern"
end
end
pattern = /[fs]it/This is the pattern. The pattern looks for 'fit' and 'sit' strings in the array. We use either 'f' or 's' from the character set.
$ ./classes.rbThere are two matches.
sit matches the pattern
MIT does not match the pattern
fit matches the pattern
fat does not match the pattern
lot does not match the pattern
pad does not match the pattern
#!/usr/bin/rubyThe example has three regular expressions with character classes.
p "car".match %r{[abc][a][rs]}
p "car".match /[a-r]+/
p "23af 433a 4ga".scan /\b[a-f0-9]+\b/
p "car".match %r{[abc][a][rs]}
The regular expression in this line consists of three character classes. Each is for one character. The [abc] is either a, b or c. The [a] is only a. The third one, [rs], is either r or s. There is a match with the 'car' string. p "car".match /[a-r]+/We can use a hyphen - character inside the character class. The hyphen is a metacharacter denoting an inclusive range of characters. In our case, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, r characters. Since the character class applies only for one character, we also use the + repetition character. This says that the previous character from the character set may be repeated one or more times. The 'car' strings meets these conditions.
p "23af 433a 4ga".scan /\b[a-f0-9]+\b/In this line, we have a string consisting of three substrings. With the
scan method we check for hexadicimal numbers. We have two ranges. The first, [a-f] stands for characters from a to f. The second one, [0-9] stands for numbers 0 to 9. The + specifies that these characters can be repeated multiple times. Finally, the \b metacharacters create boundaries, which accept only strings that consists of only these characters. $ ./classes2.rbExample output.
#<MatchData "car">
#<MatchData "car">
["23af", "433a"]
#!/usr/bin/rubyIn the example, we use a caret character inside a character class.
p "ABC".match /[^a-z]{3}/
p "abc".match /[^a-z]{3}/
p "ABC".match /[^a-z]{3}/
We look for a string having 3 letters. These letters may not be letters from a to z. The "ABC" string matches the regular expression, because all three characters are uppercase characters. p "abc".match /[^a-z]{3}/
This "abc" string does not match. All three characters are in the range, that is excluded from the search. $ ./caret.rbExample output.
#<MatchData "ABC">
nil
? - 0 or 1 matchThe above is a list of common quantifiers.
* - 0 or more
+ - 1 or more
{n} - exactly n
{n,} - n or more
{,n} - n or less (??)
{n,m} - range n to m
#!/usr/bin/rubyIn the example, we want to select those words, that have exactly three characters. The \w character is a word character, and \w{3} means three times the prevoius word character.
p "seven dig moon car lot fire".scan /\w{3}/
p "seven dig moon car lot fire".scan /\b\w{3}\b/
p "seven dig moon car lot fire".scan /\w{3}/
The first line simply cuts first three characters from each string. Which is not exactly what we want. p "seven dig moon car lot fire".scan /\b\w{3}\b/
This is an improved search. We put the previous pattern between the \b boundary metacharacter. Now the search will find only those words, that have exactly three characters. $ ./nchars.rbOutput of the example.
["sev", "dig", "moo", "car", "lot", "fir"]
["dig", "car", "lot"]
#!/usr/bin/rubyIn the above example we choose words that have two, three of four characters. We again use the boundary \b metacharacter to choose whole words.
p "I dig moon lottery it fire".scan /\b\w{2,4}\b/
$ ./rchars.rbThe example prints an array of words having 2-4 characters.
["dig", "moon", "it", "fire"]
#!/usr/bin/rubySay we have a text in which we want to look for the colour word. The word has two distinct spellings, english 'colour' and american 'color'. We want to find both occurences, plus we want to find their plurals too.
p "color colour colors colours".scan /colou?rs/
p "color colour colors colours".scan /colou?rs?/
p "color colour colors colours".scan /\bcolor\b|\bcolors\b|\bcolour\b|\bcolours\b/
p "color colour colors colours".scan /colou?rs/The colou?rs pattern finds both 'colours' and 'colors'. The u character, which precedes the ? metacharacter is optional.
p "color colour colors colours".scan /colou?rs?/The colou?rs? pattern makes the u and s characters optional. And so we find all four colour combinations.
p "color colour colors colours".scan /\bcolor\b|\bcolors\b|\bcolour\b|\bcolours\b/The same request could be written using alternations.
$ ./qmark.rbExample output.
["colors", "colours"]
["color", "colour", "colors", "colours"]
["color", "colour", "colors", "colours"]
#!/usr/bin/rubyIn the example, we have an array of numbers. Numbers can have one or more number characters.
nums = %w/ 234 1 23 53434 234532453464 23455636
324f 34532452343452 343 2324 24221 34$34232/
nums.each do |num|
m = num.match /[0-9]+/
if m.to_s.eql? num
puts num
end
end
nums = %w/ 234 1 23 53434 234532453464 23455636This is an array of strings. Two of them are not numbers, because they contain non-numerical characters. They must be excluded.
324f 34532452343452 343 2324 24221 34$34232/
nums.each do |num|We go through the array and apply the regular expression on each string. The expression is [0-9]+, which stands for any character from 0..9, repeated 0 or multiple times. Note that by default, the regular expression looks for substrings as well. In the 34$34232 the engine considers 34 to be a number. The \b boundaries do not work here, because we do not have concrete characters and the engine does not know, where to stop looking. This is why we have included an if condition in the block. The string is considered a number only if the match is equal to the original string.
m = num.match /[0-9]+/
if m.to_s.eql? num
puts num
end
end
$ ./numbers.rbThese values are numbers.
234
1
23
53434
234532453464
23455636
34532452343452
343
2324
24221
#!/usr/bin/rubyThe example show both case sensitive and case insensitive search.
p "Jane".match /Jane/
p "Jane".match /jane/
p "Jane".match /JANE/
p "Jane".match /jane/i
p "Jane".match /Jane/i
p "Jane".match /JANE/i
p "Jane".match /Jane/In these three lines the characters must exactly match the pattern. Only the first line gives a match.
p "Jane".match /jane/
p "Jane".match /JANE/
p "Jane".match /jane/iHere we use the i option, which followes the second / character. We do case insensitive search. All three lines do match.
p "Jane".match /Jane/i
p "Jane".match /JANE/i
$ ./icase.rbOutput of the example.
#<MatchData "Jane">
nil
nil
#<MatchData "Jane">
#<MatchData "Jane">
#<MatchData "Jane">
#!/usr/bin/rubyWe have 8 names in the names array. We will look for a multiple combination of strings in that array.
names = %w/Jane Thomas Robert Lucy Beky
John Peter Andy/
pattern = /Jane|Beky|Robert/
names.each do |name|
if name =~ pattern
puts "#{name} is my friend"
else
puts "#{name} is not my friend"
end
end
pattern = /Jane|Beky|Robert/This is the search pattern. It says, Jane, Beky and Robert are my friends. If you find either of them, you have found my friend.
$ ./alternation.rbOutput of the script.
Jane is my friend
Thomas is not my friend
Robert is my friend
Lucy is not my friend
Beky is my friend
John is not my friend
Peter is not my friend
Andy is not my friend
#!/usr/bin/rubyWe have the following regex pattern: book(worm)?$. The (worm) is a subpattern. Only two strings can match. Either 'book' or 'bookworm'. The ? character follows the subpattern, which means, that the subpattern might appear 0, 1 time in the final pattern. The $ character is here for the exact end match of the string. Without it, words like bookstore, bookmania would match too.
p "bookworm" =~ /book(worm)?$/
p "book" =~ /book(worm)?$/
p "worm" =~ /book(worm)?$/
p "bookstore" =~ /book(worm)?$/
#!/usr/bin/rubySubpatterns are often used with alternation. We can create then multiple word combinations. For example (shelf|worm) subpattern enables us to search for words 'bookshelf' and 'bookworm'. And with the ? metacharacter also for 'book'.
p "book" =~ /book(shelf|worm)?$/
p "bookshelf" =~ /book(shelf|worm)?$/
p "bookworm" =~ /book(shelf|worm)?$/
p "bookstore" =~ /book(shelf|worm)?$/
$ ./subpatterns2.rbOutput. The last subpattern does not match. Remember, that the 0s do not mean that there was no match. For the =~ operator, it is the index of the first character of the matched string.
0
0
0
nil
#!/usr/bin/rubyNote that this example provides only one solution. It does not have to be the best one.
emails = %w/ luke@gmail.com andy@yahoo.com 23214sdj^as
f3444@gmail.com /
pattern = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9-]+\.[a-zA-Z.]{2,5}$/
emails.each do |email|
if email.match pattern
puts "#{email} matches"
else
puts "#{email} does not match"
end
end
emails = %w/ luke@gmail.com andy@yahoocom 23214sdj^asThis is an array of emails. Only two of them are valid.
f3444@gmail.com /
pattern = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9-]+\.[a-zA-Z.]{2,5}$/
This is the pattern. The first ^ and the last $ characters are here to get an exact pattern match. No characters before and after the pattern are allowed. The email is divided into five parts. The first part is the local part. This is usually a name of a company, individual or a nickname. The [a-zA-Z0-9._-]+ lists all possible characters, we can use in the local part. They can be used one or more times. The second part is the literal @ character. The third part is the domain part. It is usually the domain name of the email provider. Like yahoo, gmail etc. [a-zA-Z0-9-]+ It is a character set providing all characters, than can be used in the domain name. The + quantifier makes use of one or more of these characters. The fourth part is the dot character. It is preceded by the escape character. (\.) This is because the dot character is a metacharacter and has a special meaning. By escaping it, we get a literal dot. Final part is the top level domain. The pattern is as follows: [a-zA-Z.]{2,5}Top level domains can have from 2 to 5 characters. Like sk, net, info, travel. There is also a dot character. This is because some top level domains have two parts. For example, co.uk. $ ./email.rbThe regular expression marked two strings as valid email adresses.
luke@gmail.com matches
andy@yahoocom does not match
23214sdj^as does not match
f3444@gmail.com matches
attr_reader, attr_writerand attr_accessor. attr_reader creates getter methods. The attr_writermethod creates setter methods and instance variables for this setters. The attr_accessor method creates both getter, setter methods and their instance variables. #!/usr/bin/rubyWe have a Car class. In the definition of the class, we use the
class Car
attr_reader :name, :price
attr_writer :name, :price
def to_s
"#{@name}: #{@price}"
end
end
c1 = Car.new
c2 = Car.new
c1.name = "Porsche"
c1.price = 23500
c2.name = "Volkswagen"
c2.price = 9500
puts "The #{c1.name} costs #{c1.price}"
p c1
p c2
attr_reader and attr_writer to create two getter and setter methods for the Car class. attr_reader :name, :priceHere we create two instance methods named name and price. Note that the
attr_reader takes symbols of methods as parameters. attr_writer :name, :priceThe
attr_writer creates two setter methods named name and price and two instance variables @name and @price. c1.name = "Porsche"In this context, two setter methods are called to fill instance variables with some data.
c1.price = 23500
puts "The #{c1.name} costs #{c1.price}"
Here two getter methods are called to get data from the instance variables of the c1 object. $ ./arw.rbOutput of the example.
The Porsche costs 23500
Porsche: 23500
Volkswagen: 9500
attr_accessor method creates both getter, setter methods and their instance variables. #!/usr/bin/rubyWe have a Book class in which the
class Book
attr_accessor :title, :pages
end
b1 = Book.new
b1.title = "Hidden motives"
b1.pages = 255
p "The book #{b1.title} has #{b1.pages} pages"
attr_accessorcreates two pairs of methods and two instance variables. class BookThe
attr_accessor :title, :pages
end
attr_accessor method that sets up title and pages methods and @title and @pages instance variables. b1 = Book.newAn object of a Book class is created. Two setter methods fill the instance variables of the object.
b1.title = "Hidden motives"
b1.pages = 255
p "The book #{b1.title} has #{b1.pages} pages"
In this code line we use two getter methods to read the values of the instance variables. $ ./accessor.rbExample output.
"The book Hidden motives has 255 pages"
#!/usr/bin/rubyWe have a MMath class with a PI constant.
class MMath
PI = 3.141592
end
puts MMath::PI
PI = 3.141592We create a PI constant. Remember that constants in Ruby are not enforced.
puts MMath::PIWe access the PI constant using the :: operator.
$ ./classconstant.rbRunning the example.
3.141592
to_s method. It returns a string representation of the object. Note that when the puts method takes an object as a parameter, the to_s of the object is being called. #!/usr/bin/rubyWe have a Being class in which we override the default implementation of the
class Being
def to_s
"This is Being class"
end
end
b = Being.new
puts b.to_s
puts b
to_s method. def to_sEach class created inherits from the base
"This is Being class"
end
Object. The to_s method belongs to this class. We overwrite the to_s method and create a new implementation. We provide a human-readable description of our object. b = Being.newWe create a Being class and call the
puts b.to_s
puts b
to_s method twice. The first time explicitly, the second time implicitly. $ ./tostring.rbThis is what we get, when we run the example.
This is Being class
This is Being class
#!/usr/bin/rubyIn the example, we have a Circle class. We overload the + operator in the class. We use it to add two circle objects.
class Circle
attr_accessor :radius
def initialize r
@radius = r
end
def +(other)
Circle.new @radius + other.radius
end
def to_s
"Circle with radius: #{@radius}"
end
end
c1 = Circle.new 5
c2 = Circle.new 6
c3 = c1 + c2
p c3
def +(other)We define a method with a + name. The method adds the radiuses of two circle objects.
Circle.new @radius + other.radius
end
c1 = Circle.new 5We create two circle objects. In the third line, we add these two objects to create a new one.
c2 = Circle.new 6
c3 = c1 + c2
$ ./operatoroverloading.rbBy adding two circle objects we have created a third one, which radius is 11.
Circle with radius: 11
#!/usr/bin/rubyThe above code example presents a Circle class. Apart from a constructor method, it has one class and one instance method.
class Circle
def initialize x
@r = x
end
def self.info
"This is a Circle class"
end
def area
@r * @r * 3.141592
end
end
p Circle.info
c = Circle.new 3
p c.area
def self.infoMethods that start with a
"This is a Circle class"
end
self keyword are class methods. def areaInstance methods do not start with the self keyword.
"Circle, radius: #{@r}"
end
p Circle.infoWe call a class method. Note that we call the method on a class name.
c = Circle.new 3To call an instance method, we must first create an object. Instance methods are always called on an object. In our case, the c variable holds the object and we call the area method on the circle object. We utilize a dot operator.
p c.area
$ ./classmethods.rbOutput of the code example describing class methods in Ruby.
"This is a Circle class"
28.274328
#!/usr/bin/rubyThe example has three classes. Each of them has one class method.
class Wood
def self.info
"This is a Wood class"
end
end
class Brick
class << self
def info
"This is a Brick class"
end
end
end
class Rock
end
def Rock.info
"This is a Rock class"
end
p Wood.info
p Brick.info
p Rock.info
def self.infoClass methods may start with a
"This is a Wood class"
end
self keyword. class << selfAnother way is to put a method definition after the class << self construct.
def info
"This is a Brick class"
end
end
def Rock.infoThis is the third way to define a class method in Ruby.
"This is a Rock class"
end
$ ./classmethods2.rbWe see the output of calling all three class methods on a Wood, Brick and Rock classes.
"This is a Wood class"
"This is a Brick class"
"This is a Rock class"
#!/usr/bin/rubyIn the example we create three instance objects from a Wood, a Brick and a Rock class. Each object has one instance method defined.
class Wood
def info
"This is a wood object"
end
end
wood = Wood.new
p wood.info
class Brick
attr_accessor :info
end
brick = Brick.new
brick.info = "This is a brick object"
p brick.info
class Rock
end
rock = Rock.new
def rock.info
"This is a rock object"
end
p rock.info
class WoodThis is probably the most common way to define and call an instance method. The info method is defined inside the Wood class. Later, the object is created and we call the info method on the object instance.
def info
"This is a wood object"
end
end
wood = Wood.new
p wood.info
class BrickAnother way is to create a method using the attribute accessors. This is a convenient way which saves some typing for the programmer. The
attr_accessor :info
end
brick = Brick.new
brick.info = "This is a brick object"
p brick.info
attr_accessor creates two methods, the getter and the setter method and it also creates an instance variable which stores the data. The brick object is created and the data is stored in the @info variable using the info setter method. Finally, the message is read by the info getter method. class RockIn the third way we create an empty Rock class. The object is instantiated. Later, a method is dynamically created and placed into the object.
end
rock = Rock.new
def rock.info
"This is a rock object"
end
p rock.info
$ ./threeways.rbExample output.
"This is a wood object"
"This is a brick object"
"This is a rock object"
#!/usr/bin/rubyWe have a simple inheritance hierarchy. There is an Animal base class and two descendants, a Cat and a Dog. Each of these three classes has its own implementation of the make_noise method. The implementation of the method of the descendants replaces the definition of a method in the Animal class.
class Animal
def make_noise
"Some noise"
end
def sleep
puts "#{self.class.name} is sleeping."
end
end
class Dog < Animal
def make_noise
'Woof!'
end
end
class Cat < Animal
def make_noise
'Meow!'
end
end
[Animal.new, Dog.new, Cat.new].each do |animal|
puts animal.make_noise
animal.sleep
end
class Dog < AnimalThe implementation of the make_noise method in the Dog class replaces the implementation of the make_noise of the Animal class.
def make_noise
'Woof!'
end
end
[Animal.new, Dog.new, Cat.new].each do |animal|We create an instance of ech of the classes. We call make_noise and sleep methods on the objects.
puts animal.make_noise
animal.sleep
end
$ ./polymorhism.rbOutput of the polymorhism.rb script.
Some noise
Animal is sleeping.
Woof!
Dog is sleeping.
Meow!
Cat is sleeping.
Module is a collection of methods, classes and constants. Modules are similar to classes with a few differences. Modules cannot have instances. They have no subclasses. #!/usr/bin/rubyRuby has a built-in
puts Math::PI
puts Math.sin 2
Math module. It has multiple methods and a constant. We access the PI constant by using the :: operator. Methods are accessed by a dot operator as in classes. #!/usr/bin/rubyIf we include a module in our script, we can refer to the Math objects directly, omitting the Math name. Modules are added to a script using the
include Math
puts PI
puts sin 2
include keyword. $ ./modules.rbOutput of the program.
3.141592653589793
0.9092974268256817
#!/usr/bin/rubyRuby code can be grouped semantically. Rocks, trees belong to a forest. And pools, cinemas, squares belong to a town. By using modules our code has some order. Plus there is another thing. Animals can be in a forest and in a town too. In a single script, we cannot define two animal classes. They would clash. Putting them in different modules we solve the issue.
module Forest
class Rock ; end
class Tree ; end
class Animal ; end
end
module Town
class Pool ; end
class Cinema ; end
class Square ; end
class Animal ; end
end
p Forest::Tree.new
p Forest::Rock.new
p Town::Cinema.new
p Forest::Animal.new
p Town::Animal.new
p Forest::Tree.newWe are creating objects that belong to a forest and to a town. To access an object in a module, we use the :: operator.
p Forest::Rock.new
p Town::Cinema.new
p Forest::Animal.newTwo different animal objects are created. The Ruby interpreter can tell between them. It identifies them by their module name.
p Town::Animal.new
$ ./modules3.rb
#<Forest::Tree:0x97f35ec>
#<Forest::Rock:0x97f35b0>
#<Town::Cinema:0x97f3588>
#<Forest::Animal:0x97f3560>
#<Town::Animal:0x97f3538>
#!/usr/bin/rubyWe have three modules and one class. The modules represent some functionality. A device can be swiched on and off. Many objects can share this functionality. Televisions, mobile phones, computers or refrigerators. Rather than creating this ability to be swiched on/off for each object class, we separate it in one module, which can be included in each object if necessary. This way the code is better organized and more compact.
module Device
def switch_on ; puts "on" end
def switch_off ; puts "off" end
end
module Volume
def volume_up ; puts "volume up" end
def vodule_down ; puts "volume down" end
end
module Pluggable
def plug_in ; puts "plug in" end
def plug_out ; puts "plug out" end
end
class CellPhone
include Device, Volume, Pluggable
def ring
puts "ringing"
end
end
cph = CellPhone.new
cph.switch_on
cph.volume_up
cph.ring
module VolumeA Volume module organizes methods, than are responsible for controlling the volume level. If a device needs these methods, it simply includes the module to its class.
def volume_up ; puts "volume up" end
def vodule_down ; puts "volume down" end
end
class CellPhoneA cell phone adds all three modules with the
include Device, Volume, Pluggable
def ring
puts "ringing"
end
end
include method. The methods of the modules are mixed in the CellPhone class. And are available for the instances of the class. The CellPhone class has also its own ring method that is specific to it. cph = CellPhone.newA CellPhone object is created and we call three methods upon the object.
cph.switch_on
cph.volume_up
cph.ring
$ ./mixins.rbRunning the example.
on
volume up
ringing
Exceptionclass. Exception objects carry information about the exception. Its type (the exception’s class name), an optional descriptive string, and optional traceback information. Programs may subclass Exception, or more often StandardError to provide custom classes and add additional information. #!/usr/bin/rubyIn the above program, we intentionally divide a number by zero. This leads to an error.
x = 35
y = 0
begin
z = x / y
puts z
rescue => e
puts e
p e
end
beginStatements that are error prone are placed after the
z = x / y
puts z
begin keyword. rescue => eIn the code following the
puts e
p e
end
rescue keyword, we deal with an exception. In this case, we print the error message to the console. The e is an exception object that is created when the error occurs. $ ./zerodivision.rbIn the output of the example, we see the message of the exception. The last line shows the exception object called ZeroDivisionError.
divided by 0
#<ZeroDivisionError: divided by 0>
raise keyword. #!/usr/bin/rubyThe entrance to a club is not allowed for people younger than 18 years. We simulate this situation in our Ruby script.
age = 17
begin
if age < 18
raise "Person is minor"
end
puts "Entry allowed"
rescue => e
puts e
p e
exit 1
end
beginIf the person is minor, an exception is raised. If the
if age < 18
raise "Person is minor"
end
puts "Entry allowed"
raise keyword does not have a specific exception as a parameter, a RuntimeError exception is raised setting its message to the given string. The code does not reach the puts "Entry allowed" line. The execution of the code is interrupted and it continues at the rescue block. rescue => eIn the rescue block, we print the error message and the string representation of the
puts e
p e
exit 1
end
RuntimeError object. We also call the exit method to inform the environment that the execution of the script ended in error. $ ./raise_exception.rbThe person was minor and he or she was not allowed to enter the club. The bash $? variable is set to the exit error of the script.
Person is minor
#<RuntimeError: Person is minor>
$ echo $?
1
ensure clause we create a block of code that is always executed. Whether there is an exception or not. #!/usr/bin/rubyIn the code example, we try to open and read the stones file. I/O operations are error prone. We could easily have an exception.
begin
f = File.open("stones", "r")
while line = f.gets do
puts line
end
rescue => e
puts e
p e
ensure
f.close if f
end
ensureIn the ensure block we close the file handler. We check if the handler exists because it might not have been created. Allocated resources are often placed in the ensure block.
f.close if f
end
StandardError class. #!/usr/bin/rubyLet's say, we have a situation in which we cannot deal with big numbers.
class BigValueError < StandardError ; end
LIMIT = 333
x = 3_432_453
begin
if x > LIMIT
raise BigValueError, "Exceeded the maximum value"
end
puts "Script continues"
rescue => e
puts e
p e
exit 1
end
class BigValueError < StandardError ; endWe have a BigValueError class. This class derives from the built-in
StandardError class. LIMIT = 333Numbers which exceed this constant are considered to be "big" by our program.
if x > LIMITIf the value is bigger than the limit, we throw our custom exception. We give the exception a message "Exceeded the maximum value".
raise BigValueError, "Exceeded the maximum value"
end
$ ./custom_exception.rbRunning the program.
Exceeded the maximum value
#<BigValueError: Exceeded the maximum value>
#!/usr/bin/rubyIn our first example, we create a simple object.
class Being
end
b = Being.new
puts b
class BeingThis is a simple class definition. The body of the template is empty. It does not have any data or methods.
end
b = Being.newWe create a new instance of the Being class. For this we have the
new method. The b variable stores the newly created object. puts bWe print the object to the console to get some basic description of the object. What does it mean, to print an object? When we print an object, we in fact call its
to_s method. But we have not defined any method yet. It is because every object created inherits from the base Object. It has some elementary functionality, which is shared among all objects created. One of this is the to_s method. $ ./simple.rbWe get the object class name.
#<Being:0x9f3c290>
initialize. Constructors do not return any values. super method. They are called in the order of inheritance. #!/usr/bin/rubyWe have a Being class.
class Being
def initialize
puts "Being is created"
end
end
Being.new
class BeingThe Being class has a constructor method called
def initialize
puts "Being is created"
end
end
initialize. It prints a message to the console. The definition of a Ruby method is placed between the def and end keywords. Being.newAn instance of the Being class is created. At the moment of the object creation, the constructor method is called.
$ ./constructor.rbThis is the output of the program.
Being is created
#!/usr/bin/rubyIn the above Ruby code, we have a Person class with one member field.
class Person
def initialize name
@name = name
end
def get_name
@name
end
end
p1 = Person.new "Jane"
p2 = Person.new "Beky"
puts p1.get_name
puts p2.get_name
class PersonIn the constructor of the Person class, we set a member field to a value name. The name parameter is passed to the constructor at creation. A constructor is a method called
def initialize name
@name = name
end
initializethat is being called at the creation of an instance object. The @name is an instance variable. Instance variables start with @ character in Ruby. def get_nameThe get_name method returns the member field. In Ruby member fields are accessible only via methods.
@name
end
p1 = Person.new "Jane"We create two objects of a Person class. A string parameter is passed to each object constructor. The names are stored inside instance variables that are unique to each object.
p2 = Person.new "Beky"
puts p1.get_nameWe print the member fields by calling the get_name on each of the objects.
puts p2.get_name
$ ./person.rbWe see the output of the program. Each instance of the Person class has its own name member field.
Jane
Beky
allocate method for this. The allocate method allocates space for a new object of a class and does not call initialize on the new instance. #!/usr/bin/rubyIn the example, we create two objects. The first object using the
class Being
def initialize
puts "Being created"
end
end
b1 = Being.new
b2 = Being.allocate
puts b2
new method, the second object using the allocate method. b1 = Being.newHere we create an instance of the object with the
new keyword. The constructor method initialize is called and the message is printed to the console. b2 = Being.allocateIn case of the
puts b2
allocate method, the constructor is not called. We call the to_s method with the puts keyword to show, that the object was created. $ ./allocate.rbOutput of the program.
Being created
#<Being:0x8ea0044>
#!/usr/bin/rubyThis example shows how we could simulate constructor overloading on a Person class that has two member fields. If we do not specify the name of the person, we have "unknown" string instead. For unspecified age we have 0.
class Person
def initialize name="unknown", age=0
@name = name
@age = age
end
def to_s
"Name: #{@name}, Age: #{@age}"
end
end
p1 = Person.new
p2 = Person.new "unknown", 17
p3 = Person.new "Becky", 19
p4 = Person.new "Robert"
p p1, p2, p3, p4
def initialize name="unknown", age=0The constructor takes two parameters. They have a default value. The default value is used, if we do not specify our own values at the object creation. Note that the order of parameters must be kept. First comes the name, then the age.
@name = name
@age = age
end
p1 = Person.newWe create four objects. The constructors take different number of parameters.
p2 = Person.new "unknown", 17
p3 = Person.new "Becky", 19
p4 = Person.new "Robert"
p p1, p2, p3, p4
$ ./consover.rbOutput of the example.
Name: unknown, Age: 0
Name: unknown, Age: 17
Name: Becky, Age: 19
Name: Robert, Age: 0
#!/usr/bin/rubyThe example shows two basic ways to call a method.
class Person
def initialize name
@name = name
end
def get_name
@name
end
end
per = Person.new "Jane"
puts per.get_name
puts per.send :get_name
puts per.get_nameThe common way is to use a dot operator on an object followed by a method name.
puts per.send :get_nameThe alternative is to use a built-in
send method. It takes a symbol of the method to be called as a parameter. #!/usr/bin/rubyIn the code example, we have a Circle class. We define two methods.
class Circle
@@PI = 3.141592
def initialize
@radius = 0
end
def set_radius radius
@radius = radius
end
def area
@radius * @radius * @@PI
end
end
c = Circle.new
c.set_radius 5
puts c.area
@@PI = 3.141592We have defined a @@PI variable in our Circle class. It is a class variable. Class variables start with @@ sigils in Ruby. Class variables belong to a class, not to an object. Each object has access to its class variables. We use the @@PI to compute the area of the circle.
def initializeWe have one member field. It is the radius of the circle. If we want to modify this variable from the outside, we must use the publicly available set_radius method. The data is protected.
@radius = 0
end
def set_radius radiusThis is the set_radius method. It gives the @radius instance variable a new value.
@radius = radius
end
def areaThe area method returns the area of a circle. This is a typical task for a method. It works with data and produces some value for us.
@radius * @radius * @@PI
end
c = Circle.newWe create an instance of the Circle class. And set its radius by calling the set_radius method on the object of the circle. We use the dot operator to call the method.
c.set_radius 5
puts c.area
$ ./circle.rbRunning the example.
78.5398
public, protectedand private. In Ruby, all data members are private. Access modifiers can be used only on methods. Ruby methods are public, unless we say otherwise. public methods can be accessed from inside the definition of the class as well as from the outside of the class. The difference between the protected and the private methods is subtle. They both cannot be accessed outside the definition of the class. They can be accessed only within the class itself and by inherited or parent classes. self keyword which points to the current receiver. #!/usr/bin/rubyThe example explains the usage of public Ruby methods.
class Some
def method1
puts "public method1 called"
end
public
def method2
puts "public method2 called"
end
def method3
puts "public method3 called"
method1
self.method1
end
end
s = Some.new
s.method1
s.method2
s.method3
def method1The method1 is public, even if we did not specify the
puts "public method1 called"
end
public access modifier. It is because methods are public by default, if not specified otherwise. publicMethods following the
def method2
puts "public method2 called"
end
...
public keyword are public. def method3From inside the public method3, we call other public method. With and without the
puts "public method3 called"
method1
self.method1
end
self keyword. s = Some.newPublic methods are the only methods that can be called outside the definition of a class as shown here.
s.method1
s.method2
s.method3
$ ./public_methods.rbRunning the example.
public method1 called
public method2 called
public method3 called
public method1 called
public method1 called
#!/usr/bin/rubyPrivate methods are tightest methods in Ruby. They can be called only inside a class definition and without the
class Some
def initialize
method1
# self.method1
end
private
def method1
puts "private method1 called"
end
end
s = Some.new
# s.method1
self keyword. def initializeIn the constructor of the method, we call the private method1. Calling the method with the self is commented. Private methods cannot be specified with a receiver.
method1
# self.method1
end
privateMethods following the
def method1
puts "private method1 called"
end
private keyword are private in Ruby. s = Some.newWe create an instance of the Some class. Calling the method outside the class definition is prohibited. If we uncomment the line, the Ruby interpreter gives an error.
# s.method1
$ ./private_methods.rbOutput of the example code.
private method called
selfkeyword specified. #!/usr/bin/rubyThe above example shows protected method in usage.
class Some
def initialize
method1
self.method1
end
protected
def method1
puts "protected method1 called"
end
end
s = Some.new
# s.method1
def initializeProtected methods can be called with and without the self keyword.
method1
self.method1
end
protectedProtected methods are preceded by the
def method1
puts "protected method1 called"
end
protected keyword. s = Some.newProtected methods cannot be called outside the class definition. Uncommenting the line would lead to an error.
# s.method1
#!/usr/bin/rubyIn this program, we have two classes. A base Being class and a derived Human class. The derived class inherits from the base class.
class Being
def initialize
puts "Being class created"
end
end
class Human < Being
def initialize
super
puts "Human class created"
end
end
Being.new
Human.new
class Human < BeingIn Ruby, we use the < operator to create inheritance relations. The Human class inherits from the Being class.
def initializeThe
super
puts "Human class created"
end
super method calls the constructor of the parent class. Being.newWe instantiate the Being and the Human class.
Human.new
$ ./inheritance.rbFirst the Being class is created. The derived Human class also calls the costructor of its parent.
Being class created
Being class created
Human class created
ancestors which gives a list of ancestors for a specific class. #!/usr/bin/rubyWe have four classes in this example. A Human is a Mammal a Living and a Being.
class Being
end
class Living < Being
end
class Mammal < Living
end
class Human < Mammal
end
p Human.ancestors
p Human.ancestorsWe print the ancestors of a Human class.
$ ./ancestors.rbA Human class has three custom and three built-in ancestors.
[Human, Mammal, Living, Being, Object, Kernel, BasicObject]
#!/usr/bin/rubyWe have four classes. The inheritance hierarchy is more complicated. The Human and the Animal classes inherit from the Being class. And the Dog class inherits directly from the Animal class and further from the Being class. We also use a class variable to count the number of beings created.
class Being
@@count = 0
def initialize
@@count += 1
puts "Being class created"
end
def show_count
"There are #{@@count} beings"
end
end
class Human < Being
def initialize
super
puts "Human is created"
end
end
class Animal < Being
def initialize
super
puts "Animal is created"
end
end
class Dog < Animal
def initialize
super
puts "Dog is created"
end
end
Human.new
d = Dog.new
puts d.show_count
@@count = 0We define a class variable. A class variable begins with @@ sigils and it belongs to the class, not to the instance of the class. We use it to count the number of beins created.
def initializeEach time the Being class is instantiated, we increase the @@count variable by one. This way we keep track of the number of instances created.
@@count += 1
puts "Being class created"
end
class Animal < BeingThe Animal inherits from the Being and the Dog inherits from the Animal. Further, the Dog inherits from the Being as well.
...
class Dog < Animal
...
Human.newWe create instances from the Human and from the Dog classes. We call the show_count method on the Dog object. The Dog class has no such method; the grandparent's (Being) method is called then.
d = Dog.new
puts d.show_count
$ ./inheritance2.rbThe Human object calls two constructors. The Dog object calls three constructors. There are two Beings instantiated.
Being class created
Human is created
Being class created
Animal is created
Dog is created
There are 2 beings
#!/usr/bin/rubyIn the example we have two classes. The Derived class inherits from the Base class. It inherits all three methods and one data field.
class Base
def initialize
@name = "Base"
end
private
def private_method
puts "private method called"
end
protected
def protected_method
puts "protected_method called"
end
public
def get_name
return @name
end
end
class Derived < Base
def public_method
private_method
protected_method
end
end
d = Derived.new
d.public_method
puts d.get_name
def public_methodIn the public_method of the Derived class we call one private and one protected method. They were defined in the parent class.
private_method
protected_method
end
d = Derived.newWe create an instance of the Derived class. We call the public_method. And call the get_name method, which returns the private @name variable. Remember that all instance variables are private in Ruby. The get_name method returns the variable regardless of the fact, that it is private and defined in the parent class.
d.public_method
puts d.get_name
$ ./inheritance3.rbThe output of the example confirms that in Ruby language, public, protected, private methods and private member fields are inherited by child objects from their parents.
private method called
protected_method called
Base
super method calls a method of the same name in the parent's class. If the method has no arguments it automatically passes all its arguments. If we write super() no arguments are passed to parent's method. #!/usr/bin/rubyIn the example, we have two classes in a hierarchy. They both have a show method. The show method in the Derived class calls the show method in the Base class using the
class Base
def show x=0, y=0
p "Base class, x: #{x}, y: #{y}"
end
end
class Derived < Base
def show x, y
super
super x
super x, y
super()
end
end
d = Derived.new
d.show 3, 3
super method. def show x, yThe
super
super x
super x, y
super()
end
super method without any arguments calls the parent's show method with the arguments that were passed to the show method of the Derived class. In our case x=3, y=3. The super() method passes no arguments to the parent's show method. $ ./super.rbOutput of the example.
"Base class, x: 3, y: 3"
"Base class, x: 3, y: 0"
"Base class, x: 3, y: 3"
"Base class, x: 0, y: 0"
