Scala Language
स्काला में ऑपरेटर
खोज…
बिल्ट इन ऑपरेटर्स
स्काला में निम्नलिखित अंतर्निहित ऑपरेटर (पूर्वनिर्धारित पूर्ववर्ती नियमों के साथ विधियाँ / भाषा तत्व) हैं:
प्रकार | प्रतीक | उदाहरण |
---|---|---|
अंकगणितीय आपरेटर | + - * / % | a + b |
संबंधपरक संकारक | == != > < >= <= | a > b |
लॉजिकल ऑपरेटर्स | && & || | ! | a && b |
बिट-वार ऑपरेटर | & | ^ ~ << >> >>> | a & b , ~a , a >>> b |
असाइनमेंट ऑपरेटर | = += -= *= /= %= <<= >>= &= ^= | = | | a += b |
जावा में स्कैला संचालकों का वही अर्थ है
ध्यान दें : के साथ समाप्त होने वाले तरीके :
दाईं ओर (और दाईं ओर साहचर्य) से list.::(value)
, इसलिए value :: list
साथ कॉल करें । value :: list
list.::(value)
value :: list
रूप में लिखा जा सकता है value :: list
ऑपरेटर सिंटैक्स के साथ value :: list
। ( 1 :: 2 :: 3 :: Nil
1 :: (2 :: (3 :: Nil))
)
ऑपरेटर ओवरलोडिंग
स्काला में आप अपने स्वयं के ऑपरेटरों को परिभाषित कर सकते हैं:
class Team {
def +(member: Person) = ...
}
उपरोक्त परिभाषित के साथ आप इसका उपयोग कर सकते हैं जैसे:
ITTeam + Jack
या
ITTeam.+(Jack)
unary_
संचालकों को परिभाषित करने के लिए आप इसे unary_
साथ उपसर्ग कर सकते हैं। जैसे unary_!
class MyBigInt {
def unary_! = ...
}
var a: MyBigInt = new MyBigInt
var b = !a
संचालक वरीयता
वर्ग | ऑपरेटर | संबद्धता |
---|---|---|
पोस्टफ़िक्स | () [] | बाएं से दाएं |
एकल | ! ~ | दाएं से बाएं |
गुणक | * / % | बाएं से दाएं |
additive | + - | बाएं से दाएं |
खिसक जाना | >> >>> << | बाएं से दाएं |
संबंधपरक | > >= < <= | बाएं से दाएं |
समानता | == != | बाएं से दाएं |
बिटवाइज़ और | & | बाएं से दाएं |
बिटवाइज़ Xor | ^ | बाएं से दाएं |
बिटवाइज या | | | बाएं से दाएं |
तार्किक और | && | बाएं से दाएं |
तार्किक या | || | बाएं से दाएं |
असाइनमेंट | = += -= *= /= %= >>= <<= &= ^= | = | | दाएं से बाएं |
अल्पविराम | , | बाएं से दाएं |
स्काला में प्रोग्रामिंग ऑपरेटर में 1 वर्ण के आधार पर निम्नलिखित रूपरेखा देता है। उदा >
ऑपरेटर में पहला वर्ण है >>>
:
ऑपरेटर |
---|
(अन्य सभी विशेष पात्र) |
* / % |
+ - |
: |
= ! |
< > |
& |
^ |
| |
(सभी पत्र) |
(सभी असाइनमेंट ऑपरेटर) |
इस नियम का एक अपवाद असाइनमेंट ऑपरेटर्स की चिंता करता है , जैसे +=
, *=
, आदि। यदि कोई ऑपरेटर समान वर्ण (=) के साथ समाप्त होता है और तुलना ऑपरेटरों में से एक नहीं है <=
, >=
, ==
या !=
फिर ऑपरेटर की पूर्ववर्ती स्थिति साधारण असाइनमेंट के समान है। दूसरे शब्दों में, किसी भी अन्य ऑपरेटर की तुलना में कम है।