What are the golang types?

Go is a statically typed programming language that supports various types including commonly used basic types, structures, arrays and slices, mappings, interfaces, and functions. The following are some commonly used Go language types:

1. Basic types

Go language supports standard basic types, such as Boolean, integer, floating point, and string and character type.

• Boolean type: bool type, only Boolean values ​​true and false.
• Integer types: int, int8, int16, int32, int64, uint, uint8, uint16, uint32 and uint64, representing signed integers and unsigned integers respectively, with sizes of 8, 16, 32 and 64 bits respectively. .
• Floating point types: float32 and float64, representing 32-bit and 64-bit floating point numbers respectively.
• Character type: rune type, which is an encoding of Unicode characters.

2. Structure

The structure in Go language is a user-defined composite type that can contain multiple fields of different types. Structures can be used to represent some complex data types. Fields in a structure can be of any type, including other structure types.

For example:

type Person struct {
    Name   string
    Age    int
    Height float32
}

3. Arrays and slices

Arrays are also a basic type in the Go language. Arrays have a fixed size, and the length of the array needs to be specified when defining. A slice is a reference to an array, dynamically allocated space, and can be increased or decreased at any time. You can use the built-in function len() to get the length of a slice.

For example:

var array [3]int // 定义一个长度为3的数组
slice := []int{1, 2, 3, 4, 5} // 定义一个切片

4. Map

A map is a data structure of key-value pairs, similar to a dictionary or hash table in other languages . In Go language, mapping is represented using the built-in map type. You can use the make() function to create a map, and then use the [] operator to access elements in the map.

For example:

scores := make(map[string]int) // 创建一个名为scores的映射
scores["Alice"] = 85 // 添加一个键值对

5. Interface

Interface is an abstract data type that can define a set of methods without implementing specific code. In a type that implements an interface, all methods defined in the interface need to be implemented. Interfaces can make code more flexible, extensible and maintainable.

For example:

type Shape interface {
    Area() float64
    Perimeter() float64
}

type Rectangle struct {
    Width  float64
    Height float64
}

func (r Rectangle) Area() float64 {
    return r.Width * r.Height
}

func (r Rectangle) Perimeter() float64 {
    return 2 * (r.Width + r.Height)
}

6. Function type

Functions are first-class citizens in the Go language. They can be passed, assigned, and return. In the Go language, a function is also a type, and function types can be defined as parameters or return values.

For example:

type Operation func(int, int) int

func Add(a, b int) int {
    return a + b
}

func Sub(a, b int) int {
    return a - b
}

func calc(op Operation, a, b int) int {
    return op(a, b)
}

sum := calc(Add, 10, 20) // 调用calc函数，传入Add函数作为参数
diff := calc(Sub, 30, 15) // 调用calc函数，传入Sub函数作为参数

The above are some commonly used Go language types. Go language also supports other types, such as channels, pointers, etc. Mastering these types is very important for writing high-quality, readable Go code.

The above is the detailed content of What are the golang types?. For more information, please follow other related articles on the PHP Chinese website!