Scala: zapisz ciąg do pliku w jednej instrukcji

Do czytania plików w Scali jest

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

Czy istnieje równoważny i zwięzły sposób zapisania ciągu znaków do pliku?

Większość języków obsługuje coś takiego. Moim ulubionym jest Groovy:

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

Chciałbym użyć kodu dla programów obejmujących od pojedynczego wiersza do krótkiej strony kodu. Korzystanie z własnej biblioteki nie ma tutaj sensu. Oczekuję, że nowoczesny język pozwoli mi wygodnie napisać coś do pliku.

Są posty podobne do tego, ale nie odpowiadają one dokładnie na moje pytanie lub dotyczą starszych wersji Scali.

Na przykład:

• Czy przeczytać cały plik w Scali?
• Jak pisać do pliku w Scali?

Zwięzła jedna linia:

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

To dziwne, że nikt nie zasugerował operacji NIO.2 (dostępnych od wersji 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))

Myślę, że jest to zdecydowanie najprostszy, najłatwiejszy i najbardziej idiomatyczny sposób, który nie wymaga żadnych zależności poza samą Javą.

Oto zwięzły, jednowierszowy tekst z użyciem pliku Reflect.io., który działa ze Scala 2.12:

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

Alternatywnie, jeśli chcesz użyć bibliotek Java, możesz zrobić to hack:

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

Jeśli podoba Ci się składnia Groovy, możesz użyć wzorca projektowego Pimp-My-Library, aby przenieść ją do Scala:

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 )

}

Będzie działać zgodnie z oczekiwaniami:

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") !

Mikro biblioteka, którą napisałem: https://github.com/pathikrit/better-files

file.write("Hi!")

lub

file << "Hi!"

Możesz łatwo użyć Apache File Utils . Spójrz na funkcję writeStringToFile. Używamy tej biblioteki w naszych projektach.

Jeden ma również ten format, który jest zwięzły, a podstawowa biblioteka jest pięknie napisana (patrz kod źródłowy):

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!")

Myślę, że jest to wystarczająco zwięzłe:

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()

Możesz to zrobić za pomocą mieszanki bibliotek Java i Scala. Będziesz mieć pełną kontrolę nad kodowaniem znaków. Niestety, uchwyty plików nie zostaną poprawnie zamknięte.

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"))

Wiem, że to nie jest jedna linijka, ale o ile wiem, rozwiązuje ona kwestie bezpieczeństwa;

// 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)

Jeśli nie dbałeś o obsługę wyjątków, możesz napisać

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

AKTUALIZACJA: od tego czasu stworzyłem bardziej efektywne rozwiązanie, nad którym omówiłem tutaj: https://stackoverflow.com/a/34277491/501113

Coraz częściej pracuję nad arkuszem Scala w środowisku Scala IDE dla Eclipse (i uważam, że w IntelliJ IDEA jest coś równoważnego). W każdym razie muszę być w stanie wykonać jedną linijkę, aby wydrukować część zawartości, gdy otrzymuję komunikat „Wyjście przekracza granicę odcięcia”. wiadomość, jeśli robię coś ważnego, szczególnie z kolekcjami Scala.

Wymyśliłem jedną linijkę, którą wstawiam na górze każdego nowego arkusza Scala, aby to uprościć (i dlatego nie muszę wykonywać całego ćwiczenia importowania biblioteki zewnętrznej z bardzo prostej potrzeby). Jeśli jesteś sticklerem i zauważysz, że technicznie jest to dwie linie, to tylko po to, aby uczynić ją bardziej czytelną na tym forum. To jest pojedyncza linia w moim arkuszu Scala.

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}}

A użycie jest po prostu:

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

Dzięki temu mogę opcjonalnie podać nazwę pliku, jeśli chcę mieć dodatkowe pliki poza domyślnymi (co całkowicie zastępuje plik za każdym razem, gdy wywoływana jest metoda).

Tak więc drugie użycie to po prostu:

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

Cieszyć się!

Użyj biblioteki ammonite ops . Składnia jest bardzo minimalna, ale rozpiętość biblioteki jest prawie tak szeroka, jak można by się spodziewać po wykonaniu takiego zadania w języku skryptowym powłoki, takim jak bash.

Na stronie, do której się łącze, pokazuje wiele operacji, które można wykonać z biblioteką, ale aby odpowiedzieć na to pytanie, oto przykład zapisu do pliku

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

Dzięki magii średnika możesz zrobić wszystko, co ci się podoba, w jednej linii.

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()