Scala: écrire une chaîne dans un fichier en une seule instruction

Pour lire des fichiers dans Scala, il existe

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

Existe-t-il un moyen équivalent et concis d'écrire une chaîne dans un fichier?

La plupart des langues prennent en charge quelque chose comme ça. Mon préféré est Groovy:

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

J'aimerais utiliser le code pour des programmes allant d'une seule ligne à une courte page de code. Devoir utiliser votre propre bibliothèque n'a pas de sens ici. Je m'attends à ce qu'un langage moderne me permette d'écrire quelque chose dans un fichier facilement.

Il existe des articles similaires à celui-ci, mais ils ne répondent pas à ma question exacte ou sont axés sur les anciennes versions de Scala.

Par exemple:

• Lire le fichier entier dans Scala?
• Comment écrire dans un fichier dans Scala?

Une ligne concise:

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

Il est étrange que personne n'ait suggéré d'opérations NIO.2 (disponibles depuis 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))

Je pense que c'est de loin le moyen le plus simple et le plus simple et le plus idiomatique, et il n'a besoin d'aucune dépendance sans Java lui-même.

Voici un one-liner concis utilisant reflect.io.file, cela fonctionne avec Scala 2.12:

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

Alternativement, si vous souhaitez utiliser les bibliothèques Java, vous pouvez faire ce hack:

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

Si vous aimez la syntaxe Groovy, vous pouvez utiliser le modèle de conception Pimp-My-Library pour l'amener à 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 )

}

Cela fonctionnera comme prévu:

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

Une micro bibliothèque que j'ai écrite: https://github.com/pathikrit/better-files

file.write("Hi!")

ou

file << "Hi!"

Vous pouvez facilement utiliser Apache File Utils . Regardez la fonction writeStringToFile. Nous utilisons cette bibliothèque dans nos projets.

On a aussi ce format, qui est à la fois concis et la bibliothèque sous-jacente est magnifiquement écrite (voir le code source):

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

C'est assez concis, je suppose:

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

Vous pouvez le faire avec un mélange de bibliothèques Java et Scala. Vous aurez un contrôle total sur l'encodage des caractères. Mais malheureusement, les descripteurs de fichiers ne seront pas fermés correctement.

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

Je sais que ce n'est pas une ligne, mais cela résout les problèmes de sécurité pour autant que je sache;

// 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 vous ne vous souciez pas de la gestion des exceptions, vous pouvez écrire

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

MISE À JOUR: J'ai depuis créé une solution plus efficace sur laquelle j'ai élaboré ici: https://stackoverflow.com/a/34277491/501113

Je travaille de plus en plus dans la feuille de travail Scala dans l'EDI Scala pour Eclipse (et je crois qu'il y a quelque chose d'équivalent dans IntelliJ IDEA). Quoi qu'il en soit, je dois être capable de faire un one-liner pour sortir une partie du contenu lorsque j'obtiens le message "La sortie dépasse la limite de coupure". message si je fais quelque chose d'important, en particulier avec les collections Scala.

J'ai créé une ligne unique que j'insère en haut de chaque nouvelle feuille de travail Scala pour simplifier cela (et je n'ai donc pas à faire tout l'exercice d'importation de bibliothèque externe pour un besoin très simple). Si vous êtes un stickler et que vous remarquez qu'il s'agit techniquement de deux lignes, c'est uniquement pour le rendre plus lisible dans ce forum. C'est une seule ligne dans ma feuille de calcul 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}}

Et l'utilisation est simplement:

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

Cela me permet de fournir éventuellement le nom du fichier si je veux avoir des fichiers supplémentaires au-delà de la valeur par défaut (qui écrase complètement le fichier à chaque fois que la méthode est appelée).

Donc, la deuxième utilisation est simplement:

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

Prendre plaisir!

Utilisez des opérations d'ammonite bibliothèque d' . La syntaxe est très minimale, mais l'étendue de la bibliothèque est presque aussi large que ce à quoi on pourrait s'attendre en tentant une telle tâche dans un langage de script shell comme bash.

Sur la page à laquelle j'ai lié, il montre de nombreuses opérations que l'on peut faire avec la bibliothèque, mais pour répondre à cette question, voici un exemple d'écriture dans un fichier

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

Grâce à la magie du point-virgule, vous pouvez créer tout ce que vous aimez en une seule ligne.

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