Can Go language be used for visualization?
- 小老鼠Original
- 2023-06-29 14:23:021481browse
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!