Ruby operator

Ruby arithmetic operator

Assuming that the value of variable an is 10 and the value of variable b is 20, then:

Ruby comparison operator

Assuming that the value of variable an is 10 and the value of variable b is 20, then:

Ruby assignment operator

Assuming that the value of variable an is 10 and the value of variable b is 20, then:

Ruby parallel assignment

Ruby also supports parallel assignment of variables. This allows multiple variables to be initialized with one line of Ruby code. For example:

a=10b=20c=30

Parallel assignments can be used to declare more quickly:

a,b,c=10,20,30

Parallel assignments are also useful when exchanging the values of two variables:

a,b=b,c

Ruby bit operator

The bit operator acts on the bit and performs the operation bit by bit.

Suppose that if a = 60 , and b = 13 now in binary format, they areas 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 bit operators supported by Ruby.

Ruby logical operator

The following table lists the logical operators supported by Ruby.

Assuming that the value of variable an is 10 and the value of variable b is 20, then:

Ruby ternary operator

There is more than one operation called a ternary operator. The first evaluates the true or false value of the expression, and then decides to execute one of the next two statements 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 start value, the end value (as the case may be), and the values between them.

In Ruby, these sequences use “..” and “.” Created by the range operator.The range created in the two-point form contains the start and end values, and the range created in the three-point form contains only the start value and not the end value.

Ruby defined? operator

defined? is a special operator that determines whether the passed expression is defined in the form of a method call. It returns the description string of the expression, or if the expression is not defined nil .

The following is defined? various uses of the operator:

Usage 1

defined?variable#True if variable has already been initialized

For example:

foo=42defined?foo#=> "local-variable"defined?$\_#=>
"global-variable"defined?bar#=> nil（undefined）

Usage 2

defined?method_call#True if the method is already defined

For example:

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

Usage 3

#If there are methods that can be called by super users; otherwise Truedefined?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 code block has been passed

For example:

defined?yield#=> "yield"（If a block has been passed）defined?yield#=>
nil（If the block is not passed）

Ruby dot operator “.” And the double colon operator “::”

You can add the class or module name and before the method name. To call a method in a class or module. You can use the class or module name and two colons:: to refer to constants in the class or module.

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

Remember: in Ruby, classes and methods can also be treated as constants.

You just need to precede the constant name of the expression with the :: prefix, the appropriate class or module object is returned.

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

Here are two examples:

MR_ COUNT=0 # defined in the main object
Constants on class moduleFooMR_ COUNT=0:: MR_ COUNT=1 # Set global count to
1MR_ COUNT=2 # Set local count to
2endputsMR_ COUNT # This is the global constant putsFoo:: MR_ COUNT # This is the local constant for 'Foo'

The second example:

CONST='out there'classInside_oneCONST=proc{'in
there'}defwhere_is_my_CONST::CONST+'inside
one'endendclassInside_twoCONST='inside
two'defwhere_is_my_CONSTCONSTendendputsInside_one.new.where_is_my_CONSTputsInside_two.
new.where_is_my_CONSTputsObject::CONST+Inside_two::CONSTputsInside_two::CONST+CONSTputsInside_one::
CONSTputsInside_one::CONST.call+Inside_two::CONST

Precedence of the Ruby operator

The following table lists all operators from highest to lowest priority.

The operator identified as yes in the method column is actually a method andcan be overloaded.