In Ruby, operators such as
+, are defined as methods on the class. Literals define their methods within the lower level, C language.
String class, for example.
Ruby objects can define or overload their own implementation for most operators.
Here is an example:
class Foo < String def +(str) self.concat(str).concat("another string") end end foobar = Foo.new("test ") puts foobar + "baz "
test baz another string
What operators are available is dependent on the implementing class.
Operator Behavior¶ ↑
How a class behaves to a given operator is specific to that class, since operators are method implementations.
When using an operator, it’s the expression on the left-hand side of the operation that specifies the behavior.
'a' * 3 #=> "aaa" 3 * 'a' # TypeError: String can't be coerced into Integer
Logical Operators¶ ↑
Logical operators are not methods, and therefor cannot be redefined/overloaded. They are tokenized at a lower level.
Short-circuit logical operators (
or) do not always result in a boolean value. Similar to blocks, it’s the last evaluated expression that defines the result of the operation.
and operators provide short-circuiting by executing each side of the operator, left to right, and stopping at the first occurence of a falsey expression. The expression that defines the result is the last one executed, whether it be the final expression, or the first occurence of a falsey expression.
true && 9 && "string" #=> "string" (1 + 2) && nil && "string" #=> nil (a = 1) && (b = false) && (c = "string") #=> false puts a #=> 1 puts b #=> false puts c #=> nil
In this last example,
c was initialized, but not defined.
The means by which
or short-circuits, is to return the result of the first expression that is truthy.
(1 + 2) || true || "string" #=> 3 false || nil || "string" #=> "string"