[GO] [Los] Erstellen Sie einen CLI-Befehl, um die Erweiterung des Bildes zu ändern

Einführung

Zuvor nahm ich am Arbeitszimmer von ** Gopher dojo ** teil und suchte nach den Themen von Gopher dojo, an denen ich mich schon lange für Github interessiert hatte. , (Ist es okay, es zu tun ...?) Ich habe geübt.

Das erste Problem war ** Ändern der Erweiterung des Bildes **. Ich möchte es vorerst ausgeben, deshalb werde ich hier verschiedene Dinge schreiben. Außerdem werde ich aus dem verwendeten Paket ein wenig über "flag", "os", "path / filepath", "image" erklären.

Umgebung

# go version
go version go1.15.2 linux/amd64

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

Tatsächlicher Code

Das Repository befindet sich derzeit hier.

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", "Angabe der Erweiterung")
	flag.StringVar(&imagepath, "f", "", "Geben Sie den Pfad der zu konvertierenden Datei an")
	flag.StringVar(&dirpath, "d", "", "Angabe des Dateinamens nach der Konvertierung")
	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("Konvertieren ...")

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

conversion.go

/*
Die Konvertierung ist ein Paket zum Ändern der Erweiterung eines Bildes.
*/
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"
)

// -Legt fest, ob die von e angegebene Erweiterung unterstützt wird.
func ExtensionCheck(ext string) error {
	switch ext {
	case JPEG, JPG, GIF, PNG:
		return nil
	default:
		return errors.New("Erweiterung, die nicht angegeben werden kann" + ext)
	}
}

// -Bestimmt, ob die durch f angegebene Datei vorhanden ist.
func FilepathCheck(imagepath string) error {
	switch imagepath {
	case "":
		return errors.New("Keine Datei angegeben")
	default:
		if f, err := os.Stat(imagepath); os.IsNotExist(err) || f.IsDir() {
			return errors.New("Die Datei existiert nicht" + imagepath)
		} else {
			return nil
		}
	}
}

func DirpathCheck(dirpath string) error {
	switch dirpath {
	case "":
		return errors.New("Der konvertierte Dateiname ist nicht angegeben")
	default:
		return nil
	}
}

