Dans Golang, les structures sont de simples conteneurs de données.

• peut avoir des champs
• aucune méthode qui leur est attachée
  • méthodes définies séparément et associées à un type struct.

Ce qui suit montre un simple équivalent de classe Book dans Ruby et 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
}

Instanciation du type GoLang

Littéral composé

Composite Literal est une syntaxe permettant de créer un type composite d'initialisation en une seule étape. Nous pouvons instancier les types suivants :

• structures
• tableaux
• tranches
• cartes

Ici, nous attribuons une nouvelle instance de Book à la variable book

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

Utilisation d'un nouveau mot-clé

La forme la plus longue consiste à utiliser le nouveau mot-clé. Cela serait similaire à la façon dont nous instancierions une classe dans Ruby avec book = Book.new(..)

Nous attribuerions les attributs du livre (c'est-à-dire le titre et l'auteur) en utilisant le signe =.

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

Sans déclaration de variable courte (:=)

Remarquez que nous avons utilisé le symbole := dans le premier exemple ?

C'est du sucre syntaxique pour la manière détaillée suivante de déclarer une variable et de lui attribuer une valeur.

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

Fonction d'usine

Nous pourrions également utiliser le modèle d'usine pour faciliter l'initialisation de la structure lorsque nous en avons besoin :

• ajouter une logique supplémentaire
• ajouter des valeurs par défaut

En supposant que nous voudrions que chaque premier caractère du titre du livre et les jetons d'auteur soient en majuscule.

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

Attacher une fonction à une structure

En Ruby, nous définirions simplement une fonction au sein de la classe. Ici, nous définissons une fonction appelée to_string() pour imprimer le nom de l'auteur du titre du livre.

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

Dans GoLang, nous "attacherions" la fonction en transmettant le stuct à la fonction.

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

Explication de :

func (book Book) ToString() string