Sissejuhatus skaalaoperaatoritesse
Operaatoreid kasutatakse loogiliste ja matemaatiliste arvutuste tegemiseks mis tahes programmeerimiskeeles. Scalal on ka mitmesuguseid operaatoreid, kes teostavad erinevaid arvutusi ja ülesandeid, kuid neid rakendatakse meetoditena, kuna Scala on objektorienteeritud keel, seetõttu käsitletakse iga sümbolit objektina ja toimingut meetodina. Need muudavad arvutamise lihtsaks ja hõlpsaks.
Scalas tegutsevad erinevad operaatorid on:
- Aritmeetikaoperaatorid
- Tööülesannete täitjad
- Suhteoperaatorid
- Loogilised operaatorid
- Bitwise operaatorid
Uurime nüüd iga operaatorit üksikasjalikult.
Scala aritmeetikaoperaatorid
Neid operaatoreid kasutatakse matemaatiliste arvutuste või arvutuste tegemiseks.
| Operaator | Sümbol | Seletus | Vorming |
| Lisamine | + | Lisab mõlemad operandid | x + y |
| Lahutamine | - | Lahutab vasakust parema operandi | x - y |
| Korrutamine | * | Korrutab mõlemad operandid | x * y |
| Jaoskond | / | Jagage lugeja nimetaja järgi | x / a |
| Moodul | % | Tagastab pärast jagamist ülejäänud summa | x% y |
Näide: aritmeetikaoperaatorid Scalas
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)
)
)
Väljund:
scala> Arith.main (null)
15
5
50
2
0
Scala määramise operaatorid
Neid operaatoreid kasutatakse muutujale või objektile väärtuste määramiseks.
| Operaator | Sümbol | Seletus | Vorming |
| Ülesanne | = | Määrab parema operandi väärtuse vasakule operandile | x = y + z |
| Lisamine | + = | Lisab mõlemad operandid ja määrab lõpuks vasakule operandile väärtuse | x + = y |
| Lahutamine | - = | Lahutab vasakult parema operandi ja seejärel annab vasakule operandile väärtuse | x - = y |
| Korrutamine | * = | Korrutab mõlemad operandid ja määrake vasakpoolsele operandile väärtus | x * = y |
| Jaoskond | / = | Jaga vasak operand parempoolse operandiga ja määra vasakpoolsele operandile väärtus | x / = y |
| Moodul | % = | Hindab kahe operandi moodulit ja määrab vasakule operandile väärtuse | x% = y |
| Bitwise JA | & = | Võrreldakse kahe operandi kahendväärtust, tagastage 1, kui mõlemad operandid on veel 1, tagastage 0 ja määrake väärtus vasakule operandile | x & = 5 |
| Bitwise VÕI | | = | Võrreldakse kahe operandi kahendväärtust, tagastage 0, kui mõlemad operandid on 0, tagastage 1 ja määrake väärtus vasakule operandile | x | = 5 |
| Bitwise XOR | = | Võrdleb kahe operandi kahendväärtust, tagastage 0, kui mõlemad operandid on samad, tagastage 1 ja määrake väärtus vasakule operandile | x = 5 |
| Vasak Shift | << = | Nihutab bitid vasakule ja määrake tulemus vasakule operandile | x << = 5 |
| Parempoolne nihe | >> = | Nihutab bitid paremale ja määrake tulemus vasakule operandile | x >> = 5 |
Näide: määramisoperaatorid Scalasobject 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);
)
)
Väljund:
scala> Assign.main (null)
15
10
50
10
0
4
11
4
16
4
Scala suhtelised operaatorid
Need operaatorid tagastavad tõeväärtuse pärast nimetatud tingimuste kontrollimist.
| Operaator | Sümbol | Seletus | Vorming |
| Võrdne | == | Tagastab tõese, kui mõlemad operandid on võrdsed, tagastab vale | x == y |
| Pole võrdne | ! = | Tagastab tõese, kui mõlemad operandid pole võrdsed, tagastab vale | x! = y |
| Suurem kui | > | Tagastab tõese, kui vasakpoolne operand on suurem kui parem, tagastab vale | x> y |
| Vähem kui | < | Tagastab tõese, kui vasakpoolne operand on väiksem kui parem, tagastab vale | x <a |
| Suurem või võrdne | > = | Tagastab tõesuse, kui vasakpoolne operand on suurem või võrdne parempoolsega, tagastab vale | x> = y |
| Vähem või võrdne | <= | Tagastab tõese, kui vasakpoolne operand on väiksem või sellega võrdne, paremal juhul tagastab vale | x <= y |
Näide: Skaala relatsioonioperaatorid
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);
)
)
Väljund:
scala> Suhe.main (null)
vale
tõsi
tõsi
vale
tõsi
vale
Scala loogiline operaator
Need operaatorid tagastavad ka sisendite või operandide järgi tõeväärtuse.
| Operaator | Sümbol | Seletus | Vorming |
| Loogiline JA | && | Tagastab tõese, kui mõlemad operandid ei ole null, vastasel juhul tagastatakse vale | x && y |
| Loogiline VÕI | || | Tagastab tõese, kui mõni operandidest on null, vastasel juhul tagastab vale | x || y |
| Loogiline EI | ! | See keerab operandi ümber. Tagastab tõese vale ja vastupidi | ! x |
Näide: loogilised operaatorid Scalas
object Logic (
def main (args: Array (String)) (
var a = true;
var b = false;
println (a && b);
println (a || b);
println !(b);
)
)
Väljund:
scala> Logic.main (null)
vale
tõsi
tõsi
Scala Bitwise operaatorid
Need operaatorid töötavad bittide kallal ja tagastavad väljundina vastava täisarvu.
| Operaator | Sümbol | Seletus | Vorming |
| Binaarne JA | & | Kontrollige operandid bitti ja naaske 1, kui mõlemad bitid on 1, vastaselt 0 | x ja y |
| Binaarne VÕI | | | Kontrollige operandid bittide kaupa ja tagastage 0, kui mõlemad bitid on 0, vastasel juhul pöörduge tagasi 1 | x | y |
| Binaarne XOR | ^ | Kontrollige operandid bitti ja tagastage väärtus 0, kui mõlemad bitid on samad, tagastage 1 | x y |
| Binaarne EI | ~ | Tagastab komplemendi, st muudab 1 väärtuseks 0 ja vastupidi | ~ x |
| Binaarne vasakpoolne vahetus | << | Vasakpoolse operandi bitid nihutatakse vasakule küljele parempoolse operandi nimetatud bittide arvu võrra | x << 3 |
| Binaarne parempoolne nihutamine | >> | Vasakpoolse operandi bitti nihutatakse paremale poole parempoolse operandi nimetatud bittide arvu võrra | x >> 3 |
| Binaarne paremklahvi nulltäide | >>> | Vasakpoolse operandi bitti nihutatakse parempoolse operandi poolt mainitud bittide arvu võrra ja nihutatud väärtused on asendatud bu nullidega. | x >>> 3 |
Näide: Bitwise operaatorid Scalas
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);
)
)
Väljund:
skala> natuke. peamine (null)
0
15
15
10
4
64
4
Soovitatavad artiklid
See on olnud Scala Operaatorite juhend. Siin käsitleme erinevaid skaalaoperaatorite tüüpe, näiteks aritmeetikaoperaatorid, ülesandeoperaatorid, relatsioonioperaatorid, loogilised operaatorid ja Bitwise-operaatorid. Lisateabe saamiseks võite vaadata ka järgmisi artikleid -
- Scala kasutusalad
- Haskell vs Scala
- Scala: funktsionaalne lähenemine
- MySQL-i operaatorid