func FileExtCheck(imagepath string) error {
	switch imagepath {
	case "." + JPEG, "." + JPG, "." + GIF, "." + PNG:
		return nil
	default:
		return errors.New("Die angegebene Datei wird nicht unterstützt. ::" + 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.Erstellung fehlgeschlagen")
	}

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

	img, _, Err := image.Decode(exFile)
	if Err != nil {
		return errors.New("Fehler dekodieren")
	}

	switch extension {
	case JPEG, JPG:
		err = jpeg.Encode(output, img, nil)
		if err != nil {
			return errors.New("Fehler codieren")
		}
		fmt.Println("Erfolgreiche Konvertierung")
		return nil
	case GIF:
		err = gif.Encode(output, img, nil)
		if err != nil {
			return errors.New("Fehler codieren")
		}
		fmt.Println("Erfolgreiche Konvertierung")
		return nil
	case PNG:
		err = png.Encode(output, img)
		if err != nil {
			return errors.New("Fehler codieren")
		}
		fmt.Println("Erfolgreiche Konvertierung")
		return nil
	}
	return nil
}

go.mod

module cvs

go 1.15

Vorerst habe ich dafür gesorgt, dass es richtig funktioniert, während die Fehlerbehandlung angemessen war.

Codekommentar

Als Thema dieses Codes --Verwenden Sie "go mod" --Verwenden Sie "go doc"

• Separate Pakete

Das habe ich beschlossen. Der Grund ist vorerst

1. go mod erleichtert die Paketaufteilung
2. Erhöhen Sie die Verfügbarkeit, indem Sie mit go doc eine Dokumentation erstellen Da sind diese beiden. Aber diesmal ist es ein Pass.

Ich werde über das diesmal verwendete Paket schreiben.

Wenn Sie das Paket aufrufen, das für den CLI-Befehl zum Ändern der Erweiterung des Abbilds verwendet wird,

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

es gibt. Ich werde jeden von ihnen erklären.

flag Dokumentation Wird verwendet, um Argumente als Option über die Befehlszeile abzurufen

Code implementiert(main.go)

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

	flag.StringVar(&extension, "e", "jpeg", "Angabe der Erweiterung")
 // -e "String" で、Stringを取得する/Standardmäßig"jpeg"Angegeben
	flag.StringVar(&imagepath, "f", "", "Geben Sie den Pfad der zu konvertierenden Datei an")
	flag.StringVar(&dirpath, "d", "", "Angabe des Dateinamens nach der Konvertierung")
	flag.Parse() 
//Ohne Parse wird es nicht in Variablen analysiert

～～～ weggelassen

Wie schreibt man

flag.StringVar(&Variablennamen, "Optionales Symbol", "Standardwert","Beschreibung dieser Option")

Sie können andere als die Zeichenfolge erhalten (sollte)

os Dokumentation Dieses Mal habe ich damit das Bild gespeichert, um festzustellen, ob das angegebene Bild wirklich vorhanden ist.

Code implementiert(conversion.go)

func FilepathCheck(imagepath string) error {
	switch imagepath {
	case "":
		return errors.New("Keine Datei angegeben")
	default:
		if f, err := os.Stat(imagepath); os.IsNotExist(err) || f.IsDir() {
			return errors.New("Die Datei existiert nicht" + imagepath)
		} else {
			return nil
		}
	}
}

//-Diese Funktion bestimmt, ob die durch f angegebene Datei vorhanden ist.

Dieser Typ kann so ziemlich alles.

path/filepath Dokumentation Ich erhalte die Argumente der Funktion, die ich zuvor eingeführt habe. Ich erhalte den Dateipfad von der Zeichenfolge.

Code implementiert(main.go)

f := filepath.Ext(imagepath)
err = conversion.FileExtCheck(f)
//Überprüfen Sie, ob der Bildpfad wirklich vorhanden ist

image Dokumentation Das Bildverarbeitungssystem kann mit diesem Kerl gemacht werden.

Code implementiert(conversion.go)

img, _, Err := image.Decode(exFile)
if Err != nil {
	return errors.New("Fehler dekodieren")
}
//Verarbeitung zum Dekodieren des Bildes

switch extension {
case JPEG, JPG:
	err = jpeg.Encode(output, img, nil)
	if err != nil {
		return errors.New("Fehler codieren")
	}
	fmt.Println("Erfolgreiche Konvertierung")
	return nil
case GIF:
	err = gif.Encode(output, img, nil)
	if err != nil {
		return errors.New("Fehler codieren")
	}
	fmt.Println("Erfolgreiche Konvertierung")
	return nil
case PNG:
	err = png.Encode(output, img)
	if err != nil {
		return errors.New("Fehler codieren")
	}
	fmt.Println("Erfolgreiche Konvertierung")
	return nil
}
//Codieren Sie entsprechend der konvertierten Erweiterung

Es scheint, dass die Bildverarbeitung fast nur mit diesem Typen durchgeführt werden kann

Zusammenfassung

Wenn ich es tatsächlich laufen lasse ...

# go build -o cvs
# ./cvs -e png -f sample.jpeg -d sample.png
Konvertieren ...
Erfolgreiche Konvertierung

Sie können es so konvertieren.

Übrigens, auch wenn Sie es anstelle von .png nach -d entsprechend schreiben, wird es ordnungsgemäß als Erweiterung konvertiert.

Wenn Sie es mit einem Browser konvertieren, scheint es nicht so, als könnten Sie seltsame Skripte einfügen, und es ist sicher.

Es war herausfordernd und hat Spaß gemacht, also frage ich mich, ob ich noch einen Befehl geben sollte.

Dann.