Go's type system is based on structures, interfaces and combinations, rather than classes and inheritance. Its core features include: 1. Declare new types through type, enhance type safety, and explicit conversion of different underlying types; 2. Use structure nesting to implement combinations, replace inheritance, and reduce coupling; 3. Define methods for any named type, the value receiver operates a copy, and the pointer receiver can modify the original value; 4. The interface supports polymorphism through implicit implementation, and as long as the corresponding method of the type is implemented, it can be assigned to the interface; 5. The empty interface any can represent any type, and restore specific types through type assertions or type switch; 6. Go 1.18 introduces generics to support writing type-safe general code. The system ensures type safety, code reuse and flexibility through explicit conversion, combinatorial, implicit interfaces, and generics, ultimately prompting developers to write clear, decoupled, and easy to test programs.

Go's type system design is concise and clear, emphasizing security and readability, while avoiding the complex inheritance system in traditional object-oriented languages. Understanding Go type system is a key step in mastering Go programming. It is not based on classes and inheritance, but is built around structures, interfaces, and combinations.

1. Basic types and type declarations

Go has common basic types, such as int , string , bool , float64 , etc. In addition, you can define new types through type keyword:

 type UserID int
type Email string

Although the underlying UserID is int , it is a different type . You cannot assign int directly to UserID variables, you must convert explicitly:

 var uid UserID = 42 // Error: Cannot implicitly convert var uid UserID = UserID(42) // Correct: Explicitly convert

This mechanism enhances type safety and avoids misuse between different types (such as confusing user ID and order ID).

2. Structure and combination

Go does not support inheritance, but implements code reuse through structure nesting (combination) :

 type Person struct {
    Name string
    Age int
}

type Employee struct {
    Person // Anonymous field, realizing the "inheritance" effect Salary float64
}

At this time, Employee will "inherit" Person 's fields and methods:

 e := Employee{
    Person: Person{Name: "Alice", Age: 30},
    Salary: 50000,
}
fmt.Println(e.Name) // Direct access to nested fields

This is called combination is better than inheritance - you are not saying "Employee is a Person", but you are saying "Employee has a Person", with clearer semantics and lower coupling.

3. Methods and Recipients

Go allows defining methods for any named type (as long as they are defined in the same package):

 func (p Person) Greet() {
    fmt.Printf("Hi, I'm %s\n", p.Name)
}

func (p *Person) SetName(name string) {
    p.Name = name
}

Note the receiver type:

• Value Receiver ( Person ): The method operates on the copy.
• Pointer Receiver ( *Person ): The method can modify the original value.

Typically, if the structure is larger or the method requires modifying the field, use the pointer receiver.

4. Interface: Abstraction of behavior

Go's interface is implicitly implemented , which is one of its most powerful features.

Define an interface:

 type Speaker interface {
    Speak() string
}

As long as a type implements Speak() method, it automatically implements the Speaker interface:

 func (p Person) Speak() string {
    return fmt.Sprintf("Hello, I'm %s", p.Name)
}

var s Speaker = Person{"Bob", 25} // No explicit declaration of implementation required

This "duck typing" mechanism makes the code more flexible: you don't need to plan the relationship between types in advance, as long as the behavior matches, it can be used.

5. Empty interface and type assertion

interface{} (before Go 1.18) or any (Go 1.18) can represent any type:

 var x any = "hello"
x = 42
x = true

To restore a concrete type from any , a type assertion is required:

 str, ok := x.(string)
if ok {
    fmt.Println("It's a string:", str)
}

Or use switch to make type judgment:

 switch v := x.(type) {
case string:
    fmt.Println("String:", v)
case int:
    fmt.Println("Int:", v)
default:
    fmt.Println("Unknown type")
}

6. Generics (Go 1.18)

Go introduced generics in 1.18, supporting writing generic code for type-safe:

 func Map[T, U any](slice []T, f func(T) U) []U {
    result := make([]U, len(slice))
    for i, v := range slice {
        result[i] = f(v)
    }
    return result
}

Now you can safely do mapping operations on any type slice without type assertion or duplicate code.

Basically that's it. Go's type system is not complex, but very practical:

• Type safety is guaranteed by explicit conversion and type declaration
• Reuse depends on combination rather than inheritance
• Implicit implementation of polymorphism by interface
• Generic code is supported by generics

It encourages you to write clear, decoupled, easy to test code instead of getting stuck in the quagmire of type levels.

The above is the detailed content of Understanding Go's Type System. For more information, please follow other related articles on the PHP Chinese website!