2019 / सितंबर / 01 को अद्यतन
- Scala 2.13 से शुरू करके, उपयोग करना पसंद करते हैं scala.util.Using
- यदि कोड फेंक दिया गया तो
finallyमूल बग जहां मूल Exceptionफेंक दिया जाएगा निगल जाएगाtryfinallyException
स्काला में आसानी से फ़ाइल लिखने के बारे में इन सभी उत्तरों की समीक्षा करने के बाद, और उनमें से कुछ काफी अच्छे हैं, मेरे पास तीन मुद्दे थे:
- में Jus12 के जवाब , का उपयोग करते हुए सहायक विधि के लिए currying के उपयोग स्काला / एफपी शुरुआती के लिए गैर स्पष्ट है
- निम्न स्तर की त्रुटियों को इनकैप्सुलेट करने की आवश्यकता है
scala.util.Try
- जावा डेवलपर्स को स्काला / एफपी को नया दिखाने की आवश्यकता है कि कैसे निर्भर संसाधनों को ठीक से घोंसला बनाया जाए इसलिए
closeविधि रिवर्स ऑर्डर में प्रत्येक आश्रित संसाधन पर की जाती है - नोट: रिवर्स ऑर्डर में निर्भर संसाधनों को बंद करना एक विफलता की घटना में शायद ही कभी समझा आवश्यकता है। java.lang.AutoCloseableविनिर्देश जो बहुत हानिकारक और मुश्किल पर आधारित होते हैं कीड़े और चलाने के समय विफलताओं को खोजने के लिए
शुरू करने से पहले, मेरा लक्ष्य निर्णायक नहीं है। यह आमतौर पर जावा से आने वाले स्काला / एफपी शुरुआती लोगों के लिए आसान समझ की सुविधा देता है। बहुत अंत में, मैं सभी बिट्स को एक साथ खींचूंगा, और फिर संक्षिप्तता बढ़ाऊंगा।
सबसे पहले, usingविधि को Tryफिर से उपयोग करने के लिए अपडेट किया जाना चाहिए (फिर, संक्षिप्तता यहां लक्ष्य नहीं है)। इसका नाम बदलकर tryUsingAutoCloseable:
def tryUsingAutoCloseable[A <: AutoCloseable, R]
(instantiateAutoCloseable: () => A) //parameter list 1
(transfer: A => scala.util.Try[R]) //parameter list 2
: scala.util.Try[R] =
Try(instantiateAutoCloseable())
.flatMap(
autoCloseable => {
var optionExceptionTry: Option[Exception] = None
try
transfer(autoCloseable)
catch {
case exceptionTry: Exception =>
optionExceptionTry = Some(exceptionTry)
throw exceptionTry
}
finally
try
autoCloseable.close()
catch {
case exceptionFinally: Exception =>
optionExceptionTry match {
case Some(exceptionTry) =>
exceptionTry.addSuppressed(exceptionFinally)
case None =>
throw exceptionFinally
}
}
}
)
उपरोक्त tryUsingAutoCloseableविधि की शुरुआत भ्रामक हो सकती है क्योंकि यह प्रथागत एकल पैरामीटर सूची के बजाय दो पैरामीटर सूचियों के लिए प्रतीत होता है। इसे कर्रिंग कहते हैं। और मैं इस बात पर विस्तार से नहीं जाऊँगा कि करीना कैसे काम करती है या यह कभी-कभार कहाँ उपयोगी है। यह पता चला है कि इस विशेष समस्या स्थान के लिए, यह काम का सही उपकरण है।
इसके बाद, हम विधि बनाने की जरूरत, tryPrintToFileहै, जो (या किसी मौजूदा अधिलेखित) एक पैदा करेगा Fileऔर एक लिखने List[String]। यह एक का उपयोग करता है FileWriterजो एक द्वारा समझाया जाता है BufferedWriterजो बदले में एक द्वारा समझाया जाता है PrintWriter। और प्रदर्शन को ऊंचा करने के लिए, डिफ़ॉल्ट बफ़र आकार डिफ़ॉल्ट से बहुत बड़ा BufferedWriterहै जिसे परिभाषित किया गया है,defaultBufferSize गया है, और 65536 मान निर्दिष्ट किया गया है।
यहाँ कोड है (और फिर, संक्षिप्तता यहाँ लक्ष्य नहीं है):
val defaultBufferSize: Int = 65536
def tryPrintToFile(
lines: List[String],
location: java.io.File,
bufferSize: Int = defaultBufferSize
): scala.util.Try[Unit] = {
tryUsingAutoCloseable(() => new java.io.FileWriter(location)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
fileWriter =>
tryUsingAutoCloseable(() => new java.io.BufferedWriter(fileWriter, bufferSize)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
bufferedWriter =>
tryUsingAutoCloseable(() => new java.io.PrintWriter(bufferedWriter)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
printWriter =>
scala.util.Try(
lines.foreach(line => printWriter.println(line))
)
}
}
}
}
उपरोक्त tryPrintToFileविधि उपयोगी है कि यह एक List[String]इनपुट के रूप में लेता है और इसे एक को भेजता है File। चलिए अब एक tryWriteToFileविधि बनाते हैं जो एक लेता है Stringऔर इसे लिखता है a File।
यहां कोड है (और मैं आपको यहां संक्षिप्तता की प्राथमिकता का अनुमान लगाने दूंगा):
def tryWriteToFile(
content: String,
location: java.io.File,
bufferSize: Int = defaultBufferSize
): scala.util.Try[Unit] = {
tryUsingAutoCloseable(() => new java.io.FileWriter(location)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
fileWriter =>
tryUsingAutoCloseable(() => new java.io.BufferedWriter(fileWriter, bufferSize)) { //this open brace is the start of the second curried parameter to the tryUsingAutoCloseable method
bufferedWriter =>
Try(bufferedWriter.write(content))
}
}
}
अंत में, यह एक के Fileरूप में एक की सामग्री लाने में सक्षम होने के लिए उपयोगी है String। जबकि scala.io.Sourceसामग्री को आसानी से प्राप्त करने के लिए एक सुविधाजनक विधि प्रदान करता है File, इस closeविधि का उपयोग Sourceअंतर्निहित JVM और फ़ाइल सिस्टम हैंडल को जारी करने के लिए किया जाना चाहिए । यदि ऐसा नहीं किया जाता है, तो संसाधन जारी नहीं किया जाता है जब तक कि जेवीएम जीसी (गारबेज कलेक्टर) Sourceअपने आप ही उदाहरण जारी करने के लिए चारों ओर न हो जाए । और फिर भी, केवल एक कमजोर जेवीएम गारंटी है finalizeविधि को जीसी द्वारा closeसंसाधन के लिए बुलाया जाएगा । इसका मतलब यह है कि यह ग्राहक की जिम्मेदारी है कि वह स्पष्ट रूप से closeविधि को बुलाए , ठीक उसी तरह जैसे कि ग्राहक की जिम्मेदारी है कि वह किसी वस्तु को लंबा closeकर सकेjava.lang.AutoCloseable । इसके लिए, हमें उपयोग करने की विधि की एक दूसरी परिभाषा की आवश्यकता है जो संभालती हैscala.io.Source।
इसके लिए यहाँ कोड है (अभी भी संक्षिप्त नहीं किया जा रहा है):
def tryUsingSource[S <: scala.io.Source, R]
(instantiateSource: () => S)
(transfer: S => scala.util.Try[R])
: scala.util.Try[R] =
Try(instantiateSource())
.flatMap(
source => {
var optionExceptionTry: Option[Exception] = None
try
transfer(source)
catch {
case exceptionTry: Exception =>
optionExceptionTry = Some(exceptionTry)
throw exceptionTry
}
finally
try
source.close()
catch {
case exceptionFinally: Exception =>
optionExceptionTry match {
case Some(exceptionTry) =>
exceptionTry.addSuppressed(exceptionFinally)
case None =>
throw exceptionFinally
}
}
}
)
और यहाँ एक सुपर सरल लाइन स्ट्रीमिंग फ़ाइल रीडर में इसका उपयोग उदाहरण है (वर्तमान में डेटाबेस आउटपुट से टैब-सीमांकित फ़ाइलों को पढ़ने के लिए उपयोग कर रहा है):
def tryProcessSource(
file: java.io.File
, parseLine: (String, Int) => List[String] = (line, index) => List(line)
, filterLine: (List[String], Int) => Boolean = (values, index) => true
, retainValues: (List[String], Int) => List[String] = (values, index) => values
, isFirstLineNotHeader: Boolean = false
): scala.util.Try[List[List[String]]] =
tryUsingSource(scala.io.Source.fromFile(file)) {
source =>
scala.util.Try(
( for {
(line, index) <-
source.getLines().buffered.zipWithIndex
values =
parseLine(line, index)
if (index == 0 && !isFirstLineNotHeader) || filterLine(values, index)
retainedValues =
retainValues(values, index)
} yield retainedValues
).toList //must explicitly use toList due to the source.close which will
//occur immediately following execution of this anonymous function
)
)
उपरोक्त फ़ंक्शन का एक अद्यतन संस्करण एक अलग लेकिन संबंधित स्टैकऑवरफ़्लो प्रश्न के उत्तर के रूप में प्रदान किया गया है ।
अब, निकाले गए आयात के साथ सभी को एक साथ लाना (इतना आसान है कि दोनों एक्लिप्स ScalaIDE और IntelliJ Scala प्लगइन में मौजूद स्कैला वर्कशीट में पेस्ट करना आसान हो जाए, ताकि डेस्कटॉप पर आउटपुट डंप करना आसान हो सके) एक टेक्स्ट एडिटर के साथ आसानी से जांच की जाए। यह वही है जो कोड जैसा दिखता है (बढ़ी हुई सहमति के साथ):
import scala.io.Source
import scala.util.Try
import java.io.{BufferedWriter, FileWriter, File, PrintWriter}
val defaultBufferSize: Int = 65536
def tryUsingAutoCloseable[A <: AutoCloseable, R]
(instantiateAutoCloseable: () => A) //parameter list 1
(transfer: A => scala.util.Try[R]) //parameter list 2
: scala.util.Try[R] =
Try(instantiateAutoCloseable())
.flatMap(
autoCloseable => {
var optionExceptionTry: Option[Exception] = None
try
transfer(autoCloseable)
catch {
case exceptionTry: Exception =>
optionExceptionTry = Some(exceptionTry)
throw exceptionTry
}
finally
try
autoCloseable.close()
catch {
case exceptionFinally: Exception =>
optionExceptionTry match {
case Some(exceptionTry) =>
exceptionTry.addSuppressed(exceptionFinally)
case None =>
throw exceptionFinally
}
}
}
)
def tryUsingSource[S <: scala.io.Source, R]
(instantiateSource: () => S)
(transfer: S => scala.util.Try[R])
: scala.util.Try[R] =
Try(instantiateSource())
.flatMap(
source => {
var optionExceptionTry: Option[Exception] = None
try
transfer(source)
catch {
case exceptionTry: Exception =>
optionExceptionTry = Some(exceptionTry)
throw exceptionTry
}
finally
try
source.close()
catch {
case exceptionFinally: Exception =>
optionExceptionTry match {
case Some(exceptionTry) =>
exceptionTry.addSuppressed(exceptionFinally)
case None =>
throw exceptionFinally
}
}
}
)
def tryPrintToFile(
lines: List[String],
location: File,
bufferSize: Int = defaultBufferSize
): Try[Unit] =
tryUsingAutoCloseable(() => new FileWriter(location)) { fileWriter =>
tryUsingAutoCloseable(() => new BufferedWriter(fileWriter, bufferSize)) { bufferedWriter =>
tryUsingAutoCloseable(() => new PrintWriter(bufferedWriter)) { printWriter =>
Try(lines.foreach(line => printWriter.println(line)))
}
}
}
def tryWriteToFile(
content: String,
location: File,
bufferSize: Int = defaultBufferSize
): Try[Unit] =
tryUsingAutoCloseable(() => new FileWriter(location)) { fileWriter =>
tryUsingAutoCloseable(() => new BufferedWriter(fileWriter, bufferSize)) { bufferedWriter =>
Try(bufferedWriter.write(content))
}
}
def tryProcessSource(
file: File,
parseLine: (String, Int) => List[String] = (line, index) => List(line),
filterLine: (List[String], Int) => Boolean = (values, index) => true,
retainValues: (List[String], Int) => List[String] = (values, index) => values,
isFirstLineNotHeader: Boolean = false
): Try[List[List[String]]] =
tryUsingSource(() => Source.fromFile(file)) { source =>
Try(
( for {
(line, index) <- source.getLines().buffered.zipWithIndex
values = parseLine(line, index)
if (index == 0 && !isFirstLineNotHeader) || filterLine(values, index)
retainedValues = retainValues(values, index)
} yield retainedValues
).toList
)
}
एक स्कैला / एफपी नौसिखिया के रूप में, मैंने उपरोक्त ज्ञान और समाधान अर्जित करने में कई घंटे (ज्यादातर सिर-खरोंच हताशा में) जलाए हैं। मुझे उम्मीद है कि यह अन्य स्कैला / एफपी न्यूबीज को इस विशेष सीखने की कूबड़ में तेजी से प्राप्त करने में मदद करता है।