Ganze Datei in Scala lesen?

Was ist eine einfache und kanonische Methode, um eine ganze Datei in Scala in den Speicher zu lesen? (Idealerweise mit Kontrolle über die Zeichenkodierung.)

Das Beste, was ich mir einfallen lassen kann, ist:

scala.io.Source.fromPath("file.txt").getLines.reduceLeft(_+_)

oder soll ich eine von Javas gottesfürchtigen Redewendungen verwenden , von denen die beste (ohne Verwendung einer externen Bibliothek) zu sein scheint:

import java.util.Scanner
import java.io.File
new Scanner(new File("file.txt")).useDelimiter("\\Z").next()

Durch das Lesen von Mailinglistendiskussionen ist mir nicht klar, dass scala.io.Source sogar die kanonische E / A-Bibliothek sein soll. Ich verstehe nicht genau, was der beabsichtigte Zweck ist.

... Ich hätte gerne etwas ganz einfaches und leicht zu merkendes. Zum Beispiel ist es in diesen Sprachen sehr schwer, die Redewendung zu vergessen ...

Ruby    open("file.txt").read
Ruby    File.read("file.txt")
Python  open("file.txt").read()

val lines = scala.io.Source.fromFile("file.txt").mkString

Übrigens ist " scala." nicht wirklich notwendig, da es sowieso immer im Geltungsbereich liegt, und Sie können natürlich den Inhalt von io ganz oder teilweise importieren und vermeiden, "io" voranstellen zu müssen. auch.

Das Obige lässt die Datei jedoch offen. Um Probleme zu vermeiden, sollten Sie es folgendermaßen schließen:

val source = scala.io.Source.fromFile("file.txt")
val lines = try source.mkString finally source.close()

Ein weiteres Problem mit dem obigen Code ist, dass er aufgrund seiner Implementierung schrecklich langsam ist. Für größere Dateien sollte man verwenden:

source.getLines mkString "\n"

Um Daniels Lösung zu erweitern, können Sie die Dinge enorm verkürzen, indem Sie den folgenden Import in jede Datei einfügen, die eine Dateimanipulation erfordert:

import scala.io.Source._

Damit können Sie jetzt Folgendes tun:

val lines = fromFile("file.txt").getLines

Ich wäre vorsichtig, wenn ich eine ganze Datei in eine einzige lesen würde String. Es ist eine sehr schlechte Angewohnheit, die dich früher und härter beißen wird, als du denkst. Die getLinesMethode gibt einen Wert vom Typ zurück Iterator[String]. Es ist praktisch ein fauler Cursor in die Datei, mit dem Sie genau die Daten untersuchen können, die Sie benötigen, ohne das Risiko einer Speicherüberlastung einzugehen.

Oh, und um Ihre implizite Frage zu beantworten Source: Ja, es ist die kanonische E / A-Bibliothek. Der meiste Code wird java.ioaufgrund seiner untergeordneten Benutzeroberfläche und der besseren Kompatibilität mit vorhandenen Frameworks verwendet. Jeder Code, der eine Auswahl hat, sollte jedoch verwendet werden Source, insbesondere für die einfache Dateimanipulation.

// for file with utf-8 encoding
val lines = scala.io.Source.fromFile("file.txt", "utf-8").getLines.mkString

(EDIT: Dies funktioniert nicht in Scala 2.9 und vielleicht auch nicht in 2.8)

Kofferraum verwenden:

scala> io.File("/etc/passwd").slurp
res0: String = 
##
# User Database
# 
... etc

import java.nio.charset.StandardCharsets._
import java.nio.file.{Files, Paths}

new String(Files.readAllBytes(Paths.get("file.txt")), UTF_8)

Kontrolle über die Zeichenkodierung und keine zu bereinigenden Ressourcen. Möglicherweise auch optimiert (z. B. Files.readAllBytesZuweisen eines der Dateigröße entsprechenden Byte-Arrays).

Mir wurde gesagt, dass Source.fromFile problematisch ist. Persönlich hatte ich Probleme beim Öffnen großer Dateien mit Source.fromFile und musste auf Java InputStreams zurückgreifen.

Eine weitere interessante Lösung ist die Verwendung von Scalax. Hier ist ein Beispiel für einen gut kommentierten Code, der eine Protokolldatei mit ManagedResource öffnet, um eine Datei mit Scalax-Helfern zu öffnen: http://pastie.org/pastes/420714

Mit getLines () in scala.io.Source wird verworfen, welche Zeichen für Zeilenabschlusszeichen verwendet wurden (\ n, \ r, \ r \ n usw.).

Das Folgende sollte es Zeichen für Zeichen beibehalten und keine übermäßige Verkettung von Zeichenfolgen (Leistungsprobleme) verursachen:

def fileToString(file: File, encoding: String) = {
  val inStream = new FileInputStream(file)
  val outStream = new ByteArrayOutputStream
  try {
    var reading = true
    while ( reading ) {
      inStream.read() match {
        case -1 => reading = false
        case c => outStream.write(c)
      }
    }
    outStream.flush()
  }
  finally {
    inStream.close()
  }
  new String(outStream.toByteArray(), encoding)
}

Noch eine: https://github.com/pathikrit/better-files#streams-and-codecs

