Comment développer une application de chat simple en utilisant le langage Go

Comment développer une application de chat simple en utilisant le langage Go

Avec le développement rapide d'Internet, les applications de chat sont devenues un élément indispensable de la vie quotidienne des gens. En tant que langage de programmation rapide, fiable et efficace, le langage Go est de plus en plus plébiscité par les développeurs. Cet article explique comment développer une application de chat simple en utilisant le langage Go.

1. Aperçu du projet

Nous utiliserons le langage Go pour écrire une application de chat simple. Les utilisateurs peuvent envoyer des messages à d'autres utilisateurs via l'application et recevoir des messages envoyés par d'autres utilisateurs. Notre application de chat communiquera sur la base du protocole TCP.

2. Préparation du projet

Avant de commencer à écrire du code, nous devons installer l'environnement de développement du langage Go. Vous pouvez télécharger le package d'installation depuis https://golang.org/dl/ et suivre les instructions pour l'installer.

Une fois l'installation terminée, nous pouvons vérifier si l'installation a réussi via la ligne de commande. Ouvrez la fenêtre de ligne de commande et entrez la commande suivante :

go version

Si le numéro de version du langage Go est affiché, cela signifie l'installation. est réussi.

3. Écrivez du code

Créez un nouveau répertoire, nommez-le chatapp, puis créez un fichier nommé main.go dans le répertoire. Nous écrirons notre code d'application de chat dans ce fichier.

1. Importer les dépendances

Tout d'abord, importez la bibliothèque standard du langage Go et les dépendances requises pour les applications de chat :

package main

import (
    "bufio"
    "fmt"
    "log"
    "net"
    "os"
    "strings"
)

2. Définissez des variables globales

Définissez certaines variables globales en dehors de la fonction principale pour stocker les informations relatives au salon de discussion. Informations :

var (
    clients   = make(map[string]net.Conn)
    messages  = make(chan string)
    entering  = make(chan net.Conn)
    leaving   = make(chan net.Conn)
    allOnline = make(chan string)
)

3. Définir des fonctions

Ensuite, nous définissons quelques fonctions pour gérer la logique du salon de discussion :

• handleConnection : gérer la logique de connexion, y compris l'adhésion et la sortie de nouvelles connexions ;
• handleMessages : gérer la logique des messages ; , Diffusez des messages à tous les utilisateurs en ligne ;
• listenForMessages : écoutez les messages lus à partir de l'entrée standard ;
• listenForCommands : écoutez les commandes lues à partir de l'entrée standard.

func handleConnection(conn net.Conn) {
    entering <- conn

    scanner := bufio.NewScanner(conn)
    for scanner.Scan() {
        messages <- scanner.Text()
    }

    leaving <- conn
}

func handleMessages() {
    for {
        select {
        case msg := <-messages:
            for _, conn := range clients {
                fmt.Fprintln(conn, msg)
            }
        case conn := <-entering:
            clients[conn.RemoteAddr().String()] = conn
            allOnline <- fmt.Sprintf("User %s joined the chat.", conn.RemoteAddr().String())
        case conn := <-leaving:
            delete(clients, conn.RemoteAddr().String())
            allOnline <- fmt.Sprintf("User %s left the chat.", conn.RemoteAddr().String())
        }
    }
}

func listenForMessages() {
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        messages <- scanner.Text()
    }
}

func listenForCommands() {
    scanner := bufio.NewScanner(os.Stdin)
    for scanner.Scan() {
        command := scanner.Text()
        if strings.HasPrefix(command, "/list") {
            fmt.Println("Online users:")
            for client := range clients {
                fmt.Println(client)
            }
        } else if command == "/exit" {
            os.Exit(0)
        } else {
            fmt.Println("Unknown command:", command)
        }
    }
}

4. fonction principale

Enfin, nous écrivons la fonction principale et y démarrons l'application de chat :

func main() {
    log.Println("Starting chat server...")

    go handleMessages()

    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatal(err)
    }

    defer listener.Close()

    go listenForMessages()
    go listenForCommands()

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Println(err)
            continue
        }
        go handleConnection(conn)
    }
}

Quatrièmement, exécutez l'application

Enregistrez et fermez le fichier main.go. Ouvrez une fenêtre de ligne de commande et entrez dans le répertoire chatapp, exécutez la commande suivante pour exécuter l'application :

go run main.go

5. Testez l'application

Ouvrez plusieurs fenêtres de ligne de commande, utilisez la commande telnet pour vous connecter au serveur d'application de chat :

telnet localhost 8080

Ensuite, vous pouvez saisir un message et l'envoyer à d'autres utilisateurs en ligne. Vous pouvez utiliser la commande "/list" pour afficher la liste des utilisateurs en ligne actuels et la commande "/exit" pour quitter l'application de chat.

6. Résumé

Grâce à l'introduction de cet article, nous avons appris à utiliser le langage Go pour développer une application de chat simple. Dans le développement actuel, nous pouvons étendre l'application de chat en fonction des besoins, comme l'ajout de l'authentification des utilisateurs, du stockage des messages et d'autres fonctions. J'espère que cet article vous sera utile et je vous souhaite de développer davantage de bonnes applications dans le monde 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!