Le langage Go peut-il être utilisé pour la visualisation ?

Le langage Go peut faire de la visualisation. Dans le langage Go, nous pouvons utiliser des bibliothèques et des outils tiers pour réaliser rapidement une visualisation de données. En tant que langage de programmation efficace et performant, le langage Go peut nous aider à effectuer facilement une visualisation de données.

L'environnement d'exploitation de ce tutoriel : système Windows 10, version go1.20.1, ordinateur Dell G3.

Avant d'introduire l'utilisation du langage Go pour la visualisation de données, nous devons d'abord comprendre les caractéristiques du langage Go. Voici les principales fonctionnalités du langage Go.

Hautes performances de concurrence

Le langage Go est un langage de programmation basé sur des opérations simultanées. Il atteint des performances de concurrence élevées grâce à des mécanismes tels que Goroutine, Channel et Mutex. Cela facilite l’écriture de programmes concurrents efficaces.

Bibliothèque standard riche

Le langage Go fournit une bibliothèque standard très riche, couvrant la programmation réseau, les E/S, le traitement de fichiers, etc. Avec le support de ces bibliothèques standards, nous pouvons facilement développer des programmes.

langage typé statiquement

Le langage Go est un langage de programmation typé statiquement. La saisie statique permet de vérifier le type de code à l'avance et d'éviter certaines erreurs de type.

Prise en charge de la compilation croisée

Le langage Go prend en charge la compilation croisée, ce qui nous permet de compiler facilement des programmes en fichiers exécutables pour différentes plates-formes. Cela permet le développement et le déploiement pour différentes plates-formes.

Utiliser le langage Go pour la visualisation de données

Dans le langage Go, nous pouvons utiliser des bibliothèques et des outils tiers pour réaliser rapidement une visualisation de données.

Étapes pour utiliser le langage Go pour la visualisation de données

Étape 1 : Installez les bibliothèques et les outils nécessaires

In Avant de commencer, nous devons installer certaines bibliothèques et outils nécessaires. Voici les bibliothèques et outils qui doivent être installés :

GoChart : une bibliothèque de graphiques en langage Go. Utilisé pour générer des graphiques. Gin : Un framework web pour le langage Go. Utilisé pour créer des serveurs Web et gérer les requêtes HTTP. Gorm : une bibliothèque ORM pour le langage Go. Utilisé pour faire fonctionner la base de données.

Vous pouvez installer ces bibliothèques et outils à l'aide de la commande suivante :

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

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

go get -u github.com/jinzhu/gorm

Étape 2 : Préparer les données

#🎜 🎜 #Avant de faire de la visualisation de données, nous devons d'abord préparer les données. Voici un exemple de fichier CSV :

日期,收入,支出
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

Nous pouvons utiliser Gorm pour lire ce fichier CSV dans une base de données. Voici le code d'un exemple :

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)
    }
}

Étape 3 : Générer des graphiques

Avec les données, nous pouvons commencer à générer des graphiques. En langage Go, nous pouvons utiliser GoChart pour générer des graphiques. Voici un exemple de code pour générer un graphique linéaire :

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")
}

Étape 4 : Démarrez le serveur Web

Avec le graphique, nous pouvons démarrer le serveur Web. En langage Go, on peut utiliser Gin pour démarrer le serveur web. Voici un exemple de 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")
}

Maintenant, nous pouvons visiter http://localhost:8080 dans le navigateur pour afficher le graphique linéaire généré.

Conclusion

Le langage Go, en tant que langage de programmation haute performance, peut nous aider à effectuer facilement une visualisation de données. Dans cet article, nous expliquons comment utiliser le langage Go pour générer rapidement des graphiques et utiliser Gin pour démarrer un serveur Web afin d'afficher ces graphiques. Si vous êtes intéressé par la visualisation de données, utiliser le langage Go pour la visualisation de données est un très bon choix.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!