scala - स्कैला के प्रतीकात्मक ऑपरेटरों का क्या मतलब है?




operators (6)

स्कैला वाक्यविन्यास में बहुत सारे प्रतीक हैं। चूंकि इस तरह के नाम खोज इंजन का उपयोग करना मुश्किल है, इसलिए उनमें से एक व्यापक सूची उपयोगी होगी।

स्कैला में सभी प्रतीकों क्या हैं, और उनमें से प्रत्येक क्या करता है?

विशेष रूप से, मैं -> , ||= , ++= , <= , _._ , :: , और :+= बारे में जानना चाहता हूं।


आप कुछ मानदंडों के अनुसार उनको पहले समूह कर सकते हैं। इस पोस्ट में मैं सिर्फ अंडरस्कोर चरित्र और दायां तीर समझाऊंगा।

_._ में एक अवधि है। स्काला में एक अवधि हमेशा एक विधि कॉल इंगित करता है। तो उस अवधि के बाएं जो आपके पास रिसीवर है, और इसका अधिकार संदेश (विधि का नाम) है। अब _ में एक विशेष प्रतीक है। इसके बारे में कई पोस्ट हैं, उदाहरण के लिए इस ब्लॉग एंट्री सभी मामलों का उपयोग करें। यहां यह एक अज्ञात फ़ंक्शन शॉर्ट कट है , यह एक फ़ंक्शन के लिए शॉर्टकट है जो एक तर्क लेता है और उस पर विधि _ को आमंत्रित करता है। अब _ एक वैध विधि नहीं है, इसलिए निश्चित रूप से आप _._1 या कुछ समान देख रहे थे, यानी, फ़ंक्शन तर्क पर विधि _._1 आह्वान करना। _1 से _22 tuples के तरीके हैं जो एक ट्यूपल के एक विशेष तत्व निकालें। उदाहरण:

val tup = ("Hallo", 33)
tup._1 // extracts "Hallo"
tup._2 // extracts 33

अब फ़ंक्शन एप्लिकेशन शॉर्टकट के लिए उपयोग केस मान लें। एक नक्शा दिया गया है जो तारों के पूर्णांक को मानचित्र करता है:

val coll = Map(1 -> "Eins", 2 -> "Zwei", 3 -> "Drei")

Wooop, एक अजीब विराम चिह्न की एक और घटना पहले से ही है। हाइफ़न और वर्णों से अधिक, जो दायां हाथ तीर जैसा दिखता है, एक ऑपरेटर है जो Tuple2 उत्पन्न करता है। तो लिखने के नतीजे में कोई अंतर नहीं है (1, "Eins") या 1 -> "Eins" , केवल बाद में पढ़ने के लिए आसान है, विशेष रूप से मानचित्र उदाहरण जैसे tuples की सूची में। -> कोई जादू नहीं है, यह कुछ अन्य ऑपरेटरों की तरह है, क्योंकि उपलब्ध है क्योंकि आपके पास ऑब्जेक्ट Predef में सभी अंतर्निहित रूपांतरण हैं। दायरे में Predef । यहां जो रूपांतरण होता है वह है

implicit def any2ArrowAssoc [A] (x: A): ArrowAssoc[A] 

जहां ArrowAssoc में -> विधि है जो Tuple2 । इस प्रकार 1 -> "Eins" Predef.any2ArrowAssoc(1).->("Eins") 1 -> "Eins" वास्तव में कॉल Predef.any2ArrowAssoc(1).->("Eins") । ठीक। अंडरस्कोर चरित्र के साथ अब मूल प्रश्न पर वापस जाएं:

// lets create a sequence from the map by returning the
// values in reverse.
coll.map(_._2.reverse) // yields List(sniE, iewZ, ierD)

अंडरस्कोर यहां निम्न समकक्ष कोड को छोटा करता है:

coll.map(tup => tup._2.reverse)

ध्यान दें कि map का map विधि कुंजी के tuple में और फ़ंक्शन तर्क के मान में गुजरता है। चूंकि हम केवल मूल्यों (तारों) में रुचि रखते हैं, इसलिए हम उन्हें tuple पर _2 विधि से निकालते हैं।


इसके बारे में :: एक और प्रविष्टि है जो :: केस को कवर करती है। संक्षेप में, इसका उपयोग हेड एलिमेंट और पूंछ सूची ' consing ' द्वारा Lists बनाने के लिए किया जाता है। यह एक class जो एक cons'ed सूची का प्रतिनिधित्व करता है और जिसे निकालने वाले के रूप में उपयोग किया जा सकता है, लेकिन आमतौर पर यह सूची में एक विधि है । जैसा कि पाब्लो फर्नांडीज बताते हैं, चूंकि यह एक कोलन में समाप्त होता है, यह सही सहयोगी है , जिसका मतलब है कि विधि कॉल का रिसीवर सही है, और ऑपरेटर के बाईं ओर तर्क है। इस तरह आप एक मौजूदा सूची में एक नया हेड तत्व तैयार करने के रूप में सुंदरता व्यक्त कर सकते हैं:

