Ruby - Operatori

Ruby supporta un ricco set di operatori, come ci si aspetterebbe da un linguaggio moderno. La maggior parte degli operatori sono in realtà chiamate a metodi. Ad esempio, a + b viene interpretato come a. + (B), dove il metodo + nell'oggetto a cui fa riferimento la variabile a viene chiamato con b come argomento.

Per ogni operatore (+ - * /% ** & | ^ << >> && ||), esiste una forma corrispondente di operatore di assegnazione abbreviata (+ = - = ecc.).

Operatori aritmetici di Ruby

Supponiamo che la variabile a contenga 10 e la variabile b ne contenga 20, quindi -

Operatore	Descrizione	Esempio
+	Addizione: aggiunge valori su entrambi i lati dell'operatore.	a + b darà 30
-	Sottrazione: sottrae l'operando di destra dall'operando di sinistra.	a - b darà -10
*	Moltiplicazione: moltiplica i valori su entrambi i lati dell'operatore.	a * b darà 200
/	Divisione: divide l'operando di sinistra per l'operando di destra.	b / a darà 2
%	Modulo: divide l'operando sinistro per l'operando destro e restituisce il resto.	b% a darà 0
**	Esponente: esegue il calcolo esponenziale (potenza) sugli operatori.	a ** b darà 10 alla potenza 20

Operatori di confronto di Ruby

Supponiamo che la variabile a contenga 10 e la variabile b ne contenga 20, quindi -

Operatore	Descrizione	Esempio
==	Controlla se il valore di due operandi è uguale o meno, in caso affermativo la condizione diventa vera.	(a == b) non è vero.
! =	Controlla se il valore di due operandi è uguale o meno, se i valori non sono uguali la condizione diventa vera.	(a! = b) è vero.
>	Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro, in caso affermativo la condizione diventa vera.	(a> b) non è vero.
<	Controlla se il valore dell'operando sinistro è inferiore al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(a <b) è vero.
> =	Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(a> = b) non è vero.
<=	Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro, in caso affermativo la condizione diventa vera.	(a <= b) è vero.
<=>	Operatore di confronto combinato. Restituisce 0 se il primo operando è uguale al secondo, 1 se il primo operando è maggiore del secondo e -1 se il primo operando è minore del secondo.	(a <=> b) restituisce -1.
===	Utilizzato per testare l'uguaglianza all'interno di una clausola when di un'istruzione case .	(1 ... 10) === 5 restituisce true.
.eql?	Vero se il destinatario e l'argomento hanno lo stesso tipo e valori uguali.	1 == 1.0 restituisce vero, ma 1.eql? (1.0) è falso.
pari?	Vero se il destinatario e l'argomento hanno lo stesso ID oggetto.	se aObj è duplicato di bObj allora aObj == bObj è vero, a.equal? ​​bObj è falso ma a.equal? ​​aObj è vero.

Operatori di assegnazione Ruby

Supponiamo che la variabile a contenga 10 e la variabile b ne contenga 20, quindi -

Operatore	Descrizione	Esempio
=	Operatore di assegnazione semplice, assegna i valori dagli operandi del lato destro all'operando del lato sinistro.	c = a + b assegnerà il valore di a + b in c
+ =	Aggiungi operatore di assegnazione AND, aggiunge l'operando destro all'operando sinistro e assegna il risultato all'operando sinistro.	c + = a è equivalente a c = c + a
- =	Sottrai l'operatore di assegnazione AND, sottrae l'operando destro dall'operando sinistro e assegna il risultato all'operando sinistro.	c - = a è equivalente a c = c - a
* =	Moltiplica l'operatore di assegnazione AND, moltiplica l'operando destro con l'operando sinistro e assegna il risultato all'operando sinistro.	c * = a è equivalente a c = c * a
/ =	Divide AND operatore di assegnazione, divide l'operando sinistro con l'operando destro e assegna il risultato all'operando sinistro.	c / = a è equivalente a c = c / a
% =	Modulo AND operatore di assegnazione, accetta il modulo utilizzando due operandi e assegna il risultato all'operando sinistro.	c% = a è equivalente a c = c% a
** =	Operatore di assegnazione AND esponenziale, esegue il calcolo esponenziale (potenza) sugli operatori e assegna un valore all'operando sinistro.	c ** = a è equivalente a c = c ** a

Ruby Parallel Assignment

Ruby supporta anche l'assegnazione parallela di variabili. Ciò consente di inizializzare più variabili con una singola riga di codice Ruby. Ad esempio:

a = 10
b = 20
c = 30

Questo può essere dichiarato più rapidamente usando l'assegnazione parallela -

a, b, c = 10, 20, 30

L'assegnazione parallela è utile anche per scambiare i valori contenuti in due variabili:

a, b = b, c

Ruby Bitwise Operators

L'operatore bit per bit lavora sui bit ed esegue l'operazione bit per bit.

Assumiamo se a = 60; e b = 13; ora in formato binario saranno i seguenti -

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

I seguenti operatori bit per bit sono supportati dal linguaggio Ruby.

