[Go] Créez une commande CLI pour changer l'extension de l'image

introduction

Avant cela, j'ai participé à la salle d'étude du ** Gopher dojo ** et recherché les numéros de Gopher dojo qui m'intéressaient depuis longtemps sur github. , (Est-ce bien de le faire ...?) J'ai pratiqué.

Le premier problème était de ** changer l'extension de l'image **. Je veux le sortir pour le moment, donc j'écrirai différentes choses ici. Aussi, à partir du paquet utilisé, je vais expliquer un peu plus sur flag, ʻos, path / filepath, ʻimage.

environnement

# go version
go version go1.15.2 linux/amd64

# tree
.
|- conversion
|       |- conversion.go
|- go.mod
|- main.go

Code réel

Pour le moment, le référentiel est ici

main.go

package main

import (
	"cvs/conversion"
	"flag"
	"fmt"
	"os"
	"path/filepath"
)

var (
	extension string
	imagepath string
	dirpath   string
)

func main() {

	flag.StringVar(&extension, "e", "jpeg", "Spécifier l'extension")
	flag.StringVar(&imagepath, "f", "", "Spécifiez le chemin du fichier à convertir")
	flag.StringVar(&dirpath, "d", "", "Spécifier le nom du fichier après la conversion")
	flag.Parse()
	err := conversion.ExtensionCheck(extension)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(1)
	}

	err = conversion.FilepathCheck(imagepath)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(1)
	}

	err = conversion.DirpathCheck(dirpath)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(1)
	}

	f := filepath.Ext(imagepath)
	err = conversion.FileExtCheck(f)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(1)
	}

	fmt.Println("Conversion ...")

	err = conversion.FileExtension(extension, imagepath, dirpath)
	if err != nil {
		fmt.Println("Error:", err)
		os.Exit(1)
	}
}

conversion.go

/*
La conversion est un package pour changer l'extension d'une image.
*/
package conversion

import (
	"errors"
	"fmt"
	"image"
	"image/gif"
	"image/jpeg"
	"image/png"
	"os"

	_ "image/gif"
	_ "image/jpeg"
	_ "image/png"
)

const (
	JPEG = "jpeg"
	JPG  = "jpg"
	GIF  = "gif"
	PNG  = "png"
)

// -Détermine si l'extension spécifiée par e est prise en charge.
func ExtensionCheck(ext string) error {
	switch ext {
	case JPEG, JPG, GIF, PNG:
		return nil
	default:
		return errors.New("Extension qui ne peut pas être spécifiée" + ext)
	}
}

// -Détermine si le fichier spécifié par f existe.
func FilepathCheck(imagepath string) error {
	switch imagepath {
	case "":
		return errors.New("Aucun fichier spécifié")
	default:
		if f, err := os.Stat(imagepath); os.IsNotExist(err) || f.IsDir() {
			return errors.New("Fichier ne existe pas" + imagepath)
		} else {
			return nil
		}
	}
}

func DirpathCheck(dirpath string) error {
	switch dirpath {
	case "":
		return errors.New("Le nom du fichier converti n'est pas spécifié")
	default:
		return nil
	}
}

func FileExtCheck(imagepath string) error {
	switch imagepath {
	case "." + JPEG, "." + JPG, "." + GIF, "." + PNG:
		return nil
	default:
		return errors.New("Le fichier spécifié n'est pas pris en charge. :" + imagepath)
	}
}

func FileExtension(extension string, imagepath string, dirpath string) error {
	exFile, err := os.Open(imagepath)
	defer exFile.Close()
	if err != nil {
		return errors.New("os.La création a échoué")
	}

	output, err := os.Create(dirpath)
	defer output.Close()
	if err != nil {
		return errors.New("échec de sortie")
	}

	img, _, Err := image.Decode(exFile)
	if Err != nil {
		return errors.New("Échec du décodage")
	}

	switch extension {
	case JPEG, JPG:
		err = jpeg.Encode(output, img, nil)
		if err != nil {
			return errors.New("Échec du codage")
		}
		fmt.Println("Conversion réussie")
		return nil
	case GIF:
		err = gif.Encode(output, img, nil)
		if err != nil {
			return errors.New("Échec du codage")
		}
		fmt.Println("Conversion réussie")
		return nil
	case PNG:
		err = png.Encode(output, img)
		if err != nil {
			return errors.New("Échec du codage")
		}
		fmt.Println("Conversion réussie")
		return nil
	}
	return nil
}

