Comment utiliser le langage Go pour développer la fonction de gestion des employés du système de commande

Avec le développement de la technologie Internet, de nombreux restaurants traditionnels ont également commencé à se transformer vers la numérisation, parmi lesquels le système de commande est devenu un élément important de la numérisation des restaurants. Dans le système de commande, la fonction de gestion des employés est un élément indispensable. Elle peut aider les administrateurs de restaurant à mieux gérer les informations sur les employés, les registres de présence, la répartition du travail, etc. Cet article présentera comment utiliser le langage Go pour développer la fonction de gestion des employés du système de commande et fournira des exemples de code spécifiques. J'espère qu'il pourra aider les lecteurs qui ont besoin de développer des fonctions similaires.

1. Créer un environnement de développement

Avant de commencer le développement, nous devons mettre en place un environnement de développement pour le langage Go. Tout d’abord, vous devez installer l’environnement d’exploitation et les outils de développement du langage Go. Il est recommandé de choisir le site Web officiel du langage Go pour télécharger et installer. Une fois l'installation terminée, configurez les variables d'environnement afin que la commande Go puisse être utilisée n'importe où.

2. Concevoir le modèle de base de données

Avant de développer la fonction de gestion des employés, nous devons concevoir le modèle de base de données. Dans cet article, nous utiliserons le framework orm du langage Go pour faire fonctionner la base de données. Nous devons d'abord définir une structure d'employé, comme indiqué ci-dessous :

type Employee struct {
    ID       uint   `gorm:"primary_key"`
    Name     string `gorm:"type:varchar(50)"`
    Phone    string `gorm:"type:varchar(50)"`
    Position string `gorm:"type:varchar(50)"`
}

Dans cette structure, nous définissons quatre attributs de l'employé : ID, Nom, Téléphone et Poste. Parmi eux, ID est la clé primaire, Name est le nom de l'employé, Phone est le numéro de téléphone et Position est le poste. Nous pouvons ajouter ou modifier les attributs des employés selon les besoins réels.

3. Initialiser la base de données

Après avoir conçu le modèle de base de données, nous devons initialiser la base de données. Le package SQL est fourni dans le langage Go pour faire fonctionner la base de données. Nous devons d'abord nous connecter à la base de données et créer une table pour le modèle Employee dans le programme, comme indiqué ci-dessous :

package main

import (
    "fmt"
    "log"

    "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
)

type Employee struct {
    ID       uint   `gorm:"primary_key"`
    Name     string `gorm:"type:varchar(50)"`
    Phone    string `gorm:"type:varchar(50)"`
    Position string `gorm:"type:varchar(50)"`
}

func main() {
    // 连接数据库
    db, err := gorm.Open("mysql", "root:password@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=True&loc=Local")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 自动创建表
    db.AutoMigrate(&Employee{})
    fmt.Println("create employee table successfully")
}

Dans ce programme, nous utilisons gorm.Open. pour se connecter à la base de données MySQL, et la table Employee est automatiquement créée via la fonction db.AutoMigrate.

4. Ajouter des informations sur les employés

Ensuite, nous devons écrire le code pour ajouter des informations sur les employés. Nous pouvons ajouter des informations sur les employés en lisant les entrées de l'utilisateur pendant l'exécution du programme. L'exemple est le suivant :

func main() {
    // 连接数据库
    db, err := gorm.Open("mysql", "root:password@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=True&loc=Local")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 添加员工信息
    var employee Employee
    fmt.Println("请输入员工姓名：")
    fmt.Scanln(&employee.Name)
    fmt.Println("请输入员工电话：")
    fmt.Scanln(&employee.Phone)
    fmt.Println("请输入员工职位：")
    fmt.Scanln(&employee.Position)

    db.Create(&employee)
    fmt.Println("add employee successfully")
}

Dans ce programme, nous lisons les entrées de l'utilisateur via la fonction fmt.Scanln et les ajoutons à la base de données via la fonction db.Create Employee. information.

5. Requête des informations sur les employés

