Operators

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 "

This prints:

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 therefore cannot be redefined/overloaded. They are tokenized at a lower level.

Short-circuit logical operators (&&, ||, and, and 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`

Both &&/and operators provide short-circuiting by executing each side of the operator, left to right, and stopping at the first occurrence of a falsey expression. The expression that defines the result is the last one executed, whether it be the final expression, or the first occurrence of a falsey expression.

Some examples:

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.

`||`, `or`

The means by which ||/or short-circuits, is to return the result of the first expression that is truthy.