GoLang-Strukturen

In Golang sind Strukturen einfache Container für Daten.

• kann Felder haben
• keine damit verbundenen Methoden
  • Methoden, die separat definiert und einem Strukturtyp zugeordnet sind.

Im Folgenden werden einfache Book-Klassenäquivalente in Ruby und GoLang gezeigt.

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
}

Instanziieren des GoLang-Typs

Zusammengesetztes Literal

Composite Literal ist eine Syntax zum Erstellen und Initialisieren zusammengesetzter Typen in einem Schritt. Wir können die folgenden Typen instanziieren:

• Strukturen
• Arrays
• Scheiben
• Karten

Hier weisen wir der Variablen book eine neue Book-Instanz zu

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

Neues Schlüsselwort verwenden

Die längere Form besteht darin, das neue Schlüsselwort zu verwenden. Dies ähnelt der Art und Weise, wie wir eine Klasse in Ruby mit book = Book.new(..)

instanziieren würden

Wir würden die Attribute des Buches (d. h. Titel und Autor) mit =-Zeichen zuweisen.

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

Ohne kurze Variablendeklaration (:=)

Beachten Sie, dass wir im ersten Beispiel das Symbol := verwendet haben?

Es ist syntaktischer Zucker für die folgende ausführliche Art, eine Variable zu deklarieren und ihr einen Wert zuzuweisen.

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

Fabrikfunktion

Wir könnten das Factory-Muster auch verwenden, um die Initialisierung der Struktur zu vereinfachen, wenn wir Folgendes benötigen:

• zusätzliche Logik hinzufügen
• Standardwerte hinzufügen

Angenommen, wir möchten, dass jedes erste Zeichen des Buchtitels und der Autoren-Tokens großgeschrieben werden.

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

Anhängen einer Funktion an eine Struktur

In Ruby würden wir einfach eine Funktion innerhalb der Klasse definieren. Hier definieren wir eine Funktion namens to_string(), um den Autor des Buchtitels auszugeben.

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 würden wir die Funktion „anhängen“, indem wir die Struktur an die Funktion übergeben.

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

Erklärung von:

func (book Book) ToString() string

Token Beschreibung func Funktionsschlüsselwort (Buch Buch) Anhängen der Funktion an den Typ „Book-Struktur“

Token	Description
func	function keyword
(book Book)	Attaching the function to the type Book struct - book: variable to access the struct within the function - Book: type of the struct
ToString()	name of the function
string	return type of the function

- book: Variable für den Zugriff auf die Struktur innerhalb der Funktion- Book: Typ der Struktur ToString() Name der Funktion Zeichenfolge Rückgabetyp der Funktion

Das obige ist der detaillierte Inhalt vonGoLang-Strukturen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!