Latest web development tutorials

Operatorzy Ruby

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).

Ruby arytmetyczne operatory

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 次方

porównanie Ruby

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 子句内的相等。 (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。

Ruby operator przypisania

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 równoległe przypisanie

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

Ruby Operatory bitowe

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

Ruby operatory logiczne

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) 为假。

Ruby trójskładnikowych operatora

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

Ruby operator zakresu

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 ".." i "..." 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ę.

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

Ruby zdefiniowane? Operator

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 ?:

Użycie 1 

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)

Użycie 2 

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)

Użycie 3 

# 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ć)

Zastosowanie 4 

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)

Ruby kropka "." A double operator dwukropek "::"

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

Ruby operator pierwszeństwo

Poniższa tabela podstawie operatora priorytetową listę wszystkich operatorów.

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

Uwaga: W kolumniejestidentyfikowany jako metoda stosowana metoda jest w rzeczywistości, może być przeciążony.