Go ile İlk Komut Satırı Aracınızı Oluşturma

Go ile İlk Komut Satırı Aracınızı Oluşturma

Giriş: Komut Satırı Araçlarının Gücü

Komut satırı araçları (CLI – Command Line Interface), yazılım geliştiriciler ve sistem yöneticileri için vazgeçilmez araçlardır. Otomasyon, sistem yönetimi, veri işleme ve hızlı prototipleme gibi birçok alanda merkezi bir rol oynarlar. Grafiksel arayüzlerin sunduğu kolaylığın aksine, CLI araçları daha hızlı, daha esnek ve komut dosyaları (script) aracılığıyla kolayca otomatize edilebilir bir etkileşim sunar. Go (Golang), bu tür araçlar geliştirmek için mükemmel bir dil seçimidir. Performansı, derlenmiş tek bir ikili dosya (binary) oluşturabilme yeteneği, güçlü standart kütüphanesi ve platformlar arası uyumluluğu sayesinde Go, CLI araçları geliştirenler arasında hızla popülerlik kazanmıştır.

Bu makalede, Go kullanarak sıfırdan basit bir komut satırı aracı oluşturmayı adım adım öğreneceksiniz. os.Args ile temel argüman işleminden başlayarak, Go’nun yerleşik flag paketini kullanacak ve ardından endüstri standardı olan cobra kütüphanesi ile daha karmaşık, alt komutlara sahip bir araç geliştireceğiz. Amacımız, Go’nun CLI geliştirme yeteneklerini keşfetmek ve kendi araçlarınızı oluşturmanız için sağlam bir temel sağlamaktır.

Go Ortamınızı Hazırlama

