স্কালার সমস্ত প্রতীকী অপারেটরগুলির অর্থ কী?


402

স্কালা সিনট্যাক্সে প্রচুর চিহ্ন রয়েছে। যেহেতু এই ধরণের নামগুলি অনুসন্ধান ইঞ্জিনগুলি ব্যবহার করে খুঁজে পাওয়া শক্ত, তাই তাদের একটি বিস্তৃত তালিকা সহায়ক হবে।

স্কালার সমস্ত চিহ্ন কী কী এবং তাদের প্রত্যেকটি কী করে?

বিশেষ করে, আমি জানতে চাই সম্পর্কে ->, ||=, ++=, <=, _._, ::, এবং :+=


4
এবং সিঁড়ি 1 ম সংস্করণ সূচি, >> artima.com/pins1ed/book-index.html#indexanchor
জিন টি

2
সম্পর্কিত: অপারেটর অক্ষর আলফানিউমেরিক অক্ষর বনাম: stackoverflow.com/questions/7656937/...
লুইজি Plinge

1
এছাড়াও, যদি "অপারেটর" থাকে (বেশিরভাগ পদ্ধতিতে ইনফিক্স ব্যবহৃত কয়েকটি শ্রেণীর নাম রয়েছে) যা আপনি স্কেলেক্সে বা সিঁড়ির বইতে খুঁজে পাচ্ছেন না, যেমন "!!", সম্ভবত উত্সগুলি আক্কা, স্কালাজের স্কেলডোকস এবং এসবিটি
জিন টি 16


অনুসন্ধান ইঞ্জিনগুলি দ্বারা ফিল্টারিংয়ের বিষয়ে, সিম্বহাউন্ড ডট কম একটি দুর্দান্ত বিকল্প
প্যাট্রিক রেফন্ডিনি

উত্তর:


526

আমি অপারেটরগুলিকে শিক্ষাদানের উদ্দেশ্যে, চারটি বিভাগে বিভক্ত করি :

  • কীওয়ার্ড / সংরক্ষিত প্রতীক
  • স্বয়ংক্রিয়ভাবে পদ্ধতিগুলি আমদানি করা
  • সাধারণ পদ্ধতি
  • সিনট্যাকটিক শর্করা / রচনা

তবে ভাগ্যবান, তবে বেশিরভাগ বিভাগেই প্রশ্নটিতে প্রতিনিধিত্ব করা হয়:

->    // 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ক্লাসে সংজ্ঞায়িত পদ্ধতি ।

সুতরাং, আসুন তাদের দেখতে দিন।

কীওয়ার্ড / সংরক্ষিত প্রতীক

স্কালায় কিছু চিহ্ন রয়েছে যা বিশেষ। এর মধ্যে দুটি যথাযথ কীওয়ার্ড হিসাবে বিবেচিত হয়, অন্যরা কেবল "সংরক্ষিত" থাকে are তারা হ'ল:

// 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 : আপনি শুধু জানতে যেখানে তাদের জন্য চেহারা আছে। বা, এটি ব্যর্থ হয়ে সূচকটি দেখুন (বর্তমানে ২.৯.১-তে ভাঙা, তবে রাতের বেলা উপলব্ধ)।

প্রতিটি স্কাল কোডটিতে তিনটি স্বয়ংক্রিয় আমদানি থাকে:

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

প্রথম দুটি কেবল ক্লাস এবং সিঙ্গলটন অবজেক্টগুলিকে উপলভ্য করে। তৃতীয়টিতে সমস্ত অন্তর্নিহিত রূপান্তর এবং আমদানি করা পদ্ধতি রয়েছেPredef এটি কোনও বস্তু।

Predefদ্রুত ভিতরে quicklyুকে কিছু প্রতীক দেখান:

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

অন্য কোনও প্রতীক একটি অন্তর্নিহিত রূপান্তর মাধ্যমে উপলব্ধ করা হবে । implicitপ্যারামিটার হিসাবে, প্রাপ্ত হওয়ার সাথে ট্যাগযুক্ত পদ্ধতিগুলি দেখুন, পদ্ধতিটি প্রাপ্ত হবার ধরণের একটি অবজেক্ট। উদাহরণ স্বরূপ:

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

উপরের ক্ষেত্রে, ->ক্লাসে ArrowAssocএমন পদ্ধতির মাধ্যমে সংজ্ঞায়িত করা হয় যা any2ArrowAssocটাইপের একটি অবজেক্ট নেয় Aযেখানে whereA একই পদ্ধতিতে আনবাউন্ডেড টাইপ পরামিতি থাকে।

সাধারণ পদ্ধতি

