Ruby - Opérateurs

Ruby prend en charge un riche ensemble d'opérateurs, comme on peut s'y attendre d'un langage moderne. La plupart des opérateurs sont en fait des appels de méthode. Par exemple, a + b est interprété comme a. + (B), où la méthode + dans l'objet référencé par la variable a est appelée avec b comme argument.

Pour chaque opérateur (+ - * /% ** & | ^ << >> && ||), il existe une forme correspondante d'opérateur d'affectation abrégé (+ = - = etc.).

Opérateurs arithmétiques Ruby

Supposons que la variable a vaut 10 et la variable b 20, alors -

Opérateur	La description	Exemple
+	Addition - Ajoute des valeurs de chaque côté de l'opérateur.	a + b donnera 30
-	Soustraction - Soustrait l'opérande de droite de l'opérande de gauche.	a - b donnera -10
*	Multiplication - Multiplie les valeurs de chaque côté de l'opérateur.	a * b donnera 200
/	Division - Divise l'opérande de gauche par l'opérande de droite.	b / a donnera 2
%	Module - Divise l'opérande de gauche par l'opérande de droite et renvoie le reste.	b% a donnera 0
**	Exposant - Effectue un calcul exponentiel (puissance) sur les opérateurs.	a ** b donnera 10 à la puissance 20

Opérateurs de comparaison Ruby

Supposons que la variable a vaut 10 et la variable b 20, alors -

Opérateur	La description	Exemple
==	Vérifie si la valeur de deux opérandes est égale ou non, si oui, la condition devient vraie.	(a == b) n'est pas vrai.
! =	Vérifie si la valeur de deux opérandes est égale ou non, si les valeurs ne sont pas égales, la condition devient vraie.	(a! = b) est vrai.
>	Vérifie si la valeur de l'opérande gauche est supérieure à la valeur de l'opérande droit, si oui, la condition devient vraie.	(a> b) n'est pas vrai.
<	Vérifie si la valeur de l'opérande gauche est inférieure à la valeur de l'opérande droit, si oui, la condition devient vraie.	(a <b) est vrai.
> =	Vérifie si la valeur de l'opérande gauche est supérieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie.	(a> = b) n'est pas vrai.
<=	Vérifie si la valeur de l'opérande gauche est inférieure ou égale à la valeur de l'opérande droit, si oui, la condition devient vraie.	(a <= b) est vrai.
<=>	Opérateur de comparaison combiné. Renvoie 0 si le premier opérande est égal au second, 1 si le premier opérande est supérieur au second et -1 si le premier opérande est inférieur au second.	(a <=> b) renvoie -1.
===	Utilisé pour tester l'égalité dans une clause when d'une instruction case .	(1 ... 10) === 5 renvoie vrai.
.eql?	Vrai si le récepteur et l'argument ont à la fois le même type et des valeurs égales.	1 == 1.0 renvoie vrai, mais 1.eql? (1.0) est faux.
égal?	Vrai si le récepteur et l'argument ont le même identifiant d'objet.	si aObj est un double de bObj alors aObj == bObj est vrai, a.equal? ​​bObj est faux mais a.equal? ​​aObj est vrai.

Opérateurs d'affectation Ruby

Supposons que la variable a vaut 10 et la variable b 20, alors -

Opérateur	La description	Exemple
=	Opérateur d'affectation simple, affecte les valeurs des opérandes du côté droit à l'opérande du côté gauche.	c = a + b attribuera la valeur de a + b dans c
+ =	Ajouter l'opérateur d'affectation AND, ajoute l'opérande droit à l'opérande gauche et attribue le résultat à l'opérande gauche.	c + = a équivaut à c = c + a
- =	Soustraire l'opérateur d'affectation ET, soustraire l'opérande droit de l'opérande gauche et affecter le résultat à l'opérande gauche.	c - = a équivaut à c = c - a
* =	Multipliez l'opérateur d'affectation ET, multiplie l'opérande droit par l'opérande gauche et affectez le résultat à l'opérande gauche.	c * = a équivaut à c = c * a
/ =	Opérateur d'affectation de division ET, divise l'opérande de gauche par l'opérande de droite et affecte le résultat à l'opérande de gauche.	c / = a équivaut à c = c / a
% =	Opérateur d'assignation de module ET, prend le module en utilisant deux opérandes et affecte le résultat à l'opérande de gauche.	c% = a équivaut à c = c% a
** =	Opérateur d'affectation exposant AND, effectue un calcul exponentiel (puissance) sur les opérateurs et attribue une valeur à l'opérande de gauche.	c ** = a équivaut à c = c ** a

Affectation parallèle Ruby

Ruby prend également en charge l'affectation parallèle de variables. Cela permet à plusieurs variables d'être initialisées avec une seule ligne de code Ruby. Par exemple -

a = 10
b = 20
c = 30

Cela peut être déclaré plus rapidement en utilisant l'affectation parallèle -

a, b, c = 10, 20, 30

L'affectation parallèle est également utile pour permuter les valeurs contenues dans deux variables -

a, b = b, c

Opérateurs Ruby Bitwise

L'opérateur au niveau du bit fonctionne sur les bits et effectue des opérations bit par bit.

Supposons si a = 60; et b = 13; maintenant au format binaire, ils seront comme suit -

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

Les opérateurs Bitwise suivants sont pris en charge par le langage Ruby.

