Najlepszy samouczek Operatorzy Ruby W 2024 r. W tym samouczku możesz dowiedzieć się Ruby arytmetyczne operatory,porównanie Ruby,Ruby operator przypisania,Ruby równoległe przypisanie,Ruby Operatory bitowe,Ruby operatory logiczne,Ruby trójskładnikowych operatora,Ruby operator zakresu,Ruby zdefiniowane? Operator,Użycie 1,Użycie 2,Użycie 3,Zastosowanie 4,Ruby kropka "." A double operator dwukropek "::",Ruby operator pierwszeństwo,
Ruby obsługuje bogaty zestaw operatorów. Większość operatorów są rzeczywiście wywołania metod. Na przykład, a + b jest interpretowane jako a. + (B), przy czym zmienne a + sposobem wskazywania jest wywołany b jako parametr wywołania metody.
Dla każdego operatora (+ - * /% ** i | ^ << >> && ||), ma odpowiedni operator przypisania skrótu (+ = - = itd).
Załóżmy, że zmienna wartość 10, zmienna wartość b 20, a następnie:
运算符 | 描述 | 实例 |
---|---|---|
+ | 加法 - 把运算符两边的操作数相加 | a + b 将得到 30 |
- | 减法 - 把左操作数减去右操作数 | a - b 将得到 -10 |
* | 乘法 - 把运算符两边的操作数相乘 | a * b 将得到 200 |
/ | 除法 - 把左操作数除以右操作数 | b / a 将得到 2 |
% | 求模 - 把左操作数除以右操作数,返回余数 | b % a 将得到 0 |
** | 指数 - 执行指数计算 | a**b 将得到 10 的 20 次方 |
Załóżmy, że zmienna wartość 10, zmienna wartość b 20, a następnie:
运算符 | 描述 | 实例 |
---|---|---|
== | 检查两个操作数的值是否相等,如果相等则条件为真。 | (a == b) 不为真。 |
!= | 检查两个操作数的值是否相等,如果不相等则条件为真。 | (a != b) 为真。 |
> | 检查左操作数的值是否大于右操作数的值,如果是则条件为真。 | (a > b) 不为真。 |
< | 检查左操作数的值是否小于右操作数的值,如果是则条件为真。 | (a < b) 为真。 |
>= | 检查左操作数的值是否大于或等于右操作数的值,如果是则条件为真。 | (a >= b) 不为真。 |
<= | 检查左操作数的值是否小于或等于右操作数的值,如果是则条件为真。 | (a <= b) 为真。 |
<=> | 联合比较运算符。如果第一个操作数等于第二个操作数则返回 0,如果第一个操作数大于第二个操作数则返回 1,如果第一个操作数小于第二个操作数则返回 -1。 | (a <=> b) 返回 -1。 |
=== | 用于测试case语句的 when 子句内的相等。 | (1pl.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。 |
Załóżmy, że zmienna wartość 10, zmienna wartość b 20, a następnie:
运算符 | 描述 | 实例 |
---|---|---|
= | 简单的赋值运算符,把右操作数的值赋给左操作数 | 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 obsługuje również równoległe przypisania zmiennych. Pozwala to na wielokrotne zmienne mogą być inicjowane przez linię kodu Ruby. Na przykład:
a = 10 b = 20 c = 30
Korzystanie zadanie równoległego szybciej Zastrzeżenie:
a, b, c = 10, 20, 30
Przypisanie równoległy przy wymianie wartości dwóch zmiennych użyteczne są również:
a, b = b, c
Bitwise podmioty działające na trochę, a bit po operacji bitowej.
Przy założeniu, że a = 60, b = 13, obecnie w formacie binarnym, który jest następujący:
a = 0011 1100
b = 0000 1101
-----------------
a & b = 0000 1100
a | b = 0011 1101
a ^ b = 0011 0001
~ A = 1100 0011
Poniższa tabela zawiera Ruby wspierać operatorów bitowe.
operatorzy | opis | Przykłady |
---|---|---|
& | Jeśli oba występują w dwóch argumentów, binarny operator AND skopiować wynik. | (A i B) będzie 12, czyli 0000 1100 |
| | Jeśli jest obecny w każdym argumencie, binarny operator OR skopiować wynik. | (A | B) będzie 61, to 00111101 |
^ | Jeśli jest obecny w jednym z argumentu, ale nie jednocześnie istnieje w dwóch liczb binarnych operatora XOR kopii do wyniku. | (A ^ B) będzie 49, to 00110001 |
~ | Dwójki Operator uzupełnieniem jest jednoargumentowy operator jest "klapka" efekt położenia. | (~ A) będzie -61, 1100 0011,2 uzupełnia formę liczby binarnej ze znakiem. |
<< | Binary lewej operatora przesunięcia. Wartość lewego argumentu, aby przejść w lewo i prawo argument określonej liczby cyfr. | << 2 będzie 240, czyli 11110000 |
>> | Binary operatora przesunięcia w prawo. Wartość lewego argumentu przesunąć prawy argument określoną liczbę bitów w prawo. | >> 2 będzie 15, to jest, 0000 1111 |
Poniższa tabela zawiera Ruby wspierać operatorów logicznych.
Załóżmy, że zmienna wartość 10, zmienna wartość b 20, a następnie:
运算符 | 描述 | 实例 |
---|---|---|
and | 称为逻辑与运算符。如果两个操作数都为真,则条件为真。 | (a and b) 为真。 |
or | 称为逻辑或运算符。如果两个操作数中有任意一个非零,则条件为真。 | (a or b) 为真。 |
&& | 称为逻辑与运算符。如果两个操作数都非零,则条件为真。 | (a && b) 为真。 |
|| | 称为逻辑或运算符。如果两个操作数中有任意一个非零,则条件为真。 | (a || b) 为真。 |
! | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | !(a && b) 为假。 |
not | 称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。 | not(a && b) 为假。 |
Jest więcej niż jedna akcja nosi nazwę operatora trójskładnikowych. Pierwsza wartość obliczeniowa prawdą wypowiedzi, a następnie zdecydowała się na wdrożenie dwóch tyłu w oświadczeniu w oparciu o wyniki. Operator warunkowy ma następującą składnię:
运算符 | 描述 | 实例 |
---|---|---|
? : | 条件表达式 | 如果条件为真 ? 则值为 X : 否则值为 Y |
W Ruby, sekwencja służy do tworzenia serii kolejnych wartości zakresu - zawiera rozpocząć wartość, wartość końcową (w miarę możliwości) i wartości między nimi.
W Ruby, te sekwencje jest wykorzystanie "pl" i "pl." operatorów Zakres utworzyć. Zakres zawiera dwie formy tworzenia wartości początkowe i końcowe, zakres trzech utworzyć formularz, który zawiera tylko wartość końcowa wartość początkowa nie jest wliczony w cenę.
运算符 | 描述 | 实例 |
---|---|---|
pl | 创建一个从开始点到结束点的范围(包含结束点) | 1pl10 创建从 1 到 10 的范围 |
pl. | 创建一个从开始点到结束点的范围(不包含结束点) | 1pl.10 创建从 1 到 9 的范围 |
zdefiniowane? Jest to specjalny operator, czy to w formie wywołania metody przekazać wyraz orzeczenie jest zdefiniowana. Zwraca ciąg opisu wyrażenie, jeśli wyrażenie jest nieokreślone zwracanil.
Poniżej przedstawiono różne podmioty określone wykorzystanie ?:
zdefiniowane? zmiennej # Jeśli zmienna została zainicjowana prawda,
Na przykład:
foo = 42 zdefiniowane? foo # => "local-variable" zdefiniowane? $ _ # => "global-zmienna" zdefiniowane? bar # => nil (nieokreślone)
zdefiniowane? method_call # Jeśli metoda została zdefiniowana, prawda
Na przykład:
zdefiniowane? stawia # => "metoda" zdefiniowane? puts (bar) # => nil (niezdefiniowany tutaj bar) zdefiniowane? rozpakować # => nil (niezdefiniowany tutaj)
# Jeśli metoda może być powoływane jako super użytkownik istnieje, to prawda zdefiniowane? Super
Na przykład:
zdefiniowane? Super # => "super" (jeśli to można nazwać) zdefiniowane? Super # => nil (jeśli nie jest się powoływać)
zdefiniowane? uzyskując # Jeśli blok kodu przeszły prawda,
Na przykład:
zdefiniowane? Wydajność # => "Wydajność" (jeżeli blok transfer) zdefiniowane? uzyskując # => nil (jeśli nie mijają blok)
Można dodać nazwę modułu i podkreślenia do wywołania metody modułu przed nazwą metody. Można użyć nazwy modułu i dwa dwukropki odwołać się na stałym poziomie.
:: Jest jednoskładnikowa operatora, dzięki czemu stałe, przykład sposoby oraz temu klasa metod zdefiniowanych w klasie lub moduł, które mogą być dowolnym dostępnym w klasie lub w module z zewnątrz.
Pamiętać W Ruby klas i metody mogą być stosowane jako stałe.
Wystarczy tylko dodać przed nazwą stałej ekspresji:: prefiksu, aby powrócić do odpowiedniej klasy lub modułu obiektu.
Jeśli wyrażenie prefiks nie jest używany domyślny master class Object.
Oto dwa przykłady:
MR_COUNT = 0 # Klasa obiektu zdefiniowano w głównym module Foo stałe MR_COUNT = 0 :: MR_COUNT = 1 #, aby ustawić globalną liczbę 1 MR_COUNT = 2 # ustawić lokalną liczbę 2 koniec stawia MR_COUNT # To jest globalna stała stawia Foo :: MR_COUNT # Co to jest "Foo" Stałe lokalne
Druga instancja:
STAŁA = "tam" Klasa Inside_one STAŁA = proc { 'tam'} def where_is_my_CONST :: STAŁA + 'wewnątrz jednego " koniec koniec Klasa Inside_two STAŁA = 'wewnątrz dwóch " def where_is_my_CONST STAŁA koniec koniec stawia Inside_one.new.where_is_my_CONST stawia Inside_two.new.where_is_my_CONST stawia Object :: STAŁA + Inside_two :: CONST stawia Inside_two :: STAŁA + STAŁA stawia Inside_one :: CONST stawia Inside_one :: CONST.call + Inside_two :: CONST
Poniższa tabela podstawie operatora priorytetową listę wszystkich operatorów.
方法 | 运算符 | 描述 |
---|---|---|
是 | :: | 常量解析运算符 |
是 | [ ] [ ]= | 元素引用、元素集合 |
是 | ** | 指数 |
是 | ! ~ + - | 非、补、一元加、一元减(最后两个的方法名为 +@ 和 -@) |
是 | * / % | 乘法、除法、求模 |
是 | + - | 加法和减法 |
是 | >> << | 位右移、位左移 |
是 | & | 位与 |
是 | ^ | | 位异或、位或 |
是 | <= < > >= | 比较运算符 |
是 | <=> == === != =~ !~ | 相等和模式匹配运算符(!= 和 !~ 不能被定义为方法) |
&& | 逻辑与 | |
|| | 逻辑或 | |
pl pl. | 范围(包含、不包含) | |
? : | 三元 if-then-else | |
= %= { /= -= += |= &= >>= <<= *= &&= ||= **= | 赋值 | |
defined? | 检查指定符号是否已定义 | |
not | 逻辑否定 | |
or and | 逻辑组成 |
Uwaga: W kolumniejestidentyfikowany jako metoda stosowana metoda jest w rzeczywistości, może być przeciążony.