Scala: Schreiben Sie einen String in eine Anweisung in eine Datei

Zum Lesen von Dateien in Scala gibt es

Source.fromFile("file.txt").mkString

Gibt es eine äquivalente und präzise Möglichkeit, einen String in eine Datei zu schreiben?

Die meisten Sprachen unterstützen so etwas. Mein Favorit ist Groovy:

def f = new File("file.txt")
// Read
def s = f.text
// Write
f.text = "file contents"

Ich möchte den Code für Programme verwenden, die von einer einzelnen Zeile bis zu einer kurzen Codepage reichen. Eine eigene Bibliothek benutzen zu müssen, macht hier keinen Sinn. Ich erwarte von einer modernen Sprache, dass ich bequem etwas in eine Datei schreiben kann.

Es gibt ähnliche Beiträge, aber sie beantworten meine genaue Frage nicht oder konzentrieren sich auf ältere Scala-Versionen.

Beispielsweise:

• Ganze Datei in Scala lesen?
• Wie schreibe ich in eine Datei in Scala?

Eine kurze Zeile:

import java.io.PrintWriter
new PrintWriter("filename") { write("file contents"); close }

Es ist seltsam, dass niemand NIO.2-Operationen vorgeschlagen hat (verfügbar seit Java 7):

import java.nio.file.{Paths, Files}
import java.nio.charset.StandardCharsets

Files.write(Paths.get("file.txt"), "file contents".getBytes(StandardCharsets.UTF_8))

Ich denke, dies ist bei weitem der einfachste und einfachste und idiomatischste Weg, und es werden keine Abhängigkeiten ohne Java selbst benötigt.

Hier ist ein prägnanter Einzeiler mit Reflect.io.file, der mit Scala 2.12 funktioniert:

reflect.io.File("filename").writeAll("hello world")

Wenn Sie die Java-Bibliotheken verwenden möchten, können Sie alternativ diesen Hack ausführen:

Some(new PrintWriter("filename")).foreach{p => p.write("hello world"); p.close}

Wenn Sie die Groovy-Syntax mögen, können Sie das Entwurfsmuster Pimp-My-Library verwenden, um es zu Scala zu bringen:

import java.io._
import scala.io._

class RichFile( file: File ) {

  def text = Source.fromFile( file )(Codec.UTF8).mkString

  def text_=( s: String ) {
    val out = new PrintWriter( file , "UTF-8")
    try{ out.print( s ) }
    finally{ out.close }
  }
}

object RichFile {

  implicit def enrichFile( file: File ) = new RichFile( file )

}

Es wird wie erwartet funktionieren:

scala> import RichFile.enrichFile
import RichFile.enrichFile

scala> val f = new File("/tmp/example.txt")
f: java.io.File = /tmp/example.txt

scala> f.text = "hello world"

scala> f.text
res1: String = 
"hello world

import sys.process._
"echo hello world" #> new java.io.File("/tmp/example.txt") !

Eine Mikrobibliothek, die ich geschrieben habe: https://github.com/pathikrit/better-files

file.write("Hi!")

oder

file << "Hi!"

Sie können Apache File Utils problemlos verwenden . Schauen Sie sich die Funktion an writeStringToFile. Wir verwenden diese Bibliothek in unseren Projekten.

Man hat auch dieses Format, das sowohl prägnant ist als auch die zugrunde liegende Bibliothek wunderschön geschrieben ist (siehe Quellcode):

import scalax.io.Codec
import scalax.io.JavaConverters._

implicit val codec = Codec.UTF8

new java.io.File("hi-file.txt").asOutput.write("I'm a hi file! ... Really!")

Das ist kurz genug, denke ich:

scala> import java.io._
import java.io._

scala> val w = new BufferedWriter(new FileWriter("output.txt"))
w: java.io.BufferedWriter = java.io.BufferedWriter@44ba4f

scala> w.write("Alice\r\nBob\r\nCharlie\r\n")

scala> w.close()

Sie können dies mit einer Mischung aus Java- und Scala-Bibliotheken tun. Sie haben die volle Kontrolle über die Zeichenkodierung. Leider werden die Dateihandles nicht richtig geschlossen.

