Scala: grava a string no arquivo em uma instrução

Para ler arquivos no Scala, há

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

Existe uma maneira equivalente e concisa de escrever uma string no arquivo?

A maioria dos idiomas suporta algo assim. O meu favorito é o Groovy:

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

Eu gostaria de usar o código para programas que variam de uma única linha a uma pequena página de código. Ter que usar sua própria biblioteca não faz sentido aqui. Espero que uma linguagem moderna me permita escrever algo em um arquivo convenientemente.

Existem posts semelhantes a este, mas eles não respondem à minha pergunta exata ou estão focados nas versões mais antigas do Scala.

Por exemplo:

• Leia o arquivo inteiro no Scala?
• Como gravar em um arquivo no Scala?

Uma linha concisa:

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

É estranho que ninguém tenha sugerido operações NIO.2 (disponíveis desde o 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))

Eu acho que essa é de longe a maneira mais simples, fácil e idiomática, e não precisa de nenhuma dependência do próprio Java.

Aqui está um alinhamento conciso usando o reflect.io.file, que funciona com o Scala 2.12:

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

Como alternativa, se você quiser usar as bibliotecas Java, poderá fazer isso:

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

Se você gosta da sintaxe Groovy, pode usar o padrão de design do Pimp-My-Library para trazê-lo para o 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á conforme o esperado:

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

Uma micro biblioteca que escrevi: https://github.com/pathikrit/better-files

file.write("Hi!")

ou

file << "Hi!"

Você pode usar facilmente o Apache File Utils . Veja a função writeStringToFile. Usamos essa biblioteca em nossos projetos.

Também se tem esse formato, que é conciso e a biblioteca subjacente é lindamente escrita (consulte o código-fonte):

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

Isso é conciso o suficiente, eu acho:

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

Você pode fazer isso com uma mistura de bibliotecas Java e Scala. Você terá controle total sobre a codificação de caracteres. Mas, infelizmente, os identificadores de arquivo não serão fechados corretamente.

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

Eu sei que não é uma linha, mas resolve os problemas de segurança, tanto quanto posso dizer;

// 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 você não se importou com o tratamento de exceções, pode escrever

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

ATUALIZAÇÃO: Desde então, criei uma solução mais eficaz sobre a qual elaborei aqui: https://stackoverflow.com/a/34277491/501113

Eu me pego trabalhando cada vez mais na Planilha Scala dentro do Scala IDE para Eclipse (e acredito que exista algo equivalente no IntelliJ IDEA). De qualquer forma, eu preciso ser capaz de criar uma única linha para produzir parte do conteúdo, pois obtenho o "Saída excede o limite de corte". mensagem se estou fazendo algo significativo, especialmente com as coleções Scala.

Eu vim com uma linha que eu insiro na parte superior de cada nova planilha Scala para simplificar isso (e, portanto, não preciso fazer todo o exercício de importação de biblioteca externa para uma necessidade muito simples). Se você é um defensor e percebe que são tecnicamente duas linhas, é apenas para torná-lo mais legível neste fórum. É uma única linha na minha planilha 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 o uso é simplesmente:

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

Isso permite que eu forneça opcionalmente o nome do arquivo, caso eu queira ter arquivos adicionais além do padrão (que substitui completamente o arquivo toda vez que o método é chamado).

Portanto, o segundo uso é simplesmente:

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

Aproveitar!

Use a biblioteca de operações de amonite . A sintaxe é muito mínima, mas a amplitude da biblioteca é quase tão ampla quanto o que se esperaria de tentar uma tarefa dessas em uma linguagem de script de shell como o bash.

Na página a que vinculei, ele mostra inúmeras operações que podemos fazer com a biblioteca, mas para responder a essa pergunta, este é um exemplo de gravação em um arquivo

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

Com a magia do ponto e vírgula, você pode fazer o que quiser como uma linha.

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