"कन्वर्ट" स्काला

Question

में विकल्प [x] एक्स के लिए मैं स्केला (2.1) के लिए खेलने के साथ काम करने और मैं एक "विकल्प [लांग]" मान "लांग" कन्वर्ट करने के लिए की जरूरत है।

मैं कैसे विपरीत करने के लिए पता है, मेरा मतलब है:

def toOption[Long](value: Long): Option[Long] = if (value == null) None else Some(value) 

लेकिन मेरे मामले में, मैं एक विधि में एक प्रकार है कि "लंबे समय लेता है के रूप में" विकल्प [लांग] "का मान पारित करने के लिए है "। कृपया कोई मदद करें।

Answer 1

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

def toOption(value: Long): Option[Long] = 
    if (value == null) None else Some(value) 

यहां तक ​​कि इस तरह की अतर्कसंगत है (के बाद से scala.Long एक संदर्भ प्रकार नहीं है और null कभी नहीं हो सकता है), जब तक आप java.lang.Long है, जो दर्द के लिए एक नुस्खा है और संदर्भ दे रहे उलझन।

def toOption(value: String): Option[String] = Option(value) 

इस विधि None वापस आ जाएगी यदि और केवल यदि valuenull है: अंत में, यहां तक ​​कि अगर आप एक संदर्भ प्रकार के साथ काम कर रहे थे (जैसे String), तो आपको निम्न में से बिल्कुल बराबर है लेखन बेहतर होगा ।

आपके प्रश्न को हल करने के लिए, मान लीजिए कि हम निम्न विधि है:

def foo(x: Long) = x * 2 

आप आम तौर पर foo के लिए एक Option[Long] गुजर के मामले में लगता है कि नहीं होना चाहिए, बल्कि "उठाने" foo के माध्यम से mapOption में :

scala> val x: Option[Long] = Some(100L) 
x: Option[Long] = Some(100) 

scala> x map foo 
res14: Option[Long] = Some(200) 

Option के पूरे मुद्दे (प्रकार स्तर पर) के लिए एक पूरे से बचने के लिए मॉडल करने के लिए एक "अशक्त" मूल्य की संभावना है NullPointerException -y की समस्याएं। पर map का उपयोग करके आप Option में उस मान पर गणना कर सकते हैं, जबकि यह संभव है कि यह खाली हो।

एक और उत्तर नोटों के रूप में, यह भी getOrElse उपयोग करने के लिए Option की "जमानत" करने के लिए संभव है, लेकिन यह आम तौर पर स्काला में मुहावरेदार दृष्टिकोण (मामलों को छोड़कर, जिनमें वाकई एक उचित डिफ़ॉल्ट मान है) नहीं है।

Answer 2

आपको तय करना क्या होता है जब विकल्प None है की जरूरत है। क्या आप एक डिफ़ॉल्ट मान प्रदान करते हैं?

def unroll(opt: Option[Long]): Long = opt getOrElse -1L // -1 if undefined 

unroll(None) // -> -1 

तुम भी एक अपवाद फेंक सकता है:

def unroll(opt: Option[Long]): Long = opt.getOrElse(throw 
    new IllegalArgumentException("The option is expected to be defined at this point") 
) 

unroll(None) // -> exception 

मामले में, null के प्रयोग से बचें, जब तक आप इसे (opt.orNull) का उपयोग करने के लिए बहुत अच्छे कारणों के लिए है।

Answer 3

विकल्प साइड-इफेक्ट को स्थानीयकृत करने का तरीका है (आपका फ़ंक्शन खाली मान वापस कर सकता है)।और अच्छी शैली विकल्प के लिए अपने गणना लिफ्ट करने के लिए (विकल्प नक्शा & flatMap तरीकों के साथ इकाई है)।

val x = Option[Long](10) 
x.map { a => a + 10 } 

और पक्ष प्रभाव के लिए मैन्युअल रूप से प्रसंस्करण के साथ निकालने मूल्य:

val res = x match { 
    case Some(a) => s"Value: $a" 
    case None => "no value" 
} 

Answer 4

इस विधि को पहले से ही विकल्प [एक] पर परिभाषित किया गया है और कहा जाता है मिलती है:

scala> val x = Some(99L) 
x: Some[Long] = Some(99) 

scala> x.get 
res0: Long = 99 

समस्या

0: कि कोई भी पर मिल बुला एक NoSucheElement अपवाद फेंक जाएगा

इस प्रकार आप एक विकल्प प्रकार का उपयोग करने से कोई लाभ प्राप्त नहीं होगा।

इस प्रकार जैसा कि आप getOrElse का उपयोग कर सकते हैं, इससे पहले कि आप एक समझदार डिफ़ॉल्ट मान प्रदान कर सकते हैं या अपवाद को संभाल सकते हैं।

मुहावरेदार स्केला रास्ता मानचित्र का उपयोग किया जाएगा या एक के लिए-समझ

x map (_ + 1) 
res2: Option[Long] = Some(100) 

या

for (i <- x) yield i +1 
res3: Option[Long] = Some(100) 

Answer 5

जैसा कि पहले ही उल्लेख किया गया है getOrElse क्या आप अपने सवाल का जवाब देने में की तलाश में हैं शायद है सीधे।

भी कृपया ध्यान दें कि एक विकल्प में बदलने के लिए आप बस कर सकते हैं:

val myOption = Option(1) 

myOption अब होगा कुछ (1)

val myOption = Option(null) 

myOption अब कोई नहीं होगा।

Answer 6

आप विकल्प के रूप में एक्स [लांग] है, तो x.get आप लंबे समय दे देंगे। वैकल्पिक मूल्य निकालने के लिए पैटर्न मिलान का उपयोग करने के लिए