Go ile geliştirme yapmaya başlamadan önce, sisteminizde Go’nun kurulu olduğundan emin olmalısınız. Go’yu kurmak için resmi web sitesi olan [go.dev/doc/install](https://go.dev/doc/install) adresindeki talimatları takip edebilirsiniz. Kurulumu tamamladıktan sonra, bir terminal penceresi açıp go version komutunu çalıştırarak kurulumu doğrulayabilirsiniz. Çıktı olarak Go sürümünüzü görmelisiniz (örneğin, go version go1.22.0 linux/amd64).

Modern Go projeleri için modül sistemi (Go Modules) kullanılır. Bu, bağımlılıkları yönetmenin standart yoludur. Yeni bir proje başlatmak için, projeniz için bir dizin oluşturun ve içine girin:

mkdir my-cli-tool
cd my-cli-tool
go mod init github.com/kullaniciadi/my-cli-tool

go mod init komutu, projeniz için bir go.mod dosyası oluşturur. Bu dosya, projenizin bağımlılıklarını ve Go sürümünü tanımlar.

Temeller: Basit Bir “Merhaba, CLI!” Aracı

Herhangi bir programlama dilinde olduğu gibi, Go’da da ilk adım genellikle bir “Merhaba Dünya” programıdır. CLI dünyasında bu, komut satırından çalıştırılabilen basit bir program anlamına gelir. Proje dizininizde main.go adında bir dosya oluşturalım:

// main.go
package main

import "fmt"

func main() {
    fmt.Println("Merhaba, CLI dünyası!")
}

Bu kodu çalıştırmak için terminalde aşağıdaki komutu kullanın:

go run main.go

Çıktı olarak Merhaba, CLI dünyası! görmelisiniz. Bu, Go programınızı doğrudan çalıştırmanın hızlı bir yoludur. Ancak bir CLI aracı genellikle derlenmiş bir ikili dosya olarak dağıtılır. Aracınızı derlemek için:

go build -o mycli

Bu komut, mycli adında bir çalıştırılabilir dosya oluşturur (Windows’ta mycli.exe). Şimdi bu dosyayı doğrudan çalıştırabilirsiniz:

./mycli

Bu, Go ile ilk komut satırı aracınızı başarıyla derleyip çalıştırdığınız anlamına gelir.

Argümanları İşleme: os.Args

Bir CLI aracının temel işlevlerinden biri, kullanıcı tarafından sağlanan argümanları işlemektir. Go’nun standart kütüphanesi, os paketi aracılığıyla bu yeteneği sunar. os.Args bir dize dilimi (slice of strings) olup, çalıştırılan programın adını ve ardından gelen tüm komut satırı argümanlarını içerir.

main.go dosyamızı güncelleyelim:

// main.go
package main

import (
	"fmt"
	"os"
)

func main() {
	if len(os.Args) > 1 {
		name := os.Args[1] // İlk argümanı isim olarak al
		fmt.Printf("Merhaba, %s!\n", name)
	} else {
		fmt.Println("Merhaba, anonim kullanıcı!")
	}
}

Bu kodu derleyip çalıştıralım:

go build -o greeting
./greeting
Çıktı: Merhaba, anonim kullanıcı!

./greeting Alper
Çıktı: Merhaba, Alper!

./greeting Go Programcısı
Çıktı: Merhaba, Go Programcısı!

os.Args ile argümanları doğrudan indeksleyerek erişebilirsiniz. os.Args[0] her zaman programın adıdır. os.Args[1] ise ilk argümanı temsil eder. Bu yöntem basit durumlar için yeterli olsa da, adlandırılmış parametreler (bayraklar/flag’ler) veya isteğe bağlı argümanlar gibi daha karmaşık senaryolar için yetersiz kalır. Örneğin, --name Alper gibi bir kullanımı doğrudan desteklemez. İşte burada Go’nun flag paketi devreye girer.

Bayrakları Tanımlama: flag Paketi

Komut satırı araçları genellikle program --bayrak değer veya program -b değer gibi adlandırılmış argümanlar kullanır. Bunlara “bayrak” (flag) denir. Go’nun standart flag paketi, bu tür bayrakları kolayca tanımlamanızı ve ayrıştırmanızı sağlar.

greeting aracımızı, --name bayrağını kullanacak şekilde güncelleyelim:

// main.go
package main

import (
	"flag"
	"fmt"
)

func main() {
	// 'name' adında bir string bayrağı tanımla.
	// Varsayılan değeri "anonim", kullanım mesajı "Karşılanacak isim"
	namePtr := flag.String("name", "anonim", "Karşılanacak isim")

	// 'loud' adında bir boolean bayrağı tanımla.
	// Varsayılan değeri false, kullanım mesajı "Mesajı yüksek sesle söyle"
	loudPtr := flag.Bool("loud", false, "Mesajı yüksek sesle söyle")

	// Komut satırı bayraklarını ayrıştır
	flag.Parse()

	// Bayrak değerlerine işaretçiler aracılığıyla eriş
	message := fmt.Sprintf("Merhaba, %s!", *namePtr)

	if *loudPtr {
		message = fmt.Sprintf("%s YÜKSEK SESLE!!!", message)
	}

	fmt.Println(message)
}

Şimdi bu kodu derleyip farklı bayraklarla çalıştıralım:

go build -o greeting-flags
./greeting-flags
Çıktı: Merhaba, anonim!

./greeting-flags --name Alper
Çıktı: Merhaba, Alper!

./greeting-flags --name "Go Geliştiricisi" --loud
Çıktı: Merhaba, Go Geliştiricisi! YÜKSEK SESLE!!!

./greeting-flags -name Ahmet
Çıktı: Merhaba, Ahmet! (Uzun form --name yerine -name de çalışır)

./greeting-flags --help
Çıktı:
Usage of ./greeting-flags:
-loud
Mesajı yüksek sesle söyle
-name string
Karşılanacak isim (default "anonim")

flag paketi, basit CLI araçları için harikadır. flag.String, flag.Int, flag.Bool gibi fonksiyonlar, farklı veri tiplerindeki bayrakları tanımlamanızı sağlar. flag.Parse() çağrısı, komut satırı argümanlarını ayrıştırır ve tanımlanmış bayraklara değerlerini atar. Ayrıca, otomatik olarak bir --help mesajı da oluşturur.

Ancak, flag paketi alt komutlar (örneğin, git add, git commit gibi) veya daha karmaşık yapılandırmalar için uygun değildir. Bu noktada cobra gibi üçüncü taraf kütüphaneler devreye girer.

Gelişmiş Bayrak Ayrıştırma ve Alt Komutlar: cobra Kütüphanesi

Büyük ve karmaşık CLI araçları genellikle birden fazla alt komuta sahiptir. Örneğin, git komutu git add, git commit, git push gibi alt komutlara sahiptir. Go dünyasında bu tür yapıları oluşturmak için en popüler ve güçlü kütüphanelerden biri cobra‘dır. cobra, Google tarafından geliştirilen spf13/viper (yapılandırma yönetimi için) kütüphanesinin de arkasındaki ekip tarafından geliştirilmiştir.

cobra‘nın temel özellikleri şunlardır:
* Alt Komutlar: Sınırsız sayıda iç içe alt komutlar tanımlama yeteneği.
* Bayrak Yönetimi: Yerel (bir komuta özel) ve kalıcı (tüm alt komutlar için geçerli) bayrakları destekler.
* Otomatik Yardım Mesajları: Komutlar ve bayraklar için otomatik olarak help mesajları oluşturur.
* Argüman Doğrulama: Komutlara geçirilen argümanların sayısını ve türünü doğrulama imkanı.
* Shell Otomatik Tamamlama: Bash, Zsh, Fish gibi kabuklar için otomatik tamamlama komutları oluşturabilir.

cobra Kurulumu

Yeni bir proje dizini oluşturalım ve cobra‘yı kuralım:

mkdir fileutil
cd fileutil
go mod init github.com/kullaniciadi/fileutil
go get github.com/spf13/cobra

cobra ile Temel Yapı

cobra projeleri genellikle belirli bir dizin yapısını takip eder:
* main.go: Uygulamanın ana giriş noktası. cmd.Execute() çağrısını içerir.
* cmd/: Tüm komut tanımlamalarının bulunduğu dizin.
* cmd/root.go: Uygulamanın ana (root) komutunu tanımlar.
* cmd/info.go: info alt komutunu tanımlar.
* cmd/hash.go: hash alt komutunu tanımlar.

Şimdi bu yapıyı oluşturalım ve basit bir fileutil aracı geliştirelim. Bu araç, bir dosyanın bilgilerini gösterecek (info) ve bir dosyanın MD5 özetini hesaplayacak (hash).

1. main.go: Uygulamanın başlangıç noktası.

// main.go
package main

import (
	"fileutil/cmd" // cmd dizinindeki paketimizi import ediyoruz
)

func main() {
	cmd.Execute() // Cobra komut ağacını çalıştır
}

2. cmd/root.go: Ana komutu tanımlar. Bu komut genellikle doğrudan bir iş yapmaz, sadece alt komutları düzenler.

// cmd/root.go
package cmd

import (
	"fmt"
	"os"

	"github.com/spf13/cobra"
)

var (
	verbose bool // Global bir bayrak örneği
)

// rootCmd, tüm alt komutlar için ana komuttur.
var rootCmd = &cobra.Command{
	Use:   "fileutil",
	Short: "Dosya yönetimi için basit bir araç",
	Long: fileutil, Go ile oluşturulmuş basit bir komut satırı aracıdır.
Dosya bilgisi alma ve dosya özetini hesaplama gibi temel işlevleri sağlar.,
	// Run: Bu komutun doğrudan çalıştırıldığında ne yapacağını tanımlar.
	// Alt komutları olan bir root komutu genellikle doğrudan bir iş yapmaz.
	// Burayı boş bırakabilir veya bir yardım mesajı gösterebilirsiniz.
	// Run: func(cmd *cobra.Command, args []string) { fmt.Println("Lütfen bir alt komut seçin.") },
}

// Execute, rootCmd'u çalıştırır. Tüm alt komutlar için giriş noktasıdır.
func Execute() {
	if err := rootCmd.Execute(); err != nil {
		fmt.Fprintf(os.Stderr, "Hata: %s\n", err)
		os.Exit(1)
	}
}

func init() {
	// Kalıcı bayraklar (Persistent Flags): Bu komut ve tüm alt komutları tarafından kullanılabilir.
	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "Detaylı çıktı göster")
}

