Ruby Operators

Ruby Arithmetic Operators

Assuming the value of variable a is 10The value of variable b is 2If 0, then:

Ruby comparison operator

Assuming the value of variable a is 10The value of variable b is 2If 0, then:

Ruby assignment operator

Assuming the value of variable a is 10The value of variable b is 2If 0, then:

Ruby Parallel Assignment

Ruby also supports parallel assignment of variables. This allows multiple variables to be initialized through a single line of Ruby code. For example:

a =　10
b =　20
c =　30

Using parallel assignment can declare more quickly:

a, b, c =　10,　20,　30

Parallel assignment is also very useful when swapping the values of two variables:

a, b = b, c

Ruby Bitwise Operators

Bitwise operators operate on bits and perform operations bit by bit.

Assuming if a = 60, and b = 13Now, in binary format, they are as follows:

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

The following table lists the bitwise operators supported by Ruby.

Ruby Logical Operators

The following table lists the logical operators supported by Ruby.

Assuming the value of variable a is 10The value of variable b is 2If 0, then:

Ruby ternary operator

Having more than one operation is called a ternary operator. The first expression calculates the true or false value of the expression, and then decides which of the two statements to execute next based on this result. The syntax of the conditional operator is as follows:

Ruby range operator

In Ruby, sequence ranges are used to create a series of consecutive values - Including the starting value, ending value (depending on the situation), and the values between them.

In Ruby, these sequences are created using the range operators ".." and "...". The range created with two dots includes both the starting and ending values, while the range created with three dots includes only the starting value and does not include the ending value.

Ruby defined? operator

defined? is a special operator that uses the form of a method call to determine if the passed expression is defined. It returns the description string of the expression, and returns nil.

Below are various usages of the defined? operator:

Usage 1

defined? variable # => True if variable has been initialized

For example:

foo =　42
defined? foo # => "local"-variable"
defined? $_ # => "global"-variable"
defined? bar # => nil (undefined)

Usage 2

defined? method_call # => True if the method has been defined

For example:

defined? puts # => "method"
defined? puts(bar) # => nil (bar is not defined here)
defined? unpack # => nil (not defined here)

Usage 3

# => True if there is a method that can be called with super
defined? super

For example:

defined? super # => "super" (if it can be called)
defined? super # => nil (if it cannot be called)

Usage 4

defined? yield # => True if a block has been passed

For example:

defined? yield # => "yield" (if a block has been passed)
defined? yield # => nil (if no block is passed)

Ruby dot operator "." and double colon operator "::"

You can call methods within a class or module by adding the class or module name and . to the method name. You can reference constants within a class or module using the class or module name and two colons ::.

:: is a unary operator that allows constants, examples, and class methods to be defined within classes or modules, and can be accessed from anywhere outside the class or module.

Remember:In Ruby, classes and methods can also be used as constants.

You just need to add the constant name before the expression. :: Prefix, you can return the appropriate class or module object.

If the expression before :: is a class or module name, it returns the corresponding constant value within that class or module; if there is no prefix expression before ::, it returns the corresponding constant value in the main Object class. .

Here are two examples:

MR_COUNT = 0 # Defined in the main Object class
module Foo
　　MR_COUNT = 0
　　::MR_COUNT =　1　　　　# Set the global count to　1
　　MR_COUNT =　2　　　　　　# Set the local count to　2
end
puts MR_COUNT # This is the global constant
puts Foo::MR_COUNT # This is the local constant of 'Foo'

Second example:

CONST = 'out there'
class Inside_one
　　　CONST = proc {'in there'}
　　　def where_is_my_CONST
　　　　　　::CONST　+　'inside one'
　　　end
end
class Inside_two
　　　CONST = 'inside two'
　　　def where_is_my_CONST
　　　　　　CONST
　　　end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST　+　Inside_two::CONST
puts Inside_two::CONST　+　CONST
puts Inside_one::CONST
puts Inside_one::CONST.call　+　Inside_two::CONST

Precedence of Ruby operators

The following table lists all operators in order of precedence from high to low.

Note:The method list is marked as is The operators are actually methods, so they can be overloaded.