Nous devons également mettre en œuvre la fonction d'interrogation des informations sur les employés. L'opération de requête est l'une des fonctions les plus couramment utilisées dans la fonction de gestion des employés du système de commande. Elle peut non seulement interroger les informations d'un seul employé, mais également afficher la liste complète des employés. L'exemple de code est le suivant :

func main() {
    // 连接数据库
    db, err := gorm.Open("mysql", "root:password@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=True&loc=Local")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 查询员工信息
    var employees []Employee
    db.Find(&employees)
    fmt.Println("======= 员工列表 =======")
    for _, employee := range employees {
        fmt.Printf("姓名：%s，电话：%s，职位：%s
", employee.Name, employee.Phone, employee.Position)
    }

    var id uint
    fmt.Println("请输入员工ID：")
    fmt.Scanln(&id)
    var target Employee
    db.First(&target, id)
    if target.ID == 0 {
        fmt.Println("查无此人")
        return
    }
    fmt.Printf("姓名：%s，电话：%s，职位：%s
", target.Name, target.Phone, target.Position)
}

Dans ce programme, nous définissons une variable de tranche d'employés, utilisons la fonction db.Find pour interroger toutes les informations sur les employés, puis parcourons la tranche d'employés pour afficher la liste des employés. Ensuite, nous utilisons db.First pour interroger les informations individuelles sur les employés via l'identifiant saisi par l'utilisateur.

6. Mettre à jour les informations sur les employés

Dans le système de commande, les informations sur les employés peuvent changer, telles que des changements de numéro de téléphone, des changements d'emploi, etc. Par conséquent, nous devons mettre en œuvre la fonction de mise à jour des informations sur les employés. L'exemple de code est le suivant :

func main() {
    // 连接数据库
    db, err := gorm.Open("mysql", "root:password@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=True&loc=Local")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 更新员工信息
    var id uint
    fmt.Println("请输入员工ID：")
    fmt.Scanln(&id)
    var target Employee
    db.First(&target, id)
    if target.ID == 0 {
        fmt.Println("查无此人")
        return
    }
    fmt.Println("请输入员工姓名：")
    fmt.Scanln(&target.Name)
    fmt.Println("请输入员工电话：")
    fmt.Scanln(&target.Phone)
    fmt.Println("请输入员工职位：")
    fmt.Scanln(&target.Position)
    db.Save(&target)
    fmt.Println("update employee successfully")
}

Dans ce programme, nous utilisons d'abord db.First pour interroger les informations individuelles des employés en fonction de l'identifiant saisi par l'utilisateur, puis lire les informations mises à jour de l'utilisateur via la fonction fmt.Scanln, et enfin utiliser la fonction db.Save pour enregistrer les informations sur les employés.

7. Supprimer les informations sur les employés

Enfin, nous devons mettre en œuvre la fonction de suppression des informations sur les employés. L'exemple de code est le suivant :

func main() {
    // 连接数据库
    db, err := gorm.Open("mysql", "root:password@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=True&loc=Local")
    if err != nil {
        log.Fatal(err)
    }
    defer db.Close()

    // 删除员工信息
    var id uint
    fmt.Println("请输入员工ID：")
    fmt.Scanln(&id)
    var target Employee
    db.First(&target, id)
    if target.ID == 0 {
        fmt.Println("查无此人")
        return
    }
    db.Delete(&target)
    fmt.Println("delete employee successfully")
}

Dans ce programme, nous utilisons d'abord db.First pour interroger les informations d'un seul employé en fonction de l'identifiant saisi par l'utilisateur, et utilisons la fonction db.Delete pour supprimer les informations sur l'employé.

Résumé

Cet article explique comment utiliser le langage Go pour développer la fonction de gestion des employés du système de commande. À travers des exemples de code spécifiques, il explique comment créer des tables de données sur les employés, ajouter des informations sur les employés, interroger, mettre à jour et supprimer des informations sur les employés et d'autres fonctions communes. J'espère que cet article pourra aider les lecteurs à mieux maîtriser les compétences de développement du langage Go.

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!