Ruby - Operatörler

Ruby, modern bir dilden bekleyeceğiniz gibi zengin bir operatör grubunu destekler. Çoğu operatör aslında yöntem çağrılarıdır. Örneğin, a + b, a. + (B) olarak yorumlanır, burada a değişkeni tarafından başvurulan nesnedeki + yöntemi , argümanı olarak b ile çağrılır .

Her operatör için (+ - * /% ** & | ^ << >> && ||), karşılık gelen bir kısaltılmış atama operatörü formu vardır (+ = - = vb.).

Ruby Aritmetik Operatörleri

A değişkeninin 10 ve b değişkeninin 20 olduğunu varsayın, o zaman -

Şebeke	Açıklama	Misal
+	Ekleme - İşlecin her iki tarafına da değerler ekler.	a + b 30 verir
-	Çıkarma - Sağ el işleneni sol el işlenenden çıkarır.	a - b -10 verir
*	Çarpma - Operatörün her iki tarafındaki değerleri çarpar.	a * b 200 verir
/	Bölme - Sol el işleneni sağ el işlenene böler.	b / a 2 verir
%	Modulus - Soldaki operandı sağ el operandına böler ve kalanı döndürür.	b% a 0 verir
**	Üs - Operatörlerde üstel (güç) hesaplama gerçekleştirir.	a ** b, 20 üssüne 10 verir

Ruby Karşılaştırma Operatörleri

A değişkeninin 10 ve b değişkeninin 20 olduğunu varsayın, o zaman -

Şebeke	Açıklama	Misal
==	İki işlenenin değerinin eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a == b) doğru değil.
! =	İki işlenenin değerinin eşit olup olmadığını kontrol eder, değerler eşit değilse koşul doğru olur.	(a! = b) doğrudur.
>	Soldaki işlenenin değerinin sağ işlenenin değerinden büyük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a> b) doğru değil.
<	Soldaki işlenenin değerinin sağ işlenenin değerinden küçük olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a <b) doğrudur.
> =	Sol işlenenin değerinin sağ işlenenin değerinden büyük veya ona eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a> = b) doğru değil.
<=	Sol işlenenin değerinin sağ işlenenin değerinden küçük veya ona eşit olup olmadığını kontrol eder, evet ise koşul doğru olur.	(a <= b) doğrudur.
<=>	Kombine karşılaştırma operatörü. İlk işlenen saniyeye eşitse 0, ilk işlenen ikinciden büyükse 1 ve ilk işlenen ikinciden küçükse -1 döndürür.	(a <=> b) -1 döndürür.
===	Bir case ifadesinin when cümlesi içinde eşitliği test etmek için kullanılır .	(1 ... 10) === 5 true değerini döndürür.
.eql?	Alıcı ve bağımsız değişken aynı türe ve eşit değerlere sahipse doğrudur.	1 == 1.0 doğru döndürür, ancak 1.eql? (1.0) yanlıştır.
eşit?	Alıcı ve bağımsız değişken aynı nesne kimliğine sahipse doğrudur.	aObj, bObj'nin kopyasıysa, aObj == bObj doğrudur, a.equal? ​​bObj yanlıştır, ancak a.equal? ​​aObj doğrudur.

Ruby Atama Operatörleri

A değişkeninin 10 ve b değişkeninin 20 olduğunu varsayın, o zaman -

Şebeke	Açıklama	Misal
=	Basit atama operatörü, sağ taraftaki işlenenlerden sol taraftaki işlenenlere değerler atar.	c = a + b, a + b'nin değerini c'ye atar
+ =	VE atama işleci ekleyin, sağ işleneni sol işlenenlere ekler ve sonucu sol işlenenlere atar.	c + = a eşdeğerdir c = c + a
- =	VE atama işlecini çıkar, sağ işleneni sol işlenenden çıkarır ve sonucu sol işlenenlere atar.	c - = a eşdeğerdir c = c - a
* =	AND atama operatörünü çarpın, sağ operandı sol operandla çarpar ve sonucu sol operanda atayın.	c * = a eşdeğerdir c = c * a
/ =	VE atama işlecini böl, sol işleneni sağ işlenenle böler ve sonucu sol işlenenle atar.	c / = a, c = c / a'ya eşdeğerdir
% =	Modül VE atama operatörü, iki işlenen kullanarak modülü alır ve sonucu sol operanda atar.	c% = a eşdeğerdir c = c% a
** =	Üslü AND atama operatörü, operatörler üzerinde üslü (kuvvet) hesaplama yapar ve sol operanda değer atar.	c ** = a eşdeğerdir c = c ** a

Ruby Paralel Ataması

Ruby ayrıca değişkenlerin paralel olarak atanmasını destekler. Bu, birden çok değişkenin tek bir Ruby kodu satırıyla başlatılmasını sağlar. Örneğin -

