manejo - Scala: escribe cadena en archivo en una declaración

que es string en java

Question

Para leer archivos en Scala, hay

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

¿Hay una forma equivalente y concisa de escribir una cadena en un archivo?

La mayoría de los lenguajes 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 utilizar el código para programas que van desde una sola línea a 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 antiguas de Scala.

Por ejemplo:

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

Answer 1

A través de la magia del punto y coma, puedes hacer todo 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()

Answer 2

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

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

Se me ocurrió una línea que inserté en la parte superior de cada nueva hoja de trabajo de Scala para simplificar esto (y así 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 observas 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 simple:

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

Esto me permite opcionalmente proporcionar el nombre del archivo si quiero tener archivos adicionales más allá del 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!

Answer 3

Aquí hay un resumen conciso utilizando la biblioteca del compilador de Scala:

scala.tools.nsc.io.File("filename").writeAll("hello world")

Alternativamente, si quiere usar las bibliotecas de Java puede hacer esto:

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

Answer 4

Es extraño que nadie haya sugerido operaciones NIO.2 (disponibles 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, de lejos, la forma más simple, fácil y idiomática, y no necesita ninguna dependencia sin Java.

Answer 5

Esto es lo suficientemente 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()

Answer 6

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

Answer 7

Puedes hacer esto con una mezcla de bibliotecas de Java y Scala. Tendrás control total sobre la codificación de caracteres. 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"))

Answer 8

Sé que no es una línea, pero resuelve los problemas de seguridad hasta donde sé;

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

Answer 9

Si le gusta la sintaxis de Groovy, puede usar el patrón de diseño de 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 espera:

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

Answer 10

Una línea concisa:

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

Answer 11

Una micro biblioteca que escribí: https://github.com/pathikrit/better-files

file.write("Hi!")

o

file << "Hi!"

Answer 12

Uno también tiene este formato, que es a la vez conciso y la biblioteca subyacente está bellamente escrita (ver 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!")

Answer 13

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