Latest web development tutorials

Gli operatori di ruby

Rubino supporta un ricco set di operatori. La maggior parte degli operatori sono in realtà chiamate a metodi. Ad esempio, a + b è interpretato come. + (B), in cui la variabile un metodo che punta + viene richiamato, b come parametro nella chiamata metodo.

Per ogni operatore (+ - * /% ** & | ^ << >> && ||), ha un corrispondente operatore di assegnazione sigla (+ = - =, etc.).

operatori aritmetici di Ruby

Supponiamo la variabile un valore di 10, il valore b variabile 20, allora:

运算符描述实例
+加法 - 把运算符两边的操作数相加 a + b 将得到 30
-减法 - 把左操作数减去右操作数 a - b 将得到 -10
*乘法 - 把运算符两边的操作数相乘 a * b 将得到 200
/除法 - 把左操作数除以右操作数 b / a 将得到 2
%求模 - 把左操作数除以右操作数，返回余数 b % a 将得到 0
**指数 - 执行指数计算 a**b 将得到 10 的 20 次方

confronto rubino

Supponiamo la variabile un valore di 10, il valore b variabile 20, allora:

运算符描述实例
==检查两个操作数的值是否相等，如果相等则条件为真。 (a == b) 不为真。
!=检查两个操作数的值是否相等，如果不相等则条件为真。 (a != b) 为真。
>检查左操作数的值是否大于右操作数的值，如果是则条件为真。 (a > b) 不为真。
<检查左操作数的值是否小于右操作数的值，如果是则条件为真。 (a < b) 为真。
>=检查左操作数的值是否大于或等于右操作数的值，如果是则条件为真。 (a >= b) 不为真。
<=检查左操作数的值是否小于或等于右操作数的值，如果是则条件为真。 (a <= b) 为真。
<=>联合比较运算符。如果第一个操作数等于第二个操作数则返回 0，如果第一个操作数大于第二个操作数则返回 1，如果第一个操作数小于第二个操作数则返回 -1。 (a <=> b) 返回 -1。
===用于测试case语句的 when 子句内的相等。 (1...10) === 5 返回 true。
.eql?如果接收器和参数具有相同的类型和相等的值，则返回 true。 1 == 1.0 返回 true，但是 1.eql?(1.0) 返回 false。
equal?如果接收器和参数具有相同的对象 id，则返回 true。如果 aObj 是 bObj 的副本，那么 aObj == bObj 返回 true，a.equal?bObj 返回 false，但是 a.equal?aObj 返回 true。

Rubino operatore di assegnazione

Supponiamo la variabile un valore di 10, il valore b variabile 20, allora:

运算符描述实例
=简单的赋值运算符，把右操作数的值赋给左操作数 c = a + b 将把 a + b 的值赋给 c
+=加且赋值运算符，把右操作数加上左操作数的结果赋值给左操作数 c += a 相当于 c = c + a
-=减且赋值运算符，把左操作数减去右操作数的结果赋值给左操作数 c -= a 相当于 c = c - a
*=乘且赋值运算符，把右操作数乘以左操作数的结果赋值给左操作数 c *= a 相当于 c = c * a
/=除且赋值运算符，把左操作数除以右操作数的结果赋值给左操作数 c /= a 相当于 c = c / a
%=求模且赋值运算符，求两个操作数的模赋值给左操作数 c %= a 相当于 c = c % a
**=指数且赋值运算符，执行指数计算，并赋值给左操作数 c **= a 相当于 c = c ** a

Rubino assegnazione parallela

Rubino supporta anche le variabili di assegnazione parallele. Questo consente variabili multiple possono essere inizializzate da una linea di codice Ruby. Ad esempio: 

a = 10
b = 20
c = 30

Utilizzando l'assegnazione parallela più veloce di responsabilità: 

a, b, c = 10, 20, 30

assegnazione parallela quando si scambiano i valori di due variabili sono anche utili: 

a, b = b, c

Rubino Operatori bit a bit

operatori bit a bit che agiscono sul bit, e poco a funzionamento bit.

Se supposto che a = 60, b = e 13, ora in formato binario, che è la seguente:

a = 0011 1100

b = 0000 1101

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

a & b = 0000 1100

A | B = 0011 1101

A ^ B = 0011 0001

~ A = 1100 0011

La seguente tabella elenca Ruby supporta operatori bit a bit.

operatori descrizione Esempi
& Se entrambi esistono in due operandi, il binario operatore per copiare un risultato. (A e B) saranno 12, che è, 0000 1100
| Se presente in uno degli operandi, il binario operatore OR per copiare un risultato. (A | b) saranno 61, è 00.111.101
^ Se presenti in uno degli operandi, ma non esistono simultaneamente in due operandi, operatore XOR binario una copia al risultato. (A ^ b) saranno 49, è 00.110.001
~ Twos operatore di complemento è un operatore unario, un "flip" effetto di posizione. (~ A) sarà -61, 1100 0011,2 costituisce un complemento della forma di numero binario con segno.
<< Binary operatore di spostamento a sinistra. Il valore dell'operando di sinistra per spostarsi a sinistra e operando di destra il numero di cifre specificato. un << 2 sarà 240, che è 11.11 milioni
>> Binary operatore di spostamento a destra. Il valore del primo operando spostare operando a destra il numero specificato di bit verso destra. un >> 2 saranno 15, cioè, 0000 1111

operatori logici di Ruby

La seguente tabella elenca Ruby supporta gli operatori logici.

Supponiamo la variabile un valore di 10, il valore b variabile 20, allora:

