blob: 8f424f019fe646c146b458c17d8754d45eaa5788 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
= Miscellaneous Syntax
== Ending an Expression
Ruby uses a newline as the end of an expression. When ending a line with an
operator, open parentheses, comma, etc. the expression will continue.
You can end an expression with a <code>;</code> (semicolon). Semicolons are
most frequently used with <code>ruby -e</code>.
== Indentation
Ruby does not require any indentation. Typically ruby programs are indented
two spaces.
If you run ruby with warnings enabled and have an indentation mis-match you
will receive a warning.
== +alias+
The +alias+ keyword is most frequently used to alias methods. When aliasing a
method you can use either its name or a symbol:
alias new_name old_name
alias :new_name :old_name
For methods, Module#alias_method can often be used instead of +alias+.
You can also use +alias+ to alias global variables:
$old = 0
alias $new $old
p $new # prints 0
You may use +alias+ in any scope.
== +undef+
The +undef+ keyword prevents the current class from responding to calls to the
named methods.
undef my_method
You may use symbols instead of method names:
undef :my_method
You may undef multiple methods:
undef method1, method2
You may use +undef+ in any scope. See also Module#undef_method
== +defined?+
+defined?+ is a keyword that returns a string describing its argument:
p defined?(UNDEFINED_CONSTANT) # prints nil
p defined?(RUBY_VERSION) # prints "constant"
p defined?(1 + 1) # prints "method"
You don't need to use parenthesis with +defined?+ but they are recommended due
to the {low precedence}[rdoc-ref:syntax/precedence.rdoc] of +defined?+.
For example, if you wish to check if an instance variable exists and that the
instance variable is zero:
defined? @instance_variable && @instance_variable.zero?
This returns <code>"expression"</code> which is not what you want if the
instance variable is not defined.
@instance_variable = 1
defined?(@instance_variable) && @instance_variable.zero?
Adding parentheses when checking if the instance variable is defined is a
better check. This correctly returns +nil+ when the instance variable is not
defined and +false+ when the instance variable is not zero.
Using the specific reflection methods such as instance_variable_defined? for
instance variables or const_defined? for constants is less error prone than
using +defined?+.
== +BEGIN+ and +END+
+BEGIN+ defines a block that is run before any other code in the current file.
It is typically used in one-liners with <code>ruby -e</code>. Similarly +END+
defines a block that is run after any other code.
+BEGIN+ must appear at top-level and +END+ will issue a warning when you use it
inside a method.
Here is an example:
BEGIN {
count = 0
}
You must use <code>{</code> and <code>}</code> you may not use +do+ and +end+.
Here is an example one-liner that adds numbers from standard input or any files
in the argument list:
ruby -ne 'BEGIN { count = 0 }; END { puts count }; count += gets.to_i'
|
