运算符表达式

• 赋值
  • 自运算
  • 并行赋值
• and
• or
• not
• 条件运算符

实例：

1+2*3/4

为了编程方便，有些方法调用和控制结构是以运算符的形式出现的。Ruby包含了下列的运算符：

   高优先级     ::
                [ ]
                **
                -(一元)  +(一元)  !  ~
                *  /  %
                +  -
                << >>
                &
                |  ^
                > >=  < <=
                <=> ==  === !=  =~  !~
                &&
                ||
                ..  ...
                ?:(条件运算符)
                =(+=, -= ... )
                not
    低优先级    and or

上表从「高」到「低」按运算符的优先度排列。如「&&」的优先度高于「||」，如下所示：

a && b || c   # => (a && b) || c
a || b && c   # =>  a || (b && c)

大多数的运算符都是特殊型态的方法调用，但是有些是嵌入语言中的运算符，因而无法重新定义。

• 可重新定义运算符（方法调用）

  +@ 和 -@ 代表一元运算符 + 和 -，在方法定义的情况下使用这种表示法。

  |  ^  &  <=>  ==  ===  =~  >   >=  <   <=   <<  >>
  +  -  *  /    %   **   ~   +@  -@  [ ]  [ ]=  `  !

• 不可重新定义运算符（控制结构）

  复合运算符无法重新定义。

  =  ?:  ..  ...  not  &&  and  ||  or  ::

赋值

实例：

foo = bar
foo[0] = bar
foo.bar = baz

语法：

变量 '=' 表达式
常量 '=' 表达式
表达式 '['表达式..']' '=' 表达式
表达式 '.' 标识符 '=' 表达式

赋值表达式是用来对变量之类的对象进行赋值的语句，赋值也可以当作区域变量或常量的声明，但是赋值表达式的左方必须为下列其中之一：

• 变量

  变量 '=' 表达式

  若是左方为变量，则将表达式之值代入变量中。

• 数组调用

  表达式1 '[' 表达式2 ... ']' '=' 表达式N

  计算表达式1获取对象，使用表达式2至表达式N作为调用「[ ]=」方法的参数。

  class C
    def initialize
      @ary = [0,1,2,3,4,5,6,7]
    end
    def [](i)
      @ary[i * 2]
    end
    def []=( i, v )
      @ary[i * 2] = v
    end
  end
  c = C.new
  p c[3]      # converted to c.[]( 3 ); result is 6
  p c[3] = 1  # converted to c.[]=(3,1); result is 1

• 属性调用

  表达式1 '.' 标识符 '=' 表达式2

  计算表达式1获取对象，用表达式2作为调用「标识符=」方法的参数。

  class C
    def foo
      @foo
    end
    def foo=( v )
      @foo = v
    end
  end
  c = C.new
  c.foo = 5   # converted to c.foo=( 5 )
  p c.foo     # => 5

  属性同样可以用 attr_accessor 来定义。

  class C
    attr_accessor :foo
  end
  c = C.new
  c.foo = 5   # converted to c.foo=( 5 )
  p c.foo     # => 5

自运算

实例：

foo += 12       # foo = foo + 12
foo *= 3        # foo = foo * 3

语法：

表达式1 op= 表达式2 # 表达式1是右方赋值的一部分。

op 代表下面的运算符，运算符和 = 之间不可以有间隔。

+, -, *, /, %, **, &, |, ^, <<, >>, &&, ||

在多数的情况下，自运算解读为：

表达式1 = 表达式1 op 表达式2

并行赋值

实例：

foo, bar, baz = 1, 2, 3
foo, = list( )
foo, *rest = list2( )

语法：

表达式 [',' [ 表达式 ',' ... ] ['*' [ 表达式 ]]] = 表达式 [, 表达式 ... ]['*' 表达式 ]
'*' [ 表达式 ] = 表达式 [, 表达式 ... ]['*' 表达式 ]

并行赋值对多个表达式或数组进行赋值。左方的所有表达式必须是可以执行赋值操作的表达式。若是右方只有一个表达式，则将该表达式之值转为数组，在将数组中的元素依次赋值给左边的表达式。若数组的元素数量多于左方的表达式数量，多余的元素则无视，若是数组的元素数量较少，则多余的表达式则代入nil。

在左方最后一个表达式前面加上 * ，则会将右方多余的元素转为数组代入其中，若没有多余的元素，则代入空数组。

foo, bar  = [1, 2]      # foo = 1; bar = 2
foo, bar  = 1, 2        # foo = 1; bar = 2
foo, bar  = 1           # foo = 1; bar = nil
foo, bar  = 1, 2, 3     # foo = 1; bar = 2
foo       = 1, 2, 3     # foo = [1, 2, 3]
*foo      = 1, 2, 3     # foo = [1, 2, 3]
foo, *bar = 1, 2, 3     # foo = 1; bar = [2, 3]

and

实例：

test && set
test and set

语法：

表达式 '&&' 表达式
表达式 and 表达式

先计算左边的表达式，若结果为 true则接着计算右边。and 与 && 作用相同，但是优先度较低。

or

实例：

demo || die
demo or die

语法：

表达式 '||' 表达式
表达式 or 表达式

先计算左边的表达式，若结果为 false则接着计算右边。or 与 || 作用相同，但是优先度较低。

not

实例：

! me
not me
i != you

语法：

'!' 表达式
not 表达式

若表达式之值为 true，则返回 false；若表达式之值为 false，则返回 true。

也可以用下面的语法：

表达式 '!=' 表达式          # 等价于 !(表达式 == 表达式)
表达式 '!~' 表达式          # 等价于 !(表达式 =~ 表达式)

条件运算符

实例：

obj == 1 ? foo : bar

语法：

表达式1 ? 表达式2 : 表达式3

依照表达式1的计算结果，选择要返回表达式2或表达式3。相当于：

if 表达式1 then 表达式2 else 表达式3 end