সুতরাং, অনেক চিহ্ন একটি ক্লাসে সহজ পদ্ধতি। উদাহরণস্বরূপ, আপনি যদি

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

আপনি পদ্ধতি পাবেন ++জন্য ScalaDoc ডানে তালিকা । তবে, একটি কনভেনশন রয়েছে যে পদ্ধতিগুলি অনুসন্ধান করার সময় আপনাকে অবশ্যই সচেতন হতে হবে। কোলনে শেষ হওয়া পদ্ধতিগুলি ( :) বামের পরিবর্তে ডানদিকে আবদ্ধ থাকে। অন্য কথায়, উপরের পদ্ধতিটির কলটি সমান:

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.

1
আপনি কি val c = ex(2)পরিবর্তে বলতে চেয়েছিলেন val ex(c) = 2?
মাইক থাকুন

3
@ মাইকস্টে না, আমার অর্থ ছিল না val ex(c) = 2
ড্যানিয়েল সি সোব্রাল

ওহ, এটি প্যাটার্ন মেলানো সিনট্যাক্স ব্যবহার করছে। ধন্যবাদ।
মাইক

=> এগুলির মধ্যে ব্যবহারের সময় 'নাম ধরে ডাকার' অবস্থাও প্রদান করে: এবং y এর মতো টাইপ করুন: => অন্তঃকরণ
স্টিফেন ডাব্লু রাইট

1
হতে পারে একটিতে: / এবং: \ সত্যই অপ্রচলিত অপারেটরগুলিরও উল্লেখ করা উচিত। সুতরাং ম্যাপ.ফোল্ডফেল্ট (ইনিশিয়ালওয়াল) হ'ল (ইনিশিয়ালওয়াল: / ম্যাপ) -: \ এর পরিবর্তে ফোল্ডরাইট।
মিঃ এমটি

24

স্কেলা এবং অন্যান্য ভাষার মধ্যে একটি (ভাল, আইএমও) পার্থক্য হ'ল এটি আপনাকে প্রায় কোনও চরিত্রের সাথে আপনার পদ্ধতিগুলির নাম দিতে দেয়।

আপনি যেটি গণনা করেছেন তা "বিরামচিহ্ন" নয় বরং সরল ও সাধারণ পদ্ধতি এবং যেমন তাদের আচরণগুলি একটি বস্তুর থেকে অন্য বস্তুর কাছে পরিবর্তিত হয় (যদিও কিছু কনভেনশন রয়েছে)।

উদাহরণস্বরূপ, তালিকার জন্য স্ক্যালডোক ডকুমেন্টেশন পরীক্ষা করে দেখুন এবং আপনি এখানে উল্লিখিত কয়েকটি পদ্ধতি দেখতে পাবেন।

কিছু বিষয় মনে রাখতে হবে:

  • A operator+equal Bসংমিশ্রণটি বেশিরভাগ সময় অনুবাদ করে A = A operator B, যেমন ||=বা ++=উদাহরণগুলিতে।

  • পদ্ধতি শেষ :ডান মিশুক হয়, এর মানে হল যে A :: Bহয় আসলে B.::(A)

স্কালা ডকুমেন্টেশন ব্রাউজ করে আপনি সর্বাধিক উত্তর খুঁজে পাবেন। এখানে একটি রেফারেন্স রাখা প্রচেষ্টা সদৃশ হবে এবং এটি দ্রুত পিছনে হবে :)


21

আপনি কিছু মানদণ্ড অনুসারে এগুলিকে প্রথমে গ্রুপ করতে পারেন। এই পোস্টে আমি কেবল আন্ডারস্কোর চরিত্র এবং ডান-তীরটি ব্যাখ্যা করব।

_._একটি সময়কাল থাকে। স্কালার একটি সময়কাল সর্বদা একটি পদ্ধতি কলকে নির্দেশ করে । পিরিয়ডের বামদিকে আপনার রিসিভার রয়েছে এবং এর ডানদিকে বার্তাটি (পদ্ধতির নাম) রয়েছে। স্কালায় এখন _একটি বিশেষ প্রতীক । এটি সম্পর্কে বেশ কয়েকটি পোস্ট রয়েছে, উদাহরণস্বরূপ এই ব্লগ এন্ট্রি সমস্ত ব্যবহারের ক্ষেত্রে। এখানে এটি একটি বেনামে ফাংশন শর্ট কাট , এটি হ'ল এটি কোনও ফাংশনের শর্টকাট যা একটি যুক্তি নেয় এবং এতে পদ্ধতিটি আহ্বান করে _। এখন _কোনও বৈধ পদ্ধতি নয়, সুতরাং আপনি অবশ্যই দেখছিলেন _._1বা অনুরূপ কিছু ছিল , এটি হ'ল _._1ফাংশন আর্গুমেন্টে অনুরোধ পদ্ধতি । _1থেকে _22tuples যা tuple একটি বিশেষ উপাদান বের করে এর পদ্ধতি। উদাহরণ:

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

