Golang, cunoscut și sub numele de Go, este un limbaj de programare open-source dezvoltat de Google. Unul dintre punctele sale forte este capacitatea de a crea aplicații eficiente și performante, inclusiv interfețe de linie de comandă (CLI).

În această lecție, vom explora cum putem crea un CLI simplu folosind Golang. Vom parcurge pașii necesari pentru a dezvolta o aplicație CLI de bază care acceptă comenzi și argumente și vom discuta structura și funcționalitatea codului.

Cerințe Prealabile

1. Cunoștințe de bază în Golang: Este necesar să înțelegi fundamentele limbajului Golang.

2. Mediu de dezvoltare configurat: Presupunem că ai Go instalat și configurat corect pe sistemul tău.

Pașii de Urmărit

1. Crearea unui proiect Go

2. Definirea structurii proiectului

3. Implementarea funcționalității CLI

1. Crearea unui Proiect Go

Începe prin a crea un nou director pentru proiectul tău și inițializează un modul Go.

mkdir mycli
cd mycli
go mod init mycli

2. Definirea Structurii Proiectului

Vom crea un fișier principal main.go unde vom scrie codul nostru CLI.

touch main.go

Structura directorului ar trebui să arate astfel:

mycli/

│

├── main.go

├── go.mod

3. Implementarea Funcționalității CLI

Vom folosi pachetul standard flag pentru a analiza argumentele din linia de comandă.

Exemplu de Cod

Deschide fișierul main.go și adaugă următorul cod:

package main

import (
    "flag"
    "fmt"
    "os"
)

// Functie pentru afișarea utilizării CLI

func printUsage() {
    fmt.Println("Usage:")
    fmt.Println("  mycli [command] [arguments]")
    fmt.Println("\nCommands:")
    fmt.Println("  greet   Print a greeting message")
    fmt.Println("  sum     Calculate the sum of two numbers")
}

func main() {
    if len(os.Args) < 2 {
        printUsage()
        os.Exit(1)
    }

    switch os.Args[1] {
    case "greet":
        greetCommand := flag.NewFlagSet("greet", flag.ExitOnError)
        name := greetCommand.String("name", "World", "the name to greet")
        greetCommand.Parse(os.Args[2:])
        fmt.Printf("Hello, %s!\n", *name)
    case "sum":
        sumCommand := flag.NewFlagSet("sum", flag.ExitOnError)
        num1 := sumCommand.Float64("num1", 0, "first number")
        num2 := sumCommand.Float64("num2", 0, "second number")
        sumCommand.Parse(os.Args[2:])
        result := *num1 + *num2
        fmt.Printf("The sum of %f and %f is %f\n", *num1, *num2, result)
    default:
        printUsage()
        os.Exit(1)
    }
}

Explicația Codului

1. Importarea Pachetelor

import (
    "flag"
    "fmt"
    "os"
)

• flag: Pachetul folosit pentru a defini și analiza argumentele din linia de comandă.

• fmt: Pachetul folosit pentru formatarea textului.

• os: Pachetul folosit pentru a accesa argumentele din linia de comandă.

1. Funcția printUsage

func printUsage() {
    fmt.Println("Usage:")
    fmt.Println("  mycli [command] [arguments]")
    fmt.Println("\nCommands:")
    fmt.Println("  greet   Print a greeting message")
    fmt.Println("  sum     Calculate the sum of two numbers")
}

• Această funcție afișează instrucțiunile de utilizare a CLI-ului nostru.

1. Funcția main

func main() {
    if len(os.Args) < 2 {
        printUsage()
        os.Exit(1)
    }

    switch os.Args[1] {
    case "greet":
        greetCommand := flag.NewFlagSet("greet", flag.ExitOnError)
        name := greetCommand.String("name", "World", "the name to greet")
        greetCommand.Parse(os.Args[2:])
        fmt.Printf("Hello, %s!\n", *name)
    case "sum":
        sumCommand := flag.NewFlagSet("sum", flag.ExitOnError)
        num1 := sumCommand.Float64("num1", 0, "first number")
        num2 := sumCommand.Float64("num2", 0, "second number")
        sumCommand.Parse(os.Args[2:])
        result := *num1 + *num2
        fmt.Printf("The sum of %f and %f is %f\n", *num1, *num2, result)
    default:
        printUsage()
        os.Exit(1)
    }
}

• Verificăm dacă există suficiente argumente (len(os.Args) < 2). Dacă nu, afișăm utilizarea CLI-ului și terminăm execuția (os.Exit(1)).

• switch os.Args[1]: Verificăm prima comandă după numele programului.

• greet: Definim un set de argumente pentru comanda greet, specificând un argument name.

• sum: Definim un set de argumente pentru comanda sum, specificând două argumente num1 și num2.

• default: Dacă comanda nu este recunoscută, afișăm utilizarea CLI-ului și terminăm execuția (os.Exit(1)).

Testarea CLI-ului

Pentru a testa CLI-ul, compilează și execută programul:

go build -o mycli
./mycli greet -name="Alice"
./mycli sum -num1=3 -num2=5

Concluzie

Am creat un CLI simplu în Golang care suportă două comenzi: greet și sum. Acest exemplu poate fi extins pentru a adăuga mai multe comenzi și funcționalități, făcându-l un instrument util pentru diverse sarcini automate.

Aceasta a fost o introducere de bază în crearea de CLI-uri cu Golang. Continuă să explorezi și să îți extinzi cunoștințele prin adăugarea de noi caracteristici și îmbunătățiri.