Um package padrão do Go e que, no meu ponto de vista, é pouco explorado, é o text/template. Com a ajuda desse package, podemos preencher os valores em qualquer template no formato texto, como por exemplo, arquivos JSON, YAML e TXT.

Para exemplificar melhor, vamos criar um arquivo YAML com o nome template.yaml e o seguinte conteúdo.

name: {{ .Name }}
age: {{ .Age }}

Com o template criado, podemos iniciar nosso main.go.

package main

func main() {
}

Como distribuir o binário e o arquivo de template separados pode se tornar um problema, vamos utilizar a técnica de embed, a qual faz com que o arquivo de template seja incluído no binário durante o processo de build.

package main

import (
	_ "embed"
)

//go:embed template.yaml
var content string

func main() {
}

Se você quiser saber mais sobre essa técnica, recomendo a leitura do post “Armazenando arquivos estáticos dentro de programas Go”.

Continuando… Para facilitar a escrita dos valores no template, vamos criar uma pequena struct com os atributos Name e Age.

type Person struct {
    Name string
    Age  string
}

Afim de não deixar muito complexo a implementação desse exemplo, vamos receber os valores através de argumentos na execução do programa.

Sendo que precisamos receber o nome e a idade, a primeira coisa que vamos fazer na nossa função main, será validar a quantidade de argumentos passados durante a chamada do programa.

if len(os.Args) < 2 {
    panic("min args 2")
}

Agora que validamos, precisamos criar um novo objeto atribuindo os valores passados por argumento.

p := Person{
    Name: os.Args[1],
    Age:  os.Args[2],
}

Com o objeto criado, vamos chamar a função template.New, que é responsável por criar um novo objeto do tipo *template.Template, e em seguida o método Parse, que fará o parse do template.

tmpl, err := template.New("person").Parse(content)
if err != nil {
    panic(err)
}

Ao final da execução desse programa, queremos que um novo arquivo tenha sido gerado com os valores que passamos. Por isso, nessa parte do programa, vamos criar esse arquivo através da função os.Create.

file, err := os.Create("output.yaml")
if err != nil {
    panic(err)
}

Por fim, chamamos o método *template.Execute para que o novo arquivo seja preenchido com o template e os valores que foram passados.

err = tmpl.Execute(file, p)
if err != nil {
    panic(err)
}

O código completo ficará assim:

package main

import (
    _ "embed"
    "os"
    "text/template"
)

//go:embed template.yaml
var content string

type Person struct {
    Name string
    Age  string
}

func main() {
    if len(os.Args) < 2 {
        panic("min args 2")
    }

    p := Person{
        Name: os.Args[1],
        Age:  os.Args[2],
    }

    tmpl, err := template.New("person").Parse(content)
    if err != nil {
        panic(err)
    }

    file, err := os.Create("output.yaml")
    if err != nil {
        panic(err)
    }

    err = tmpl.Execute(file, p)
    if err != nil {
        panic(err)
    }
}

Para testar o programa, é só executar um go run passando o nome e idade.

$ go run main.go "Tiago Temporin" 32

Nota: as aspas foram usadas no nome, não por ser string, mas por ter um espaço entre as duas palavras.

Ao olhar na pasta, um novo arquivo com o nome output.yaml deverá existir com o seguinte conteúdo:

name: Tiago Temporin
age: 32

Espero que tenham gostado.

Até a próxima!

Se inscreva na nossa newsletter