3. cmd/info.go: info alt komutunu tanımlar. Bu komut, bir dosyanın temel bilgilerini (boyut, değiştirme tarihi, izinler) gösterir.

// cmd/info.go
package cmd

import (
	"fmt"
	"os"
	"strconv"
	"time"

	"github.com/spf13/cobra"
)

// infoCmd, 'fileutil info ' komutunu temsil eder.
var infoCmd = &cobra.Command{
	Use:   "info ",
	Short: "Bir dosyanın temel bilgilerini gösterir",
	Long: Belirtilen dosyanın boyutunu, son değiştirme tarihini ve izinlerini gösterir.
Kullanım: fileutil info ,
	Args: cobra.ExactArgs(1), // Tam olarak 1 argüman bekler (dosya yolu)
	Run: func(cmd *cobra.Command, args []string) {
		filePath := args[0]

		fileInfo, err := os.Stat(filePath)
		if err != nil {
			if os.IsNotExist(err) {
				fmt.Fprintf(os.Stderr, "Hata: '%s' dosyası bulunamadı.\n", filePath)
			} else {
				fmt.Fprintf(os.Stderr, "Hata: Dosya bilgileri alınırken bir sorun oluştu: %v\n", err)
			}
			os.Exit(1)
		}

		fmt.Printf("Dosya Adı: %s\n", fileInfo.Name())
		fmt.Printf("Boyut: %d bayt\n", fileInfo.Size())
		fmt.Printf("Son Değişiklik: %s\n", fileInfo.ModTime().Format(time.RFC822))
		fmt.Printf("İzinler: %s (%s)\n", fileInfo.Mode().String(), strconv.FormatUint(uint64(fileInfo.Mode().Perm()), 8))

		if verbose { // root komutunda tanımlanan global bayrağı kullan
			fmt.Println("--- Detaylı Bilgi (Verbose) ---")
			fmt.Printf("Dizin mi?: %t\n", fileInfo.IsDir())
			fmt.Printf("Sistem Modu: %s\n", fileInfo.Mode().String())
		}
	},
}

