In Golang, structs are simple containers for data.

• can have fields
• no methods attached to them
  • methods defined separately and associated with a struct type.

The following show a simple Book class equivalents in Ruby and 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
}

Instantiating GoLang type

Composite Literal

Composite Literal is syntax to create an initialise composite types in one step. We can instantiate the following types:

• structs
• arrays
• slices
• maps

Here we are assigning a new Book instance to the variable book

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

Using new keyword

The longer form is to use the new keyword. This would be similar to the way we would instantiate a class in Ruby with book = Book.new(..)

We would assign the attributes of the book (i.e. Title and Author) using = sign.

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

Without Short Variable Declaration (:=)

Notice that we used the symbol := in the first example?

It's syntactic sugar for the following verbose way of declaring a variable and assigning it a value.

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

Factory Function

We could also use the factory pattern to make it easier when initialising the struct when we need to:

• add additional logic
• add default values

Assuming we would want to make each first character of the book's title and author tokens to be capitalised.

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

Attaching a function to a struct

In Ruby, we would simply define a function within the class. Here, we are defining a function called to_string() to print the book title name author.

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

In GoLang, we would "attach" the function by passing in the stuct to the function.

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

Explanation of:

func (book Book) ToString() string