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 वर्ण के आधार पर निम्नलिखित रूपरेखा देता है। उदा > ऑपरेटर में पहला वर्ण है >>> :
| ऑपरेटर |
|---|
| (अन्य सभी विशेष पात्र) |
* / % |
+ - |
: |
= ! |
< > |
& |
^ |
| |
| (सभी पत्र) |
| (सभी असाइनमेंट ऑपरेटर) |
इस नियम का एक अपवाद असाइनमेंट ऑपरेटर्स की चिंता करता है , जैसे += , *= , आदि। यदि कोई ऑपरेटर समान वर्ण (=) के साथ समाप्त होता है और तुलना ऑपरेटरों में से एक नहीं है <= , >= , == या != फिर ऑपरेटर की पूर्ववर्ती स्थिति साधारण असाइनमेंट के समान है। दूसरे शब्दों में, किसी भी अन्य ऑपरेटर की तुलना में कम है।