Verschiedene Möglichkeiten, eine Datei zu schlürfen, ohne den Inhalt in den Speicher zu laden:

val bytes  : Iterator[Byte]            = file.bytes
val chars  : Iterator[Char]            = file.chars
val lines  : Iterator[String]          = file.lines
val source : scala.io.BufferedSource   = file.content 

Sie können auch Ihren eigenen Codec für alles bereitstellen, was ein Lese- / Schreibvorgang ausführt (dies setzt scala.io.Codec.default voraus, wenn Sie keinen angeben):

val content: String = file.contentAsString  // default codec
// custom codec:
import scala.io.Codec
file.contentAsString(Codec.ISO8859)
//or
import scala.io.Codec.string2codec
file.write("hello world")(codec = "US-ASCII")

Genau wie in Java mit der CommonsIO-Bibliothek:

FileUtils.readFileToString(file, StandardCharsets.UTF_8)

Auch viele Antworten hier vergessen Charset. Es ist besser, es immer explizit anzugeben, sonst wird es eines Tages getroffen.

Berücksichtigen Sie diese implizite Klasse (Scala 2.10 und höher), um die Ruby-Syntax (und die Semantik) des Öffnens und Lesens einer Datei zu emulieren.

import java.io.File

def open(filename: String) = new File(filename)

implicit class RichFile(val file: File) extends AnyVal {
  def read = io.Source.fromFile(file).getLines.mkString("\n")
}

Auf diese Weise,

open("file.txt").read

Wie einige Leute bereits erwähnt haben, ist scala.io.Source aufgrund von Verbindungslecks am besten zu vermeiden.

Wahrscheinlich sind Scalax und reine Java-Bibliotheken wie Commons-Io die besten Optionen, bis das neue Inkubator-Projekt (dh Scala-Io) zusammengeführt wird.

Sie können auch Path from scala io verwenden, um Dateien zu lesen und zu verarbeiten.

import scalax.file.Path

Jetzt können Sie den Dateipfad folgendermaßen abrufen: -

val filePath = Path("path_of_file_to_b_read", '/')
val lines = file.lines(includeTerminator = true)

Sie können auch Terminatoren einschließen, diese sind jedoch standardmäßig auf false gesetzt.

Um das Lesen / Hochladen einer (großen) Datei insgesamt zu beschleunigen, sollten Sie die Größe von bufferSize( Source.DefaultBufSizeauf 2048) setzen, z. B. wie folgt:

val file = new java.io.File("myFilename")
io.Source.fromFile(file, bufferSize = Source.DefaultBufSize * 2)

Hinweis Source.scala . Weitere Informationen finden Sie unter Scala Fast-Textdatei lesen und in den Speicher hochladen .

Sie müssen nicht jede einzelne Zeile analysieren und dann erneut verketten ...

Source.fromFile(path)(Codec.UTF8).mkString

Ich benutze das lieber:

import scala.io.{BufferedSource, Codec, Source}
import scala.util.Try

def readFileUtf8(path: String): Try[String] = Try {
  val source: BufferedSource = Source.fromFile(path)(Codec.UTF8)
  val content = source.mkString
  source.close()
  content
}

Wenn Ihnen eine Abhängigkeit von Drittanbietern nichts ausmacht, sollten Sie meine OS-Lib-Bibliothek verwenden . Dies macht das Lesen / Schreiben von Dateien und das Arbeiten mit dem Dateisystem sehr bequem:

// Make sure working directory exists and is empty
val wd = os.pwd/"out"/"splash"
os.remove.all(wd)
os.makeDir.all(wd)

// Read/write files
os.write(wd/"file.txt", "hello")
os.read(wd/"file.txt") ==> "hello"

// Perform filesystem operations
os.copy(wd/"file.txt", wd/"copied.txt")
os.list(wd) ==> Seq(wd/"copied.txt", wd/"file.txt")

mit einzeiligen Helfern zum Lesen von Bytes , Lesen von Chunks , Lesen von Zeilen und vielen anderen nützlichen / allgemeinen Operationen

Die offensichtliche Frage lautet: "Warum möchten Sie die gesamte Datei einlesen?" Dies ist offensichtlich keine skalierbare Lösung, wenn Ihre Dateien sehr groß werden. Das scala.io.Sourcegibt Ihnen eine Iterator[String]von der getLinesMethode zurück, die sehr nützlich und prägnant ist.

Es ist keine große Aufgabe, eine implizite Konvertierung mit den zugrunde liegenden Java-E / A-Dienstprogrammen zu erstellen, um a File, a Readeroder a InputStreamin a zu konvertieren String. Ich denke, dass die mangelnde Skalierbarkeit bedeutet, dass sie richtig sind, dies nicht zur Standard-API hinzuzufügen.

Drucken Sie jede Zeile aus, wie z. B. Java BufferedReader, lesen Sie jede Zeile und drucken Sie sie aus:

scala.io.Source.fromFile("test.txt" ).foreach{  print  }

Äquivalent:

scala.io.Source.fromFile("test.txt" ).foreach( x => print(x))

import scala.io.source
object ReadLine{
def main(args:Array[String]){
if (args.length>0){
for (line <- Source.fromLine(args(0)).getLine())
println(line)
}
}

In Argumenten können Sie einen Dateipfad angeben, der alle Zeilen zurückgibt