Baca seluruh file di Scala?

Apa cara sederhana dan kanonik untuk membaca seluruh file ke dalam memori di Scala? (Idealnya, dengan kontrol atas pengkodean karakter.)

Yang terbaik yang bisa saya dapatkan adalah:

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

atau apakah saya seharusnya menggunakan salah satu idiom mengerikan Jawa , yang terbaik (tanpa menggunakan perpustakaan eksternal) tampaknya adalah:

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

Dari membaca diskusi milis, tidak jelas bagi saya bahwa scala.io.Sumber bahkan seharusnya menjadi perpustakaan I / O kanonik. Saya tidak mengerti apa tujuan yang dimaksudkan, tepatnya.

... Saya ingin sesuatu yang mati sederhana dan mudah diingat. Misalnya, dalam bahasa ini sangat sulit untuk melupakan idiom ...

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

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

Ngomong-ngomong, " scala." tidak benar-benar diperlukan, karena selalu ada dalam ruang lingkup, dan Anda tentu saja dapat mengimpor konten io, sepenuhnya atau sebagian, dan menghindari keharusan untuk menambahkan "io." terlalu.

Namun, file di atas tetap terbuka. Untuk menghindari masalah, Anda harus menutupnya seperti ini:

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

Masalah lain dengan kode di atas adalah sangat lambat karena sifat implementasinya. Untuk file yang lebih besar harus digunakan:

source.getLines mkString "\n"

Hanya untuk memperluas solusi Daniel, Anda dapat mempersingkat banyak hal dengan memasukkan impor berikut ke dalam file apa pun yang memerlukan manipulasi file:

import scala.io.Source._

Dengan ini, Anda sekarang dapat melakukan:

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

Saya akan berhati-hati membaca seluruh file menjadi satu String. Ini adalah kebiasaan yang sangat buruk, yang akan menggigit Anda lebih cepat dan lebih keras daripada yang Anda pikirkan. The getLinesmethod mengembalikan nilai tipe Iterator[String]. Secara efektif kursor malas ke dalam file, memungkinkan Anda untuk memeriksa hanya data yang Anda butuhkan tanpa risiko kekenyangan memori.

Oh, dan untuk menjawab pertanyaan tersirat Anda tentang Source: ya, itu adalah perpustakaan I / O kanonik. Sebagian besar kode akhirnya digunakan java.iokarena antarmuka tingkat rendah dan kompatibilitas yang lebih baik dengan kerangka kerja yang ada, tetapi kode apa pun yang memiliki pilihan harus digunakan Source, terutama untuk manipulasi file sederhana.

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

(EDIT: Ini tidak berfungsi di scala 2.9 dan mungkin juga tidak 2.8)

Gunakan bagasi:

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)

Kontrol atas pengkodean karakter, dan tidak ada sumber daya untuk dibersihkan. Juga, mungkin dioptimalkan (misalnya Files.readAllBytesmengalokasikan array byte yang sesuai dengan ukuran file).

Saya telah diberitahu bahwa Source.fromFile bermasalah. Secara pribadi, saya punya masalah membuka file besar dengan Source.fromFile dan harus menggunakan Java InputStreams.

Solusi lain yang menarik adalah menggunakan scalax. Berikut adalah contoh beberapa kode yang berkomentar dengan baik yang membuka file log menggunakan ManagedResource untuk membuka file dengan scalax helpers: http://pastie.org/pastes/420714

Menggunakan getLines () di scala.io.Source membuang karakter apa yang digunakan untuk terminator garis (\ n, \ r, \ r \ n, dll.)

Berikut ini harus mempertahankannya karakter-untuk-karakter, dan tidak melakukan penggabungan string yang berlebihan (masalah kinerja):

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

Satu lagi: https://github.com/pathikrit/better-files#streams-and-codecs

Berbagai cara untuk menyeruput file tanpa memuat konten ke dalam memori:

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 

Anda juga dapat menyediakan codec Anda sendiri untuk apa pun yang melakukan baca / tulis (ini mengasumsikan scala.io.Codec.default jika Anda tidak menyediakannya):

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

Sama seperti di Jawa, menggunakan perpustakaan CommonsIO:

FileUtils.readFileToString(file, StandardCharsets.UTF_8)

Juga, banyak jawaban di sini melupakan Charset. Lebih baik untuk selalu memberikannya secara eksplisit, atau itu akan mencapai satu hari.

Untuk meniru sintaksis Ruby (dan menyampaikan semantik) dari membuka dan membaca file, pertimbangkan kelas implisit ini (Scala 2.10 dan lebih tinggi),

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

Lewat sini,

open("file.txt").read

karena beberapa orang menyebutkan scala.io.Source sebaiknya dihindari karena kebocoran koneksi.

Mungkin scalax dan lib java murni seperti commons-io adalah opsi terbaik sampai proyek inkubator baru (yaitu scala-io) digabung.

Anda juga dapat menggunakan Path dari scala io untuk membaca dan memproses file.

import scalax.file.Path

Sekarang Anda bisa mendapatkan jalur file menggunakan ini: -

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

Anda juga dapat menyertakan terminator tetapi secara default diatur ke false ..

Untuk keseluruhan lebih cepat membaca / mengunggah file (besar), pertimbangkan untuk meningkatkan ukuran bufferSize( Source.DefaultBufSizediatur ke 2048), misalnya sebagai berikut,

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

Catatan Source.scala . Untuk diskusi lebih lanjut lihat Scala file teks cepat baca dan unggah ke memori .

Anda tidak perlu menguraikan setiap baris dan kemudian menggabungkannya lagi ...

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

Saya lebih suka menggunakan ini:

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
}

Jika Anda tidak keberatan dengan ketergantungan pihak ketiga, Anda harus mempertimbangkan untuk menggunakan perpustakaan OS-Lib saya . Ini membuat membaca / menulis file dan bekerja dengan sistem file sangat nyaman:

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

dengan pembantu satu baris untuk membaca byte , bacaan bacaan , baris bacaan , dan banyak operasi lain yang bermanfaat / umum

Pertanyaan yang jelas adalah "mengapa Anda ingin membaca di seluruh file?" Ini jelas bukan solusi yang dapat diskalakan jika file Anda menjadi sangat besar. The scala.io.Sourcememberi Anda kembali sebuah Iterator[String]darigetLines metode, yang sangat berguna dan ringkas.

Tidak banyak pekerjaan untuk menghasilkan konversi implisit menggunakan utilitas IO java yang mendasari untuk mengkonversi a File, a Readeratau a InputStreamke String. Saya pikir kurangnya skalabilitas berarti mereka benar untuk tidak menambahkan ini ke API standar.

cetak setiap baris, seperti gunakan Java BufferedReader baca setiap baris, dan cetak:

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

setara:

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

dalam argumen Anda dapat memberikan path file dan itu akan mengembalikan semua baris