¿Leer todo el archivo en Scala?

¿Cuál es una manera simple y canónica de leer un archivo completo en la memoria en Scala? (Idealmente, con control sobre la codificación de caracteres).

Lo mejor que se me ocurre es:

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

o se supone que debo usar uno de los espantosos modismos de Java , el mejor de los cuales (sin usar una biblioteca externa) parece ser:

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

Al leer las discusiones de la lista de correo, no me queda claro que scala.io.Source incluso sea la biblioteca de E / S canónica. No entiendo cuál es su propósito, exactamente.

... Me gustaría algo muy simple y fácil de recordar. Por ejemplo, en estos idiomas es muy difícil olvidar el idioma ...

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

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

Por cierto, " scala." no es realmente necesario, ya que de todos modos siempre está dentro del alcance y, por supuesto, puede importar el contenido de io, total o parcialmente, y evitar tener que anteponer "io". también.

Sin embargo, lo anterior deja el archivo abierto. Para evitar problemas, debe cerrarlo así:

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

Otro problema con el código anterior es que es muy lento debido a su naturaleza de implementación. Para archivos más grandes uno debe usar:

source.getLines mkString "\n"

Solo para ampliar la solución de Daniel, puede acortar enormemente las cosas insertando la siguiente importación en cualquier archivo que requiera manipulación de archivos:

import scala.io.Source._

Con esto, ahora puedes hacer:

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

Sería cauteloso de leer un archivo completo en uno solo String. Es un mal hábito, uno que te morderá antes y con más fuerza de lo que piensas. El getLinesmétodo devuelve un valor de tipo Iterator[String]. Es efectivamente un cursor lento en el archivo, lo que le permite examinar solo los datos que necesita sin arriesgar el exceso de memoria.

Ah, y para responder a su pregunta implícita sobre Source: sí, es la biblioteca de E / S canónica. La mayoría del código termina usando java.iodebido a su interfaz de nivel inferior y una mejor compatibilidad con los marcos existentes, pero cualquier código que tenga una opción debe usarse Source, particularmente para la simple manipulación de archivos.

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

(EDITAR: Esto no funciona en scala 2.9 y quizás tampoco 2.8)

Usar baúl:

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)

Control sobre la codificación de caracteres y sin recursos para limpiar. Además, posiblemente optimizado (por ejemplo, Files.readAllBytesasignando una matriz de bytes adecuada al tamaño del archivo).

Me han dicho que Source.fromFile es problemático. Personalmente, tuve problemas para abrir archivos grandes con Source.fromFile y tuve que recurrir a Java InputStreams.

Otra solución interesante es usar scalax. Aquí hay un ejemplo de un código bien comentado que abre un archivo de registro usando ManagedResource para abrir un archivo con ayudantes de scalax: http://pastie.org/pastes/420714

El uso de getLines () en scala.io.Source descarta qué caracteres se usaron para los terminadores de línea (\ n, \ r, \ r \ n, etc.)

Lo siguiente debería preservarlo carácter por carácter, y no hace una concatenación excesiva de cadenas (problemas de rendimiento):

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

Uno más: https://github.com/pathikrit/better-files#streams-and-codecs

Varias formas de sorber un archivo sin cargar el contenido en la memoria:

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 

También puede suministrar su propio códec para cualquier cosa que haga una lectura / escritura (se supone scala.io.Codec.default si no proporciona uno):

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

Al igual que en Java, usando la biblioteca CommonsIO:

FileUtils.readFileToString(file, StandardCharsets.UTF_8)

Además, muchas respuestas aquí olvidan Charset. Es mejor proporcionarlo siempre explícitamente, o llegará algún día.

Para emular la sintaxis de Ruby (y transmitir la semántica) de abrir y leer un archivo, considere esta clase implícita (Scala 2.10 y superior),

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

De este modo,

open("file.txt").read

como algunas personas mencionaron scala.io.Source es mejor evitarlo debido a fugas de conexión.

Probablemente, scalax y las bibliotecas Java puras como commons-io son las mejores opciones hasta que el nuevo proyecto de incubadora (es decir, scala-io) se fusione.

También puede usar Path from Scala io para leer y procesar archivos.

import scalax.file.Path

Ahora puede obtener la ruta del archivo con esto: -

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

También puede incluir terminadores, pero de forma predeterminada está establecido en falso.

Para una lectura / carga general más rápida de un archivo (grande), considere aumentar el tamaño de bufferSize( Source.DefaultBufSizeestablecido en 2048), por ejemplo, de la siguiente manera,

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

Nota Source.scala . Para una discusión más detallada, vea el archivo de texto rápido Scala leído y cargado en la memoria .

No es necesario analizar cada línea y luego volver a concatenarlas ...

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

Prefiero usar esto:

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
}

Si no le importa una dependencia de terceros, debería considerar usar mi biblioteca OS-Lib . Esto hace que leer / escribir archivos y trabajar con el sistema de archivos sea muy conveniente:

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

con ayudantes de una línea para leer bytes , leer fragmentos , leer líneas y muchas otras operaciones útiles / comunes

La pregunta obvia es "¿por qué quieres leer todo el archivo?" Obviamente, esta no es una solución escalable si sus archivos se hacen muy grandes. El scala.io.Sourceda hacer una copia de un Iterator[String]Del getLinesmétodo, que es muy útil y concisa.

No es un gran trabajo lograr una conversión implícita utilizando las utilidades Java IO subyacentes para convertir a File, a Readero an en InputStreama String. Creo que la falta de escalabilidad significa que son correctos para no agregar esto a la API estándar.

imprima cada línea, como utilizar Java BufferedReader, lea cada línea e imprímala:

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

equivalente:

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

en argumentos, puede dar la ruta del archivo y devolverá todas las líneas