scala> import java.io.ByteArrayInputStream
import java.io.ByteArrayInputStream

scala> import java.io.FileOutputStream
import java.io.FileOutputStream

scala> BasicIO.transferFully(new ByteArrayInputStream("test".getBytes("UTF-8")), new FileOutputStream("test.txt"))

Ich weiß, dass es nicht eine Zeile ist, aber es löst die Sicherheitsprobleme, soweit ich das beurteilen kann.

// This possibly creates a FileWriter, but maybe not
val writer = Try(new FileWriter(new File("filename")))
// If it did, we use it to write the data and return it again
// If it didn't we skip the map and print the exception and return the original, just in-case it was actually .write() that failed
// Then we close the file
writer.map(w => {w.write("data"); w}).recoverWith{case e => {e.printStackTrace(); writer}}.map(_.close)

Wenn Sie sich nicht um die Ausnahmebehandlung gekümmert haben, können Sie schreiben

writer.map(w => {w.writer("data"); w}).recoverWith{case _ => writer}.map(_.close)

UPDATE: Ich habe seitdem eine effektivere Lösung erstellt, auf die ich hier näher eingegangen bin: https://stackoverflow.com/a/34277491/501113

Ich arbeite immer mehr im Scala-Arbeitsblatt innerhalb der Scala-IDE für Eclipse (und ich glaube, dass IntelliJ IDEA etwas Äquivalentes enthält). Wie auch immer, ich muss in der Lage sein, einen Einzeiler zu erstellen, um einen Teil des Inhalts auszugeben, wenn ich die Meldung "Ausgabe überschreitet Grenzwert" erhalte. Nachricht, wenn ich etwas Bedeutendes tue, insbesondere mit den Scala-Sammlungen.

Ich habe mir einen Einzeiler ausgedacht, den ich oben in jedes neue Scala-Arbeitsblatt eingefügt habe, um dies zu vereinfachen (und daher muss ich nicht die gesamte Übung zum Importieren externer Bibliotheken für einen sehr einfachen Bedarf durchführen). Wenn Sie ein Stickler sind und feststellen, dass es sich technisch gesehen um zwei Zeilen handelt, dient dies nur dazu, die Lesbarkeit in diesem Forum zu verbessern. Es ist eine einzelne Zeile in meinem Scala-Arbeitsblatt.

def printToFile(content: String, location: String = "C:/Users/jtdoe/Desktop/WorkSheet.txt") =
  Some(new java.io.PrintWriter(location)).foreach{f => try{f.write(content)}finally{f.close}}

Und die Verwendung ist einfach:

printToFile("A fancy test string\ncontaining newlines\nOMG!\n")

Auf diese Weise kann ich optional den Dateinamen angeben, falls ich zusätzliche Dateien über den Standard hinaus haben möchte (wodurch die Datei bei jedem Aufruf der Methode vollständig überschrieben wird).

Die zweite Verwendung ist also einfach:

printToFile("A fancy test string\ncontaining newlines\nOMG!\n", "C:/Users/jtdoe/Desktop/WorkSheet.txt")

Genießen!

Verwenden Sie die Ammonite Ops Library. Die Syntax ist sehr minimal, aber die Breite der Bibliothek ist fast so groß, wie man es erwarten würde, wenn man eine solche Aufgabe in einer Shell-Skriptsprache wie bash versucht.

Auf der Seite, auf die ich verlinkt habe, werden zahlreiche Vorgänge angezeigt, die mit der Bibliothek ausgeführt werden können. Um diese Frage zu beantworten, ist dies ein Beispiel für das Schreiben in eine Datei

import ammonite.ops._
write(pwd/'"file.txt", "file contents")

Durch die Magie des Semikolons können Sie alles, was Sie möchten, zu einem Einzeiler machen.

import java.io.PrintWriter
import java.nio.file.Files
import java.nio.file.Paths
import java.nio.charset.StandardCharsets
import java.nio.file.StandardOpenOption
val outfile = java.io.File.createTempFile("", "").getPath
val outstream = new PrintWriter(Files.newBufferedWriter(Paths.get(outfile)
  , StandardCharsets.UTF_8
  , StandardOpenOption.WRITE)); outstream.println("content"); outstream.flush(); outstream.close()