go.mod

module cvs

go 1.15

Pour l'instant, je l'ai fait fonctionner correctement tout en rendant la gestion des erreurs appropriée.

Commentaire de code

Comme thème de ce code --Utilisez go mod --Utilisez go doc

• Forfaits séparés

J'ai décidé cela. Pour le moment, la raison est

1. go mod facilite l'utilisation du fractionnement
2. Augmentez la disponibilité en créant de la documentation avec go doc Il y a ces deux. Mais cette fois, c'est une passe.

J'écrirai sur le paquet utilisé cette fois.

Si vous augmentez le package utilisé pour la commande CLI pour modifier l'extension de l'image,

1. flag
2. os
3. path/filepath
4. image

il y a. Je vais expliquer chacun d'eux.

flag Documentation Utilisé pour obtenir des arguments en option depuis la ligne de commande

Code implémenté(main.go)

var (
	extension string
	imagepath string
	dirpath   string
)
func main() {

	flag.StringVar(&extension, "e", "jpeg", "Spécifier l'extension")
 // -e "Chaîne" で、Chaîneを取得する/Par défaut"jpeg"Est spécifié
	flag.StringVar(&imagepath, "f", "", "Spécifiez le chemin du fichier à convertir")
	flag.StringVar(&dirpath, "d", "", "Spécifier le nom du fichier après la conversion")
	flag.Parse() 
//Sans Parse, il ne sera pas analysé en variables

～～～ omis

Comment écrire

flag.StringVar(&Nom de variable, "Symbole facultatif", "Valeur par défaut","Description de cette option")

Vous pouvez obtenir autre chose que d'obtenir la chaîne de caractères (devrait)

os Documentation Cette fois, je l'ai utilisé pour enregistrer l'image pour voir si l'image spécifiée existe vraiment.

Code implémenté(conversion.go)

func FilepathCheck(imagepath string) error {
	switch imagepath {
	case "":
		return errors.New("Aucun fichier spécifié")
	default:
		if f, err := os.Stat(imagepath); os.IsNotExist(err) || f.IsDir() {
			return errors.New("Fichier ne existe pas" + imagepath)
		} else {
			return nil
		}
	}
}

//-C'est une fonction qui détermine si le fichier spécifié par f existe.

Ce type peut faire à peu près tout.

path/filepath Documentation J'obtiens les arguments de la fonction que j'ai introduite plus tôt. J'obtiens le chemin du fichier à partir de la chaîne.

Code implémenté(main.go)

f := filepath.Ext(imagepath)
err = conversion.FileExtCheck(f)
//Vérifiez si le chemin d'image existe vraiment

image Documentation Le système de traitement d'image peut être fait avec ce type.

Code implémenté(conversion.go)

img, _, Err := image.Decode(exFile)
if Err != nil {
	return errors.New("Échec du décodage")
}
//Traitement pour décoder l'image

switch extension {
case JPEG, JPG:
	err = jpeg.Encode(output, img, nil)
	if err != nil {
		return errors.New("Échec du codage")
	}
	fmt.Println("Conversion réussie")
	return nil
case GIF:
	err = gif.Encode(output, img, nil)
	if err != nil {
		return errors.New("Échec du codage")
	}
	fmt.Println("Conversion réussie")
	return nil
case PNG:
	err = png.Encode(output, img)
	if err != nil {
		return errors.New("Échec du codage")
	}
	fmt.Println("Conversion réussie")
	return nil
}
//Encoder selon l'extension convertie

Il semble que le traitement d'image ne peut être fait presque qu'avec ce type

Sommaire

Quand je l'exécute ...

# go build -o cvs
# ./cvs -e png -f sample.jpeg -d sample.png
Conversion ...
Conversion réussie

Vous pouvez le convertir comme ça.

À propos, même si vous l'écrivez correctement au lieu de .png après -d, il est converti correctement en tant qu'extension.

Si vous le convertissez avec un navigateur, il ne semble pas que vous puissiez insérer des scripts étranges, et c'est sûr.

C'était stimulant et amusant, alors je me demande si je devrais faire une autre commande.

Ensuite.