Scala: escribe una cadena en un archivo en una declaración

Para leer archivos en Scala, hay

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

¿Hay una manera concisa y equivalente de escribir una cadena en el archivo?

La mayoría de los idiomas admiten algo así. Mi favorito es Groovy:

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

Me gustaría usar el código para programas que van desde una sola línea hasta una página corta de código. Tener que usar tu propia biblioteca no tiene sentido aquí. Espero que un lenguaje moderno me permita escribir algo en un archivo convenientemente.

Hay publicaciones similares a esta, pero no responden a mi pregunta exacta o se centran en versiones anteriores de Scala.

Por ejemplo:

• ¿Leer todo el archivo en Scala?
• ¿Cómo escribir en un archivo en Scala?

Una línea concisa:

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

Es extraño que nadie haya sugerido operaciones NIO.2 (disponible desde 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))

Creo que esta es, con mucho, la forma más simple, fácil e idiomática, y no necesita ninguna dependencia sin Java.

Aquí hay una línea concisa que usa reflect.io.file, esto funciona con Scala 2.12:

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

Alternativamente, si desea utilizar las bibliotecas de Java, puede hacer este truco:

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

Si le gusta la sintaxis de Groovy, puede usar el patrón de diseño Pimp-My-Library para llevarlo a 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 )

}

Funcionará como se esperaba:

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 que escribí: https://github.com/pathikrit/better-files

file.write("Hi!")

o

file << "Hi!"

Puede usar fácilmente Apache File Utils . Mira la función writeStringToFile. Usamos esta biblioteca en nuestros proyectos.

Uno también tiene este formato, que es conciso y la biblioteca subyacente está bellamente escrita (vea el código fuente):

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

Esto es bastante conciso, supongo:

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

Puede hacer esto con una combinación de bibliotecas Java y Scala. Tendrá control total sobre la codificación de caracteres. Pero desafortunadamente, los identificadores de archivo no se cerrarán correctamente.

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

Sé que no es una línea, pero resuelve los problemas de seguridad por lo que puedo ver;

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

Si no le importó el manejo de excepciones, puede escribir

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

ACTUALIZACIÓN: desde entonces he creado una solución más efectiva sobre la cual he elaborado aquí: https://stackoverflow.com/a/34277491/501113

Me encuentro trabajando cada vez más en la Hoja de trabajo de Scala dentro del IDE de Scala para Eclipse (y creo que hay algo equivalente en IntelliJ IDEA). De todos modos, necesito poder hacer una línea para generar algunos de los contenidos a medida que obtengo el mensaje "La salida excede el límite de corte". mensaje si estoy haciendo algo significativo, especialmente con las colecciones Scala.

Se me ocurrió una línea que inserto en la parte superior de cada nueva hoja de trabajo de Scala para simplificar esto (y, por lo tanto, no tengo que hacer todo el ejercicio de importación de la biblioteca externa para una necesidad muy simple). Si eres un fanático y notas que técnicamente son dos líneas, es solo para hacerlo más legible en este foro. Es una sola línea en mi Hoja de trabajo de 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}}

Y el uso es simplemente:

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

Esto me permite proporcionar opcionalmente el nombre del archivo si deseo tener archivos adicionales más allá del valor predeterminado (que sobrescribe completamente el archivo cada vez que se llama al método).

Entonces, el segundo uso es simplemente:

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

¡Disfrutar!

Utilice la biblioteca de operaciones de ammonite . La sintaxis es muy mínima, pero la amplitud de la biblioteca es casi tan amplia como lo que cabría esperar al intentar tal tarea en un lenguaje de scripting de shell como bash.

En la página a la que enlacé, muestra numerosas operaciones que uno puede hacer con la biblioteca, pero para responder a esta pregunta, este es un ejemplo de cómo escribir en un archivo

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

A través de la magia del punto y coma, puedes hacer lo que quieras con un solo trazo.

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