Operatori Ruby

Operatore aritmetico Ruby

Supponiamo che il valore della variabile a sia 10 e il valore della variabile b sia 20, allora:

Operatore di confronto Ruby

Supponiamo che il valore della variabile a sia 10 e il valore della variabile b sia 20, allora:

Operatore di assegnamento Ruby

Supponiamo che il valore della variabile a sia 10 e il valore della variabile b sia 20, allora:

Assegnamento parallelo Ruby

Ruby supporta anche l'assegnamento parallelo delle variabili. Questo permette di inizializzare più variabili in una singola riga di codice Ruby. Ad esempio:

a　=　10
b　=　20
c　=　30

L'assegnamento parallelo può dichiarare più velocemente:

a,　b,　c　=　10,　20,　30

L'assegnamento parallelo è molto utile anche per scambiare i valori di due variabili:

a,　b　=　b,　c

Operatore di bitwise Ruby

Gli operatori di bit operano sui bit e eseguono le operazioni bit per bit.

Supponiamo che se a = 60 e b = 13, ora li mostriamo in formato binario:

a = 0011 1100

b = 0000 1101

-----------------

a&b = 0000 1100

a|b = 0011 1101

a^b = 0011 0001

~a = 1100 0011

La tabella seguente elenca gli operatori bit a bit supportati da Ruby.

Operatori logici Ruby

La tabella seguente elenca gli operatori logici supportati da Ruby.

Supponiamo che il valore della variabile a sia 10 e il valore della variabile b sia 20, allora:

Operatore ternario Ruby

Esistono più di una operazioni chiamate operatori ternari. Il primo calcola il valore vero/falso dell'espressione, poi in base a questo risultato decide di eseguire una delle due istruzioni successive. La sintassi dell'operatore condizionale è la seguente:

Operatori di intervallo in Ruby

In Ruby, gli intervalli di sequenza vengono utilizzati per creare una serie di valori consecutivi - includono il valore di inizio, il valore di fine (a seconda del caso) e i valori tra di loro.

In Ruby, queste sequenze sono create utilizzando gli operatori di intervallo ".." e "...". La forma a due punti crea un intervallo che contiene sia il valore di inizio che il valore di fine, mentre la forma a tre punti crea un intervallo che contiene solo il valore di inizio e non il valore di fine.

Operatore defined? in Ruby

defined? è un operatore speciale che, sotto forma di chiamata di metodo, determina se un'espressione è definita. Restituisce la stringa di descrizione dell'espressione, se l'espressione non è definita restituisce nil.

Di seguito sono elencati vari usi dell'operatore defined?

Uso 1

definito? variable # => True se variable è stata inizializzata

Ad esempio:

foo = 42
definito? foo # => "variabile-locale"
definito? $_ # => "variabile-globale"
definito? bar # => nil (non definito)

Uso 2

definito? method_call # => True se il metodo è già definito

Ad esempio:

definito? puts # => "method"
definito? puts(bar) # => nil (bar non definito qui)
definito? unpack # => nil (non definito qui)

Uso 3

# => True se esiste un metodo che può essere chiamato con super
definito? super

Ad esempio:

definito? super # => "super" (se può essere chiamato)
definito? super # => nil (se non può essere chiamato)

Uso 4

definito? yield # => True se è stato passato un blocco di codice

Ad esempio:

definito? yield # => "yield" (se è stato passato un blocco)
definito? yield # => nil (se non è stato passato un blocco)

Il punto di Ruby "." e l'operatore a doppio duepunto "::"

Puoi chiamare i metodi di una classe o modulo aggiungendo il nome della classe o modulo e . al nome del metodo. Puoi anche utilizzare il nome della classe o modulo e due duepunti :: per riferirti a costanti all'interno della classe o modulo.

:: è un operatore unario, che permette di definire costanti, esempi di metodo e metodi di classe all'interno di una classe o modulo, accessibili da qualsiasi parte fuori dalla classe o modulo.

Ricorda:In Ruby, le classi e i metodi possono essere trattati come costanti.

Ti basta aggiungere il nome del costante all'inizio dell'espressione. :: Un prefisso, si può restituire l'oggetto appropriato della classe o modulo.

Se l'espressione prima di :: è il nome di una classe o modulo, restituisce il valore della costante corrispondente all'interno della classe o modulo; se non c'è un'espressione prefissa prima di ::, restituisce il valore della costante corrispondente nel tipo Object principale. .

Ecco due esempi:

MR_COUNT = 0 # Definita nel tipo Object principale
module Foo
　　MR_COUNT = 0
　　::MR_COUNT = 1 # Imposta il conteggio globale a 1
　　MR_COUNT = 2 # Imposta il conteggio locale a 2
end
puts MR_COUNT # Questa è la costante globale
puts Foo::MR_COUNT # Questa è la costante locale di "Foo"

Secondo esempio:

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

Priorità degli operatori Ruby

La seguente tabella elenca tutti gli operatori in ordine di priorità, da alta a bassa.

Attenzione:È indicato nella lista dei metodi come È Gli operatori sono effettivamente metodi, quindi possono essere sovrascritti.