a = 10
b = 20
c = 30

Bu, paralel atama kullanılarak daha hızlı bildirilebilir -

a, b, c = 10, 20, 30

Paralel atama, iki değişkende tutulan değerleri değiştirmek için de kullanışlıdır -

a, b = b, c

Ruby Bitsel Operatörleri

Bitsel operatör bitler üzerinde çalışır ve bit işlem gerçekleştirir.

Varsayalım ki a = 60; ve b = 13; şimdi ikili biçimde aşağıdaki gibi olacaklar -

a    =  0011 1100
 b    =  0000 1101
 ------------------
 a&b  =  0000 1100
 a|b  =  0011 1101
 a^b  =  0011 0001
 ~a   =  1100 0011

Aşağıdaki Bitwise operatörleri Ruby dili tarafından desteklenmektedir.

Şebeke	Açıklama	Misal
&	İkili AND İşleci, her iki işlenende de varsa sonuca bir bit kopyalar.	(a & b) 0000 1100 olan 12 verir
|	İkili VEYA İşleci, işlenenlerden herhangi birinde varsa bir bit kopyalar.	(a | b), 0011 1101 olan 61 verecek
^	İkili XOR İşleci, bir işlenen içinde ayarlanmışsa, ancak her ikisinde birden ayarlanmamışsa biti kopyalar.	(a ^ b), 0011 0001 olan 49 verecek
~	İkili Birler Tamamlayıcı Operatörü tekli ve bitleri 'çevirme' etkisine sahiptir.	(~ a), işaretli bir ikili sayı nedeniyle 2'nin tamamlayıcı formunda 1100 0011 olan -61'i verecektir.
<<	İkili Sol Kaydırma Operatörü. Soldaki işlenenler değeri, sağ işlenen tarafından belirtilen bit sayısı kadar sola taşınır.	a << 2 240 verir, yani 1111 0000
>>	İkili Sağ Shift Operatörü. Soldaki işlenenler değeri, sağ işlenen tarafından belirtilen bit sayısı kadar sağa taşınır.	a >> 2, 0000 1111 olan 15 verir

Ruby Mantıksal Operatörleri

Aşağıdaki mantıksal operatörler Ruby dili tarafından desteklenmektedir

Varsayalım değişken bir 10 tutar ve değişken b , daha sonra 20 tutar -

Şebeke	Açıklama	Misal
ve	Mantıksal AND operatörü çağrıldı. Her iki işlenen de doğruysa, koşul doğru olur.	(a ve b) doğrudur.
veya	Mantıksal VEYA Operatörü çağrıldı. İki işlenenden herhangi biri sıfır değilse, koşul doğru olur.	(a veya b) doğrudur.
&&	Mantıksal AND operatörü çağrıldı. Her iki işlenen de sıfır değilse, koşul doğru olur.	(a && b) doğrudur.
||	Mantıksal VEYA Operatörü çağrıldı. İki işlenenden herhangi biri sıfır değilse, koşul doğru olur.	(a || b) doğrudur.
!	Mantıksal NOT Operatörü olarak adlandırıldı. İşleneninin mantıksal durumunu tersine çevirmek için kullanın. Bir koşul doğruysa, Mantıksal NOT operatörü yanlış yapar.	! (a && b) yanlıştır.
değil	Mantıksal NOT Operatörü olarak adlandırıldı. İşleneninin mantıksal durumunu tersine çevirmek için kullanın. Bir koşul doğruysa, Mantıksal NOT operatörü yanlış yapar.	not (a && b) yanlıştır.

Ruby Üçlü İşleci

Üçlü Operatör adında bir operatör daha var. Önce doğru veya yanlış değer için bir ifadeyi değerlendirir ve ardından değerlendirmenin sonucuna bağlı olarak verilen iki ifadeden birini yürütür. Koşullu operatör bu sözdizimine sahiptir -

Şebeke	Açıklama	Misal
? :	Koşullu İfade	Koşul doğruysa? Ardından X değeri: Aksi takdirde Y değeri

Ruby Aralığı Operatörleri

Ruby'deki sıra aralıkları, bir başlangıç ​​değeri, bir bitiş değeri ve aradaki bir dizi değerden oluşan bir dizi ardışık değer oluşturmak için kullanılır.

Ruby'de bu diziler ".." ve "..." aralık operatörleri kullanılarak oluşturulur. İki noktalı form, kapsayıcı bir aralık oluştururken, üç noktalı form, belirtilen yüksek değeri hariç tutan bir aralık oluşturur.

