Em Golang, estruturas são contêineres simples para dados.

• pode ter campos
• nenhum método anexado a eles
  • métodos definidos separadamente e associados a um tipo de estrutura.

A seguir, mostramos equivalentes simples da classe Book em Ruby e GoLang.

class Book
  attr_reader(:title, :author)

  def initalize(title, author)
    @title  = title
    @author = authoer
  end
end

# usage
book = Book.new('Title', 'Jon Snow')

// Equivalent to `class Book` in ruby
type Book struct {
  Title string,
  Author string
}

Instanciando o tipo GoLang

Literal Composto

Composite Literal é uma sintaxe para criar e inicializar tipos compostos em uma única etapa. Podemos instanciar os seguintes tipos:

• estruturas
• matrizes
• fatias
• mapas

Aqui estamos atribuindo uma nova instância de Book à variável book

// Composite Literal
book := Book{
  Title: "Title",
  Author: "Author"
}

Usando nova palavra-chave

A forma mais longa é usar a nova palavra-chave. Isso seria semelhante à maneira como instanciaríamos uma classe em Ruby com book = Book.new(..)

Atribuiríamos os atributos do livro (ou seja, Título e Autor) usando o sinal =.

// Using the `new` keyword
book        := new(Book)
book.Title  = "Book Title"
book.Author = "John Snow"

Sem declaração curta de variável (:=)

Observe que usamos o símbolo := no primeiro exemplo?

É um açúcar sintático para a seguinte maneira detalhada de declarar uma variável e atribuir um valor a ela.

// Without Short Virable Declaration

// Example 1
var book Book // Declare variable `book` of type `Book`
book.Title = "Book Title" // Assign the value to book variable
book.Author = "John Snow"

// Example 2
var count int
count = 20

Função de fábrica

Também poderíamos usar o padrão de fábrica para facilitar a inicialização da estrutura quando precisarmos:

• adicionar lógica adicional
• adicionar valores padrão

Supondo que gostaríamos de colocar cada primeiro caractere do título do livro e dos tokens do autor em maiúscula.

// Factory Function
func NewBook(title string, author string) Book {
  return Book{
    Title: titlelise(title), // default logic to "titlelise" 
    Author: titlelist(author)
  }
}

func titlelise(str string) {
  caser := cases.Title(lanaguage.English)
  return caser.String(str)
}

Anexando uma função a uma estrutura

Em Ruby, simplesmente definiríamos uma função dentro da classe. Aqui, estamos definindo uma função chamada to_string() para imprimir o nome do título do livro autor.

class Book
  attr_reader(:title, :author)

  def initalize(title, author)
    @title  = title
    @author = authoer
  end

  # new function we added
  def to_string()
    put "#{title} by #{string}"
  end
end

No GoLang, "anexariamos" a função passando o stuct para a função.

// Equivalent to `class Book` in ruby
type Book struct {
  Title string,
  Author string
}

// Attaching the function to the `struct`
func (book Book) ToString() string {
  return fmt.Sprintf("%s by %s", book.Title, book.Author)
}

// Usage
book := Book{
  Title: "Title",
  Author: "Author"
}

book.ToString()
// => Title by Author

Explicação de:

func (book Book) ToString() string