go - txt - manual de programacion android pdf

Leer el archivo de texto en una matriz de cadenas(y escribir)

Question

La capacidad de leer (y escribir) un archivo de texto dentro y fuera de una matriz de cadenas es, creo, un requisito bastante común. También es bastante útil cuando se comienza con un idioma eliminando la necesidad inicial de acceder a una base de datos. ¿Existe uno en Golang?
por ejemplo, func ReadLines(sFileName string, iMinLines int) ([]string, bool) {
y func WriteLines(saBuff[]string, sFilename string) (bool) { .
Preferiría usar uno existente en lugar de duplicarlo.

Answer 1

A partir de la versión Go1.1, hay una API bufio.Scanner que puede leer fácilmente las líneas de un archivo. Considere el siguiente ejemplo de arriba, reescrito con Scanner:

package main
import (
"bufio"
"fmt"
"log"
"os"
)
// readLines reads a whole file into memory
// and returns a slice of its lines.
func readLines(path string) ([]string, error) {
file, err := os.Open(path)
if err != nil {
return nil, err
}
defer file.Close()
var lines []string
scanner := bufio.NewScanner(file)
for scanner.Scan() {
lines = append(lines, scanner.Text())
}
return lines, scanner.Err()
}
// writeLines writes the lines to the given file.
func writeLines(lines []string, path string) error {
file, err := os.Create(path)
if err != nil {
return err
}
defer file.Close()
w := bufio.NewWriter(file)
for _, line := range lines {
fmt.Fprintln(w, line)
}
return w.Flush()
}
func main() {
lines, err := readLines("foo.in.txt")
if err != nil {
log.Fatalf("readLines: %s", err)
}
for i, line := range lines {
fmt.Println(i, line)
}
if err := writeLines(lines, "foo.out.txt"); err != nil {
log.Fatalf("writeLines: %s", err)
}
}

Answer 2

No se puede actualizar la primera respuesta.
De todos modos, después del lanzamiento de Go1, hay algunos cambios importantes, así que actualicé como se muestra a continuación:

package main
import (
"os"
"bufio"
"bytes"
"io"
"fmt"
"strings"
)
// Read a whole file into the memory and store it as array of lines
func readLines(path string) (lines []string, err error) {
var (
file *os.File
part []byte
prefix bool
)
if file, err = os.Open(path); err != nil {
return
}
defer file.Close()
reader := bufio.NewReader(file)
buffer := bytes.NewBuffer(make([]byte, 0))
for {
if part, prefix, err = reader.ReadLine(); err != nil {
break
}
buffer.Write(part)
if !prefix {
lines = append(lines, buffer.String())
buffer.Reset()
}
}
if err == io.EOF {
err = nil
}
return
}
func writeLines(lines []string, path string) (err error) {
var (
file *os.File
)
if file, err = os.Create(path); err != nil {
return
}
defer file.Close()
//writer := bufio.NewWriter(file)
for _,item := range lines {
//fmt.Println(item)
_, err := file.WriteString(strings.TrimSpace(item) + "/n");
//file.Write([]byte(item));
if err != nil {
//fmt.Println("debug")
fmt.Println(err)
break
}
}
/*content := strings.Join(lines, "/n")
_, err = writer.WriteString(content)*/
return
}
func main() {
lines, err := readLines("foo.txt")
if err != nil {
fmt.Println("Error: %s/n", err)
return
}
for _, line := range lines {
fmt.Println(line)
}
//array := []string{"7.0", "8.5", "9.1"}
err = writeLines(lines, "foo2.txt")
fmt.Println(err)
}

Answer 3

Puede usar os.File (que implementa la interfaz io.Reader ) con el paquete golang.org/pkg/bufio para eso. Sin embargo, esos paquetes están diseñados teniendo en cuenta el uso de la memoria fija (no importa qué tan grande sea el archivo) y son bastante rápidos.

Desafortunadamente, esto hace que leer todo el archivo en la memoria sea un poco más complicado. Puede usar bytes.Buffer para unir las partes de la línea si exceden el límite de línea. De todos modos, te recomiendo que trates de usar el lector de línea directamente en tu proyecto (¡especialmente si no sabes cuán grande es el archivo de texto!). Pero si el archivo es pequeño, el siguiente ejemplo podría ser suficiente para usted:

package main
import (
"os"
"bufio"
"bytes"
"fmt"
)
// Read a whole file into the memory and store it as array of lines
func readLines(path string) (lines []string, err os.Error) {
var (
file *os.File
part []byte
prefix bool
)
if file, err = os.Open(path); err != nil {
return
}
reader := bufio.NewReader(file)
buffer := bytes.NewBuffer(make([]byte, 1024))
for {
if part, prefix, err = reader.ReadLine(); err != nil {
break
}
buffer.Write(part)
if !prefix {
lines = append(lines, buffer.String())
buffer.Reset()
}
}
if err == os.EOF {
err = nil
}
return
}
func main() {
lines, err := readLines("foo.txt")
if err != nil {
fmt.Println("Error: %s/n", err)
return
}
for _, line := range lines {
fmt.Println(line)
}
}

Otra alternativa podría ser usar io.ioutil.ReadAll para leer en el archivo completo a la vez y hacer el corte por línea después. No le doy un ejemplo explícito de cómo volver a escribir las líneas en el archivo, pero eso es básicamente un os.Create() seguido de un bucle similar al del ejemplo (vea main() ).

Answer 4

Si el archivo no es demasiado grande, esto se puede hacer con las funciones ioutil.ReadFile y strings.Split así:

content, err := ioutil.ReadFile(filename)
if err != nil {
//Do something
}
lines := strings.Split(string(content), "/n")

Puede leer la documentación en ioutil y paquetes de strings .

Answer 5

func readToDisplayUsingFile1(f *os.File){
defer f.Close()
reader := bufio.NewReader(f)
contents, _ := ioutil.ReadAll(reader)
lines := strings.Split(string(contents), ''/n'')
}

o

func readToDisplayUsingFile1(f *os.File){
defer f.Close()
slice := make([]string,0)
reader := bufio.NewReader(f)
for{
str, err := reader.ReadString(''/n'')
if err == io.EOF{
break
}
slice = append(slice, str)
}