पैटर्न मैच args और एक हल्के स्काला स्क्रिप्ट

Question

मैं सरल स्केला लिपियों कि अंत की तरह args पर एक साधारण पैटर्न मैच के साथ शुरू के एक नंबर लिखने में त्रुटि संदेश देना तर्कों की गलत संख्या, मुझे एक अचूक त्रुटि मिलती है जैसे:

scala.MatchError: [Ljava.lang.String;@7786df0f 
    at Main$$anon$1.<init>(FollowUsers.scala:5) 
    ... 

क्या कोई और उपयोगी त्रुटि संदेश देने का कोई आसान तरीका है? मेरे वर्तमान वैकल्पिक हल की तरह कुछ करने के लिए है:

args match { 
    case Array(path, foo, whatever) => someFunction(path, foo, whatever) 
    case _ => System.err.println("usage: path foo whatever") 
} 
def someFunction(path: String, foo: String, whatever: String) = { 
    // .. rest of the script uses "path", "foo", etc. 
} 

लेकिन उस बॉयलरप्लेट का एक बहुत की तरह लगता है क्या एक पूरी अन्य समारोह को परिभाषित करने के लिए, और "पथ", "foo" और "जो कुछ भी" को दोहराने के लिए होने के साथ इतने सारे स्थान क्या कोई बेहतर तरीका है? मुझे लगता है कि मैं समारोह खो सकता हूं और शरीर को मैच स्टेटमेंट में डाल सकता हूं, लेकिन यह मेरे लिए कम पठनीय लगता है।

मुझे पता है कि मैं कई कमांड लाइन तर्क पार्सिंग पैकेजों में से एक का उपयोग कर सकता हूं, लेकिन मैं वास्तव में बहुत हल्का वजन ढूंढ रहा हूं कि मुझे निर्भरता जोड़ने और मेरे क्लासपाथ को संशोधित करने की आवश्यकता नहीं है।

try { 
    val Array(path, foo, whatever) = args 
} catch { 
    case _: MatchError => System.err.println("usage: path foo whatever") 
} 

Answer 1

कैसे?

val Array(path, foo, whatever) = if (args.length == 3) args 
    else throw new Exception("usage:path foo whatever") 

== संपादित ==

रंडाल्स टिप्पणी के आधार पर:

require(args.length == 3, "usage: path foo whatever") 
val Array(path, foo, whatever) = args 

न्यूनतम बॉयलरप्लेट है यही कारण है कि। आपके vals गुंजाइश में हैं, आपको बंद ब्रेस से निपटने की ज़रूरत नहीं है और आपको उपयोग त्रुटि संदेश मिलता है।

Answer 2

एक तरह से MatchError को पकड़ने के लिए है पहले संभालना और शेष कोड को एक साथ रखता है, हालांकि यह मुझे इतना बड़ा प्रयास करने के लिए थोड़ा परेशान करता है (कि ऐरे पैटर्न मिलान के साथ दूसरा ब्लॉक अनिवार्य रूप से सभी एक ही प्रयास ब्लॉक में है अपवाद द्वारा झुकाव।

संपादित करें: ऐसा लगता है कि गायब फ़ैक्टर ने भी वही चीज़ पोस्ट की है, लेकिन स्पष्ट रूप से परिभाषित फ़ंक्शन और लागू करने के लिए एक स्पष्ट कॉल के साथ।

Answer 3

scala> val args = Array("evil", "mad", "scientist") 
args: Array[java.lang.String] = Array(evil, mad, scientist) 

scala> def logToConsole(th: Throwable) { Console.err.println("Usage: path foo bar") } 
logToConsole: (th: Throwable)Unit 

scala> handling(classOf[MatchError]) by logToConsole apply { 
    | val Array(path, foo, bar) = args 
    | println(path) 
    | } 
evil 

scala> handling(classOf[MatchError]) by logToConsole apply { 
    | val Array(path, foo, bar) = Array("#fail") 
    | println(path) 
    | } 
Usage: path foo bar 

Answer 4

मुझे लगा कि शायद नए util.control.Exception एक समाधान हो सकता है:

import scala.util.control.Exception 

Exception.handling(classOf[scala.MatchError]).by{ 
    e => System.err.println("usage: path foo whatever") 
} { 
    val Array(path, foo, whatever) = args 
    // .. rest of the script uses "path", "foo", etc. 
} 

यह कम से कम त्रुटि डालता