Go-Sprachentwicklung des Tür-zu-Tür-Kochsystems: Wie implementiert man die Funktion zum Sammeln von Gerichten?

Go-Sprachentwicklung des Tür-zu-Tür-Kochsystems: Wie implementiert man die Funktion zum Sammeln von Gerichten?

Mit der Verbesserung des Lebensstandards entscheiden sich immer mehr Menschen dafür, dass Köche für sie kochen. Das Tür-zu-Tür-Kochsystem ist zeitgemäß entstanden und bietet den Nutzern eine komfortable Serviceplattform. Bei der Entwicklung eines solchen Systems ist die Geschirrsammelfunktion eine der wichtigsten Funktionen. In diesem Artikel wird erläutert, wie Sie mithilfe der Go-Sprache ein Tür-zu-Tür-Kochsystem entwickeln und die Funktion zum Sammeln von Gerichten implementieren.

1. Analyse der Projektanforderungen
Bevor wir mit der Entwicklung beginnen, müssen wir zunächst die spezifischen Anforderungen der Geschirrsammelfunktion verstehen. Normalerweise können Benutzer ihre Lieblingsgerichte finden, indem sie die Speisekarte durchsuchen oder nach Gerichten suchen, und sie zu ihren Favoriten hinzufügen, um zukünftige Suche und Bestellung zu erleichtern.

Basierend auf dieser Anforderung können wir die folgende Datenstruktur entwerfen:

1. Benutzer (Benutzer): grundlegende Informationen des Benutzers, einschließlich Benutzer-ID, Benutzername usw.
2. Gericht: Grundlegende Informationen zum Gericht, einschließlich Gericht-ID, Name des Gerichts, Preis usw.
3. Favorit: Eine Liste der vom Benutzer gesammelten Gerichte. Jeder Benutzer entspricht einem Favoriten, einschließlich Benutzer-ID und Gericht-ID.

2. Datenbankdesign und Tabellenerstellung
Wir verwenden MySQL als Datenbank. Basierend auf den Anforderungen müssen wir drei Tabellen erstellen: Benutzer, Gericht und Favorit.

Die Struktur der Benutzertabelle (user) ist wie folgt:
CREATE TABLE user (user (
id int(11) NOT NULL AUTO_INCREMENT,
name varchar(255) NOT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

菜品表(dish)结构如下：
CREATE TABLE dish (
id int(11) NOT NULL AUTO_INCREMENT,
name varchar(255) NOT NULL,
price decimal(10,2) NOT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

收藏夹表(favorite)结构如下：
CREATE TABLE favorite (
id int(11) NOT NULL AUTO_INCREMENT,
user_id int(11) NOT NULL,
dish_id int(11) NOT NULL,
PRIMARY KEY (id),
KEY idx_user_id (user_id),
KEY idx_dish_id (dish_id),
CONSTRAINT fk_user_id FOREIGN KEY (user_id) REFERENCES user (id),
CONSTRAINT fk_dish_id FOREIGN KEY (dish_id) REFERENCES dish (id id int(11) NOT NULL AUTO_INCREMENT,
name varchar( 255) NOT NULL,

PRIMARY KEY (id)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Die Struktur der Dish-Tabelle (dish) ist wie folgt:

CREATE TABLE dish (

id int(11) NOT NULL AUTO_INCREMENT,

name varchar(255) NOT NULL,

price code> decimal(10,2) NOT NULL ,<p> PRIMARY KEY (<code>id)

) ENGINE=InnoDB DEFAULT CHARSET=utf8;

Die Favoritentabelle (favorite) hat die folgende Struktur:

CREATE TABLE favorite (

id int(11) NOT NULL AUTO_INCREMENT,

user_id int(11) NOT NULL,

dish_id int(11) NOT NULL,

PRIMARY KEY ( id),

KEY idx_user_id (user_id),

KEY idx_dish_id (<code>dish_id ),
1. CONSTRAINT fk_user_id FOREIGN KEY (user_id) REFERENCES user (id ),
CONSTRAINT fk_dish_id FOREIGN KEY (dish_id) REFERENCES dish (id)

) ENGINE =InnoDB DEFAULT CHARSET=utf8;

3. Go-Sprachimplementierung

Als nächstes implementieren wir die Go-Sprache, um die Dish-Collection-Funktion zu implementieren. Zuerst müssen wir die entsprechende Struktur definieren, die mit der Tabelle in der Datenbank verknüpft werden soll:

type User struct {

2. ID   int    `json:"id"`
   Name string `json:"name"`

}

type Dish struct {

ID    int     `json:"id"`
Name  string  `json:"name"`
Price float64 `json:"price"`

}

type Favorite struct {

ID     int `json:"id"`
UserID int `json:"user_id"`
DishID int `json:"dish_id"`

}

Als nächstes müssen wir die entsprechende API-Schnittstelle schreiben, um die Funktion zum Sammeln von Gerichten zu implementieren. Hier ist ein Beispielcode: 🎜🎜🎜Liste der Lieblingsgerichte des Benutzers abrufen🎜🎜🎜func GetUserFavorite(userID int) ([]Dish, error) {🎜

favorites := make([]Favorite, 0)
dishes := make([]Dish, 0)

err := db.Where("user_id = ?", userID).Find(&favorites).Error
if err != nil {
    return nil, err
}

for _, favorite := range favorites {
    dish := Dish{}
    err := db.Where("id = ?", favorite.DishID).First(&dish).Error
    if err != nil {
        return nil, err
    }

    dishes = append(dishes, dish)
}

return dishes, nil

🎜}🎜🎜🎜Gerichte zu Benutzerfavoriten hinzufügen🎜🎜🎜func AddDishToFavorite (userID, DishID int) Fehler {🎜

favorite := Favorite{
    UserID: userID,
    DishID: dishID,
}

err := db.Create(&favorite).Error
if err != nil {
    return err
}

return nil

🎜}🎜🎜Der obige Beispielcode zeigt, wie die Go-Sprache verwendet wird, um die Funktion zum Sammeln von Gerichten zu implementieren. Durch Definieren der Struktur und Schreiben der entsprechenden API-Schnittstelle können wir die Favoriten entsprechend den Benutzeranforderungen bedienen, einschließlich des Abrufens der Liste der Lieblingsgerichte und des Hinzufügens von Gerichten zu den Favoriten. 🎜🎜4. Zusammenfassung🎜In diesem Artikel haben wir vorgestellt, wie man mit der Go-Sprache ein Tür-zu-Tür-Kochsystem entwickelt und die Funktion zum Sammeln von Gerichten implementiert. Durch das Entwerfen von Datenstrukturen, das Erstellen von Tabellen und das Schreiben von API-Schnittstellen können wir die Anforderungen der Benutzer erfüllen und eine praktische und schnelle Funktion zum Sammeln von Gerichten bereitstellen. Dies ist natürlich nur ein einfaches Beispiel, und in tatsächlichen Projekten müssen möglicherweise einige andere Faktoren berücksichtigt werden, z. B. die Klassifizierung von Gerichten, die Änderung von Sammlungen usw. 🎜

Das obige ist der detaillierte Inhalt vonGo-Sprachentwicklung des Tür-zu-Tür-Kochsystems: Wie implementiert man die Funktion zum Sammeln von Gerichten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!