Golang: write []int to file

Question

I have some data in p []int, I want to save/load it to/from file. Should i convert this slice to []byte and use (if yes, how?)

func (f *File) Read(b []byte) (n int, err Error)
func (f *File) Write(b []byte) (n int, err error)

or there are other way to save []int to file?

I read this How to read/write from/to file using golang?, and it didn't help.

How do you want the data to be stored? If it is binary, should it be big or little endian? The `int` type has different size on different platforms, so what precision should be stored? — James Henstridge, Apr 01 '14 at 14:50
It's not important how data be stored, i want to save it, restart app, and get the same data in RAM. I want to store `[]int32`. — Sam, Apr 01 '14 at 15:11
@Sam, no you can't say it's not important: data in memory is, on the one hand, is an abstract concept (in Go, you work with `int`s which might have different representation from one hardware platform to another), on the other hand, data on a storage medium *has to* have certain format. And it's you who decides which exactly. This might be a JSON file, XML file, a database, a plain binary file with custom format, a plain text file with custom format -- the possibilities are endless. — kostix, Apr 01 '14 at 15:31

Not_a_Golfer · Accepted Answer · 2014-04-01T15:23:33.267

If interchanging the format (between languages other than go) or reading it as a stream is not important to you, just use the gob encoder and decoder.

http://golang.org/pkg/encoding/gob/

The idea is that you create an encoder around a writer, or a decoder around a reader, and then just ask them to encode or decode a struct. Encoding goes something like this:

p := []int{1,2,3,4}

encoder := gob.NewEncoder(myFileWriter)
err = encoder.Encode(p)
if err != nil {
    panic(err)
}

decoding works just the opposite way:

decoder := gob.NewDecoder(myFileReader)
p := []int{}

err = decoder.Decode(&p)
if err != nil {
         panic(err)
}

Alternatively, you can use similar methods available in the standard library, for storing the data as JSON or XML, which allow you more easily to debug things, and open the data from other languages (at the cost of size and efficiency).

if format interchange between languages is import? :) What would be the approach to this. — Roy Lee, Jan 15 '16 at 10:41
@Roylee json would be the simplest solution. but there are many. — Not_a_Golfer, Jan 15 '16 at 13:25

score 2 · Answer 2 · answered Sep 28 '17 at 13:23

you can use

file.WriteString(fmt.Sprintln(p))

a complete example:

    /*path of the file test.txt : you have to change it*/
var path = "/Users/Pippo/workspace/Go/src/......./test.txt"

func main() {

    p := []int{1, 2, 3, 4, 5, 8, 99}
    fmt.Println(p)
    createFile()
    writeFile(p)

}

/*create file*/
func createFile() {

    // detect if file exists
    var _, err = os.Stat(path)

    // create file if not exists
    if os.IsNotExist(err) {
        var file, err = os.Create(path)
        if isError(err) {
            return
        }
        defer file.Close()
    }

    fmt.Println("==> done creating file", path)
}



/* print errors*/
func isError(err error) bool {
    if err != nil {
        fmt.Println(err.Error())
    }

    return (err != nil)
}

/*writeFile write the data into file*/
func writeFile(p []int) {

    // open file using READ & WRITE permission
    var file, err = os.OpenFile(path, os.O_RDWR, 0644)

    if isError(err) {
        return
    }
    defer file.Close()

    // write into file
    _, err = file.WriteString(fmt.Sprintln(p))
    if isError(err) {
        return
    }

    // save changes
    err = file.Sync()
    if isError(err) {
        return
    }

    fmt.Println("==> done writing to file")
}

Golang: write []int to file

2 Answers2