Golang, ¿hay alguna manera mejor de leer un archivo de enteros en una matriz?

Question

Necesito leer un archivo de enteros en una matriz. Tengo que trabajar con esto:

package main 

import (
    "fmt" 
    "io" 
    "os" 
) 

func readFile(filePath string) (numbers []int) { 
    fd, err := os.Open(filePath) 
    if err != nil { 
     panic(fmt.Sprintf("open %s: %v", filePath, err)) 
    } 
    var line int 
    for { 

     _, err := fmt.Fscanf(fd, "%d\n", &line) 

     if err != nil { 
      fmt.Println(err) 
      if err == io.EOF { 
       return 
      } 
      panic(fmt.Sprintf("Scan Failed %s: %v", filePath, err)) 

     } 
     numbers = append(numbers, line) 
    } 
    return 
} 

func main() { 
    numbers := readFile("numbers.txt") 
    fmt.Println(len(numbers)) 
} 

El archivo numbers.txt es simplemente:

1 
2 
3 
... 

ReadFile() parece demasiado largo (tal vez debido a la entrega de error).

¿Hay una manera más corta/más idiomática de cargar un archivo?

Answer 1

lo haría así:

package main 

import (
"fmt" 
    "io/ioutil" 
    "strconv" 
    "strings" 
) 

// It would be better for such a function to return error, instead of handling 
// it on their own. 
func readFile(fname string) (nums []int, err error) { 
    b, err := ioutil.ReadFile(fname) 
    if err != nil { return nil, err } 

    lines := strings.Split(string(b), "\n") 
    // Assign cap to avoid resize on every append. 
    nums = make([]int, 0, len(lines)) 

    for i, l := range lines { 
     // Empty line occurs at the end of the file when we use Split. 
     if len(l) == 0 { continue } 
     // Atoi better suits the job when we know exactly what we're dealing 
     // with. Scanf is the more general option. 
     n, err := strconv.Atoi(l) 
     if err != nil { return nil, err } 
     nums = append(nums, n) 
    } 

    return nums, nil 
} 

func main() { 
    nums, err := readFile("numbers.txt") 
    if err != nil { panic(err) } 
    fmt.Println(len(nums)) 
} 

Answer 2

su solución con fmt.Fscanf está muy bien. Sin embargo, hay una serie de otras formas de hacerlo, dependiendo de su situación. La técnica de Mostafa es una que yo uso mucho (aunque podría asignar el resultado de una sola vez con make. ¡Vaya! ¡Raspe eso!). Pero para el control final, debería aprender bufio.ReadLine. Consulte go readline -> string para obtener un código de ejemplo.

Answer 3

El uso de bufio.Scanner hace las cosas bien. También utilicé io.Reader en lugar de tomar un nombre de archivo. A menudo esa es una buena técnica, ya que permite que el código se use en cualquier objeto similar a un archivo y no solo un archivo en el disco. Aquí está "leyendo" de una cadena.

package main 

import (
    "bufio" 
    "fmt" 
    "io" 
    "strconv" 
    "strings" 
) 

// ReadInts reads whitespace-separated ints from r. If there's an error, it 
// returns the ints successfully read so far as well as the error value. 
func ReadInts(r io.Reader) ([]int, error) { 
    scanner := bufio.NewScanner(r) 
    scanner.Split(bufio.ScanWords) 
    var result []int 
    for scanner.Scan() { 
     x, err := strconv.Atoi(scanner.Text()) 
     if err != nil { 
      return result, err 
     } 
     result = append(result, x) 
    } 
    return result, scanner.Err() 
} 

func main() { 
    tf := "1\n2\n3\n4\n5\n6" 
    ints, err := ReadInts(strings.NewReader(tf)) 
    fmt.Println(ints, err) 
}