এখন ফাংশন অ্যাপ্লিকেশন শর্টকাটের জন্য একটি ব্যবহারের কেস ধরে নেওয়া যাক। একটি মানচিত্র দেওয়া যা স্ট্রিংগুলিতে পূর্ণসংখ্যার মানচিত্র দেয়:

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

ওহুপ, একটি অদ্ভুত বিরামচিহ্নের ইতিমধ্যে অন্য ঘটনা রয়েছে। হাইফেন এবং এর চেয়ে বড় অক্ষরগুলি, যা ডান হাতের তীরের অনুরূপ , একটি অপারেটর যা একটি উত্পাদন করে Tuple2। সুতরাং (1, "Eins")বা লেখার ফলাফলের মধ্যে কোনও পার্থক্য নেই 1 -> "Eins", কেবলমাত্র পরবর্তীটি পড়া সহজ, বিশেষত মানচিত্রের উদাহরণের মতো টিপলগুলির তালিকায়। ->কোন ম্যাজিক এটি উপলব্ধ কয়েক অন্যান্য অপারেটরদের মত,, কারণ আপনি সব আছে, অন্তর্নিহিত বস্তু ধর্মান্তর scala.Predefসুযোগ। এখানে রূপান্তরটি ঘটে is

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

কোথায় ArrowAssocগেছে ->পদ্ধতি যা সৃষ্টি Tuple2। এইভাবে 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মানচিত্রের পদ্ধতিটি কী এবং টিউবলে ফাংশন আর্গুমেন্টে যায়। যেহেতু আমরা কেবল মানগুলিতে (স্ট্রিংগুলি) আগ্রহী তাই আমরা _2টিপলের পদ্ধতিতে এগুলি বের করি ।


+1 ->পদ্ধতিটি বুঝতে চেষ্টা করেও আমার সমস্যা হয়েছে তবে আপনার বাক্য "সুতরাং লেখার ফলাফলের মধ্যে কোনও পার্থক্য নেই " (1, "Eins")বা 1 -> "Eins"সিনট্যাক্স এবং এর ব্যবহার বুঝতে আমাকে সহায়তা করেছে।
জেসি ওয়েব

fyi আপনার ব্লগ এন্ট্রি লিঙ্কটি মারা গেছে
এখনও

15

ড্যানিয়েল এবং 0__ এর উজ্জ্বল উত্তরের সংযোজন হিসাবে, আমাকে বলতে হবে যে স্কালা কিছু চিহ্নগুলির জন্য ইউনিকোড অ্যানালগগুলি বোঝে , তাই পরিবর্তে

for (n <- 1 to 10) n % 2 match {
  case 0 => println("even")
  case 1 => println("odd")
}

এক লিখতে পারে

for (n ← 1 to 10) n % 2 match {
  case 0 ⇒ println("even")
  case 1 ⇒ println("odd")
}

10

সম্পর্কিত ::অন্য স্ট্যাকওভারফ্লো এন্ট্রি রয়েছে যা কেসটি কভার করে ::। সংক্ষেপে, এটি একটি প্রধান উপাদান এবং একটি লেজ তালিকা Lists' কনসেন্ট ' দ্বারা তৈরি করতে ব্যবহৃত হয় । এটি উভয় শ্রেণি যা কনসযুক্ত তালিকা উপস্থাপন করে এবং এটি একটি এক্সট্র্যাক্টর হিসাবে ব্যবহার করা যেতে পারে তবে বেশিরভাগ ক্ষেত্রে এটি তালিকার একটি পদ্ধতি । পাবলো ফার্নান্দেজ যেমন উল্লেখ করেছেন, যেহেতু এটি একটি কোলনে শেষ হয়, এটি ডান সংশ্লেষী , যার অর্থ পদ্ধতি কলটির রিসিভারটি ডানদিকে এবং অপারেটরের বাম দিকে যুক্তি। এই ভাবে আপনি এইরূপ সূচারূভাবে consing প্রকাশ করতে পারেন যেমন prepending একটি বিদ্যমান তালিকায় একটি নতুন মাথা উপাদান:

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 (1)"
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"
}

আপনি এই পোস্টে এক্সট্র্যাক্টর সম্পর্কে আরও পড়তে পারেন ।


9

