Nesta seção vamos ver como lidamos com argumentos informados em linha de comando na linguagem Go.

A linha de comando é uma forma mais básica para passsarmos argumentos para nossos programas. Para manipularmos esses argumentos, precisamos recorrer ao package os. Esse package possui várias funções para integração com o sistema operacional, porém apenas os relacionados a linha de comando serão visto aqui.

Sintaxe

import "os"

Para termos conhecimento de quais argumentos foram passados ao nosso programa, utilizamos o vetor Args que armazena esses argumentos em forma de strings. O primeiro elemento de Args é sempre o nome de nosso programa.

Sintaxe

os.Args

A quantidade de argumentos pode ser verificada utilizando a função len vistos em Go: Strings, Go: Vetores. A iteração sobre Args é feita utilizando o comando de repetição for com e auxilio do comando range. A conversão de dados deve ser feita utilizando as funções vistas em Go: Conversão de dados.

Exemplo 1

package main
import "fmt"
import "os"

func main() {
    
    fmt.Printf("argumentos.:%d\n",len(os.Args))

    for indice,valor := range os.Args{
      fmt.Printf("indice:%d arg.:%s\n",indice,valor)
    }
}

Entrada

nome_executavel.exe um dois tres quatro

Saída

argumentos:5
indice:0 argumento:nome_executave.exe
indice:1 argumento:um
indice:2 argumento:dois
indice:3 argumento:tres
indice:4 argumento:quatro

A quantidade de elementos contidos em Args deve sempre ser validada antes de qualquer operação sobre seus argumentos para evitar erros. Os comando de decisão vistos em Go: Comandos devem ser utilizados.

Para demostrar o que foi visto sobre linha de comando como exemplo, um calculadora aritmética básica será utilizada como exemplo.

Exemplo 2

package main
import ( 
    "fmt"
    "os"
    "strconv"
)

func soma(a , b int ) int{
    return a + b
}

func subt(a , b int ) int{
    return a - b
}

func mult(a , b int ) int{
    return a * b
}

func divi(a , b int ) int{
    return a / b
}

func main() {
    
    if len(os.Args) == 4 { 
        arga := os.Args[1]
        argb := os.Args[2]
        op := os.Args[3]
        
        a,_:= strconv.Atoi(arga)
        b,_:= strconv.Atoi(argb)
        
        switch ( op){
            case "+": fmt.Println(soma(a,b))
            case "-": fmt.Println(subt(a,b))
            case "x": fmt.Println(mult(a,b))
            case "/": fmt.Println(divi(a,b))
            default: fmt.Println("operação não reconhecida")
        }
    }else {
        fmt.Println("Número de argumentos inválidos\nEx:\n1 2 +\n1 2 -\n1 2 x\n1 2 /")
    }
}

Entrada

main.exe 1 2 +

Saída

3

Go fornece o package nativo flags para lidar com os argumentos em linha de comando de forma mais fácil.

Sintaxe

import "flags"

Para definir ou configurar nossas flags ou argumentos, de acordo com seus tipos, utilizamos as funções Bool, Int, String e outras cujas sintaxes são mostradas logo abaixo:

Sintaxe

Bool(<name> string, value bool , usage string) *bool
Int(<name> string, value int , usage string) *int
String(<name> string, value string , usage string) *string
Int64(name string, value int64, usage string) *int64
Float64(name string, value float64, usage string) *float64
Uint(name string, value uint, usage string) *uint
Uint64(name string, value uint64, usage string) *uint64

Onde

<name>: nome da flag
value: valor default caso um associado valor não seja informado
usage: descrição da flag para gerar a ajuda

Exemplo 3

import (
    "fmt"
    "flag"
)

func main(){
    
    flag1 := flag.String("flag1","teste","descricao flag1") //
    flag2 := flag.String("flag2","","descricao flag2") //
}

As flags podem ser prefixadas com com (-) ou (--) quando informadas na linha de comando pelo usuário da aplicação.

Exemplo 4

main.exe -flag
main.exe --flag
main.exe flag=1

Para "montar" as flags definidas ou configuradas, invocamos a função Parse do package como mostrado na sintaxe abaixo:

Sintaxe

flag.Parse()

Exemplo 5

import (
    "fmt"
    "flag"
)

func main(){
    
    flag1 := flag.String("flag1","teste","descricao flag1") //
    flag2 := flag.String("flag2","","descricao flag2") //
    
    flag.Parse()
}

As flags devem ser verificadas com o comando if usado para exibir mensagem de ajuda caso não sejam informadas ou para fazer os devidos tratamentos ou processamento de acordo com a aplicação.

Exemplo 6

import (
    "fmt"
    "flag"
)

func main(){
    
    flag1 := flag.String("flag1","teste","descricao flag1") //
    flag2 := flag.String("flag2","teste","descricao flag2") //
    
    flag.Parse();
    
    fmt.Printf("flag1: %s\n",*flag1);
    fmt.Printf("flag2: %s",*flag2);
    
    if *flag1 == "" {
        fmt.Printf("fornecer flag1\n");
        //sair da aplicação
    }
    
    if *flag2 == "" {
        fmt.Printf("fornecer flag2\n");
        //sair da aplicação
    }

    //tratamento das flags
}

Entrada

main.exe flag1=1 flag2=1

Saída

flag1=1
flag2=1

Tendo as flags definidas e invocando a função Parse, podemos utilizar o argumento -help ou --help como argumento informado na linha de comando para exibir uma mensagem padrão criada para informar sobre o uso das flags.

Exemplo 7

package main

import (
    "flag"
)

func main(){
    
    flag.String("flag1","teste","descricao flag1") //
    flag.String("flag2","","descricao flag2") //
    
    flag.Parse();

   //omitido
}

Entrada

main.exe -help

Saída

Usage of main.exe:
  -flag1 string
        descricao flag1 (default "teste")
  -flag2 string
        descricao flag2

1. 30/10/2025 - revisão 4 - Adição: 'package flags'
2. 08/09/2025 - revisão 3 - Ajustes pontuais
3. 16/09/2024 - revisão 2 - Ajustes gramaticais
4. 02/10/2023 - revisão 1 - Correção em referências, erros gramaticais
5. 21/08/2023 - versão inicial