operators - Documentation for Ruby 4.0
Description: operators: code>, are defined as methods on the class. literals.
Keywords: ruby,documentation,operators

🔍

No recent searches

# 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.

Some examples:

    (1 + 2) || true || "string"                 #=> 3
    false || nil || "string"                    #=> "string"