Comment utiliser Golang pour charger et compresser progressivement des images

Comment utiliser Golang pour charger et compresser progressivement des images

1 Introduction
De nos jours, l'utilisation d'images sur Internet est devenue extrêmement courante. Cependant, des problèmes tels qu'un chargement lent de grandes images et l'impossibilité d'afficher progressivement se produisent également fréquemment, affectant l'expérience utilisateur. Cet article explique comment utiliser Golang pour charger et compresser progressivement des images afin d'améliorer la vitesse et l'expérience de chargement des utilisateurs.

2. Chargement progressif
Le chargement dit progressif signifie qu'avant que l'image ne soit complètement chargée, une petite partie de sa qualité peut être affichée progressivement.

Dans Golang, j'ai utilisé la bibliothèque tierce "github.com/chai2010/webp" pour effectuer un traitement de chargement et de compression progressif. Ensuite, je vous expliquerai étape par étape pour comprendre l'ensemble du processus.

3. Installez les bibliothèques dépendantes
Tout d'abord, ouvrez le terminal et exécutez la commande suivante pour installer la bibliothèque "webp" :

go get -u github.com/chai2010/webp

4. Exemple de code de chargement progressif
L'exemple de code suivant montrera comment utiliser Golang pour charger et charger progressivement. compresser les images. Traitement :

package main

import (
    "fmt"
    "github.com/chai2010/webp"
    "image/jpeg"
    "log"
    "os"
)

func main() {
    file, err := os.Open("path/to/image.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    img, err := jpeg.Decode(file)
    if err != nil {
        log.Fatal(err)
    }

    dest, err := os.Create("path/to/progressive_image.webp")
    if err != nil {
        log.Fatal(err)
    }
    defer dest.Close()

    options := webp.Options{
        Lossless:        false,
        Quality:         80,
        Method:          6,
        SnsStrength:     50,
        FilterSharpness: 0,
    }

    err = webp.Encode(dest, img, &options)
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Progressive image generated successfully!")
}

Le code ci-dessus ouvre d'abord une image. Si une erreur se produit pendant le processus de chargement, un message d'erreur sera affiché. Ensuite, utilisez la fonction jpeg.Decode pour décoder l'image en une structure d'image en mémoire. Ensuite, un fichier cible est créé et la structure webp.Options est utilisée pour définir les paramètres de chargement progressif, tels que la perte de compression, la qualité, la méthode, la force SNS, etc. Enfin, la fonction webp.Encode est appelée pour encoder l'image au format webp progressivement chargé et la sortir dans le fichier cible.

5. Traitement de compression
Sur la base du chargement progressif, nous devons également compresser les images pour réduire la taille de leur fichier et améliorer la vitesse de chargement et l'expérience utilisateur.

L'exemple de code suivant montre comment utiliser Golang pour compresser des images :

package main

import (
    "bytes"
    "fmt"
    "github.com/chai2010/webp"
    "image"
    "image/jpeg"
    "log"
    "os"
)

func main() {
    file, err := os.Open("path/to/image.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    img, err := jpeg.Decode(file)
    if err != nil {
        log.Fatal(err)
    }

    dest, err := os.Create("path/to/compressed_image.webp")
    if err != nil {
        log.Fatal(err)
    }
    defer dest.Close()

    options := webp.Options{
        Lossless:        false,
        Quality:         80,
        Method:          6,
        SnsStrength:     50,
        FilterSharpness: 0,
    }

    buff := new(bytes.Buffer)
    err = webp.Encode(buff, img, &options)
    if err != nil {
        log.Fatal(err)
    }

    err = webp.Write(dest, buff.Bytes())
    if err != nil {
        log.Fatal(err)
    }

    fmt.Println("Compressed image generated successfully!")
}

Le code ci-dessus est fondamentalement le même que le code de chargement progressif. La seule différence est que les données de l'image compressée sont finalement écrites dans le fichier cible via le webp. .Fonction d’écriture.

Grâce aux exemples de code ci-dessus, nous avons appris à utiliser Golang pour charger et compresser progressivement des images afin d'améliorer la vitesse et l'expérience de chargement des utilisateurs. J'espère que cet article vous sera utile. Apprendre Golang apportera de nombreux défis, mais cela nous fournira également plus d'outils et de bibliothèques pour résoudre des problèmes pratiques. Qu'il s'agisse de traitement d'images, de communications réseau ou d'autres domaines, Golang est un choix puissant et populaire.

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!