val x = 2 :: 3 :: Nil  // same result as List(2, 3)
val y = 1 :: x         // yields List(1, 2, 3)

यह बराबर है

val x = Nil.::(3).::(2) // successively prepend 3 and 2 to an empty list
val y = x.::(1)         // then prepend 1

एक्स्ट्रेक्टर ऑब्जेक्ट के रूप में उपयोग निम्नानुसार है:

def extract(l: List[Int]) = l match {
   case Nil          => "empty"
   case head :: Nil  => "exactly one element (" + head + ")"
   case head :: tail => "more than one element"
}

extract(Nil)          // yields "empty"
extract(List(1))      // yields "exactly one element (33)"
extract(List(2, 3))   // yields "more than one element"

यह यहां एक ऑपरेटर की तरह दिखता है, लेकिन यह वास्तव में लेखन का एक और (अधिक पठनीय) तरीका है

def extract2(l: List[Int]) = l match {
   case Nil            => "empty"
   case ::(head, Nil)  => "exactly one element (" + head + ")"
   case ::(head, tail) => "more than one element"
}

आप इस पोस्ट में निकालने वालों के बारे में अधिक पढ़ सकते हैं।


बस अन्य उत्कृष्ट उत्तरों में जोड़ना। foldLeft दो अक्सर आलोचनात्मक प्रतीकात्मक ऑपरेटरों, /: ( foldLeft ) और :\ ( foldRight ) ऑपरेटर प्रदान करता है, पहला सही-सहयोगी होता है। तो निम्नलिखित तीन कथन समकक्ष हैं:

( 1 to 100 ).foldLeft( 0, _+_ )
( 1 to 100 )./:( 0 )( _+_ )
( 0 /: ( 1 to 100 ) )( _+_ )

ये तीन हैं:

( 1 to 100 ).foldRight( 0, _+_ )
( 1 to 100 ).:\( 0 )( _+_ )
( ( 1 to 100 ) :\ 0 )( _+_ )

मैं चार श्रेणियों में शिक्षण के उद्देश्य के लिए ऑपरेटरों को विभाजित करता हूं:

  • कीवर्ड / आरक्षित प्रतीक
  • स्वचालित रूप से आयातित विधियां
  • सामान्य तरीकों
  • सिंटेक्टिक शर्करा / संरचना

यह भाग्यशाली है, तो, अधिकांश श्रेणियों को प्रश्न में दर्शाया गया है:

->    // Automatically imported method
||=   // Syntactic sugar
++=   // Syntactic sugar/composition or common method
<=    // Common method
_._   // Typo, though it's probably based on Keyword/composition
::    // Common method
:+=   // Common method

इनमें से अधिकतर तरीकों का सटीक अर्थ उन वर्गों पर निर्भर करता है जो उन्हें परिभाषित कर रहे हैं। उदाहरण के लिए, <= Int अर्थ है "इससे कम या बराबर" । पहला, -> , मैं नीचे उदाहरण के रूप में दे दूंगा। :: शायद List परिभाषित विधि है (हालांकि यह एक ही नाम का ऑब्जेक्ट हो सकता है), और :+= शायद विभिन्न Buffer वर्गों पर परिभाषित विधि है।

तो, चलो उन्हें देखते हैं।

कीवर्ड / आरक्षित प्रतीक

स्कैला में कुछ प्रतीक हैं जो विशेष हैं। उनमें से दो उचित कीवर्ड माना जाता है, जबकि अन्य सिर्फ "आरक्षित" हैं। वो हैं:

// Keywords
<-  // Used on for-comprehensions, to separate pattern from generator
=>  // Used for function types, function literals and import renaming

