Scala: scrivere una stringa su un file in un'istruzione

Per leggere i file in Scala, c'è

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

Esiste un modo equivalente e conciso per scrivere una stringa su file?

Molte lingue supportano qualcosa del genere. Il mio preferito è Groovy:

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

Vorrei usare il codice per programmi che vanno da una singola riga a una breve pagina di codice. Dover usare la tua libreria non ha senso qui. Mi aspetto che un linguaggio moderno mi permetta di scrivere comodamente qualcosa su un file.

Ci sono post simili a questo, ma non rispondono alla mia domanda esatta o si concentrano su versioni precedenti di Scala.

Per esempio:

• Leggi l'intero file in Scala?
• Come scrivere su un file in Scala?

Una riga concisa:

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

È strano che nessuno abbia suggerito operazioni NIO.2 (disponibili da 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))

Penso che questo sia di gran lunga il modo più semplice, più semplice e più idiomatico, e non ha bisogno di dipendenze rispetto a Java stesso.

Ecco un conciso one-liner che utilizza reflection.io.file, funziona con Scala 2.12:

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

In alternativa, se si desidera utilizzare le librerie Java, è possibile eseguire questo hack:

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

Se ti piace la sintassi di Groovy, puoi usare il modello di progettazione Pimp-My-Library per portarlo su 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 )

}

Funzionerà come previsto:

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

Una micro biblioteca che ho scritto: https://github.com/pathikrit/better-files

file.write("Hi!")

o

file << "Hi!"

Puoi facilmente usare i file Apache Utils . Guarda la funzione writeStringToFile. Usiamo questa libreria nei nostri progetti.

Uno ha anche questo formato, che è allo stesso tempo conciso e la libreria sottostante è magnificamente scritta (vedi il codice sorgente):

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

Questo è abbastanza conciso, immagino:

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

Puoi farlo con un mix di librerie Java e Scala. Avrai il pieno controllo sulla codifica dei caratteri. Ma sfortunatamente, gli handle di file non verranno chiusi correttamente.

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

So che non è una riga, ma risolve i problemi di sicurezza per quanto posso dire;

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

Se non ti interessa la gestione delle eccezioni, puoi scrivere

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

AGGIORNAMENTO: Da allora ho creato una soluzione più efficace su cui ho elaborato qui: https://stackoverflow.com/a/34277491/501113

Mi ritrovo a lavorare sempre di più nel foglio di lavoro Scala all'interno dell'IDE Scala per Eclipse (e credo che ci sia qualcosa di equivalente in IntelliJ IDEA). In ogni caso, devo essere in grado di fare un solo liner per produrre alcuni dei contenuti man mano che ottengo il "Output supera il limite di cutoff". messaggio se sto facendo qualcosa di significativo, specialmente con le collezioni Scala.

Mi è venuta in mente una riga che inserisco nella parte superiore di ogni nuovo foglio di lavoro Scala per semplificare ciò (e quindi non devo fare l'intero esercizio di importazione di librerie esterne per un bisogno molto semplice). Se sei un pignolo e noti che è tecnicamente due righe, è solo per renderlo più leggibile in questo forum. È una riga singola nel mio foglio di lavoro 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}}

E l'uso è semplicemente:

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

Questo mi permette di fornire facoltativamente il nome del file se voglio avere file aggiuntivi oltre il valore predefinito (che sovrascrive completamente il file ogni volta che viene chiamato il metodo).

Quindi, il secondo utilizzo è semplicemente:

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

Godere!

Usa la libreria di ammonite ops . La sintassi è molto minima, ma l'ampiezza della libreria è quasi ampia quanto quello che ci si aspetterebbe da tentare una simile attività in un linguaggio di script di shell come bash.

Nella pagina a cui mi sono collegato, mostra numerose operazioni che è possibile eseguire con la libreria, ma per rispondere a questa domanda, questo è un esempio di scrittura su un file

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

Attraverso la magia del punto e virgola, puoi creare qualsiasi cosa ti piaccia una fodera.

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