 # Ruby运算符

Ruby支持一系列丰富的运算符的一个现代化的语言。大多数运算符实际上是方法调用。例如，a + b的被解释为a,
+(b)变量引用的对象的方法被称为一个用b作为它的参数。

## Ruby算术运算符：

+ Addition - Adds values on either side of the operator a + b = 30
- Subtraction - Subtracts right hand operand from left hand operand a - b = -10
* Multiplication - Multiplies values on either side of the operator a * b = 200
/ Division - Divides left hand operand by right hand operand b / a = 2
% Modulus - Divides left hand operand by right hand operand and returns remainder b % a = 0
** Exponent - Performs exponential (power) calculation on operators a**b = 10 to the power 20

## Ruby比较操作符：

== Checks if the value of two operands are equal or not, if yes then condition becomes true. (a == b) is not true.
!= Checks if the value of two operands are equal or not, if values are not equal then condition becomes true. (a != b) is true.
> Checks if the value of left operand is greater than the value of right operand, if yes then condition becomes true. (a > b) is not true.
< Checks if the value of left operand is less than the value of right operand, if yes then condition becomes true. (a < b) is true.
>= Checks if the value of left operand is greater than or equal to the value of right operand, if yes then condition becomes true. (a >= b) is not true.
<= Checks if the value of left operand is less than or equal to the value of right operand, if yes then condition becomes true. (a <= b) is true.
<=> Combined comparison operator. Returns 0 if first operand equals second, 1 if first operand is greater than the second and -1 if first operand is less than the second. (a <=> b) returns -1.
=== Used to test equality within a when clause of a case statement. (1...10) === 5 returns true.
.eql? True if the receiver and argument have both the same type and equal values. 1 == 1.0 returns true, but 1.eql?(1.0) is false.
equal? True if the receiver and argument have the same object id. if aObj is duplicate of bObj then aObj == bObj is true, a.equal?bObj is false but a.equal?aObj is true.

## Ruby赋值运算符：

= Simple assignment operator, Assigns values from right side operands to left side operand c = a + b will assigne value of a + b into c
+= Add AND assignment operator, It adds right operand to the left operand and assign the result to left operand c += a is equivalent to c = c + a
-= Subtract AND assignment operator, It subtracts right operand from the left operand and assign the result to left operand c -= a is equivalent to c = c - a
*= Multiply AND assignment operator, It multiplies right operand with the left operand and assign the result to left operand c *= a is equivalent to c = c * a
/= Divide AND assignment operator, It divides left operand with the right operand and assign the result to left operand c /= a is equivalent to c = c / a
%= Modulus AND assignment operator, It takes modulus using two operands and assign the result to left operand c %= a is equivalent to c = c % a
**= Exponent AND assignment operator, Performs exponential (power) calculation on operators and assign value to the left operand c **= a is equivalent to c = c ** a

## Ruby并行赋值：

Ruby还支持并行赋值的变量。这使得多个一行Ruby代码来初始化变量。例如：

`a = 10 b = 20 c = 30`

`a, b, c = 10, 20, 30`

`a, b = b, c`

## Ruby位运算符：

a = 0011 1100

b = 0000 1101

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

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a  = 1100 0011

& Binary AND Operator copies a bit to the result if it exists in both operands. (a & b) will give 12 which is 0000 1100
| Binary OR Operator copies a bit if it exists in either operand. (a | b) will give 61 which is 0011 1101
^ Binary XOR Operator copies the bit if it is set in one operand but not both. (a ^ b) will give 49 which is 0011 0001
~ Binary Ones Complement Operator is unary and has the efect of 'flipping' bits. (~a ) will give -61 which is 1100 0011 in 2's complement form due to a signed binary number.
<< Binary Left Shift Operator. The left operands value is moved left by the number of bits specified by the right operand. a << 2 will give 240 which is 1111 0000
>> Binary Right Shift Operator. The left operands value is moved right by the number of bits specified by the right operand. a >> 2 will give 15 which is 0000 1111

## Ruby逻辑运算符：

and Called Logical AND operator. If both the operands are true then then condition becomes true. (a and b) is true.
or Called Logical OR Operator. If any of the two operands are non zero then then condition becomes true. (a or b) is true.
&& Called Logical AND operator. If both the operands are non zero then then condition becomes true. (a && b) is true.
|| Called Logical OR Operator. If any of the two operands are non zero then then condition becomes true. (a || b) is true.
! Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. !(a && b) is false.
not Called Logical NOT Operator. Use to reverses the logical state of its operand. If a condition is true then Logical NOT operator will make false. not(a && b) is false.

## Ruby三元运算符：

? : Conditional Expression If Condition is true ? Then value X : Otherwise value Y

## Ruby范围运算符：

Ruby中的序列范围是用来创建连续值 - 组成了开始值/结束值，并在两者之间的值的范围内。

.. Creates a range from start yiibai to end yiibai inclusive 1..10 Creates a range from 1 to 10 inclusive
... Creates a range from start yiibai to end yiibai exclusive 1...10 Creates a range from 1 to 9

## Ruby defined? 操作符:

defined? 是一个特殊的操作符采取的形式的方法调用，以确定是否通过表达式定义。如果没有被定义的表达式，它返回一个描述字符串求解出的表达式或nil

## 用法 1

`defined? variable # True if variable is initialized`

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

## 用法 2

`defined? method_call # True if a method is defined`

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

## 用法 3

`# True if a method exists that can be called with super user defined? super`

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

## 用法 4

`defined? yield # True if a code block has been passed`

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

## Ruby "." 双冒号 "::" 运算符:

::使得一元运算符，常数，实例方法和类方法在类或模块定义，从任何地方访问外的类或模块。

`MR_COUNT = 0 # constant defined on main Object class module Foo MR_COUNT = 0 ::MR_COUNT = 1 # set global count to 1 MR_COUNT = 2 # set local count to 2 end puts MR_COUNT # this is the global constant puts Foo::MR_COUNT # this is the local "Foo" constant`

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```

## Ruby运算符优先级

Yes :: Constant resolution operator
Yes [ ] [ ]= Element reference, element set
Yes ** Exponentiation (raise to the power)
Yes ! ~ + - Not, complement, unary plus and minus (method names for the last two are +@ and -@)
Yes * / % Multiply, divide, and modulo
Yes + - Addition and subtraction
Yes >> << Right and left bitwise shift
Yes & Bitwise 'AND'
Yes ^ | Bitwise exclusive `OR' and regular `OR'
Yes <= < > >= Comparison operators
Yes <=> == === != =~ !~ Equality and pattern match operators (!= and !~ may not be defined as methods)
&& Logical 'AND'
|| Logical 'OR'
.. ... Range (inclusive and exclusive)
? : Ternary if-then-else
= %= { /= -= += |= &= >>= <<= *= &&= ||= **= Assignment
defined? Check if specified symbol defined
not Logical negation
or and Logical composition