kotlin - reales - libro de android studio en español pdf

¿Cómo escribo en un archivo en Kotlin?

Question

Parece que aún no puedo encontrar esta pregunta, pero ¿cuál es la forma más simple e idiomática de abrir / crear un archivo, escribir en él y luego cerrarlo? Mirando la referencia de kotlin.io y la documentación de Java logré obtener esto:

fun write() {
val writer = PrintWriter("file.txt") // java.io.PrintWriter
for ((member, originalInput) in history) { // history: Map<Member, String>
writer.append("$member, $originalInput/n")
}
writer.close()
}

Esto funciona, pero me preguntaba si existía una forma "correcta" de Kotlin de hacer esto.

Answer 1

Cierta magia de Kotlin permite omitir hacer referencia a la transmisión en cada llamada de lectura o escritura:

fun <T : Closeable, R> T.useWith(block: T.() -> R): R = use { with(it, block) }
File("a.in").bufferedReader().useWith {
File("a.out").printWriter().useWith {
val (a, b) = readLine()!!.split('' '').map(String::toInt)
println(a + b)
}
}
Scanner(File("b.in")).useWith {
PrintWriter("b.out").useWith {
val a = nextInt()
val b = nextInt()
println(a + b)
}
}

Answer 2

En su mayoría se ve bien para mí. Lo único diferente que haría es usar la extensión " use " definida en ReadWrite para cerrar automáticamente el escritor.

PrintWriter("file.txt").use {
for ((member, originalInput) in history) { // history: Map<Member, String>
it.append("$member, $originalInput/n")
}
}

Answer 3

Un poco más idiomático. Para PrintWriter, este ejemplo:

File("somefile.txt").printWriter().use { out ->
history.forEach {
out.println("${it.key}, ${it.value}")
}
}

El ciclo for , o forEach depende de tu estilo. No hay razón para usar append(x) ya que es básicamente write(x.toString()) y ya le da una cadena. Y println(x) básicamente write(x) después de convertir un null en "null" . Y println() hace el final de línea correcto.

Si está utilizando clases de data de Kotlin, ya pueden salir porque ya tienen un buen método toString() .

Además, en este caso, si quisiera usar BufferedWriter , produciría los mismos resultados:

File("somefile.txt").bufferedWriter().use { out ->
history.forEach {
out.write("${it.key}, ${it.value}/n")
}
}

También puede usar out.newLine() lugar de /n si desea que sea correcto para el sistema operativo actual en el que se está ejecutando. Y si estuvieras haciendo eso todo el tiempo, probablemente crearías una función de extensión:

fun BufferedWriter.writeLn(line: String) {
this.write(line)
this.newLine()
}

Y luego usa eso en su lugar:

File("somefile.txt").bufferedWriter().use { out ->
history.forEach {
out.writeLn("${it.key}, ${it.value}")
}
}

Y así es como Kotlin rueda. Cambia las cosas en las API para que sean como quieres que sean.

Sorprendentemente diferentes sabores para esto se encuentran en otra respuesta: https://.com/a/35462184/3679676

Answer 4

Otras variaciones divertidas para que pueda ver el poder de Kotlin:

Una versión rápida creando la cadena para escribir todo de una vez:

File("somefile.txt").writeText(history.entries.joinToString("/n") { "${it.key}, ${it.value}" })
// or just use the toString() method without transform:
File("somefile.txt").writeText(x.entries.joinToString("/n"))

O suponiendo que puede hacer otras cosas funcionales como líneas de filtro o tomar solo los primeros 100, etc. Podría seguir esta ruta:

File("somefile.txt").printWriter().use { out ->
history.map { "${it.key}, ${it.value}" }
.filter { ... }
.take(100)
.forEach { out.println(it) }
}

O dado un Iterable , permite escribirlo en un archivo usando una transformación en una cadena, creando funciones de extensión (similar a la versión anterior de writeText() , pero transmite el contenido en lugar de materializar primero una cadena grande):

fun <T: Any> Iterable<T>.toFile(output: File, transform: (T)->String = {it.toString()}) {
output.bufferedWriter().use { out ->
this.map(transform).forEach { out.write(it); out.newLine() }
}
}
fun <T: Any> Iterable<T>.toFile(outputFilename: String, transform: (T)->String = {it.toString()}) {
this.toFile(File(outputFilename), transform)
}

utilizado como cualquiera de estos:

history.entries.toFile(File("somefile.txt")) { "${it.key}, ${it.value}" }
history.entries.toFile("somefile.txt") { "${it.key}, ${it.value}" }

o use default toString () en cada elemento:

history.entries.toFile(File("somefile.txt"))
history.entries.toFile("somefile.txt")

O dado un File , permita llenarlo desde un Iterable , al crear esta función de extensión:

fun <T: Any> File.fillWith(things: Iterable<T>, transform: (T)->String = {it.toString()}) {
this.bufferedWriter().use { out ->
things.map(transform).forEach { out.write(it); out.newLine() }
}
}

con el uso de:

File("somefile.txt").fillWith(history.entries) { "${it.key}, ${it.value}" }

o use default toString () en cada elemento:

File("somefile.txt").fillWith(history.entries)

que si ya tuviera la otra extensión de toFile , podría reescribir una llamada de extensión con la otra:

fun <T: Any> File.fillWith(things: Iterable<T>, transform: (T)->String = {it.toString()}) {
things.toFile(this, transform)
}