Czytasz cały plik w Scali?

Jaki jest prosty i kanoniczny sposób wczytywania całego pliku do pamięci w Scali? (Idealnie, z kontrolą kodowania znaków.)

Najlepsze, co mogę wymyślić, to:

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

czy mam użyć jednego z okropnych idiomów Javy , z których najlepszym (bez użycia zewnętrznej biblioteki) wydaje się być:

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

Z lektury dyskusji na temat list mailingowych nie jest dla mnie jasne, że scala.io.Source ma być nawet kanoniczną biblioteką I / O. Nie rozumiem dokładnie, jaki jest jego zamierzony cel.

... Chciałbym coś prostego i łatwego do zapamiętania. Na przykład w tych językach bardzo trudno zapomnieć o idiomie ...

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

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

Nawiasem mówiąc, „ scala.” nie jest tak naprawdę konieczne, ponieważ i tak zawsze ma zasięg, i możesz oczywiście zaimportować zawartość io, całkowicie lub częściowo, i unikać konieczności dodawania „io”. też.

Powyższe pozostawia jednak plik otwarty. Aby uniknąć problemów, zamknij go w następujący sposób:

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

Innym problemem związanym z powyższym kodem jest to, że jest on strasznie wolny ze względu na jego charakter implementacyjny. W przypadku większych plików należy użyć:

source.getLines mkString "\n"

Aby rozwinąć rozwiązanie Daniela, możesz ogromnie skrócić ten proces, wstawiając następujący import do dowolnego pliku wymagającego manipulacji:

import scala.io.Source._

Dzięki temu możesz teraz:

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

Byłbym ostrożny, czytając cały plik w jeden String. To bardzo zły nawyk, który gryzie cię wcześniej i mocniej niż myślisz. getLinesMetoda zwraca wartość typu Iterator[String]. W rzeczywistości jest to leniwy kursor w pliku, pozwalający na sprawdzenie tylko potrzebnych danych bez ryzyka nadmiaru pamięci.

Aha, i aby odpowiedzieć na twoje dorozumiane pytanie dotyczące Source: tak, jest to kanoniczna biblioteka we / wy. Większość kodu używa java.ioze względu na interfejs niższego poziomu i lepszą kompatybilność z istniejącymi frameworkami, ale każdy kod, który ma wybór, powinien używać Source, szczególnie do prostej manipulacji plikami.

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

(EDYCJA: To nie działa w Scala 2.9 i może nie 2.8)

Użyj pnia:

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)

Kontrola kodowania znaków i brak zasobów do czyszczenia. Również ewentualnie zoptymalizowany (np. Files.readAllBytesAlokując tablicę bajtów odpowiednią do rozmiaru pliku).

Powiedziano mi, że Source.fromFile jest problematyczny. Osobiście miałem problemy z otwieraniem dużych plików za pomocą Source.fromFile i musiałem skorzystać z Java InputStreams.

Innym ciekawym rozwiązaniem jest użycie skalaksu. Oto przykład dobrze skomentowanego kodu, który otwiera plik dziennika za pomocą ManagedResource w celu otwarcia pliku za pomocą helperów: http://pastie.org/pastes/420714

Użycie getLines () na scala.io.Source odrzuca znaki, które zostały użyte dla terminatorów linii (\ n, \ r, \ r \ n itd.)

Poniższe powinny zachować znak po znaku i nie powodują nadmiernej konkatenacji ciągów (problemy z wydajnością):

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

Jeszcze jeden: https://github.com/pathikrit/better-files#streams-and-codecs

Różne sposoby usuwania pliku bez ładowania zawartości do pamięci:

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 

Możesz także podać swój własny kodek do wszystkiego, co wykonuje odczyt / zapis (przyjmuje kod scala.io.Codec.default, jeśli go nie podasz):

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

Podobnie jak w Javie, używając biblioteki CommonsIO:

FileUtils.readFileToString(file, StandardCharsets.UTF_8)

Wiele odpowiedzi tutaj zapomina o Charsecie. Lepiej zawsze podawać to wprost, bo inaczej pewnego dnia trafi.

Aby emulować składnię Rubiego (i przekazać semantykę) otwierania i czytania pliku, rozważ tę ukrytą klasę (Scala 2.10 i wyższa),

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

W ten sposób,

open("file.txt").read

jak kilka osób wspomniało o scala.io.Source najlepiej unikać ze względu na wycieki z połączenia.

Prawdopodobnie scalax i czyste biblioteki Java, takie jak commons-io, są najlepszymi opcjami do czasu scalenia nowego projektu inkubatora (tj. Scala-io).

możesz także użyć Ścieżki od scala io do odczytu i przetwarzania plików.

import scalax.file.Path

Teraz możesz uzyskać ścieżkę do pliku, używając: -

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

Możesz także dołączyć terminatory, ale domyślnie jest ustawiony na false.

Aby przyspieszyć ogólny odczyt / przesyłanie (dużego) pliku, rozważ zwiększenie rozmiaru bufferSize( Source.DefaultBufSizeustaw na 2048), na przykład w następujący sposób:

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

Uwaga Source.scala . Dalsza dyskusja znajduje się w sekcji Szybki odczyt pliku tekstowego Scala i przesłanie do pamięci .

Nie musisz analizować każdej linii, a następnie ponownie łączyć je ...

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

Wolę użyć tego:

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
}

Jeśli nie masz nic przeciwko zależności od innych firm, powinieneś rozważyć użycie mojej biblioteki OS-Lib . Dzięki temu odczytywanie / zapisywanie plików i praca z systemem plików jest bardzo wygodna:

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

z pomocnikami jednowierszowymi do odczytu bajtów , odczytu fragmentów , czytania linii i wielu innych przydatnych / typowych operacji

Oczywistym pytaniem jest „dlaczego chcesz przeczytać w całym pliku?” To oczywiście nie jest skalowalne rozwiązanie, jeśli twoje pliki stają się bardzo duże. scala.io.SourceDaje grzbiecie Iterator[String]z getLinesmetody, która jest bardzo przydatna i zwięzły.

Wymyślenie niejawnej konwersji przy użyciu podstawowych narzędzi IO Java do konwersji a File, a Readerlub a InputStreamna String. Nie jest wielkim zadaniem . Myślę, że brak skalowalności oznacza, że ​​słusznie nie dodają tego do standardowego interfejsu API.

wypisz każdą linię, np. użyj Java BufferedReader przeczytaj każdą linię i wydrukuj:

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

odpowiednik:

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

w argumentach możesz podać ścieżkę do pliku, a to zwróci wszystkie wiersze