আমি কটাক্ষপাত গ্রহণ করেছি তালিকা গ্রহণ সার্ভে scala-lang.org এবং একটি অদ্ভুত প্রশ্ন খেয়াল: " " আপনি কি এর সমস্ত ব্যবহার নাম করতে পারি ": _ "। পারবে তুমি? যদি হ্যাঁ হয় তবে দয়া করে এখানে করুন। ব্যাখ্যামূলক উদাহরণ প্রশংসা করা হয়।
উত্তর:
আমি যা ভাবতে পারি সেগুলি
def foo(l: List[Option[_]]) = ...case class A[K[_],T](a: K[T])val _ = 5List(1, 2, 3) foreach { _ => println("Hi") }trait MySeq { _: Seq[_] => }Some(5) match { case Some(_) => println("Yes") }"abc" match { case s"a$_c" => }C(1, 2, 3) match { case C(vs @ _*) => vs.foreach(f(_)) }import java.util._import java.util.{ArrayList => _, _}def bang_!(x: Int) = 5def foo_=(x: Int) { ... }List(1, 2, 3) map (_ + 2)List(1, 2, 3) foreach println _def toFunction(callByName: => Int): () => Int = callByName _var x: String = _ // unloved syntax may be eliminatedআমি অন্যকে ভুলে থাকতে পারে!
কেন foo(_)এবং foo _পৃথক রয়েছে তা উদাহরণ :
এই উদাহরণটি 0__ থেকে এসেছে :
trait PlaceholderExample {
def process[A](f: A => Unit)
val set: Set[_ => Unit]
set.foreach(process _) // Error
set.foreach(process(_)) // No Error
}প্রথম ক্ষেত্রে, process _একটি পদ্ধতি প্রতিনিধিত্ব করে; স্কালা বহুগুণিত পদ্ধতি গ্রহণ করে এবং টাইপ প্যারামিটারটি পূরণ করে এটি মনোমরফিক করার চেষ্টা করে, তবে বুঝতে পারে যে কোনও ধরণের পূরণ করা যায় না Aযা প্রকারটি দেবে (_ => Unit) => ?(অস্তিত্ব _একটি প্রকার নয়)।
দ্বিতীয় ক্ষেত্রে, process(_)একটি ল্যাম্বডা হয়; কোনও সুস্পষ্ট আর্গুমেন্ট প্রকার ছাড়াই ল্যাম্বদা লেখার সময়, স্কালা foreachপ্রত্যাশিত যুক্তি থেকে প্রকারটি অনুমান করে এবং _ => Unit এটি একটি প্রকার (যেখানে কেবল সরল _নয়), তাই এটি প্রতিস্থাপন এবং অনুমান করা যায়।
আমি যে স্কেলার মুখোমুখি হয়েছিলাম এটি সম্ভবত সবচেয়ে জটিল কৌশল।
নোট করুন যে এই উদাহরণটি 2.13 এ সংকলিত হয়েছে। এটি আন্ডারস্কোর হিসাবে নির্ধারিত ছিল যেমন এটি উপেক্ষা করুন।
val x: Any = _
println _এবং println(_)পৃথক। আপনি এটি উদাহরণস্বরূপ দেখতে পাচ্ছেন যে তারা অস্তিত্ব ও পলিমারফিক ধরণের কিছুটা আলাদাভাবে পরিচালনা করে। কিছুটা উদাহরণ নিয়ে হাজির হবে।
FAQ- এ (আমার প্রবেশ) থেকে , যা আমি অবশ্যই সম্পূর্ণ হওয়ার নিশ্চয়তা দিচ্ছি না (আমি মাত্র দু'দিন আগে দুটি এন্ট্রি যুক্ত করেছি):
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
val (a, _) = (1, 2) // same thing
for (_ <- 1 to 10) // same thing
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
var i: Int = _ // Initialization to the default value
def abc_<>! // An underscore must separate alphanumerics from symbols on identifiers
t._2 // Part of a method name, such as tuple getters
1_000_000 // Numeric literal separator (Scala 2.13+)এটিও এই প্রশ্নের অংশ ।
var i: Int = _বা প্যাটার্ন মিলের val (a, _) = (1, 2)বিশেষ ক্ষেত্রে বা ফেলে দেওয়া for (_ <- 1 to 10) doIt()
def f: T; def f_=(t: T)মিউটেবল এফ সদস্য তৈরির জন্য কম্বো।
_পদ্ধতিতে নাম প্রতারণা করছে। তবে, ঠিক আছে, ঠিক আছে। আমি কেবল আশা করি যে অন্য কেউ FAQ আপডেট করেছে ... :-)
আন্ডারস্কোর ব্যবহারের একটি দুর্দান্ত ব্যাখ্যা হ'ল স্কেলা _ [আন্ডারস্কোর] যাদু ।
উদাহরণ:
def matchTest(x: Int): String = x match {
case 1 => "one"
case 2 => "two"
case _ => "anything other than one and two"
}
expr match {
case List(1,_,_) => " a list with three element and the first element is 1"
case List(_*) => " a list with zero or more elements "
case Map[_,_] => " matches a map with any key type and any value type "
case _ =>
}
List(1,2,3,4,5).foreach(print(_))
// Doing the same without underscore:
List(1,2,3,4,5).foreach( a => print(a))স্কেলায়, প্যাকেজ আমদানি করার সময় জাভাতে _অনুরূপ কাজ *করে।
// Imports all the classes in the package matching
import scala.util.matching._
// Imports all the members of the object Fun (static import in Java).
import com.test.Fun._
// Imports all the members of the object Fun but renames Foo to Bar
import com.test.Fun.{ Foo => Bar , _ }
// Imports all the members except Foo. To exclude a member rename it to _
import com.test.Fun.{ Foo => _ , _ }স্কালায়, একজন গেটর এবং সেটারকে কোনও বস্তুর সমস্ত বেসরকারী ভার্সের জন্য স্পষ্টভাবে সংজ্ঞায়িত করা হবে। গেটারের নামটি ভেরিয়েবলের নামের মতো এবং _=সেটার নামের জন্য যুক্ত হয়।
class Test {
private var a = 0
def age = a
def age_=(n:Int) = {
require(n>0)
a = n
}
}ব্যবহার:
val t = new Test
t.age = 5
println(t.age)আপনি যদি কোনও নতুন ভেরিয়েবলের জন্য কোনও ফাংশন নির্ধারণের চেষ্টা করেন তবে ফাংশনটি শুরু করা হবে এবং ফলাফলটি ভেরিয়েবলের জন্য বরাদ্দ করা হবে। পদ্ধতির প্রার্থনার জন্য alচ্ছিক বন্ধনীগুলির কারণে এই বিভ্রান্তি ঘটে। এটি অন্য ভেরিয়েবলে নির্ধারণের জন্য আমাদের ফাংশন নামের পরে _ ব্যবহার করা উচিত।
class Test {
def fun = {
// Some code
}
val funLike = fun _
}List(1,2,3,4,5).foreach(print(_))এটি কেবল আরও পাঠযোগ্য List(1,2,3,4,5).foreach(print), আপনার এমনকি এমনকি আন্ডারস্কোরের আদৌ প্রয়োজন নেই, তবে আমার ধারণা এটি কেবল স্টাইলের বিষয়
এখানে একটি ব্যবহার রয়েছে যা আমি দেখতে পাচ্ছি এখানে উপস্থিত সবাই তালিকার জন্য ভুলে গেছে বলে মনে হচ্ছে ...
বরং এটি করা:
List("foo", "bar", "baz").map(n => n.toUpperCase())আপনি কেবল এটি করতে পারেন:
List("foo", "bar", "baz").map(_.toUpperCase())n => n
এখানে _ব্যবহৃত হয় আরও কয়েকটি উদাহরণ :
val nums = List(1,2,3,4,5,6,7,8,9,10)
nums filter (_ % 2 == 0)
nums reduce (_ + _)
nums.exists(_ > 5)
nums.takeWhile(_ < 8)উপরের সমস্ত উদাহরণে একটি আন্ডারস্কোর তালিকার একটি উপাদানকে উপস্থাপন করে (প্রথম আন্ডারস্কোর হ্রাস করার জন্য সঞ্চয়ের প্রতিনিধিত্ব করে)
জাইরো উল্লিখিত ব্যবহারগুলি ছাড়াও , আমি এটি পছন্দ করি:
def getConnectionProps = {
( Config.getHost, Config.getPort, Config.getSommElse, Config.getSommElsePartTwo )
}কারও যদি সংযোগের সমস্ত বৈশিষ্ট্যের প্রয়োজন হয় তবে তিনি তা করতে পারেন:
val ( host, port, sommEsle, someElsePartTwo ) = getConnectionPropsআপনার যদি কেবল একটি হোস্ট এবং একটি বন্দর দরকার হয় তবে আপনি এটি করতে পারেন:
val ( host, port, _, _ ) = getConnectionPropsএকটি নির্দিষ্ট উদাহরণ রয়েছে যা "_" ব্যবহার করা হবে:
type StringMatcher = String => (String => Boolean)
def starts: StringMatcher = (prefix:String) => _ startsWith prefixএর সমান হতে পারে:
def starts: StringMatcher = (prefix:String) => (s)=>s startsWith prefixকিছু পরিস্থিতিতে "_" প্রয়োগ করা স্বয়ংক্রিয়ভাবে "(x $ n) => x $ n" তে রূপান্তরিত হবে