Introduktion till Scala-operatörer
Operatörer används för att utföra logisk och matematisk beräkning på alla programmeringsspråk. Scala har också olika operatörer för att utföra olika beräkningar och uppgifter, men de implementeras som metoder eftersom Scala är ett objektorienterat språk, varför den behandlar varje symbol som objekt och operation som en metod. De gör beräkningen enkel och enkel.
Olika operatörer som finns i Scala är:
- Aritmetiska operatörer
- Uppdragsoperatörer
- Relationsoperatörer
- Logiska operatörer
- Bitvisa operatörer
Låt oss nu studera varje operatör i detalj.
Scala aritmetiska operatörer
Dessa operatörer används för att utföra matematiska beräkningar eller beräkningar.
| Operatör | Symbol | Förklaring | Formatera |
| Tillägg | + | Lägger till båda operanderna | x + y |
| Subtraktion | - | Drar från höger operand från vänster | x - y |
| Multiplikation | * | Multipliserar båda operanderna | x * y |
| Division | / | Dela upp telleren med nämnaren | x / å |
| modul | % | Returnerar resten efter uppdelning | x% y |
Exempel: Aritmetiska operatörer i Scala
object Arith (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a + b);
println (a – b);
println (a * b);
println (a / b);
println (a % b)
)
)
Produktion:
scala> Arith.main (null)
15
5
50
2
0
Scala tilldelningsoperatörer
Dessa operatörer används för att tilldela värden till en variabel eller ett objekt.
| Operatör | Symbol | Förklaring | Formatera |
| Uppdrag | = | Tilldelar värdet på höger operand till vänster operand | x = y + z |
| Tillägg | + = | Lägger till båda operanderna och tilldelar slutligen värdet till vänsteroperand | x + = y |
| Subtraktion | - = | Subtraherar höger operand från vänster och tilldelar sedan värdet till vänster operand | x - = y |
| Multiplikation | * = | Multipliserar båda operanderna och tilldelar värdet till vänsteroperand | x * = y |
| Division | / = | Dela vänsteroperand med höger operand och tilldela värdet till vänsteroperand | x / = y |
| modul | % = | Utvärderar modul för två operander och tilldelar värdet till vänster operand | x% = y |
| Bitvis OCH | & = | Jämför det binära värdet för två operander, returnera 1 om båda operandarna är 1 annars return 0 och tilldela värdet till vänster operand | x & = 5 |
| Bitvis ELLER | | = | Jämför det binära värdet för två operander, returnera 0 om båda operanderna är 0 annars returnera 1 och tilldela värdet till vänster operand | x | = 5 |
| Bitvis XOR | = | Jämför det binära värdet för två operander, returnera 0 om båda operanderna är samma annars returnera 1 och tilldela värdet till vänster operand | x = 5 |
| Vänster Shift | << = | Flyttar bitarna mot vänster och tilldelar resultatet till vänsteroperand | x << = 5 |
| Höger skift | >> = | Skifter bitarna åt höger och tilldelar resultatet till vänsteroperand | x >> = 5 |
Exempel: Uppdragsoperatörer i Scalaobject Assign (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a += b);
println (a –= b);
println (a *= b);
println (a /= b);
println (a %= b);
a = 20;
b = 15;
println (a &= b);
println (a |= b);
println (a ^= b);
println (a <<= 2);
println (a >>= 2);
)
)
Produktion:
scala> Assign.main (null)
15
10
50
10
0
4
11
4
16
4
Scala Relational Operators
Dessa operatörer returnerar booleskt värde efter kontroll av de nämnda villkoren.
| Operatör | Symbol | Förklaring | Formatera |
| Lika med | == | Returnerar sant om båda operanderna är lika annars returnerar falskt | x == y |
| Inte lika med | ! = | Returnerar sant om båda operanderna inte är lika annars returnerar falskt | x! = y |
| Större än | > | Returnerar sant om den vänstra operand är större än höger annars returnerar falsk | x> y |
| Mindre än | < | Returnerar sant om den vänstra operanden är mindre än höger annars returnerar falsk | x <y |
| Större än eller lika med | > = | Returnerar sant om den vänstra operanden är större än eller lika med höger annars returnerar falsk | x> = y |
| Mindre än eller lika med | <= | Returnerar sant om den vänstra operanden är mindre än eller lika med höger annars returnerar falsk | x <= y |
Exempel: Relationsoperatörer i skala
object Relation (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a == b);
println (a != b);
println (a > b);
println (a < b);
println (a >= b);
println (a <= b);
)
)
Produktion:
scala> Relation.main (null)
falsk
Sann
Sann
falsk
Sann
falsk
Scala Logical Operator
Dessa operatörer returnerar också booleskt värde beroende på ingångar eller operander.
| Operatör | Symbol | Förklaring | Formatera |
| Logiskt OCH | && | Returnerar sant om båda operanderna är icke noll annars returnerar falsk | x && y |
| Logisk ELLER | || | Återlämnar sant om någon av operanderna är noll, annars är falsk | x || y |
| Logiskt INTE | ! | Det vänder operanden. Returnerar sant för falskt och vice versa | ! x |
Exempel: Logiska operatörer i Scala
object Logic (
def main (args: Array (String)) (
var a = true;
var b = false;
println (a && b);
println (a || b);
println !(b);
)
)
Produktion:
scala> Logic.main (null)
falsk
Sann
Sann
Scala Bitvis-operatörer
Dessa operatörer arbetar på bitar och returnerar motsvarande heltal som utgång.
| Operatör | Symbol | Förklaring | Formatera |
| Binär OCH | & | Kontrollera operanterna bitvis och returnera 1 om båda bitarna är 1 annars returnerar 0 | x & y |
| Binär ELLER | | | Kontrollera operanderna bitvis och returnera 0 om båda bitarna är 0 annars returnerar 1 | x | y |
| Binär XOR | ^ | Kontrollera operanderna bitvis och returnera 0 om båda bitarna är samma annars returnerar 1 | x y |
| Binär INTE | ~ | Returnerar komplement, dvs ändringar 1 till 0 och vice versa | ~ x |
| Binär vänsterförskjutning | << | Den vänstra operandens bitar flyttas till vänster med antalet bitar som nämns av den högra operanden | x << 3 |
| Binary Right Shift | >> | Den vänstra operandens bitar flyttas till höger med antalet bitar som nämns av den högra operanden | x >> 3 |
| Binary Right Shift zero fill | >>> | Bitarna i den vänstra operanden skiftas höger med antalet bitar som nämns av höger operand och skiftade värden är ersatta bu nollor. | x >>> 3 |
Exempel: Bitvisa operatörer i Scala
object Bit (
def main (args: Array (String)) (
var a = 10;
var b = 5;
println (a & b);
println (a | b);
println (a b);
println ( ~ b);
a = 16;
b = 12;
println (a >> b);
println (a << b);
println (a >>> b);
)
)
Produktion:
skala> Bit. huvud (null)
0
15
15
10
4
64
4
Rekommenderade artiklar
Detta har varit en guide till Scala Operators. Här diskuterar vi olika typer av Scala-operatörer som aritmetiska operatörer, tilldelningsoperatörer, relationella operatörer, logiska operatörer och bitvisoperatörer med exempel. Du kan också titta på följande artiklar för att lära dig mer -
- Användningar av Scala
- Haskell vs Scala
- Scala: Den funktionella strategin
- MySQL-operatörer