September 27, 1999
* prepended to an argument?
& prepended to an argument?
Proc.new without a block do?
:exit mean?
loop a control structure?
a +b gives an error.
s = "x"; puts s *10 gives an error.
p {}.
def pos= (val) print @pos,"\n"; @pos = val end,
I cannot use the method pos = 1.
'\1' and '\\1'?
p true or true and false prints true, while
a=true if true or true and false does not assign true
to a.
p(nil || "") returns "", while p(nil or "")
gives parse error.
+ and - operators?
private and
protected.
super yields an ArgumentError.
load and require?
include and extend?
self mean?
instance_methods(nil)?
rand generate the same random number sequence?
Fixnum, true, nil, and false
are implemented as immediate values, what is the difference between
an immediate value and a reference?
nil and false?
less to display strings?
File object which has no reference?
true in a condition expression.
"abcd"[0] return?
sub and sub!?
.. and ...?
thread and fork?
trap?
gtk+ or xforms interface in Ruby?
a ? b : c mean?
begin and end of MatchingData return?
Originally written by Shugo Maeda
shugo@netlab.co.jp
Transformed to SGML by Ozawa Sakuro
crouton@duelists.org
Translated into English by gotoken
gotoken@math.sci.hokudai.ac.jp
Revised by Akira Endo
akendo@t3.rim.or.jp
since June 7, 1999 (original Sep 18, 1997)
Transformed to private XML on June 28, 1999, parsed with xmlparser by
Yoshida Masato
yoshidam@inse.co.jp,
yoshidam@yoshidam.net.
a simple and powerful object oriented scripting language.
Well, Ruby was born in Feb. 24 1993. At that day, I was talking with my colleague about the possibility of object-oriented scripting language. I knew Perl (Perl4, not Perl5), but I didn't like it really, because it had smell of toy language (it still has). The object-oriented scripting language seemed very promising.
I knew Python then. But I didn't like it, because I didn't think it was a true object-oriented language. OO features are appeared to be add-on to the language. I, as a language mania and OO fan for 15 years, really really wanted a genuine object-oriented, easy-to-use object-oriented scripting language. I looked for, but couldn't find one.
So, I decided to make it. It took several months to make the interpreter run. I put it the features I love to have in my language, such as iterators, exception handling, garbage collection.
Then, I reorganized the features in Perl into class library, and implemented them. I posted Ruby 0.95 to the Japanese domestic newsgroups in Dec. 1995.
Since then, mail lists are established, web pages are formed. Highly active discussion was held in the mail lists. The oldest list ruby-list has 14789 messages until now.
Ruby 1.0 was released in Dec. 1996, 1.1 in Aug. 1997, 1.2 (stable version) and 1.3 (development version) were released in Dec. 1998.
ftp://ftp.netlab.co.jp/pub/lang/ruby/
Mirror sites are as follows:
ftp://ftp.TokyoNet.AD.JP/pub/misc/ruby/
ftp://ftp.iij.ad.jp/pub/lang/ruby/
ftp://blade.nagaokaut.ac.jp/pub/lang/ruby/
ftp://ftp.krnet.ne.jp/pub/ruby/
ftp://mirror.nucba.ac.jp/mirror/ruby/
http://mirror.nucba.ac.jp/mirror/ruby/
pc/.
http://www.netlab.co.jp/ruby/jp/
(in Japanese) and
http://www.netlab.co.jp/ruby/
(in English).
http://blade.nagaokaut.ac.jp/ruby/ruby-talk/index.shtml
A rubyist regards him/herself more than a customer to Ruby. For example:On the other hand, let's call those who show high technical level on Ruby as Ruby hackers. For example:
- recommending Ruby to colleagues,
- editing FAQs of Ruby,
- opening a BBS on Ruby,
- writing a Ruby book,
- mailing to the author of Ruby to encourage,
- the author of Ruby ^^;;;
These titles are given to those who believe themselves as such, but the preceding phrases have almost identified the names who are Rubyists and Ruby hackers in my view.
- writing an extension module of Ruby,
- writing patches to fix Ruby bugs,
- writing Ruby transports to djgpp or win32,
- writing a useful (and considerably large) program in Ruby,
- writing an obfuscated script in Ruby,
- the author of Ruby ^^;;;
ruby -v,
and your script.
irb, it has its own limitation. Try the
script using irb --single-irb or ruby itself.
while, until, and for are control structures and
the scope is shared with the outside of these structures.
loop is a method and the appended block introduces a new scope.
Ruby interpreter first reads in a script and analyzes it into a
parsed tree. If parsing goes well according to the syntax, the parsed
tree is interpreted to get the desired result.
for i in 1..2
if i == 2
print a
else
a = 1
end
end
test.rb, we get
test.rb:3: undefined local variable or method `a' for
#<Object:0x40101f4c> (NameError)
from test.rb:1:in `each'
from test.rb:1
i is 1, there occurs no error, and when i becomes
2, an error occurs. In the first phase of syntax analysis, the
interpreter does not know that print a appears after a is
assigned 1, and in the statement print a the interpreter
does not know the local variable a. When executed, it
searches for a method named a but fails and an error is
reported.
a = 1 if false; print a
# ->nil
a = nil
before accessing a local variable not to be bothered by such behaviour of
local variables. There is an additional goodie of speeding up the
access time to local variables if defined outside a block.
:: operator, designating the class/module name on the left
hand side.
* prepended to an argument?
def foo(*all)
for e in all
print e, " "
end
end
foo(1, 2, 3)
# -> 1 2 3
* denotes to expand an array to pass
the elements as arguments.
a = [1, 2, 3]
foo(*a)
* to the last argument of
when clause of case structure.
x, *y = [7, 8, 9]
x = 7, y = [8, 9].
x is 7.
x, = [7, 8, 9]
x = [7, 8, 9].
x = [7, 8, 9]
& prepended to an argument?
||.
These arguments are local variables and, when an argument is already
used outside the block, the scope is shared.
A = a = b = "abc"; b << "d"; print a, " ", A
# ->abcd abcd
data = [1, 2, 3]
data.each do |i|
print i, "\n"
end
$ ruby test.rb
1
2
3
do and end is repeatedly executed
on each element of an array "data".
int data[3] = {1, 2, 3};
int i;
for (i = 0; i < 3; i++) {
printf("%d\n", data[i]);
}
do...end, you can use {...}.
data = [1, 2, 3]
data.each { |i|
print i, "\n"
}
do...end and {...} act differently.
foobar a, b do .. end # foobar is the iterator.
foobar a, b { .. } # b is the iterator.
{ } attaches stronger to the preceding expression
than a do block.
yield control structure, a block argument, and Proc.new.
( rb_yield is used in C extension library.)
yield statement may have arguments which are passed to the
block as block parameters and the block is executed.
method.call(args...) form.
Proc.new, when used in an iterator definition, takes the block which
is given to the method as
its argument, generates a procedure object generated from the block. The
same applies to proc and lambda.
def a (&b)
yield
b.call
Proc.new.call
proc.call
lambda.call
end
a{print "test\n"}
Proc.new without a block do?
Proc.new without a block cannot generate a procedure object and an
error occurs. In a method definition, Proc.new without a block
implies the existence of a block given by the method call.
:exit mean?
a = 'This is the content of "a"'
b = eval(:a.id2name)
a.id == b.id
loop a control structure?
Kernel. The block which follows introduces
a new scope for local variables.
a +b gives an error.
a(+b). Remove the space to the left of +
or add a space to the right of +.
s = "x"; puts s *10 gives an error.
p {}.
p({}).
def pos= (val) print @pos,"\n"; @pos = val end,
I cannot use the method pos = 1.
= appended are called in a receiver form. Invoke it as
self.pos = 1.
'\1' and '\\1'?
\' and
\\ are transformed and other combinations remain unchanged.
p true or true and false prints true, while
a=true if true or true and false does not assign true
to a.
(p true) or true and false.
and/or is not parsed as an element of the argument of p
but an element of an expression.
p(nil || "") returns "", while p(nil or "")
gives parse error.
or combines only expressions,
not arguments.
Try p nil or "" and p((nil or "")).
method_missing is searched in the same order.
Module Indexed
def [](n)
to_a[n]
end
end
Class String
include Indexed
end
p String.ancestors # [String, Indexed, Enumerable, Comparable, Object, Kernel]
p "abcde".gsub!(/./, "\\&\n")[1]
+ and - operators?
+, -, and the like are not operators but method calls.
Therefore these can be overloaded by new definitions.
class MyString < String
def +(other)
print super(other)
end
end
=, .., ..., !, not, &&, and, |, or, ~, ::
+@ and -@ as the method names.
= is used in the access method definition as follows.
If operators like + and - are also defined,
you can use self assignment form like +=.
def attribute=(val)
@attribute = val
end
self) are omitted, e.g.,
def writeln(str)
print(str, "\n")
end
writeln("Hello, World!")
writeln resembles a function but it is a method belonging to
the Object class and sent as a message to the hidden reciever
self. Thus Ruby is a pure OOL.
Module#attr, attr_reader, attr_writer,
attr_accessor.
Of course you can define a referring method by yourself.
method=, you cannot insert
a space between method and =, but you can insert one
when you call
this style of a method. You can also utilize self assignments like
+= and -=, if + or - methods are defined.
private and
protected.
private means to make the method callable
only in a function form. It cannot be called in receiver
designating form.
The private method is callable only within the class in which the
method was defined or in its subclasses.
attr method is an easy way to define an
access method, and an instance variable behaves like variables
from outside.
class Foo
def initialize(str)
@name = str
end
attr("name")
# This means:
# def name
# return @name
# end
end
foo = Foo.new("Tom")
print foo.name, "\n" # Tom
true to the second argument of attr(name, public),
whose default value is false, you can define a value-setter.
class Foo
def initialize(str)
@name = str
end
attr("name", true)
# This means:
# def name
# return @name
# end
# def name=(str)
# @name = str
# end
end
foo = Foo.new("Tom")
foo.name = "Jim"
print foo.name, "\n" # Jim
Module#attr_reader, attr_writer, and
attr_accessor.
class Foo
def test
print "hello\n"
end
private :test
end
foo = Foo.new
foo.test
# -> test.rb:9: private method `test' called for #<Foo:0x400f3eec>(Foo)
private_class_method.
class Foo
def Foo.test
print "hello\n"
end
private_class_method :test
end
Foo.test
# -> test.rb:8: private method `test' called for Foo(Class)
public or
public_class_method.
super yields an ArgumentError.
super in a method definition passes all the arguments.
If the number of arguments disagrees with super, an
ArgumentError occurs. You must specify explicitly the
parentheses to super and pass suitable number of arguments.
super invokes the same name method one level upper.
Use alias before calling the same name method of more than that level.
super. Original definition is
reserved if you alias the original method beforehand. Or, you can
call the original method as a singleton method of Kernel.
def foo(str)
str.sub!(/foo/, "baz")
end
obj = "foo"
foo(obj)
print obj
# -> "baz"
return 1, 2, 3
return [1, 2, 3]
def foo
return 20, 4, 17
end
a, b, c = foo
print "a:", a, "\n" # -> a:20
print "b:", b, "\n" # -> b:4
print "c:", c, "\n" # -> c:17
Array, Hash, etc) assigned to a class constant
can be used as a class variable.
class Foo
F = [0]
def foo
F[0] += 1
print F[0], "\n"
end
end
class Foo
@a = 123 # (1)
def foo
p @a # (2) ... nil not 123
end
end
Foo, and
(1) belongs to the class object Foo, which is an instance of
Class class.
nil.
foo = Foo.new
def foo.hello
print "Hello\n"
end
foo.hello
Foo which is an instance of
Class.
class Foo
def Foo.test
print "this is foo\n"
end
end
Foo.test
Class can
be used as class methods for every class.
class Foo
def hello
print "hello.\n"
end
end
foo = Foo.new
foo.hello
# -> hello.
class << foo
attr :name, TRUE
def hello
print "hello. I'm ", @name, ".\n"
end
end
foo.name = "Tom"
foo.hello
# -> hello. I'm Tom.
private_class_method?
class Foo
...
end
class << Foo
def class_method
print "class method\n"
end
private :class_method
end
Foo.class_method " # -> Error
Math.sqrt(2)
include.
include Math
sqrt(2)
module_function :method_name
load and require?
*.rb) is loaded and executed in load.
required, *.o file is also looked for. An already
required file is never loaded again.
include and extend?
include is used to include a module to a class/module, and methods
in the module are called in function-style. extend is used to
include a module to an object(instance), and methods in the module
become singleton methods of the object.
self mean?
self means the object itself to which a method is applied.
A function form method call implies self as the receiver.
instance_methods(nil)?
instance_methods returns an array of the methods of an
object, whereas instance_methods(nil) returns the methods which are
defined in the class of the object, excluding the methods inherited
from superclasses.
rand generate the same random number sequence?
rand generates the same sequence every time the script runs.
You need to give a different seed by srand to generate
different random numbers every time. srand called without
an argument makes the seed as the time being, and generates different
random numbers.
def sample(n, m)
if m.zero?
[]
else
s = sample(n-1, m-1)
t = rand(n+1)
s.concat s.include?(t) ? n : t
end
end
def sample(n, m)
s = []
((n-m)...n).each do |j|
t = rand(j+2)
s.concat s.include?(t) ? j+1 : t
end
s
end
Fixnum, true, nil, and false
are implemented as immediate values, what is the difference between
an immediate value and a reference?
Fixnums of the same value are
always the same instance, so when instance variables are defined,
they point the same objects.
nil and false?
nil and false is
shown by executing nil.methods - false.methods and
false.methods - nil.methods.
nil cannot be a value, but false can.
true or false
if it is a predicate, and a value or nil otherwise.
? is usually a predicate, but
some built-in functions are not.
open("example", "r+").readlines.each_with_index{|l, i|
l[0,0] = (i+1).to_s + ": "}
readlines. You must write back the
result to the file.
io = open("example", "r+")
ary = io.readlines
ary.each_with_index{|l, i| l[0,0] = (i+1).to_s + ": "}
io.rewind
io.print ary
io.close
-i, or built-in variable $-i,
you can read a file and replace it.
$ ruby -i -ne 'print "#$.: #$_"' example
-i.bak or
whatever you like.
open('file', 'w').print "This is a file.\n"
system 'cp file copy'
file in this script, the content is not yet
flushed. You should close the file before copying.
f = open('file', 'w')
f.print "This is a file.\n"
f.close
system "cp file copy"
less to display strings?
f = open '|less', 'w'
f.print "abc\n"
less displaying.
Use close to wait until less ends.
f = open '|less', 'w'
f.print "abc\n"
f.close
f = IO.popen 'less', 'w'.
File object which has no reference?
File object, which is not referred as in open("file").read,
will be garbage collected in next GC, when it is closed.
(1)
a = open "file"
begin
a.each {|l| print l}
ensure
a.close
end
(2)
IO.foreach("file") {|l| print l}
(3)
IO.readlines("file").each {|l| print l}
Dir.glob("*").filter{|f| [File.mtime(f), f]}.
sort{|a,b| b[0]<=>a[0]}.filter{|e| e[1]}
Dir.glob("*").sort{|a,b| File.mtime(b)<=>File.mtime(a)}
freq = Hash.new(0)
open("file").read.scan(/\w+/){|w| freq[w] += 1}
freq.keys.sort.each {|k| print k, "--", freq[k], "\n"}
true in a condition expression.
nil or false returns false condition.
You can use empty? or compare the string to "" or compare
length to 0 to find out if a string is empty.
"abcd"[0] return?
a, do either of following.
1 while a.sub!(/(^[^\t]*)\t(\t*)/){$1+' '*(8-$1.size%8+8*$2.size)}
1 while a.sub!(/\t(\t*)/){' '*(8-$~.begin(0)%8+8*$1.size)}
a.gsub!(/([^\t]{8})|([^\t]*)\t/n){[$+].pack("A8")}
Regexp.quote('\\') escapes a backslash.
gsub, if you write gsub(/\\/, '\\\\'), the second
argument is
analyzed as '\\' in syntax analysis and when the substitution occurs
it is again analyzed as '\' which means to substitute one backslash
to one backslash. You need to write gsub(/\\/, '\\\\\\'). Using the
fact that \& expresses the match, you can write
gsub(/\\/, '\&\&').
gsub, i.e. gsub(/\\/){'\\\\'},
the string for substitution is analyzed only once and the result is
what you intended.
sub and sub!?
sub, a copy of the receiver is generated, substituted
and returned.
sub!, the receiver is altered and returned if any match was
found. Otherwise, nil is returned.
sub! are called
destructive methods which alter the
attribute of the receiver. If there are two similar methods and one
is destructive, the destructive one has a suffix ! to denote the
destructiveness.
def foo(str)
str = str.sub(/foo/, "baz")
end
obj = "foo"
foo(obj)
print obj
# -> "foo"
def foo(str)
str = str.sub!(/foo/, "baz")
end
foo(obj)
print obj
# -> "baz"
sub! sometimes return an unexpected
result. Be careful.
.. and ...?
.. includes the right hand side in the range, ... does not.
Proc.new, proc, or lambda
serves as a function pointer.
thread and fork?
Thread and fork have following characteristics.
fork is slow, thread is not.fork does not share the memory space.fork,
thread worse.thread does not cause thrashing.thread works on DOS.thread gets in a deadlock, whole process stops.fork and thread.
thread in Ruby is implemented by time sharing, dividing to
threads does not gain the speed of execution.
Marshal.dump obj, io, lev
io is a writable IO object, lev designate the level to which
referred objects are dereferred and stored. If lev levels of
dereferring are done and still object referrences exist, then
the dump of the object is only the referrence. It cannot be
reconstructed when loaded.
obj = Marshal.load io
obj = Marshal.load str
begin
statements which may raise exceptions.
rescue [exception class name]
statements when an exception occurred.
ensure
statements to be done in the end.
end
begin clause, rescue clause
is executed. The ensure clause is executed whether an exception
occurred or not. rescue and ensure claused can be omitted.
If no exception class is designated for rescue clause,
StandardError exception is implied, and exceptions which are
in a is_a? relation to StandardError are captured.
$!.
The kind of exception is checked by $!.type.
trap?
trap("PIPE") {raise "SIGPIPE"}
ruby -r debug your_script
ext/tcltk/ and loaded with
require "tcltk". The syntax is almost written as in
Tcl, which is passed to Tcl interpreter.
Unfortunately, the description for this library is written in
Japanese.
ext/tk/ and loaded with require "tk".
Its syntax is more like Ruby, which is transformed to Tcl script
and passed to Tcl.
gtk+ or xforms interface in Ruby?
contrib/ in ftp sites, there are ruby-gtk-x.xx.tar.gz
and ruby-forms-x.x.tar.gz.
require "date" or
require "date2". date.rb is fixed to use English
calendar, while date2.rb is for general purpose. Please
also refer sample/cal.rb.
a ? b : c mean?
if a then b else c end.
open("file").read.count("\n")
begin and end of MatchingData return?