Opérateurs Scala
Que sont les opérateurs à Scala?
L'opérateur est associé au code et à la syntaxe uniques qui s'exécutent pour effectuer une tâche. Les opérateurs sont utilisés entre les opérandes. Ces opérandes peuvent être un ou plusieurs basés sur l'opération.
Types et exemples d'opérateurs Scala dans Ubuntu 20.04?
Il existe une vaste gamme d'opérations dans le langage de programmation Scala. Nous discuterons des opérateurs communs avec leurs sous-types ainsi que les codes d'exemple.
Exemple # 1: Utilisation de l'opérateur arithmétique à Scala
Comme son nom l'indique, ils sont utilisés pour effectuer l'arithmétique ou vous pouvez dire des opérations mathématiques entre deux valeurs. Voici les opérateurs arithmétiques largement utilisés dans Scala.
Ajout: Le signe de l'opérateur d'addition est «+» qui ajoute deux variables ou opérandes.
Soustraction: Indiqué par le signe «-». L'opérateur utilisé entre les deux valeurs pour soustraire.
Multiplication: L'opérateur utilise le signe «*» pour multiplier deux opérandes ou plus.
Division: La division des opérateurs est indiquée avec le signe «/» divise le premier opérande par le second.
Exposant: Il spécifie avec le signe «**» connu sous le nom de puissance. Il renvoie la valeur exponentielle de l'opérande.
Exécutons l'exemple. Ici ci-dessous, nous avons initialisé les variables avec différentes valeurs et dans l'instruction IMPREST, nous avons appelé toutes les opérations arithmétiques.
Les valeurs de sortie de toutes les opérations arithmétiques sont présentées dans l'image ci-dessous.
Exemple # 2: Utilisation de l'opérateur relationnel à Scala
L'opérateur relationnel définit la comparaison entre l'opérande qui est également connu sous le nom d'opérateur de comparaison. L'opérateur est utilisé sur les instructions conditionnelles et renvoie la valeur booléenne True ou False. Voici les sous-types d'opérateurs relationnels.
Égal à (=): L'égalité à l'opérateur compare les deux opérandes, qu'ils soient égaux ou non et renvoient une valeur booléenne vraie autrement false.
Pas égal à (!=): L'opérateur est utilisé pour comparaison si deux opérandes ne sont pas égaux à une condition donnée.
Supérieur à (>): Il est utilisé pour vérifier les valeurs plus élevées de l'opérande donné. Si la valeur donnée doit être supérieure à celle des renvoyages autrement faux.
Moins que (<): L'opérateur moins que celle est utilisé pour vérifier la valeur plus petite de l'opérande donné et retourne vraie si l'opérande est plus petit que le deuxième opérande sinon nous avons une fausse valeur.
Inférieur à l'égal à (<=): Il est utilisé pour vérifier qu'un opérande donné doit être plus petit et égal au deuxième opérande. En fin de compte, nous aurons des conditions vraies ou fausses.
Nous avons un exemple de code d'opérateurs relationnels ci-dessous. Comme vous pouvez le voir, nous avons utilisé tous les opérateurs discutés ci-dessus dans les opérateurs relationnels. Grâce à la fonction d'impression, nous pouvons avoir les résultats de sortie.
Comme affichant la valeur de résultat de sortie en utilisant des opérateurs relationnels.
Exemple # 3: Utilisation de l'opérateur logique à Scala
L'opérateur logique est utilisé pour associer la sortie logique comme une vraie valeur ou une fausse valeur. Il inverse également la sortie logique d'un opérande conditionnel.
Logique et (&&): L'opérateur et l'opérateur entre deux opérandes renvoie une vraie valeur si les deux opérandes sont des valeurs non nulles car 1 autre renvoie false.
Logique ou (||): Si l'un des opérandes donnés est non nul dans le logique ou l'opérateur, nous aurons vrai en tant que valeur de retour sinon faux est la valeur de retour.
Logique pas (!): Il donnera la valeur inverse de l'opérande étant donné i.e. Si vrai alors false vice versa.
Maintenant, nous avons un exemple de code. Nous avons initialisé une valeur booléenne dans une variable. La fonction d'impression renverra la sortie de la variable après avoir utilisé des opérateurs logiques.
La sortie est illustrée ci-dessous sur l'écran du terminal.
Exemple # 4: Utilisation de l'opérateur bitwise à Scala
L'opérateur bit. Ci-dessous, nous avons des opérateurs bit.
Bitwise et (&): L'opérateur prend deux opérandes et effectue l'opération «et» à chaque valeur bit.
Bitwise ou (|): Il vérifie le fonctionnement du bit sur chaque opérande donné si les valeurs de bit sont nulles ou non. Si les deux bits sont nuls, il retournera 0 autrement, il renverra 1 en tant que sortie.
Xor bit (^): Si les deux bits sont les mêmes, il retournera 0 Else Retour 1. Il vérifiera l'opérande.
Bitwise -not (~): La valeur que nous aurons après avoir utilisé le bit-dans le bit n'est pas une valeur de complément de l'opérande. Il passe de 1 à 0 et vice versa.
Shift gauche à gauche (<<): Dans cet opérateur, les opérandes se sont déplacés vers le côté gauche par un nombre si le bit est donné dans le côté droit de l'opérande
Shift à droite bitwise (>>): L'opérateur a déplacé le bit de l'opérande gauche vers le côté droit par plusieurs bits spécifiés par l'opérande droit
Bitwise à droite à droite zéro remplissage (>>>): Il déplace l'opérande gauche vers la droite par l'opérande droit avec un nombre spécifique de bits et le zéro est rempli de valeurs décalées.
Ayons un exemple de code de l'opérateur bitwise. Nous avons utilisé tous les opérateurs de bit mentionnés ci-dessus.
La valeur de sortie que nous obtenons de différents opérateurs d'affectation est sur l'écran ci-dessous.
Conclusion
Dans l'article, nous avons une discussion profonde sur les opérateurs de Scala. Nous avons appris quatre principaux opérateurs qui incluent l'opérateur arithmétique, l'opérateur logique, l'opérateur relationnel et l'opérateur de bit. De plus, nous avons une grande compréhension des sous-types d'opérateurs avec leurs codes d'exemple en cours d'exécution. Ce guide aidera les scripts Scala.