运算符描述实例
and称为逻辑与运算符。如果两个操作数都为真，则条件为真。 (a and b) 为真。
or称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 (a or b) 为真。
&&称为逻辑与运算符。如果两个操作数都非零，则条件为真。 (a && b) 为真。
||称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。 (a || b) 为真。
!称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 !(a && b) 为假。
not称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 not(a && b) 为假。

Rubino operatore ternario

C'è più di una azione è chiamato operatore ternario. Il primo valore di calcolo verità dell'espressione, e poi ha deciso di implementare due dietro in una dichiarazione in base al risultato. operatore condizionale ha la seguente sintassi:

运算符描述实例
? :条件表达式如果条件为真 ? 则值为 X : 否则值为 Y

Rubino operatore gamma

In Ruby, la sequenza viene utilizzato per creare una serie di valori intervallo consecutivo - contiene il valore, valore finale (soggetto a disponibilità) e valori tra loro inizio.

In Ruby, queste sequenze è l'uso di ".." e "..." operatori gamma per creare. Gamma contiene due forme creano valori di inizio e fine, la gamma di tre per creare un modulo che contiene solo il valore finale valore iniziale non è incluso.

运算符描述实例
..创建一个从开始点到结束点的范围（包含结束点） 1..10 创建从 1 到 10 的范围
...创建一个从开始点到结束点的范围（不包含结束点） 1...10 创建从 1 到 9 的范围

Rubino definito? Operator

definito? è un operatore speciale, sia sotto forma di una chiamata di metodo per passare espressione giudizio è definita. Restituisce l'espressione stringa di descrizione, se l'espressione è resi indefinitinullo.

Di seguito sono riportati i vari operatori definiti utilizzo ?:

Uso 1 

definito? variabile # Se la variabile è stata inizializzata vero,

Ad esempio: 

foo = 42
definito? foo # => "locale-variabile"
definito? $ _ # => "global-variabile"
definito? bar # => nil (non definito)

Uso 2 

definito? method_call # Se il metodo è stato definito, True

Ad esempio: 

definito? mette # "metodo" =>
definiti? puts (bar) # => nil (undefined qui bar)
definito? decomprimere # => nil (undefined qui)

Uso 3 

# Se il metodo può essere invocato come super utente esiste, allora Vera
definito? eccellente

Ad esempio: 

definito? Super # => "super" (se si può chiamare)
definito? Super # => nil (se non essere invocata)

Uso 4 

definito? cedere # Se il blocco di codice passò vero,

Ad esempio: 

definito? resa # => "resa" (se il blocco di trasferimento)
definito? cedere # => nil (se non passa blocco)

Rubino operatore punto "." E il doppio operatore due punti "::"

È possibile aggiungere il nome del modulo e di sottolineatura per chiamare un metodo di modulo prima del nome del metodo. È possibile utilizzare il nome del modulo e due punti per fare riferimento a una costante.

:: È un operatore unario, consentendo costanti, metodi di istanza e metodi della classe definiti all'interno della classe o del modulo che si può accedere in qualsiasi punto della classe o del modulo dall'esterno.

Ricordare: In Ruby, classi e metodi possono anche essere usati come costante.

Hai solo bisogno di aggiungere prima del nome della costante espressione:: prefisso, per tornare all'oggetto classe o modulo appropriato.

Se l'espressione prefisso non viene utilizzato, il master class oggetto predefinito.

Ecco due esempi: 

MR_COUNT = 0 # classe Object definita nel principali costanti modulo Foo
  MR_COUNT = 0
  :: MR_COUNT = 1 # per impostare il conteggio globale 1
  MR_COUNT = 2 # impostare il numero di locali di 2
fine
mette MR_COUNT # Questa è una costante globale mette Foo :: MR_COUNT # Che cosa è "Foo" costanti locali

Secondo esempio: 

CONST = 'là fuori'
classe Inside_one
   CONST = proc { 'in là'}
   DEF where_is_my_CONST
      :: CONST + 'all'interno di uno'
   fine
fine
classe Inside_two
   CONST = 'all'interno di due'
   DEF where_is_my_CONST
      CONST
   fine
fine
mette Inside_one.new.where_is_my_CONST
mette Inside_two.new.where_is_my_CONST
mette oggetto :: CONST + Inside_two :: CONST
mette Inside_two :: CONST + CONST
mette Inside_one :: CONST
mette Inside_one :: CONST.call + Inside_two :: CONST

Rubino precedenza degli operatori

La tabella che segue in relazione all'operatore di elenchi di priorità tutti gli operatori.

方法运算符描述
是 :: 常量解析运算符
是 [ ] [ ]= 元素引用、元素集合
是 ** 指数
是 ! ~ + - 非、补、一元加、一元减（最后两个的方法名为 +@ 和 -@）
是 * / % 乘法、除法、求模
是 + - 加法和减法
是 >> << 位右移、位左移
是 & 位与
是 ^ | 位异或、位或
是 <= < > >= 比较运算符
是 <=> == === != =~ !~ 相等和模式匹配运算符（!= 和 !~ 不能被定义为方法）
&& 逻辑与
|| 逻辑或
.. ... 范围（包含、不包含）
? : 三元 if-then-else
= %= { /= -= += |= &= >>= <<= *= &&= ||= **= 赋值
defined? 检查指定符号是否已定义
not 逻辑否定
or and 逻辑组成

Nota: La colonnavieneidentificato come il metodo operatore è in realtà un metodo, può essere sovraccaricato.