Şebeke	Açıklama	Misal
..	Başlangıç ​​noktasından bitiş noktasına kadar dahil bir aralık oluşturur.	1..10 1'den 10'a kadar bir aralık oluşturur.
...	Başlangıç ​​noktasından bitiş noktasına özel bir aralık oluşturur.	1 ... 10 1 ile 9 arasında bir aralık oluşturur.

Ruby tanımlandı mı? Operatörler

tanımlı mı? aktarılan ifadenin tanımlanıp tanımlanmadığını belirlemek için bir yöntem çağrısı şeklini alan özel bir operatördür. İfadenin açıklama dizesini döndürür veya ifade tanımlanmamışsa nil döndürür .

Tanımlanmış çeşitli kullanımları vardır? Şebeke

Kullanım 1

defined? variable # True if variable is initialized

For Example

foo = 42
defined? foo    # => "local-variable"
defined? $_     # => "global-variable"
defined? bar    # => nil (undefined)

Kullanım 2

defined? method_call # True if a method is defined

For Example

defined? puts        # => "method"
defined? puts(bar)   # => nil (bar is not defined here)
defined? unpack      # => nil (not defined here)

Kullanım 3

# True if a method exists that can be called with super user
defined? super

For Example

defined? super     # => "super" (if it can be called)
defined? super     # => nil (if it cannot be)

Kullanım 4

defined? yield   # True if a code block has been passed

For Example

defined? yield    # => "yield" (if there is a block passed)
defined? yield    # => nil (if there is no block)

Ruby Dot "." ve Çift İki Nokta "::" Operatörleri

Adından önce modül adı ve bir nokta koyarak bir modül yöntemini çağırırsınız ve modül adını ve iki iki nokta üst üste kullanarak bir sabite başvurursunuz.

:: Bir sınıf veya modül içinde tanımlanan sabitlere, örnek yöntemlerine ve sınıf yöntemlerine, sınıf veya modülün dışındaki herhangi bir yerden erişilmesine izin veren tekli bir operatördür.

Remember Ruby'de sınıflar ve yöntemler de sabit olarak kabul edilebilir.

Sadece önek olarak :: Uygun sınıf veya modül nesnesini döndüren bir ifade ile Const_name.

Önek ifadesi kullanılmazsa, varsayılan olarak ana Object sınıfı kullanılır.

İşte iki örnek -

MR_COUNT = 0         # constant defined on main Object class
module Foo
   MR_COUNT = 0
   ::MR_COUNT = 1    # set global count to 1
   MR_COUNT = 2      # set local count to 2
end
puts MR_COUNT        # this is the global constant
puts Foo::MR_COUNT   # this is the local "Foo" constant

Second Example

CONST = ' out there'
class Inside_one
   CONST = proc {' in there'}
   def where_is_my_CONST
      ::CONST + ' inside one'
   end
end
class Inside_two
   CONST = ' inside two'
   def where_is_my_CONST
      CONST
   end
end
puts Inside_one.new.where_is_my_CONST
puts Inside_two.new.where_is_my_CONST
puts Object::CONST + Inside_two::CONST
puts Inside_two::CONST + CONST
puts Inside_one::CONST
puts Inside_one::CONST.call + Inside_two::CONST

Ruby Operatörlerinin Önceliği

Aşağıdaki tablo en yüksek öncelikten en düşüğe doğru tüm operatörleri listeler.

Yöntem	Şebeke	Açıklama
Evet	::	Sabit çözünürlük operatörü
Evet	[] [] =	Öğe referansı, öğe kümesi
Evet	**	Üs alma (kuvvete yükseltme)
Evet	! ~ + -	Değil, tamamlayıcı, tekli artı ve eksi (son ikisi için yöntem adları + @ ve - @ şeklindedir)
Evet	* /%	Çarp, böl ve modulo
Evet	+ -	Toplama ve çıkarma
Evet	>> <<	Sağ ve sol bitsel kaydırma
Evet	&	Bitsel "VE"
Evet	^ |	Bit düzeyinde özel `VEYA 've normal` `VEYA' '
Evet	<= <>> =	Karşılaştırma operatörleri
Evet	<=> == ===! = = ~! ~	Eşitlik ve örüntü eşleştirme operatörleri (! = Ve! ~ Yöntem olarak tanımlanmayabilir)
	&&	Mantıksal "VE"
	||	Mantıksal "VEYA"
	.. ...	Aralık (kapsayıcı ve özel)
	? :	Üçlü eğer-ise-değilse
	=% = {/ = - = + = | = & = >> = << = * = && = || = ** =	Görev
	tanımlı mı?	Belirtilen sembolün tanımlanıp tanımlanmadığını kontrol edin
	değil	Mantıksal olumsuzluk
	veya ve	Mantıksal kompozisyon

NOTE- Yöntem sütununda Evet bulunan işleçler aslında yöntemlerdir ve bu nedenle geçersiz kılınabilir.