Antwoord.

In de programmeertaal Go kan een ontwikkelaar eigen types creëren op basis van bestaande types of aliases declareren voor het gemak van leesbaarheid van de code en integratie met externe bibliotheken.

Achtergrond van de vraag:

Go vereenvoudigt het type-systeem fundamenteel door de concepten van het creëren van een nieuw type (type MyInt int) en een alias (type MyIntAlias = int) te scheiden. Vaak ontstaat er verwarring tussen deze twee, wat invloed heeft op de compatibiliteit van gegevens tussen verschillende delen van het systeem.

Probleem:

Als je de verkeerde manier kiest om een type te declareren, kun je tal van impliciete fouten krijgen: het kan niet mogelijk zijn om gegevens tussen pakketten te verzenden, onjuiste werking met externe bibliotheken of verlies van alle methoden bij het proberen om gebruik te maken van de alias.

Oplossing:

Een nieuw type (type Foo T) creëert een daadwerkelijk nieuw type met een eigen identiteit, zelfs als het is gebaseerd op een bestaande (bijvoorbeeld, int, struct).
Een type-alias (type Foo = T) geeft een alternatieve naam voor een bestaand type, waarbij het zijn methoden en gedrag volledig behoudt, inclusief interface-compatibiliteit.

Codevoorbeeld:

package main
import "fmt"

type MyInt int           // nieuw type
func (m MyInt) Double() int { return int(m) * 2 }

type MyIntAlias = int    // type-alias

func main() {
    var a MyInt = 5
    var b MyIntAlias = 10
    fmt.Println(a.Double()) // werkt
    //fmt.Println(b.Double()) // fout: methode niet gedefinieerd op int
}

Belangrijke kenmerken:

Een nieuw type is volledig gescheiden van zijn basis type
Een alias creëert geen nieuw type, alleen een nieuwe naam
Methoden gedefinieerd voor een nieuw type zijn niet toepasbaar op een alias

Vragen met een valstrik.

Is het mogelijk om een alias voor een struct te maken en eraan methoden toe te voegen die verschillen van die van de basisstruct?

Nee. Methoden kunnen alleen worden gedefinieerd voor een nieuw type, niet voor een alias. Een alias is gewoon een andere naam voor hetzelfde type, een deel van het programma zal niets weten van de "uitbreiding" van het type.

type MyStructAlias = SomeStruct
// func (s MyStructAlias) NewMethod() {} // Fout

Kunnen de methoden van het basis type automatisch aan de alias worden “geplakt”?

Ja, omdat het in feite hetzelfde type is voor de compiler. Maar je kunt niet met nieuwe methoden werken: je kunt geen unieke methoden aan een alias toevoegen.

type MyString = string // alle methoden en functies voor string werken

Wat is het verschil tussen type casting naar een type en naar een alias?

Bij het declareren van een nieuw type is expliciete casting vereist: MyInt(x) waar x — int is. Voor een alias is casting niet nodig — de types zijn volledig uitwisselbaar.

type A int
type B = int
var x int = 3
var a A = A(x)      // expliciete conversie
var b B = x         // impliciet, hetzelfde als int

Typefouten en anti-patronen

Verwarring in de structuur van de code door het mengen van nieuwe types en aliases
Onverwachts gebrek aan methoden bij een alias
Gebruik van aliases voor gegevensisolatie — ze zijn hier niet voor bedoeld (nieuwe types zijn beter)

Voorbeeld uit het leven

Negatieve case

Een ontwikkelaar maakt een type-alias voor een externe bibliotheek, ten onrechte denkend dat hij bovenop dit type zijn eigen methoden kan toevoegen en de logica van de overgang kan kapselen.

Voordelen:

Gemakkelijke integratie met een externe API

Nadelen:

Methoden worden niet toegevoegd, gedrag wordt niet uitgebreid, er ontstaat onvoorspelbare logica van gegevens

Positieve case

Een team creëert een nieuw type op basis van int voor het voorstellen van gebruikers-id's om de bedrijfslogica te beschermen tegen onbedoeld verwarren met andere gehele getalswaarden, en voegt speciale methoden toe (validators, converters).