In Ruby nearly all operators are class methods: types, operators and functions are all joined in an strong object oriented paradigm.
Only the assignment operators and some logical operators are not implemented as class methods. These operators are:
|=||assignment : a=1|
|+= -= *=||operation and re-assignment, implemented for all numerical operators|
|or||logical operator "or" with lower precedence|
|and||logical operator "and"with lower precedence|
|.. ...||range operators (create range objects)|
|defined?||nil if not defined, otherwise the type: Es.: a=1; defined?(a) => "local-variable"|
The assignment operator "=" defines a reference to an object, and, for some basic objects, creates an instance of the object:
anum=1 # creates an instance of the Integer class (the number one) # and a reference (the name "anum") to the instance bnum=anum # creates a second reference to the same integer
In the following example, when a new instance of Integer (the number six) is created, the anum reference is redefined, but bnum continues to reference to the number one:
anum=1 bnum=anum anum=6
If instead of numbers we had a composite object, like an array, we could change the object using any of the references (anum or bnum) and both see the modified object; this can confuse inexperienced users:
anum=["a","b","c"] # anum is a reference to an object array. bnum=anum # I make a copy of the reference, anum="k" # Now I change the first element, ; # and both bnum and anum point to: ["k", "b", "c"]
Multiple assignments are possible:
a=b=c=3 # a,b,c , all reference to '3' a,b=1,2 # a refers to one, b to two a,b=1,2,3,4 # extra elements are ignored a,b,c=1,2 # c is unassigned (c==nil)
Many values can be assigned to a single array, or an array can be expanded to single values in an assignment; in this case the "*" operator is used: it is called "splat" operator:
a,b=[1,2] # the assignment can be used to expand an array x,*y=[1,2,3] # extra elements are assigned to an array: x => 1 ; y => [2, 3] *y,x=[2,3,1] # since Ruby 1.9 the array can be in the first position a,*y,b=1,2,3,4,5 # and can also be in the middle: a => 1 ; y => [2, 3, 4] ; b => 5 x,y,z=1,*[2,3] # assignment can be used to expand an array: x=>1 ; y => 2 ; z => 3
The operators of the form: "+=,-=,*=" etc. are shorthands for operation and assignment.
The "++" operator doesn't exists in Ruby.
a=a+1 # same as: a+=1 a=a-1 # same as: a-=1
The logical operators: "and" ,"or" ,"&&" , "||" , evaluate the second operand only if the first doesn't define the relation:
a && b # evaluates 'a' ; # if 'a' is false (or nil), returns 'a' (false), # otherwise evaluates and returns 'b' a || b # evaluates 'a' ; # if true returns 'a', # otherwise evaluates and returns 'b'
This can be used in conditional expressions to execute a routine, as in the Bash shell, or to define a variable only if not yet defined:
condition && func("aaa") # 'func' is executed only if the condition is true var || =77 # an undefined variable is false; the assignment is executed.
The ternary operators evaluates a condition, if true returns the first expression, otherwise the second:
1==1 ? 'Yes' : 'No' # the condition is true, the operator returns: 'yes' 1==2 ? 'yes' : 'No' # the condition is false, the operator returns: 'No'