func init() {
	rootCmd.AddCommand(infoCmd) // infoCmd'yi ana komuta ekle
}

4. cmd/hash.go: hash alt komutunu tanımlar. Bu komut, bir dosyanın MD5 özetini hesaplar.

// cmd/hash.go
package cmd

import (
	"crypto/md5"
	"encoding/hex"
	"fmt"
	"io"
	"os"

	"github.com/spf13/cobra"
)

// hashCmd, 'fileutil hash ' komutunu temsil eder.
var hashCmd = &cobra.Command{
	Use:   "hash ",
	Short: "Bir dosyanın MD5 özetini hesaplar",
	Long: Belirtilen dosyanın MD5 özetini (checksum) hesaplar ve ekrana yazdırır.
Kullanım: fileutil hash ,
	Args: cobra.ExactArgs(1), // Tam olarak 1 argüman bekler (dosya yolu)
	Run: func(cmd *cobra.Command, args []string) {
		filePath := args[0]

		file, err := os.Open(filePath)
		if err != nil {
			if os.IsNotExist(err) {
				fmt.Fprintf(os.Stderr, "Hata: '%s' dosyası bulunamadı.\n", filePath)
			} else {
				fmt.Fprintf(os.Stderr, "Hata: Dosya açılırken bir sorun oluştu: %v\n", err)
			}
			os.Exit(1)
		}
		defer file.Close() // Fonksiyon bitiminde dosyayı kapat

		hash := md5.New()
		if _, err := io.Copy(hash, file); err != nil {
			fmt.Fprintf(os.Stderr, "Hata: Dosya okunurken bir sorun oluştu: %v\n", err)
			os.Exit(1)
		}

		hashInBytes := hash.Sum(nil)[:16]
		md5String := hex.EncodeToString(hashInBytes)

		fmt.Printf("Dosya: %s\n", filePath)
		fmt.Printf("MD5 Özeti: %s\n", md5String)

		if verbose { // root komutunda tanımlanan global bayrağı kullan
			fmt.Println("--- Detaylı Bilgi (Verbose) ---")
			fmt.Println("MD5 algoritması kullanıldı.")
		}
	},
}

func init() {
	rootCmd.AddCommand(hashCmd) // hashCmd'yi ana komuta ekle
}

fileutil Aracını Çalıştırma

Şimdi bu kodu derleyip çalıştırabiliriz. Öncelikle, örnek bir dosya oluşturalım:

echo "Bu bir deneme dosyasıdır." > test.txt

Şimdi aracımızı derleyelim:

go build -o fileutil .

Ve çeşitli komutlarla çalıştıralım:

./fileutil
Çıktı: fileutil, Go ile oluşturulmuş basit bir komut satırı aracıdır.
... (yardım mesajı)

./fileutil info test.txt
Çıktı:
Dosya Adı: test.txt
Boyut: 28 bayt
Son Değişiklik: ...
İzinler: -rw-rw-r-- (664)

./fileutil info non_existent_file.txt
Çıktı: Hata: 'non_existent_file.txt' dosyası bulunamadı.

./fileutil hash test.txt
Çıktı:
Dosya: test.txt
MD5 Özeti: 5316374972f10b3711d95015b7b9f8f4

./fileutil info test.txt -v
Çıktı: (Yukarıdaki info çıktısına ek olarak detaylı bilgi)
...
--- Detaylı Bilgi (Verbose) ---
Dizin mi?: false
Sistem Modu: -rw-rw-r--

