opérateurs Ruby
Ruby prend en charge un riche ensemble d'opérateurs. La plupart des opérateurs sont en fait des appels de méthode. Par exemple, a + b est interprété comme un. + (B), dans lequel la variable d'une méthode de pointage + est invoquée, b en tant que paramètre dans l'appel de méthode.
Pour chaque opérateur (+ - * /% ** & | ^ << >> && ||), a un opérateur d'affectation correspondant abréviation (+ = - =, etc.).
Ruby opérateurs arithmétiques
Supposons que la variable d'une valeur de 10, la valeur de b variable de 20, puis:
运算符 | 描述 | 实例 |
---|---|---|
+ | 加法 - 把运算符两边的操作数相加 | a + b 将得到 30 |
- | 减法 - 把左操作数减去右操作数 | a - b 将得到 -10 |
* | 乘法 - 把运算符两边的操作数相乘 | a * b 将得到 200 |
/ | 除法 - 把左操作数除以右操作数 | b / a 将得到 2 |
% | 求模 - 把左操作数除以右操作数,返回余数 | b % a 将得到 0 |
** | 指数 - 执行指数计算 | a**b 将得到 10 的 20 次方 |
comparaison Ruby
Supposons que la variable d'une valeur de 10, la valeur de b variable de 20, puis:
运算符 | 描述 | 实例 |
---|---|---|
== | 检查两个操作数的值是否相等,如果相等则条件为真。 | (a == b) 不为真。 |
!= | 检查两个操作数的值是否相等,如果不相等则条件为真。 | (a != b) 为真。 |
> | 检查左操作数的值是否大于右操作数的值,如果是则条件为真。 | (a > b) 不为真。 |
< | 检查左操作数的值是否小于右操作数的值,如果是则条件为真。 | (a < b) 为真。 |
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是则条件为真。 | (a >= b) 不为真。 |
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是则条件为真。 | (a <= b) 为真。 |
<=> | 联合比较运算符。如果第一个操作数等于第二个操作数则返回 0,如果第一个操作数大于第二个操作数则返回 1,如果第一个操作数小于第二个操作数则返回 -1。 | (a <=> b) 返回 -1。 |
=== | 用于测试case语句的 when 子句内的相等。 | (1fr.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。 |
Ruby opérateur d'affectation
Supposons que la variable d'une valeur de 10, la valeur de b variable de 20, puis:
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符,把右操作数的值赋给左操作数 | 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 |
Ruby cession parallèle
Ruby prend également en charge les variables d'affectation parallèles. Cela permet à plusieurs variables peuvent être initialisées par une ligne de code Ruby. Par exemple:
a = 10 b = 20 c = 30
Utilisation de l'affectation parallèle plus rapide Avertissement:
a, b, c = 10, 20, 30
Affectation parallèle lors de l'échange des valeurs de deux variables sont également utiles:
a, b = b, c
Opérateurs sur les bits Ruby
Opérateurs binaires agissant sur le bit et bit par opération binaire.
Si supposé que a = 60, b = 13, maintenant dans un format binaire, qui est le suivant:
a = 0011 1100
b = 0000 1101
-----------------
a & b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
~ A = 1100 0011
Le tableau suivant indique le Ruby supporte les opérateurs de bits.
opérateurs | description | Exemples |
---|---|---|
& | Si les deux existent en deux opérandes, le binaire opérateur AND pour copier un résultat. | (A & b) sera 12, qui est, 0000 1100 |
| | Si elle est présente dans l'une des opérandes, le binaire opérateur OR pour copier un résultat. | (A | b) sera 61, est 00111101 |
^ | Si elle est présente dans l'un des opérandes, mais pas exister simultanément dans deux opérandes, l'opérateur XOR binaire copie au résultat. | (A ^ b) sera 49, est 00110001 |
~ | Twos opérateur de complément est un opérateur unaire, un "flip" effet de position. | (~ A) sera -61, 1100 0011,2 doit compléter sous forme de nombre binaire avec signe. |
<< | opérateur de décalage gauche binaire. La valeur de l'opérande gauche pour aller à gauche et à droite opérande le nombre de chiffres spécifié. | un << 2 sera 240, soit 11,11 millions |
>> | opérateur de décalage à droite binaire. La valeur de l'opérande gauche déplacer opérande de droite le nombre spécifié de bits vers la droite. | une >> 2 sera 15, soit 0000 1111 |
opérateurs logiques Ruby
Le tableau suivant indique le Ruby supporte les opérateurs logiques.
Supposons que la variable d'une valeur de 10, la valeur de b variable de 20, puis:
运算符 | 描述 | 实例 |
---|---|---|
and | 称为逻辑与运算符。如果两个操作数都为真,则条件为真。 | (a and b) 为真。 |
or | 称为逻辑或运算符。如果两个操作数中有任意一个非零,则条件为真。 | (a or b) 为真。 |
&& | 称为逻辑与运算符。如果两个操作数都非零,则条件为真。 | (a && b) 为真。 |
|| | 称为逻辑或运算符。如果两个操作数中有任意一个非零,则条件为真。 | (a || b) 为真。 |
! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(a && b) 为假。 |
not | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | not(a && b) 为假。 |
Ruby opérateur ternaire
Il y a plus d'une action est appelée opérateur ternaire. La première valeur de calcul de la vérité de l'expression, puis a décidé de mettre en œuvre deux derrière dans une déclaration sur la base du résultat. Opérateur conditionnel a la syntaxe suivante:
运算符 | 描述 | 实例 |
---|---|---|
? : | 条件表达式 | 如果条件为真 ? 则值为 X : 否则值为 Y |
opérateur de gamme Ruby
Dans Ruby, la séquence est utilisée pour créer une série de valeur de plage consécutive - contient la valeur de départ, la valeur finale (sous réserve de disponibilité) et les valeurs entre elles.
Dans Ruby, ces séquences est l'utilisation de "fr" et "fr." les opérateurs de gamme pour créer. Range contient deux formes créent des valeurs de début et de fin, la gamme de trois pour créer un formulaire qui ne contient que la valeur finale de la valeur de départ ne sont pas inclus.
运算符 | 描述 | 实例 |
---|---|---|
fr | 创建一个从开始点到结束点的范围(包含结束点) | 1fr10 创建从 1 到 10 的范围 |
fr. | 创建一个从开始点到结束点的范围(不包含结束点) | 1fr.10 创建从 1 到 9 的范围 |
Ruby défini? Opérateur
défini? est un opérateur spécial, que ce soit sous la forme d'un appel de méthode pour passer l'expression du jugement est défini. Elle renvoie la chaîne expression de description, si l'expression est undefined retournenil.
Voici les différents opérateurs définis utilisation ?:
Utilisation 1
défini? variable # Si la variable a été initialisée vrai,
Par exemple:
foo = 42 défini? foo # => "local-variable" défini? $ _ # => "global-variable" défini? bar # => nil (undefined)
Utilisation 2
défini? method_call # Si la méthode a été définie, True
Par exemple:
défini? met # "méthode" => puts définis? (bar) # => nil (undefined ici bar) défini? déballer # => nil (undefined ici)
Utilisation 3
# Si la méthode peut être invoquée en tant que super utilisateur existe donc vrai défini? Super
Par exemple:
défini? Super # => "super" (si on peut appeler) défini? Super # => nil (si pas être invoquée)
Utilisation 4
défini? céder # Si le bloc de code adopté Vrai,
Par exemple:
défini? rendement # => "rendement" (si le bloc de transfert) défini? céder # => nil (si pas passer le bloc)
Ruby dot opérateur "." Et l'opérateur double colon "::"
Vous pouvez ajouter le nom du module et de souligner d'appeler une méthode de module avant le nom de la méthode. Vous pouvez utiliser le nom du module et deux deux-points pour faire référence à une constante.
:: Est un opérateur unaire, permettant des constantes, des méthodes d'instance et les méthodes de classe définies dans la classe ou le module qui peut être consulté partout dans la classe ou le module de l'extérieur.
Rappelez - vous:Dans Ruby, classes et méthodes peuvent également être utilisés comme une constante.
Vous avez seulement besoin d'ajouter avant le nom de l'expression:: préfixe constant, pour revenir à l'objet de classe ou module approprié.
Si l'expression de préfixe est pas utilisé, la classe principale de l'objet par défaut.
Voici deux exemples:
MR_COUNT = 0 # classe Object défini dans les principales constantes Module Foo MR_COUNT = 0 :: MR_COUNT = 1 # pour définir le nombre global 1 MR_COUNT = 2 # définir le nombre local 2 fin met MR_COUNT # Ceci est une constante globale met Foo :: MR_COUNT # Qu'est-ce que "Foo" constantes locales
Deuxième exemple:
CONST = 'là-bas' classe Inside_one CONST = proc { 'y'} def where_is_my_CONST :: CONST + 'une à l'intérieur' fin fin classe Inside_two CONST = 'intérieur de deux' def where_is_my_CONST CONST fin fin met Inside_one.new.where_is_my_CONST met Inside_two.new.where_is_my_CONST met Object :: CONST + Inside_two :: CONST met Inside_two :: CONST + CONST met Inside_one :: CONST met Inside_one :: CONST.call + Inside_two :: CONST
Ruby priorité des opérateurs
Le tableau suivant Sur la base de l'opérateur de priorité répertorie tous les opérateurs.
方法 | 运算符 | 描述 |
---|---|---|
是 | :: | 常量解析运算符 |
是 | [ ] [ ]= | 元素引用、元素集合 |
是 | ** | 指数 |
是 | ! ~ + - | 非、补、一元加、一元减(最后两个的方法名为 +@ 和 -@) |
是 | * / % | 乘法、除法、求模 |
是 | + - | 加法和减法 |
是 | >> << | 位右移、位左移 |
是 | & | 位与 |
是 | ^ | | 位异或、位或 |
是 | <= < > >= | 比较运算符 |
是 | <=> == === != =~ !~ | 相等和模式匹配运算符(!= 和 !~ 不能被定义为方法) |
&& | 逻辑与 | |
|| | 逻辑或 | |
fr fr. | 范围(包含、不包含) | |
? : | 三元 if-then-else | |
= %= { /= -= += |= &= >>= <<= *= &&= ||= **= | 赋值 | |
defined? | 检查指定符号是否已定义 | |
not | 逻辑否定 | |
or and | 逻辑组成 |
Remarque: La colonneestidentifiée comme étant la méthode de l' opérateur est en fait une méthode, il peut être surchargé.