// Reserved
( )        // Delimit expressions and parameters
[ ]        // Delimit type parameters
{ }        // Delimit blocks
.          // Method call and path separator
// /* */   // Comments
#          // Used in type notations
:          // Type ascription or context bounds
<: >: <%   // Upper, lower and view bounds
<? <!      // Start token for various XML elements
" """      // Strings
'          // Indicate symbols and characters
@          // Annotations and variable binding on pattern matching
`          // Denote constant or enable arbitrary identifiers
,          // Parameter separator
;          // Statement separator
_*         // vararg expansion
_          // Many different meanings

ये भाषा का हिस्सा हैं , और, जैसा कि, किसी भी पाठ में पाया जा सकता है जो भाषा का सही वर्णन करता है, जैसे स्कैला विशिष्टता (पीडीएफ) स्वयं।

आखिरी वाला, अंडरस्कोर, एक विशेष विवरण के लायक है, क्योंकि इसका व्यापक रूप से उपयोग किया जाता है, और इसके कई अलग-अलग अर्थ हैं। यहां एक नमूना है:

import scala._    // Wild card -- all of Scala is imported
import scala.{ Predef => _, _ } // Exception, everything except Predef
def f[M[_]]       // Higher kinded type parameter
def f(m: M[_])    // Existential type
_ + _             // Anonymous function placeholder parameter
m _               // Eta expansion of method into method value
m(_)              // Partial function application
_ => 5            // Discarded parameter
case _ =>         // Wild card pattern -- matches anything
f(xs: _*)         // Sequence xs is passed as multiple parameters to f(ys: T*)
case Seq(xs @ _*) // Identifier xs is bound to the whole matched sequence

मैं शायद कुछ और अर्थ भूल गया, हालांकि।

स्वचालित रूप से आयातित विधियां

इसलिए, यदि आपको उपरोक्त सूची में वह प्रतीक नहीं मिला है, तो यह एक विधि या एक का हिस्सा होना चाहिए। लेकिन, अक्सर, आप कुछ प्रतीक देखेंगे और कक्षा के लिए प्रलेखन में वह विधि नहीं होगी। जब ऐसा होता है, तो आप किसी और चीज़ के साथ एक या अधिक तरीकों की संरचना को देख रहे हैं, या विधि को दायरे में आयात किया गया है, या आयातित निहित रूपांतरण के माध्यम से उपलब्ध है।

ये अभी भी ScalaDoc पर पाए जा सकते हैं : आपको सिर्फ यह जानना होगा कि उन्हें कहां देखना है। या, उसमें असफल रहा, index (वर्तमान में 2.9.1 पर टूटा हुआ है, लेकिन रात में उपलब्ध है)।

प्रत्येक स्कैला कोड में तीन स्वचालित आयात होते हैं:

// Not necessarily in this order
import _root_.java.lang._      // _root_ denotes an absolute path
import _root_.scala._
import _root_.scala.Predef._

पहले दो केवल कक्षाओं और सिंगलटन वस्तुओं को उपलब्ध कराते हैं। तीसरे में सभी अंतर्निहित रूपांतरण और आयातित विधियां हैं, क्योंकि Predef एक ऑब्जेक्ट है।

Predef के अंदर Predef कुछ प्रतीकों को तुरंत दिखाएं:

class <:<
class =:=
object <%<
object =:=

कोई अन्य प्रतीक एक निहित रूपांतरण के माध्यम से उपलब्ध कराया जाएगा। विधि प्राप्त करने वाले प्रकार के ऑब्जेक्ट को पैरामीटर के रूप में प्राप्त करने वाले implicit साथ टैग की गई विधियों को देखें। उदाहरण के लिए:

"a" -> 1  // Look for an implicit from String, AnyRef, Any or type parameter

उपर्युक्त मामले में, -> ArrowAssoc विधि के माध्यम से ArrowAssoc श्रेणी में परिभाषित किया गया है जो टाइप A का ऑब्जेक्ट लेता है, जहां A एक ही विधि के लिए एक असंबद्ध प्रकार पैरामीटर है।

सामान्य तरीकों

तो, कई प्रतीकों को कक्षा में बस तरीके हैं। उदाहरण के लिए, यदि आप करते हैं

List(1, 2) ++ List(3, 4)

आपको List लिए स्कालाडॉक पर विधि ++ मिल जाएगी। हालांकि, एक ऐसा सम्मेलन है जिसे तरीकों की खोज करते समय आपको अवगत होना चाहिए। कोलन में समाप्त होने वाले तरीके (:) बाईं ओर दाईं ओर बाएं हैं। दूसरे शब्दों में, उपरोक्त विधि कॉल के बराबर है:

List(1, 2).++(List(3, 4))

यदि मेरे पास था, तो इसके बजाय 1 :: List(2, 3) , जो इसके बराबर होगी:

List(2, 3).::(1)

इसलिए आपको कोलन में समाप्त होने वाली विधियों की तलाश करते समय दाईं ओर मिले प्रकार को देखने की आवश्यकता है। उदाहरण के लिए, पर विचार करें:

1 +: List(2, 3) :+ 4

पहली विधि ( +: :) दाईं ओर बाध्य होती है, और List पाई जाती है। दूसरी विधि ( :+ ) सिर्फ एक सामान्य विधि है, और बाएं - फिर से, List बांधती है।

सिंटेक्टिक शर्करा / संरचना

तो, यहां कुछ वाक्य रचनात्मक शर्करा हैं जो एक विधि छुपा सकते हैं:

class Example(arr: Array[Int] = Array.fill(5)(0)) {
  def apply(n: Int) = arr(n)
  def update(n: Int, v: Int) = arr(n) = v
  def a = arr(0); def a_=(v: Int) = arr(0) = v
  def b = arr(1); def b_=(v: Int) = arr(1) = v
  def c = arr(2); def c_=(v: Int) = arr(2) = v
  def d = arr(3); def d_=(v: Int) = arr(3) = v
  def e = arr(4); def e_=(v: Int) = arr(4) = v
  def +(v: Int) = new Example(arr map (_ + v))
  def unapply(n: Int) = if (arr.indices contains n) Some(arr(n)) else None
}

val Ex = new Example // or var for the last example
println(Ex(0))  // calls apply(0)
Ex(0) = 2       // calls update(0, 2)
Ex.b = 3        // calls b_=(3)
// This requires Ex to be a "val"
val Ex(c) = 2   // calls unapply(2) and assigns result to c
// This requires Ex to be a "var"
Ex += 1         // substituted for Ex = Ex + 1

आखिरी व्यक्ति दिलचस्प है, क्योंकि किसी भी प्रतीकात्मक विधि को असाइनमेंट जैसी विधि बनाने के लिए जोड़ा जा सकता है।

और, ज़ाहिर है, कोड में दिखाई देने वाले विभिन्न संयोजन हैं:

(_+_) // An expression, or parameter, that is an anonymous function with
      // two parameters, used exactly where the underscores appear, and
      // which calls the "+" method on the first parameter passing the
      // second parameter as argument.

स्कैला और अन्य भाषाओं के बीच एक (अच्छा, आईएमओ) अंतर यह है कि यह आपको लगभग किसी भी चरित्र के साथ अपने तरीकों का नाम देने देता है।

जो आप गिनती करते हैं वह "विराम चिह्न" नहीं बल्कि सादे और सरल तरीकों से होता है, और जैसे उनका व्यवहार एक वस्तु से दूसरे में भिन्न होता है (हालांकि कुछ सम्मेलन होते हैं)।

उदाहरण के लिए, सूची के लिए स्कालाडोक दस्तावेज़ देखें, और आप यहां बताए गए कुछ तरीकों को देखेंगे।

कुछ चीजों को ध्यान में रखना:

  • ज्यादातर बार A operator+equal B संयोजन A = A operator B अनुवाद करता है, जैसे ||= या ++= उदाहरणों में।

  • जिस तरीके से समाप्त होता है : सही सहयोगी हैं, इसका मतलब है कि A :: B वास्तव में A :: B B.::(A)

स्कैला दस्तावेज़ ब्राउज़ करके आपको अधिकतर जवाब मिलेंगे। यहां एक संदर्भ रखने से प्रयासों को डुप्लिकेट किया जाएगा, और यह जल्दी से पीछे आ जाएगा :)


स्कैला को जावा के अधिकांश अंकगणितीय ऑपरेटरों को विरासत में मिला है। इसमें bitwise- या | (एकल पाइप चरित्र), bitwise- & ,, bitwise- अनन्य- या ^ , साथ ही तार्किक (बूलियन) या || (दो पाइप वर्ण) और तार्किक-और && । दिलचस्प बात यह है कि आप boolean पर एकल चरित्र ऑपरेटर का उपयोग कर सकते हैं, इसलिए जावाश लॉजिकल ऑपरेटर पूरी तरह से अनावश्यक हैं:

true && true   // valid
true & true    // valid as well

3 & 4          // bitwise-and (011 & 100 yields 000)
3 && 4         // not valid

जैसा कि एक और पोस्ट में बताया गया है, एक बराबर चिह्न = में समाप्त होने वाली कॉल को हल किया गया है (अगर उस नाम के साथ कोई विधि मौजूद नहीं है!) पुन: असाइनमेंट द्वारा:

var x = 3
x += 1         // `+=` is not a method in `int`, Scala makes it `x = x + 1`

यह 'डबल-चेक' संभव बनाता है, एक अपरिवर्तनीय संग्रह के लिए आसानी से एक परिवर्तनीय विनिमय करने के लिए:

val m = collection.mutable.Set("Hallo")   // `m` a val, but holds mutable coll
var i = collection.immutable.Set("Hallo") // `i` is a var, but holds immutable coll

m += "Welt" // destructive call m.+=("Welt")
i += "Welt" // re-assignment i = i + "Welt" (creates a new immutable Set)




operators