Bu örnek, cobra‘nın nasıl alt komutlar tanımladığını, argümanları nasıl işlediğini ve global bayrakları (--verbose) nasıl kullandığını göstermektedir. cobra.Command yapısı, Use, Short, Long, Args ve Run gibi alanlarla komutun davranışını kolayca yapılandırmanıza olanak tanır. init() fonksiyonları ise alt komutları rootCmd‘ye eklemek için kullanılır.

Hata Yönetimi ve Kullanıcı Geribildirimi

Sağlam bir CLI aracı, hataları düzgün bir şekilde yönetmeli ve kullanıcıya anlaşılır geri bildirim sağlamalıdır. Go’da hata yönetimi genellikle fonksiyonların error türünde bir değer döndürmesiyle yapılır. CLI araçlarında, bir hata durumunda programın uygun bir çıkış koduyla (os.Exit(1)) sonlandırılması önemlidir. Bu, komut dosyalarının (shell scripts) aracın başarılı olup olmadığını anlamasını sağlar.

Örneklerimizde fmt.Fprintf(os.Stderr, "Hata: ...") kullanarak hata mesajlarını standart hata akışına (stderr) yazdırdık. Bu, normal çıktıdan (stdout) ayrı tutulması gereken bir iyi uygulamadır.

cobra ayrıca cobra.CheckErr gibi yardımcı fonksiyonlar sunar. Ancak genellikle if err != nil kalıbı yeterlidir.

Çıktı Biçimlendirme

CLI araçlarının çıktısı, kullanıcı tarafından kolayca okunabilir ve programlar tarafından kolayca ayrıştırılabilir olmalıdır.
* İnsan Okunabilir Çıktı: fmt.Printf veya text/tabwriter gibi paketler, verileri sütunlar halinde hizalayarak okunabilirliği artırır.
* Makine Okunabilir Çıktı: Bazı durumlarda, CLI aracınızın çıktısını başka bir programın işlemesi gerekebilir. Bu durumda, JSON (encoding/json) veya CSV gibi yapılandırılmış formatlar kullanmak faydalı olabilir. Örneğin, --json bayrağı ekleyerek çıktının JSON formatında olmasını sağlayabilirsiniz.

CLI Aracınızı Test Etme

CLI araçları için test yazmak, diğer Go programları için test yazmaya benzer.
* Birim Testleri: Komutlarınızın arkasındaki iş mantığını (örneğin, bir dosyanın MD5 özetini hesaplayan fonksiyon) ayrı ayrı test edin.
* Entegrasyon Testleri: Tüm CLI aracının beklediğiniz gibi çalıştığını doğrulamak için exec.Command kullanarak komutları çalıştırabilir ve çıktıyı kontrol edebilirsiniz.

Örneğin, fileutil hash komutunu test etmek için:

// fileutil_test.go
package main_test

import (
	"bytes"
	"io/ioutil"
	"os"
	"os/exec"
	"strings"
	"testing"
)

func TestFileUtilHashCommand(t *testing.T) {
	// Geçici bir dosya oluştur
	testContent := "Test içeriği"
	tmpFile, err := ioutil.TempFile("", "testfile*.txt")
	if err != nil {
		t.Fatalf("Geçici dosya oluşturulamadı: %v", err)
	}
	defer os.Remove(tmpFile.Name()) // Test bitiminde dosyayı sil

	if _, err := tmpFile.WriteString(testContent); err != nil {
		t.Fatalf("Geçici dosyaya yazılamadı: %v", err)
	}
	tmpFile.Close()

	// CLI aracını çalıştır
	cmd := exec.Command("./fileutil", "hash", tmpFile.Name())
	var out bytes.Buffer
	cmd.Stdout = &out
	err = cmd.Run()
	if err != nil {
		t.Fatalf("fileutil hash komutu çalışırken hata: %v", err)
	}

	// Çıktıyı kontrol et
	expectedMD5 := "f339178f0d8a0d9237c3525287515d01" // "Test içeriği" MD5'i
	if !strings.Contains(out.String(), expectedMD5) {
		t.Errorf("Beklenen MD5 özeti '%s' çıktıda bulunamadı: %s", expectedMD5, out.String())
	}
}

Bu test, fileutil ikili dosyasının oluşturulduğunu ve go test komutuyla çalıştırılabileceğini varsayar.