Opérateur	La description	Exemple
&	L'opérateur binaire AND copie un bit dans le résultat s'il existe dans les deux opérandes.	(a & b) donnera 12, qui est 0000 1100
|	L'opérateur OR binaire copie un bit s'il existe dans l'un ou l'autre des opérandes.	(a | b) donnera 61, soit 0011 1101
^	L'opérateur XOR binaire copie le bit s'il est défini dans un opérande mais pas dans les deux.	(a ^ b) donnera 49, soit 0011 0001
~	L'opérateur de complément Binary Ones est unaire et a pour effet de «retourner» les bits.	(~ a) donnera -61, qui est 1100 0011 en forme de complément à 2 en raison d'un nombre binaire signé.
<<	Opérateur de décalage binaire gauche. La valeur des opérandes de gauche est déplacée vers la gauche du nombre de bits spécifié par l'opérande de droite.	a << 2 donnera 240, soit 1111 0000
>>	Opérateur de décalage binaire vers la droite. La valeur des opérandes de gauche est déplacée vers la droite du nombre de bits spécifié par l'opérande de droite.	un >> 2 donnera 15, soit 0000 1111

Opérateurs logiques Ruby

Les opérateurs logiques suivants sont pris en charge par le langage Ruby

Supposons que la variable a vaut 10 et la variable b 20, alors -

Opérateur	La description	Exemple
et	Opérateur logique ET appelé. Si les deux opérandes sont vrais, la condition devient vraie.	(a et b) est vrai.
ou	Opérateur OU logique appelé. Si l'un des deux opérandes est différent de zéro, la condition devient vraie.	(a ou b) est vrai.
&&	Opérateur logique ET appelé. Si les deux opérandes sont différents de zéro, la condition devient vraie.	(a && b) est vrai.
||	Opérateur OU logique appelé. Si l'un des deux opérandes est différent de zéro, la condition devient vraie.	(a || b) est vrai.
!	Opérateur PAS logique appelé. Utilisez pour inverser l'état logique de son opérande. Si une condition est vraie, alors l'opérateur logique NOT rendra faux.	! (a && b) est faux.
ne pas	Opérateur PAS logique appelé. Utilisez pour inverser l'état logique de son opérande. Si une condition est vraie, alors l'opérateur logique NOT rendra faux.	not (a && b) est faux.

Opérateur ternaire rubis

Il existe un autre opérateur appelé opérateur ternaire. Il évalue d'abord une expression pour une valeur vraie ou fausse, puis exécute l'une des deux instructions données en fonction du résultat de l'évaluation. L'opérateur conditionnel a cette syntaxe -

Opérateur	La description	Exemple
? :	Expression conditionnelle	Si la condition est vraie? Alors valeur X: Sinon valeur Y

Opérateurs de la gamme Ruby

Les plages de séquence dans Ruby sont utilisées pour créer une plage de valeurs successives - consistant en une valeur de début, une valeur de fin et une plage de valeurs intermédiaires.

Dans Ruby, ces séquences sont créées à l'aide des opérateurs de plage ".." et "...". Le formulaire à deux points crée une plage inclusive, tandis que le formulaire à trois points crée une plage qui exclut la valeur élevée spécifiée.

Opérateur	La description	Exemple
..	Crée une plage allant du point de départ au point final inclus.	1..10 Crée une plage de 1 à 10 inclus.
...	Crée une plage du point de départ au point de fin exclusif.	1 ... 10 Crée une plage de 1 à 9.

Ruby défini? Les opérateurs

défini? est un opérateur spécial qui prend la forme d'un appel de méthode pour déterminer si l'expression passée est définie ou non. Il renvoie une chaîne de description de l'expression, ou nil si l'expression n'est pas définie.

Il existe diverses utilisations de défini? Opérateur

Utilisation 1

defined? variable # True if variable is initialized

For Example

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

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

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

Utilisation 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 "." et Opérateurs Double Colon "::"

Vous appelez une méthode de module en faisant précéder son nom du nom du module et d'un point, et vous référencez une constante en utilisant le nom du module et deux deux-points.

le :: est un opérateur unaire qui permet: des constantes, des méthodes d'instance et des méthodes de classe définies dans une classe ou un module, d'être accessibles de n'importe où en dehors de la classe ou du module.

Remember dans Ruby, les classes et les méthodes peuvent également être considérées comme des constantes.

Vous devez simplement préfixer le :: Const_name avec une expression qui renvoie la classe ou l'objet module approprié.

Si aucune expression de préfixe n'est utilisée, la classe Object principale est utilisée par défaut.

Voici deux exemples -

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

Priorité des opérateurs Ruby

Le tableau suivant répertorie tous les opérateurs de la priorité la plus élevée à la plus basse.

Méthode	Opérateur	La description
Oui	::	Opérateur à résolution constante
Oui	[] [] =	Référence d'élément, jeu d'éléments
Oui	**	Exponentiation (élever au pouvoir)
Oui	! ~ + -	Not, complément, unaire plus et moins (les noms de méthode pour les deux derniers sont + @ et - @)
Oui	* /%	Multiplier, diviser et modulo
Oui	+ -	Addition et soustraction
Oui	>> <<	Décalage du bit à droite et à gauche
Oui	&	Bitwise 'ET'
Oui	^ |	`` OR '' exclusif au niveau du bit et `` OR '' régulier
Oui	<= <>> =	Opérateurs de comparaison
Oui	<=> == ===! = = ~! ~	Opérateurs d'égalité et de correspondance de modèle (! = Et! ~ Ne peuvent pas être définis comme des méthodes)
	&&	'ET' logique
	||	'OU' logique
	.. ...	Gamme (inclusive et exclusive)
	? :	Ternaire si-alors-autre
	=% = {/ = - = + = | = & = >> = << = * = && = || = ** =	Affectation
	défini?	Vérifiez si le symbole spécifié est défini
	ne pas	Négation logique
	ou et	Composition logique

NOTE- Les opérateurs avec un Oui dans la colonne de méthode sont en fait des méthodes et peuvent donc être remplacés.