<=ঠিক যেমন আপনি এটি "পড়তে" চান: 'কম বা সমান'। সুতরাং এটি একটি গাণিতিক অপারেটর <(এর চেয়ে কম?), >(এর চেয়ে বড়?), ==(সমান?), !=(সমান নয়?), <=(এর চেয়ে কম বা সমান?), এবং>= (এর চেয়ে বড় বা সমান?)।

এই করা আবশ্যক বিভ্রান্ত সঙ্গে =>যা এক ধরণের ডবল ডানদিকের তীর , একটি ফাংশনের শরীর থেকে আর্গুমেন্ট তালিকার আলাদা করতে এবং প্যাটার্ন ম্যাচিং (ক পরীক্ষার শর্ত আলাদা করতে ব্যবহৃত caseশরীর মৃত্যুদন্ড কার্যকর থেকে ব্লক) যখন কোনো মিল পাওয়া যায় । আপনি আমার আগের দুটি উত্তরে এর উদাহরণ দেখতে পাচ্ছেন। প্রথমত, ফাংশনটি ব্যবহার করুন:

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

প্রকারগুলি বাদ দেওয়া হওয়ায় এটি ইতিমধ্যে সংক্ষেপিত। অনুসরণ ফাংশন হবে

// function arguments         function body
(tup: Tuple2[Int, String]) => tup._2.reverse

এবং প্যাটার্ন ম্যাচিং ব্যবহার:

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

4
এই বিভ্রান্তি এড়ানোর কারণেই আমি ডান ডাবল তীর (\ U21D2), একক ডান "মানচিত্র" তীর (\ U2192) এবং বাম একক "তীর (\ U2190) এর জন্য ইউনিকোড অক্ষর ব্যবহার শুরু করার সিদ্ধান্ত নিয়েছি। স্কেলা এটিকে সমর্থন করে তবে কিছুক্ষণ চেষ্টা না করা পর্যন্ত আমি কিছুটা সংশয়ী ছিলাম। আপনার সিস্টেমে কীভাবে এই কোড পয়েন্টগুলি যুক্ত করতে হয় তা সন্ধান করুন। ওএস এক্সে এটি সত্যিই সহজ ছিল
কনার ডয়েল

5

আমি একটি আধুনিক আইডিই বড় স্কাল প্রকল্পগুলি বোঝার জন্য সমালোচনা হিসাবে বিবেচনা করি। যেহেতু এই অপারেটরগুলিও পদ্ধতি, তাই ইন্টেলিজ আইডিয়ায় আমি কেবল সংজ্ঞা-ক্লিক বা সংজ্ঞা-বিতে নিয়ন্ত্রণ-বিতে ক্লিক করি।

আপনি ডানপন্থী অপারেটরটিতে ডানদিকে কন্ট্রোল-ক্লিক করতে পারেন (: :) এবং স্কেল জাভাদোকের শেষে "এই তালিকার শুরুতে একটি উপাদান যুক্ত করুন saying" ব্যবহারকারী-সংজ্ঞায়িত অপারেটরগুলিতে, এটি আরও জটিল হয়ে ওঠে, যেহেতু তাদের হার্ড-টু-সন্ধানের অনুলিপিগুলিতে সংজ্ঞায়িত করা যেতে পারে ... আপনার আইডিই জানে কোথায় অন্তর্নিহিত সংজ্ঞা দেওয়া হয়েছিল।


4

কেবলমাত্র অন্যান্য দুর্দান্ত উত্তরে যুক্ত করা। স্কালা দুটি সমালোচিত প্রতীকী অপারেটর, /:( 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 )( _+_ )

2

স্কেলার জাভার বেশিরভাগ পাটিগণিত অপারেটরদের উত্তরাধিকার সূত্রে প্রাপ্ত । এর মধ্যে বিটওয়াইস-বা |(একক পাইপ চরিত্র), বিটওয়াইস-এবং &, বিটওয়াইস-এক্সক্লুসিভ-বা ^পাশাপাশি লজিকাল (বুলিয়ান) বা ||(দুটি পাইপ অক্ষর) এবং লজিক্যাল-এবং অন্তর্ভুক্ত রয়েছে &&। মজার বিষয় হল, আপনি একক অক্ষর অপারেটরগুলি ব্যবহার করতে পারেন 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)

4
পিএস বুলিয়ানগুলিতে একক বনাম ডাবল চরিত্র অপারেটর ব্যবহারের মধ্যে পার্থক্য রয়েছে — প্রাক্তন আগ্রহী (সমস্ত পদটি মূল্যায়ন করা হয়), ফলস্বরূপ বুলিয়ানটি জানা থাকলে পরবর্তীকালের অবসান ঘটে: true | { println( "Icke" ); true }ints প্রিন্টগুলি! Print প্রিন্ট true || { println( "Icke" ); true }করে না !
0__
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.