Aracınızı Derleme ve Dağıtma

Go’nun en büyük avantajlarından biri, tüm bağımlılıkları içeren tek, statik olarak derlenmiş bir ikili dosya üretmesidir. Bu, dağıtımı inanılmaz derecede kolaylaştırır.

Derleme

Proje dizininizin kökünden aşağıdaki komutla aracınızı derleyebilirsiniz:

go build -o fileutil .

Bu, bulunduğunuz işletim sistemi ve mimari için fileutil adında bir çalıştırılabilir dosya oluşturur.

Çapraz Derleme (Cross-Compilation)

Go, farklı işletim sistemleri ve mimariler için kolayca çapraz derleme yapmanıza olanak tanır. Örneğin, Linux üzerinde Windows için bir ikili dosya oluşturmak isterseniz:

GOOS=windows GOARCH=amd64 go build -o fileutil.exe .

MacOS için:

GOOS=darwin GOARCH=amd64 go build -o fileutil_mac .

Bu, Go’nun “bir kez yaz, her yerde çalıştır” felsefesinin güçlü bir göstergesidir.

Dağıtım

Derlenmiş ikili dosyayı kullanıcılarınıza doğrudan verebilirsiniz. Kullanıcıların Go kurulu olmasına gerek yoktur. Genellikle, bu ikili dosyayı sistemlerinin PATH ortam değişkeninde tanımlı bir dizine (örneğin /usr/local/bin veya ~/bin) kopyalamaları yeterlidir, böylece komutu doğrudan terminalden çalıştırabilirler.

Daha gelişmiş dağıtım senaryoları için goreleaser gibi araçlar, otomatik olarak farklı platformlar için ikili dosyalar oluşturabilir, sıkıştırabilir, GitHub sürümlerine yükleyebilir ve paket yöneticileri için paketler (Homebrew, Scoop vb.) oluşturabilir.

Gelişmiş Konulara Kısa Bir Bakış

Bu makalede temel bir CLI aracı oluşturmayı öğrendik, ancak Go ve cobra ekosistemi daha birçok gelişmiş özellik sunar:

* Yapılandırma Yönetimi (viper): spf13/viper kütüphanesi, CLI araçlarınız için yapılandırma dosyalarını (JSON, YAML, TOML, INI), ortam değişkenlerini ve komut satırı bayraklarını tutarlı bir şekilde yönetmenizi sağlar.
* Etkileşimli İstekler (survey): Kullanıcıdan girdi almak için interaktif menüler, onay kutuları veya metin giriş alanları sağlamak isterseniz, AlecAivazis/survey gibi kütüphaneler yardımcı olabilir.
* İlerleme Çubukları (go-progress): Uzun süren işlemler için kullanıcıya geri bildirim sağlamak amacıyla ilerleme çubukları gösterebilirsiniz.
* Günlükleme (zap, logrus): Basit fmt.Println yerine, daha gelişmiş ve yapılandırılabilir günlükleme için uber-go/zap veya sirupsen/logrus gibi kütüphaneler kullanabilirsiniz.
* Bağımlılık Enjeksiyonu: Daha büyük projelerde kodun test edilebilirliğini ve bakımını artırmak için bağımlılık enjeksiyonu desenlerini uygulayabilirsiniz.

Sonuç

Go, komut satırı araçları geliştirmek için olağanüstü bir dildir. Performansı, tek ikili dosya oluşturma yeteneği ve zengin standart kütüphanesi sayesinde, geliştiricilere güçlü ve dağıtımı kolay araçlar yaratma imkanı sunar. Bu makalede, os.Args ile temel argüman işleminden başlayarak, flag paketi ile bayrak yönetimine ve son olarak cobra kütüphanesi ile alt komutlara sahip, profesyonel düzeyde bir CLI aracı oluşturmaya kadar Go’nun CLI geliştirme yeteneklerini keşfettik.

Artık kendi Go CLI araçlarınızı oluşturmak için sağlam bir temele sahipsiniz. Kendi ihtiyaçlarınıza uygun otomasyon araçları, sistem yardımcıları veya veri işleme programları geliştirerek Go’nun gücünü keşfetmeye devam edin. Unutmayın, pratik yapmak en iyi öğrenme yöntemidir. Küçük projelerle başlayın, hatalar yapın ve onlardan ders çıkarın. Go topluluğu ve zengin dokümantasyon, bu yolculukta size her zaman destek olacaktır. Başarılar dileriz!