En Golang, las estructuras son contenedores simples para datos.

• puede tener campos
• no hay métodos adjuntos a ellos
  • métodos definidos por separado y asociados con un tipo de estructura.

A continuación se muestran equivalentes simples de la clase Libro en Ruby y 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
}

Creación de instancias del tipo GoLang

Literal compuesto

Composite Literal es una sintaxis para crear e inicializar tipos compuestos en un solo paso. Podemos crear instancias de los siguientes tipos:

• estructuras
• matrices
• rebanadas
• mapas

Aquí estamos asignando una nueva instancia de Libro a la variable libro

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

Usando nueva palabra clave

La forma más larga es utilizar la nueva palabra clave. Esto sería similar a la forma en que crearíamos una instancia de una clase en Ruby con book = Book.new(..)

Asignaríamos los atributos del libro (es decir, Título y Autor) usando el signo =.

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

Sin declaración de variable corta (:=)

¿Notaste que usamos el símbolo := en el primer ejemplo?

Es azúcar sintáctico para la siguiente forma detallada de declarar una variable y asignarle un valor.

// 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

Función de fábrica

También podríamos usar el patrón de fábrica para que sea más fácil inicializar la estructura cuando lo necesitemos:

• agregar lógica adicional
• agregar valores predeterminados

Suponiendo que quisiéramos que cada primer carácter del título del libro y los tokens de autor estén en mayú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)
}

Adjuntar una función a una estructura

En Ruby, simplemente definiríamos una función dentro de la clase. Aquí, estamos definiendo una función llamada to_string() para imprimir el nombre del título del libro, 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

En GoLang, "adjuntaríamos" la función pasando el stuct a la función.

// 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

Explicación de:

func (book Book) ToString() string