Operatore	Descrizione	Esempio
&	L'operatore AND binario copia un po 'nel risultato se esiste in entrambi gli operandi.	(a & b) darà 12, che è 0000 1100
|	L'operatore OR binario copia un bit se esiste in uno degli operandi.	(a | b) darà 61, che è 0011 1101
^	L'operatore XOR binario copia il bit se è impostato in un operando ma non in entrambi.	(a ^ b) darà 49, che è 0011 0001
~	Binary Ones Complement Operator è unario e ha l'effetto di "ribaltare" i bit.	(~ a) darà -61, che è 1100 0011 in forma di complemento a 2 a causa di un numero binario con segno.
<<	Operatore binario di spostamento sinistro. Il valore dell'operando sinistro viene spostato a sinistra del numero di bit specificato dall'operando destro.	a << 2 darà 240, che è 1111 0000
>>	Operatore binario di spostamento a destra. Il valore dell'operando sinistro viene spostato a destra del numero di bit specificato dall'operando destro.	a >> 2 darà 15, che è 0000 1111

Operatori logici Ruby

I seguenti operatori logici sono supportati dal linguaggio Ruby

Supponiamo che la variabile a contenga 10 e la variabile b ne contenga 20, quindi -

Operatore	Descrizione	Esempio
e	Chiamato operatore AND logico. Se entrambi gli operandi sono veri, la condizione diventa vera.	(aeb) è vero.
o	Chiamato Operatore OR logico. Se uno dei due operandi è diverso da zero, la condizione diventa vera.	(aob) è vero.
&&	Chiamato operatore AND logico. Se entrambi gli operandi sono diversi da zero, la condizione diventa vera.	(a && b) è vero.
||	Chiamato Operatore OR logico. Se uno dei due operandi è diverso da zero, la condizione diventa vera.	(a || b) è vero.
!	Chiamato operatore NOT logico. Utilizzare per invertire lo stato logico del suo operando. Se una condizione è vera, l'operatore NOT logico la renderà falsa.	! (a && b) è falso.
non	Chiamato operatore NOT logico. Utilizzare per invertire lo stato logico del suo operando. Se una condizione è vera, l'operatore NOT logico la renderà falsa.	not (a && b) è falso.

Ruby Ternary Operator

C'è un altro operatore chiamato Operatore ternario. Prima valuta un'espressione per un valore vero o falso e quindi esegue una delle due istruzioni fornite a seconda del risultato della valutazione. L'operatore condizionale ha questa sintassi:

Operatore	Descrizione	Esempio
? :	Espressione condizionale	Se la condizione è vera? Quindi valore X: altrimenti valore Y

Ruby Range Operators

Gli intervalli di sequenza in Ruby vengono utilizzati per creare un intervallo di valori successivi, costituito da un valore iniziale, un valore finale e un intervallo di valori intermedi.

In Ruby, queste sequenze vengono create utilizzando gli operatori di intervallo ".." e "...". Il modulo a due punti crea un intervallo inclusivo, mentre il modulo a tre punti crea un intervallo che esclude il valore alto specificato.

Operatore	Descrizione	Esempio
..	Crea un intervallo dal punto iniziale al punto finale compreso.	1..10 Crea un intervallo da 1 a 10 inclusi.
...	Crea un intervallo dal punto iniziale al punto finale esclusivo.	1 ... 10 Crea un intervallo da 1 a 9.

Ruby definito? Operatori

definito? è un operatore speciale che assume la forma di una chiamata al metodo per determinare se l'espressione passata è definita o meno. Restituisce una stringa di descrizione dell'espressione o nil se l'espressione non è definita.

Ci sono vari utilizzi di definiti? Operatore

Utilizzo 1

defined? variable # True if variable is initialized

For Example

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

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

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

Utilizzo 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 "." e Double Colon "::" Operatori

Si chiama un metodo del modulo facendo precedere il suo nome con il nome del modulo e un punto e si fa riferimento a una costante utilizzando il nome del modulo e due due punti.

Il :: è un operatore unario che consente di accedere da qualsiasi punto esterno alla classe o al modulo: costanti, metodi di istanza e metodi di classe definiti all'interno di una classe o di un modulo.

Remember in Ruby, anche classi e metodi possono essere considerati costanti.

Devi solo aggiungere il prefisso :: Const_name con un'espressione che restituisce la classe o l'oggetto modulo appropriato.

Se non viene utilizzata alcuna espressione di prefisso, per impostazione predefinita viene utilizzata la classe Object principale.

Ecco due esempi:

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

Precedenza degli operatori Ruby

La tabella seguente elenca tutti gli operatori dalla precedenza più alta al più basso.

Metodo	Operatore	Descrizione
sì	::	Operatore a risoluzione costante
sì	[] [] =	Riferimento elemento, set di elementi
sì	**	Esponenziazione (aumento alla potenza)
sì	! ~ + -	No, complemento, più e meno unario (i nomi dei metodi per gli ultimi due sono + @ e - @)
sì	* /%	Moltiplica, dividi e modulo
sì	+ -	Addizione e sottrazione
sì	>> <<	Spostamento bit per bit destro e sinistro
sì	&	Bitwise "AND"
sì	^ |	"OR" esclusivo bit per bit e "OR" regolare
sì	<= <>> =	Operatori di confronto
sì	<=> == ===! = = ~! ~	Uguaglianza e operatori di corrispondenza del modello (! = E! ~ Potrebbero non essere definiti come metodi)
	&&	Logico "AND"
	||	"OR" logico
	.. ...	Gamma (inclusiva ed esclusiva)
	? :	Ternario se-allora-altro
	=% = {/ = - = + = | = & = >> = << = * = && = || = ** =	Incarico
	definito?	Verificare se il simbolo specificato è definito
	non	Negazione logica
	o e	Composizione logica

NOTE- Gli operatori con un Sì nella colonna del metodo sono in realtà metodi e come tali possono essere sovrascritti.