Golang file reading practice: how to deal with files in different formats

Golang is an efficient programming language that can handle various data types and file formats. In terms of file reading, Golang provides a variety of methods that enable us to cope with the reading needs of various file formats. This article will introduce how to read several common file formats in Golang, including text, JSON, CSV, XML, etc. At the same time, code examples will also be given to help readers better understand and use it.

1. Reading text files

Reading text files in Golang is very simple. You only need to use standard libraries such as "os" and "bufio". The sample code is as follows:

package main

import (
    "bufio"
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("test.txt")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }

    if err := scanner.Err(); err != nil {
        panic(err)
    }
}

In the above code, first use the "os.Open" function to open the file, and create a scanner object through the "bufio.NewScanner" function. Then read each line in the file by looping through the scanner object. Finally, use the "scanner.Err()" function to determine whether an error occurs.

2. Reading JSON files

Similar to text files, reading JSON files in Golang is also very simple. We can use standard libraries such as "os" and "json" to achieve this. The sample code is as follows:

package main

import (
    "encoding/json"
    "fmt"
    "os"
)

type Person struct {
    Name    string   `json:"name"`
    Age     int      `json:"age"`
    Address string   `json:"address"`
}

func main() {
    file, err := os.Open("test.json")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    var person Person
    decoder := json.NewDecoder(file)
    if err := decoder.Decode(&person); err != nil {
        panic(err)
    }

    fmt.Println(person.Name)
    fmt.Println(person.Age)
    fmt.Println(person.Address)
}

In the above code, we first define a "Person" structure, which represents an object in JSON. Then use the "os.Open" function to open the file, and create a decoder object through the "json.NewDecoder" function. Finally, we use the "decoder.Decode" function to decode the JSON file content into the "Person" structure.

3. Reading CSV files

CSV files are a common data exchange format, and we can also easily read it in Golang. This can be achieved using standard libraries such as "os" and "csv". The sample code is as follows:

package main

import (
    "encoding/csv"
    "fmt"
    "os"
)

func main() {
    file, err := os.Open("test.csv")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    csvReader := csv.NewReader(file)
    records, err := csvReader.ReadAll()
    if err != nil {
        panic(err)
    }

    for i, record := range records {
        fmt.Printf("Record %d is %s
", i, record)
    }
}

In the above code, we open the CSV file through the "os.Open" function and create a csvReader object through the "csv.NewReader" function. Then use the "csvReader.ReadAll" function to read the contents of all CSV files at once, and finally use a loop to traverse the output.

4. Reading XML files

XML files are a common data exchange format, and we can also easily read them through standard libraries such as "os" and "xml". The sample code is as follows:

package main

import (
    "encoding/xml"
    "fmt"
    "os"
)

type Person struct {
    XMLName xml.Name `xml:"Person"`
    Name    string   `xml:"Name"`
    Age     int      `xml:"Age"`
    Address string   `xml:"Address"`
}

func main() {
    file, err := os.Open("test.xml")
    if err != nil {
        panic(err)
    }
    defer file.Close()

    var person Person
    decoder := xml.NewDecoder(file)
    if err := decoder.Decode(&person); err != nil {
        panic(err)
    }

    fmt.Println(person.Name)
    fmt.Println(person.Age)
    fmt.Println(person.Address)
}

In the above code, we first define a "Person" structure, which represents an object in XML. Then use the "os.Open" function to open the XML file, and create a decoder object through the "xml.NewDecoder" function. Finally, use the "decoder.Decode" function to decode the XML file content into the "Person" structure.

Summary

The above is the practical method of reading Golang files. We introduced four common file format reading methods respectively and gave specific code examples. By studying these examples, I believe that readers have the basic skills to read files in Golang.

The above is the detailed content of Golang file reading practice: how to deal with files in different formats. For more information, please follow other related articles on the PHP Chinese website!