Can Go language be used for visualization?

Go language can do visualization. In the Go language, we can use third-party libraries and tools to quickly realize data visualization. As an efficient and high-performance programming language, the Go language can help us easily perform data visualization.

The operating environment of this tutorial: Windows 10 system, go1.20.1 version, Dell G3 computer.

Before introducing the use of Go language for data visualization, we need to first understand the characteristics of Go language. The following are the main features of Go language.

High concurrency performance

Go language is a programming language based on concurrent operations. It achieves high concurrency performance through mechanisms such as Goroutine, Channel and Mutex. This makes it easy to write efficient concurrent programs.

Rich standard library

Go language provides a very rich standard library, covering network programming, I/O, file processing, etc. With the support of these standard libraries, we can easily develop programs.

Static typed language

Go language is a statically typed programming language. Static typing can check the type of code in advance and avoid some type errors.

Cross-compilation support

Go language supports cross-compilation, which allows us to easily compile programs into executable files for different platforms. This allows development and deployment for different platforms.

Use Go language for data visualization

In Go language, we can use third-party libraries and tools to quickly achieve data visualization.

Steps to use Go language for data visualization

Step 1: Install the necessary libraries and tools

Before we start, we need to install some necessary libraries and tools. The following are the libraries and tools that need to be installed:

GoChart: a charting library in Go language. Used to generate charts. Gin: A web framework for Go language. Used to build web servers and handle HTTP requests. Gorm: an ORM library for Go language. Used to operate the database.

You can install these libraries and tools using the following command:

go get -u github.com/wcharczuk/go-chart

go get -u github.com/ gin-gonic/gin

go get -u github.com/jinzhu/gorm

Step 2: Prepare data

Before doing data visualization, we need to prepare it first data. Here is an example CSV file:

日期,收入,支出
2020-01-01,10000,8000
2020-01-02,12000,9000
2020-01-03,11000,10000
2020-01-04,13000,8000
2020-01-05,14000,12000

We can use Gorm to read this CSV file into a database. The following is an example code:

package main
import (
    "bufio"
    "encoding/csv"
    "io"
    "log"
    "os"
    "time"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/sqlite"
)
type Record struct {
    gorm.Model
    Date   time.Time `gorm:"not null"`
    Income int       `gorm:"not null"`
    Expense int      `gorm:"not null"`
}
func main() {
    db, err := gorm.Open("sqlite3", "test.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    db.AutoMigrate(&Record{})
    file, err := os.Open("data.csv")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()
    reader := csv.NewReader(bufio.NewReader(file))
    for {
        line, err := reader.Read()
        if err == io.EOF {
            break
        } else if err != nil {
            log.Fatal(err)
        }
        date, err := time.Parse("2006-01-02", line[0])
        if err != nil {
            log.Fatal(err)
        }
        income, err := strconv.Atoi(line[1])
        if err != nil {
            log.Fatal(err)
        }
        expense, err := strconv.Atoi(line[2])
        if err != nil {
            log.Fatal(err)
        }
        record := Record{
            Date:    date,
            Income:  income,
            Expense: expense,
        }
        db.Create(&record)
    }
}

Step 3: Generate charts

With the data, we can start generating charts. In Go language, we can use GoChart to generate charts. The following is a sample code to generate a line chart:

package main
import (
    "net/http"
    "strconv"
    "github.com/gin-gonic/gin"
    "github.com/wcharczuk/go-chart"
    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/sqlite"
)
func main() {
    db, err := gorm.Open("sqlite3", "test.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        var records []Record
        db.Find(&records)
        var xvalues []time.Time
        var yvalues1 []float64
        var yvalues2 []float64
        for _, record := range records {
            xvalues = append(xvalues, record.Date)
            yvalues1 = append(yvalues1, float64(record.Income))
            yvalues2 = append(yvalues2, float64(record.Expense))
        }
        graph := chart.Chart{
            Title: "收入支出",
            XAxis: chart.XAxis{
                Name: "日期",
                Ticks: []chart.Tick{
                    {Value: chart.TimeToFloat64(xvalues[0]), Label: xvalues[0].Format("2006-01-02")},
                    {Value: chart.TimeToFloat64(xvalues[len(xvalues)-1]), Label: xvalues[len(xvalues)-1].Format("2006-01-02")},
                },
            },
            YAxis: chart.YAxis{
                Name: "金额",
            },
            Series: []chart.Series{
                chart.TimeSeries{
                    Name:    "收入",
                    XValues: xvalues,
                    YValues: yvalues1,
                },
                chart.TimeSeries{
                    Name:    "支出",
                    XValues: xvalues,
                    YValues: yvalues2,
                },
            },
        }
        buffer := bytes.NewBuffer([]byte{})
        graph.Render(chart.PNG, buffer)
        c.Data(http.StatusOK, "image/png", buffer.Bytes())
    })
    r.Run(":8080")
}

Step 4: Start the Web server

With the chart, we can start the Web server. In Go language, we can use Gin to start the web server. The following is a sample code:

func main() {
    db, err := gorm.Open("sqlite3", "test.db")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()
    r := gin.Default()
    r.GET("/", func(c *gin.Context) {
        var records []Record
        db.Find(&records)
        // 生成图表的代码
        // ...
        c.Data(http.StatusOK, "image/png", buffer.Bytes())
    })
    r.Run(":8080")
}

Now, we can visit http://localhost:8080 in the browser to view the generated line chart.

Conclusion

Go language, as an efficient and high-performance programming language, can help us easily perform data visualization. In this article, we introduce how to use the Go language to quickly generate charts and use Gin to start a web server to display these charts. If you are interested in data visualization, then using Go language for data visualization is a very good choice.

The above is the detailed content of Can Go language be used for visualization?. For more information, please follow other related articles on the PHP Chinese website!