Discutez de la façon de transférer des fichiers dans Golang

Avec le développement d'Internet, le transfert de fichiers est devenu un élément indispensable de la société moderne. En programmation, le transfert de fichiers est souvent nécessaire, notamment en programmation réseau. Golang est un langage de programmation simultané efficace à écrire et facile à maintenir. Il propose également de nombreuses solutions pour le transfert de fichiers. Dans cet article, nous explorerons comment transférer des fichiers dans Golang.

1. Utilisez le package http pour transférer des fichiers

Dans Golang, vous pouvez utiliser le package http pour transférer des fichiers rapidement et facilement. Pour ce faire, nous devons créer un serveur HTTP qui répondra aux demandes des clients et enverra des fichiers au client.

Par exemple, nous pouvons créer le serveur suivant :

package main

import (
    "fmt"
    "net/http"
)

func main() {
    http.HandleFunc("/", func(responseWriter http.ResponseWriter, request *http.Request) {
        http.ServeFile(responseWriter, request, "example.txt")
    })

    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        fmt.Println(err)
    }
}

Le code ci-dessus crée un serveur HTTP dont la fonction principale est d'envoyer un fichier nommé "exemple.txt" en réponse au client. La fonction http.HandleFunc est utilisée ici, qui enregistre "/" comme chemin et une fonction anonyme comme fonction de gestionnaire. Cette fonction anonyme utilise la fonction http.ServeFile pour lire et envoyer le fichier. Enfin, imprimez les informations d’erreur lorsque err != nil.

Il est à noter qu'avant de transférer le fichier, nous devons créer un fichier texte nommé "exemple.txt" et l'enregistrer dans le répertoire du serveur.

2. Utilisez TCP pour transférer des fichiers

Dans Golang, nous pouvons également utiliser le protocole TCP pour transférer des fichiers. Cette méthode nécessite la création d'un client et d'un serveur pour transférer des fichiers entre eux. Ici, nous devons utiliser le package net, qui fournit des fonctions et des types d'utilitaires pour la programmation réseau basée sur les sockets.

Ce qui suit est un exemple d'utilisation du protocole TCP pour transférer des fichiers :

• Serveur :

package main

import (
    "fmt"
    "net"
    "os"
)

func main() {
    // 创建TCP监听器，监听请求
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        fmt.Println("Error listening:", err.Error())
        os.Exit(1)
    }
    defer listener.Close()
    fmt.Println("Listening on :8080")

    // 开始监听
    for {
        // 等待客户端连接
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Error accepting:", err.Error())
            continue
        }

        // 先读取文件名，再读取文件
        fileName := make([]byte, 64)
        _, err = conn.Read(fileName)
        if err != nil {
            fmt.Println("Error reading filename:", err.Error())
            continue
        }
        file, err := os.Create(string(fileName))
        if file != nil {
            defer file.Close()
        }
        if err != nil {
            fmt.Println("Error create file:", err.Error())
            continue
        }

        // 开始读取文件内容，并写入本地文件
        buf := make([]byte, 1024)
        for {
            n, err := conn.Read(buf)
            if err != nil {
                fmt.Println("Error reading content:", err.Error())
                break
            }
            if n == 0 {
                break
            }
            _, err = file.Write(buf[:n])
            if err != nil {
                fmt.Println("Error writing to file:", err.Error())
                break
            }
        }
        fmt.Printf("Receive file %s success\n", string(fileName))
    }
}

Le code ci-dessus crée un serveur TCP qui écoutera la demande du client et lira le contenu du fichier via le nom du fichier. et enregistrez le fichier dans le répertoire actuel. Ensuite, nous enverrons un fichier à ce serveur via le programme client suivant :

• Client :

package main

import (
    "fmt"
    "io/ioutil"
    "net"
    "os"
)

func main() {
    // 打开本地文件
    file, err := os.Open("example.txt")
    if err != nil {
        fmt.Println("Error open file:", err.Error())
        os.Exit(1)
    }
    defer file.Close()

    // 连接服务端
    conn, err := net.Dial("tcp", "127.0.0.1:8080")
    if err != nil {
        fmt.Println("Error connect to server:", err.Error())
        os.Exit(1)
    }
    defer conn.Close()

    // 先发送文件名，再发送文件内容
    fileName := "example.txt"
    _, _ = conn.Write([]byte(fileName))
    content, err := ioutil.ReadFile(fileName)
    if err != nil {
        fmt.Println("Error Read file:", err.Error())
        os.Exit(1)
    }

    _, err = conn.Write(content)
    if err != nil {
        fmt.Println("Error send file:", err.Error())
        os.Exit(1)
    }
    fmt.Println("Send success")
}

Ce client peut envoyer un fichier nommé "exemple.txt" au serveur TCP que nous avons créé précédemment. Le client envoie des informations sur le fichier au serveur en ouvrant un fichier local et en utilisant net.Dial et conn.Write.

Résumé :

Dans Golang, nous pouvons transférer des fichiers en utilisant les protocoles HTTP et TCP. La mise en œuvre du protocole HTTP est généralement plus simple et plus pratique, mais dans certains cas, il peut être plus utile d'utiliser le protocole TCP, par exemple lorsque des fichiers volumineux doivent être transférés ou qu'un contrôle précis des transferts de fichiers est requis. Comprendre les avantages et les inconvénients des deux méthodes de transfert et les adapter à vos besoins est essentiel pour réussir un transfert de fichiers.

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!