Apprenez les fonctions d'exploitation de fichiers en langage Go et implémentez les fonctions de compression, de cryptage, de téléchargement et de décompression de fichiers.

Apprenez les fonctions d'exploitation de fichiers en langage Go et implémentez les fonctions de compression, de cryptage, de téléchargement, de téléchargement et de décompression de fichiers

Dans les applications informatiques modernes, l'exploitation de fichiers est une fonction très importante. Pour les développeurs, l'apprentissage et la maîtrise des fonctions d'exploitation des fichiers peuvent non seulement améliorer l'efficacité du développement, mais également ajouter des fonctions pratiques aux applications. Cet article explique comment utiliser les fonctions d'exploitation de fichiers dans le langage Go et implémenter les fonctions de compression, de cryptage, de téléchargement et de décompression de fichiers.

Tout d'abord, nous devons comprendre certaines fonctions de base des opérations sur les fichiers en langage Go.

1. Créer un fichier

Pour créer un nouveau fichier, nous pouvons utiliser la fonction Créer dans le package os.

file, err := os.Create("example.txt")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

2. Write data

Pour écrire des données dans un fichier, nous pouvons utiliser la méthode Write de l'objet fichier.

data := []byte("Hello, World!")
_, err = file.Write(data)
if err != nil {
    log.Fatal(err)
}

3. Lecture de données

Pour lire les données d'un fichier, nous pouvons utiliser la méthode Read de l'objet fichier.

data := make([]byte, 100)
n, err := file.Read(data)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("Read %d bytes: %s
", n, data[:n])

4. Supprimer des fichiers

Pour supprimer des fichiers, vous pouvez utiliser la fonction Supprimer dans le package os.

err := os.Remove("example.txt")
if err != nil {
    log.Fatal(err)
}

Maintenant que nous maîtrisons les fonctions de base d'exploitation des fichiers, nous pouvons continuer à mettre en œuvre les fonctions de compression, de cryptage, de téléchargement, de téléchargement et de décompression de fichiers.

Tout d’abord, voyons comment compresser et décompresser des fichiers. Nous pouvons utiliser le package archive/zip pour y parvenir.

func compressFile(filename string) {
    zipfilename := filename + ".zip"
    zipFile, err := os.Create(zipfilename)
    if err != nil {
        log.Fatal(err)
    }
    defer zipFile.Close()

    zipWriter := zip.NewWriter(zipFile)
    defer zipWriter.Close()

    file, err := os.Open(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    fileInfo, err := file.Stat()
    if err != nil {
        log.Fatal(err)
    }

    header, err := zip.FileInfoHeader(fileInfo)
    if err != nil {
        log.Fatal(err)
    }

    writer, err := zipWriter.CreateHeader(header)
    if err != nil {
        log.Fatal(err)
    }

    _, err = io.Copy(writer, file)
    if err != nil {
        log.Fatal(err)
    }
}

func decompressFile(zipfilename string) {
    zipFile, err := zip.OpenReader(zipfilename)
    if err != nil {
        log.Fatal(err)
    }
    defer zipFile.Close()

    for _, file := range zipFile.File {
        rc, err := file.Open()
        if err != nil {
            log.Fatal(err)
        }
        defer rc.Close()

        newFile, err := os.Create(file.Name)
        if err != nil {
            log.Fatal(err)
        }
        defer newFile.Close()

        _, err = io.Copy(newFile, rc)
        if err != nil {
            log.Fatal(err)
        }
    }
}

Voyons ensuite comment crypter et décrypter des fichiers. Nous pouvons utiliser le package crypto/aes pour y parvenir.

func encryptFile(filename string, key []byte) {
    inputFile, err := os.Open(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer inputFile.Close()

    outputFile, err := os.Create(filename + ".enc")
    if err != nil {
        log.Fatal(err)
    }
    defer outputFile.Close()

    block, err := aes.NewCipher(key)
    if err != nil {
        log.Fatal(err)
    }

    iv := make([]byte, aes.BlockSize)
    outputFile.Write(iv)

    outputFileWriter := cipher.StreamWriter{
        S: cipher.NewCTR(block, iv),
        W: outputFile,
    }

    _, err = io.Copy(outputFileWriter, inputFile)
    if err != nil {
        log.Fatal(err)
    }
}

func decryptFile(filename string, key []byte) {
    inputFile, err := os.Open(filename + ".enc")
    if err != nil {
        log.Fatal(err)
    }
    defer inputFile.Close()

    outputFile, err := os.Create(filename + ".dec")
    if err != nil {
        log.Fatal(err)
    }
    defer outputFile.Close()

    block, err := aes.NewCipher(key)
    if err != nil {
        log.Fatal(err)
    }

    iv := make([]byte, aes.BlockSize)
    inputFile.Read(iv)

    inputFileReader := cipher.StreamReader{
        S: cipher.NewCTR(block, iv),
        R: inputFile,
    }

    _, err = io.Copy(outputFile, inputFileReader)
    if err != nil {
        log.Fatal(err)
    }
}

Maintenant que nous avons implémenté les fonctions de compression, de cryptage et de décodage de fichiers, voyons comment implémenter le téléchargement et le téléchargement de fichiers. Nous pouvons utiliser le package net/http pour y parvenir.

func uploadFile(filename string, url string) {
    file, err := os.Open(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    body := &bytes.Buffer{}
    writer := multipart.NewWriter(body)
    part, err := writer.CreateFormFile("file", filepath.Base(filename))
    if err != nil {
        log.Fatal(err)
    }

    _, err = io.Copy(part, file)
    if err != nil {
        log.Fatal(err)
    }

    writer.Close()

    request, err := http.NewRequest("POST", url, body)
    if err != nil {
        log.Fatal(err)
    }
    request.Header.Add("Content-Type", writer.FormDataContentType())

    client := &http.Client{}
    response, err := client.Do(request)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    fmt.Println("Upload OK!")
}

func downloadFile(url string, filename string) {
    response, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer response.Body.Close()

    file, err := os.Create(filename)
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    _, err = io.Copy(file, response.Body)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Download OK!")
}

Nous avons désormais implémenté des fonctions de compression, de cryptage, de téléchargement, de téléchargement et de décompression de fichiers. Nous pouvons utiliser ces fonctions selon nos propres besoins pour gérer les opérations sur les fichiers et les besoins de transfert de fichiers. En utilisant ces fonctions ensemble, nous pouvons développer des fonctions d'exploitation de fichiers plus sécurisées et plus efficaces.

Résumé : Cet article présente les fonctions d'opération de fichiers dans le langage Go et fournit des exemples de codes pour la compression, le cryptage, le téléchargement et la décompression de fichiers. En apprenant et en maîtrisant ces fonctions, nous pouvons ajouter des fonctions d'exploitation de fichiers plus pratiques et plus puissantes à nos applications. J'espère que cet article vous sera utile pour apprendre et utiliser le langage Go pour gérer les opérations sur les 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!