Basic types and complex types in Go language

Go language is a fast, safe, and reliable programming language developed by Google in 2009. The type system of Go language is simple, clear and strongly typed.

In Go language, basic types include boolean, integer, floating point, complex number, string and pointer types, etc. In addition, the Go language also provides some complex types, such as arrays, slices, maps, channels, interfaces, and structures. Next, we will introduce basic types and complex types in Go language in detail.

1. Basic types

1. Boolean type

The Boolean type has only two values: true and false. It is not case-sensitive. Use the bool type. express. For example:

var b bool = true

2. Integer type

Integer type is one of the basic types in Go language, including int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64 and uintptr, etc. Among them, int, uint and uintptr are system-related types, which can have different number of bits and value ranges according to different operating systems and hardware architectures. For example:

var i int = 100
var ui uint = 100
var uptr uintptr = 0x123456789abcdef0

3. Floating point type

Floating point types are divided into float32 and float64, which are used to represent floating point numbers. For example:

var f32 float32 = 3.1415
var f64 float64 = 3.141592653589793

4. Complex number type

The complex number type consists of real part and imaginary part , divided into complex64 and complex128, used to represent complex numbers. For example:

var c64 complex64 = 3 4i
var c128 complex128 = 3 4i

5. String type

String type is used to represent Character sequence, enclosed in double quotes. For example:

var s string = "Hello, world!"

6. Pointer type

The pointer type is used to represent the memory address and can be used for indirection Access variables and allocate memory, etc. For example:

var p *int = &i

2. Complex type

1. Array

An array is a group with the same data An ordered collection of variables of type. The length of the array is fixed and you need to specify the length when defining it. For example:

var a [3]int = [3]int{1, 2, 3}

2. Slicing

Slicing is for arrays A package that allocates memory dynamically and the length can vary. Slices do not need to be specified in length and are created using the make function. For example:

var s []int = make([]int, 3)
s[0] = 1
s[1] = 2
s[2] = 3

3. Mapping

Mapping is a data structure of key-value pairs, also known as a dictionary or associative array. The keys and values ​​of the map can be of any type and are created through the make function. For example:

var m map[string]int = make(map[string]int)
m["one"] = 1
m["two"] = 2

4. Channel

Channel is a mechanism used for communication between coroutines, which can achieve data synchronization and sharing. Channels are divided into buffered channels and unbuffered channels, which are created using the make function. For example:

var ch chan int = make(chan int, 3)
ch ch ch

5. Interface

An interface is a type that defines behavior and implements the interface by agreeing to implement specific methods. Interfaces can achieve polymorphism, improving program flexibility and scalability. For example:

type MyInterface interface {

MyMethod() int

}

6. Structure

A structure is a combination of several fields Types formed together. The fields of a structure are typed and can also contain fields of other structure types. For example:

type Person struct {

Name string
Age int

}

3. Summary

The type system of Go language is simple, clear and strongly typed. The basic types include Boolean type, integer type, floating point type, complex number type, string type, pointer type, etc. Complex types include arrays, slices, maps, channels, interfaces, structures, etc. Proficiency in basic types and complex types in Go language can improve programming efficiency and code quality.

The above is the detailed content of Basic types and complex types in Go language. For more information, please follow other related articles on the PHP Chinese website!