What are the types of go language?

The types of go language include boolean (bool), integer (int8, byte, int16, etc.), floating point (float32, float64), complex number (complex64, complex128), string, character type , error type, pointer, array, slice, dictionary, channel, structure, interface. The floating point type uses the IEEE-754 standard expression; a complex number is actually composed of two real numbers (represented by floating point numbers in computers), one representing the real part and one representing the imaginary part.

The operating environment of this tutorial: Windows 7 system, GO version 1.18, Dell G3 computer.

Types of Go language

Go language has built-in the following basic types:

• Boolean type: bool.

• Integer type: int8, byte, int16, int, uint, uintptr, etc.

• Floating point types: float32, float64.

• Plural types: complex64, complex128.

• String: string.

• Character type: rune.

• Error type: error.

In addition, the Go language also supports the following composite types:

• Pointer (pointer)

• Array(array)

• Slice(slice)

• Dictionary(map)

• Channel(chan)

• Structure(struct)

• Interface(interface)

On top of these basic types, Go also encapsulates the following types:

int, uint and uintptr, etc.. These types are characterized by ease of use, but the user cannot make any assumptions about the length of these types. For regular development, it is enough to use int and uint. There is no need to use types with explicitly specified lengths such as int8 to avoid porting difficulties. [Related recommendations: Go video tutorial]

Boolean type

The bool type is used in Go language Declare Boolean type data. Boolean type data has only two values: true

and false. It should be noted that:

• go language Forced conversion of integer type to Boolean type is not allowed in

• The default value of Boolean type variables is false

• Boolean types cannot participate in numerical operations, and Cannot be converted to other types

The Boolean type in Go language is basically the same as other languages. The keyword is also bool and can be assigned a value. The sample codes for predefined true and false are as follows:

var v1 bool
v1 = true
v2 := (1 == 2) // v2也会被推导为bool类型

The Boolean type cannot accept assignments from other types and does not support automatic or forced type conversion.
The following examples are some incorrect usages that will cause compilation errors:

var b bool
b = 1 // 编译错误
b = bool(1) // 编译错误
以下的用法才是正确的：
var b bool
b = (1!=0) // 编译正确 
fmt.Println("Result:", b) // 打印结果为Result: true

##Integer type

Integer is the most basic data type in all programming languages. The Go language supports these integer types shown in Table 2-1.

##1. Type representationIt should be noted that int and int32 are considered

two different types

in Go language, and the compiler will not automatically do type conversion for you, for example, the following example will have a compilation error:

var value2 int32
value1 := 64 // value1将会被自动推导为int类型
value2 = value1 // 编译错误

The compilation error is similar to:

cannot use value1 (type int) as type int32 in assignment

Use forced type conversion This compilation error can be solved:

value2 = int32(value1) // 编译通过

Of course, when developers do forced type conversion, they need to pay attention to the loss of data accuracy caused by the truncation of the data length (such as forcing floating point numbers to integers) and value overflow (when a value exceeds the value range of the converted target type) problem.

Type conversion

There is only strong type conversion in the Go language, and there is no implicit conversion. This syntax can only be used when conversion between the two types

is supported. The syntax for coercion is as follows:

The example is as follows:

2. Numerical operations

Go language supports the following regular integer operations: , -, *, / and %

Addition, subtraction, multiplication and division will not be explained in detail. What needs to be said is that % is the remainder operation just like in C language, for example:

5 % 3 // 结果为：2

3. 比较运算

Go语言支持以下的几种比较运算符：>、=、

这一点与大多数其他语言相同，与C语言完全一致。

下面为条件判断语句的例子：

i, j := 1, 2 
if i == j { 
 fmt.Println("i and j are equal.") 
}

两个不同类型的整型数不能直接比较，比如int8类型的数和int类型的数不能直接比较，但各种类型的整型变量都可以直接与字面常量（literal）进行比较，比如

var i int32
var j int64
i, j = 1, 2 
if i == j { // 编译错误
 fmt.Println("i and j are equal.") 
} 
if i == 1 || j == 2 { // 编译通过
 fmt.Println("i and j are equal.") 
}

4. 位运算

Go语言支持表2-2所示的位运算符。

Go语言的大多数位运算符与C语言都比较类似，除了取反在C语言中是~x，而在Go语言中是^x。

编程语言中表示固定值的符号叫做字面量常量，简称字面量。如整形

字面量八进制：“012”或者“0o17”，十六进制: “0x12”，二进制：”0b101”，

输出表示如下图：

浮点型

字面量八进制：“012”或者“0o17”，十六进制: “0x12”，二进制：”0b101”，
输出表示如下图：
浮点型用于表示包含小数点的数据，比如1.234就是一个浮点型数据。Go语言中的浮点类型采用IEEE-754标准的表达方式

1. 浮点数表示

Go语言定义了两个类型float32和float64，其中float32等价于C语言的float类型，float64等价于C语言的double类型

在Go语言里，定义一个浮点数变量的代码如下：

var fvalue1 float32
fvalue1 = 12 
fvalue2 := 12.0 // 如果不加小数点，fvalue2会被推导为整型而不是浮点型

对于以上例子中类型被自动推导的fvalue2，需要注意的是其类型将被自动设为float64，而不管赋给它的数字是否是用32位长度表示的。因此，对于以上的例子，下面的赋值将导致编译错误：

fvalue1 = fvalue2

而必须使用这样的强制类型转换：

fvalue1 = float32(fvalue2)

2. 浮点数比较

因为浮点数不是一种精确的表达方式，所以像整型那样直接用==来判断两个浮点数是否相等是不可行的，这可能会导致不稳定的结果
下面是一种推荐的替代方案：

import "math" 
// p为用户自定义的比较精度，比如0.00001 
func IsEqual(f1, f2, p float64) bool { 
 return math.Fdim(f1, f2) <h2>
<a id="_187"></a><strong>复数类型</strong>
</h2><p>复数实际上由两个实数（在计算机中用浮点数表示）构成，一个表示实部（real），一个表示虚部（imag）。如果了解了数学上的复数是怎么回事，那么Go语言的复数就非常容易理解了。</p><p>复数有实部和虚部，<strong>complex64 的实部和虚部为 32 位，complex128的实部和虚部为 64 位。</strong></p><p><img src="https://img.php.cn/upload/image/844/148/824/166997848093462What%20are%20the%20types%20of%20go%20language?" title="166997848093462What are the types of go language?" alt="What are the types of go language?"></p><p><span   style="max-width:90%"><strong>1. 复数表示</strong></span></p><p>复数表示的示例如下：</p><pre class="brush:php;toolbar:false">var value1 complex64 // 由2个float32构成的复数类型
value1 = 3.2 + 12i 
value2 := 3.2 + 12i // value2是complex128类型
value3 := complex(3.2, 12) // value3结果同 value2

2. 实部与虚部

对于一个复数z = complex(x, y)，就可以通过Go语言内置函数real(z)获得该复数的实部，也就是x，通过imag(z)获得该复数的虚部，也就是y。

字符串

Go 语言中的字符串以原生数据类型出现，使用字符串就像使用其他

原生数据类型一样。Go 语言里的字符串的内部实现使用 utf-8 编码。字符串的值为双引号中的内容，如

在Go语言中，字符串也是一种基本类型。相比之下， C/C++语言中并不存在原生的字符类型，通常使用字符数组来表示，并以字符指针来传递。

Go语言中字符串的声明和初始化非常简单，举例如下：

var str string // 声明一个字符串变量
str = "Hello world" // 字符串赋值
ch := str[0] // 取字符串的第一个字符
fmt.Printf("The length of \"%s\" is %d \n", str, len(str)) 
fmt.Printf("The first character of \"%s\" is %c.\n", str, ch)

输出结果为：

The length of "Hello world" is 11 
The first character of "Hello world" is H.

字符串的内容可以用类似于数组下标的方式获取，但与数组不同，字符串的内容不能在初始化后被修改，比如以下的例子：

str := "Hello world" // 字符串也支持声明时进行初始化的做法
str[0] = 'X' // 编译错误

编译器会报类似如下的错误：

cannot assign to str[0]

在这个例子中我们使用了一个Go语言内置的函数len()来取字符串的长度。这个函数非常有用，我们在实际开发过程中处理字符串、数组和切片时将会经常用到。

Printf()函数的用法与C语言运行库中的printf()函数如出一辙。

Go编译器支持UTF-8的源代码文件格式。这意味着源代码中的字符串可以包含非ANSI的字符，比如“Hello world. 你好，世界！”可以出现在Go代码中。但需要注意的是，如果你的Go代码需要包含非ANSI字符，保存源文件时请注意编码格式必须选择UTF-8。特别是在Windows下一般编辑器都默认存为本地编码，比如中国地区可能是GBK编码而不是UTF-8，如果没注意这点在编译和运行时就会出现一些意料之外的情况。

字符串的编码转换是处理文本文档（比如TXT、XML、HTML等）非常常见的需求，不过可惜的是Go语言仅支持UTF-8和Unicode编码。对于其他编码，Go语言标准库并没有内置的编码转换支持。不过，所幸的是我们可以很容易基于iconv库用Cgo包装一个。这里有一个开源项目：https://github.com/xushiwei/go-iconv。

1. 字符串操作

平时常用的字符串操作如表2-3所示。

更多的字符串操作，请参考标准库strings包。

2. 字符串遍历

Go语言支持两种方式遍历字符串。一种是以字节数组的方式遍历：

str := "Hello,世界"n := len(str) for i := 0; i <p>这个例子的输出结果为：</p><pre class="brush:php;toolbar:false">0 72 1 101 2 108 3 108 4 111 5 44 6 32 7 228 8 184 9 150 10 231 11 149 12 140

可以看出，这个字符串长度为13。尽管从直观上来说，这个字符串应该只有9个字符。这是因为每个中文字符在UTF-8中占3个字节，而不是1个字节

另一种是以Unicode字符遍历：

str := "Hello,世界"for i, ch := range str { 
 fmt.Println(i, ch)//ch的类型为rune }

输出结果为：

0 72 1 101 2 108 3 108 4 111 5 44 6 32 7 19990 10 30028

以Unicode字符方式遍历时，每个字符的类型是rune（早期的Go语言用int类型表示Unicode字符），而不是byte。

字符串的常见操作

字符类型

在Go语言中支持两个字符类型，一个是byte（实际上是uint8的别名），代表UTF-8字符串的单个字节的值；另一个是rune，代表单个Unicode字符。

关于rune相关的操作，可查阅Go标准库的unicode包。另外unicode/utf8包也提供了UTF8和Unicode之间的转换。

出于简化语言的考虑，Go语言的多数API都假设字符串为UTF-8编码。尽管Unicode字符在标准库中有支持，但实际上较少使用。

byte 和 rune 类型

字符指类字形单位或符号，包括字母、数字、运算符号、标点符

号和其他符号，以及一些功能性符号。每个字符在计算机中都有相应的二进制代码

Go 语言内置两种字符类型：

• 一种是 byte 的字节类型，它是 uint8 的别名。

• 另一种是 Unicode 编码的 rune 类型，它是 int32 类型的别名。

Go 语言默认的字符编码就是 UTF-8 类型的。

遍历字符串

如下：

UTF-8 编码下一个中文汉字由 3-4 个字节组成，所以我们不能简
单的按照字节去遍历一个包含中文字符的字符串。
字符串底层是一个 byte 数组，所以可以和[]byte 类型相互转换。
字符串是不能修改的，字符串由 byte 字节组成，所以字符串的长度
就是 byte 字节的长度。rune 类型用来表示 utf-8 字符，一个 rune 字
符由一个或多个 byte 组成。

修改字符串

要修改字符串，需要先将其转换成[]rune 或者[]byte，修改以后，再转换为 string。

无论哪种转换，都会重新分配内存并复制字节数组。如下：

常见的转义字符

多行字符串的显示，可以使用反引号进行，需要注意的是反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出

数组

数组是Go语言编程中最常用的数据结构之一。顾名思义，数组就是指一系列同一类型数据的集合。数组中包含的每个数据被称为数组元素（element），一个数组包含的元素个数被称为数组的长度。

以下为一些常规的数组声明方法：

[32]byte // 长度为32的数组，每个元素为一个字节
[2*N] struct { x, y int32 } // 复杂类型数组
[1000]*float64 // 指针数组
[3][5]int // 二维数组
[2][2][2]float64 // 等同于[2]([2]([2]float64))

从以上类型也可以看出，数组可以是多维的，比如[3][5]int就表达了一个3行5列的二维整型数组，总共可以存放15个整型元素。
在Go语言中，数组长度在定义后就不可更改，在声明时长度可以为一个常量或者一个常量表达式（常量表达式是指在编译期即可计算结果的表达式）。数组的长度是该数组类型的一个内置常量，可以用Go语言的内置函数len() 来获取。

下面是一个获取数组arr元素个数的写法：

arrLength := len(arr)

1. 元素访问

可以使用数组下标来访问数组中的元素。与C语言相同，数组下标从0开始，len(array)-1则表示最后一个元素的下标。下面的示例遍历整型数组并逐个打印元素内容：

for i := 0; i < len(array); i++ { 
 fmt.Println("Element", i, "of array is", array[i]) 
}

Go语言还提供了一个关键字range，用于便捷地遍历容器中的元素。当然，数组也是range的支持范围。上面的遍历过程可以简化为如下的写法：

for i, v := range array { 
 fmt.Println("Array element[", i, "]=", v) 
}

在上面的例子里可以看到

range具有两个返回值，第一个返回值是元素的数组下标，第二个返回值是元素的值。

2. 值类型

需要特别注意的是，在Go语言中数组是一个值类型（value type）。所有的值类型变量在赋值和作为参数传递时都将产生一次复制动作。

如果将数组作为函数的参数类型，则在函数调用时该参数将发生数据复制。因此，在函数体中无法修改传入的数组的内容，因为函数内操作的只是所传入数组的一个副本。

下面用例子来说明这一特点：

package main 
import "fmt" 
func modify(array [10]int) { 
 array[0] = 10 // 试图修改数组的第一个元素
 fmt.Println("In modify(), array values:", array) 
} 
func main() { 
 array := [5]int{1,2,3,4,5} // 定义并初始化一个数组
 modify(array) // 传递给一个函数，并试图在函数体内修改这个数组内容
 fmt.Println("In main(), array values:", array) 
}

该程序的执行结果为：

In modify(), array values: [10 2 3 4 5] 
In main(), array values: [1 2 3 4 5]

从执行结果可以看出，函数modify()内操作的那个数组跟main()中传入的数组是两个不同的实例。

数组切片

我们已经提过数组的特点：数组的长度在定义之后无法再次修改；数组是值类型，每次传递都将产生一份副本。显然这种数据结构无法完全满足开发者的真实需求。

不用失望，Go语言提供了数组切片（slice） 这个非常酷的功能来弥补数组的不足。

初看起来，数组切片就像一个指向数组的指针，实际上它拥有自己的数据结构，而不仅仅是个指针。

数组切片的数据结构可以抽象为以下3个变量：

• 一个指向原生数组的指针；

• 数组切片中的元素个数；

• 数组切片已分配的存储空间。

从底层实现的角度来看，数组切片实际上仍然使用数组来管理元素，因此它们之间的关系让C++程序员们很容易联想起STL中std::vector和数组的关系。基于数组，数组切片添加了一系列管理功能，可以随时动态扩充存放空间，并且可以被随意传递而不会导致所管理的元素被重复复制。

1. 创建数组切片

创建数组切片的方法主要有两种——基于数组和直接创建，下面我们来简要介绍一下这两种方法。

• 基于数组

数组切片可以基于一个已存在的数组创建。数组切片可以只使用数组的一部分元素或者整个数组来创建，甚至可以创建一个比所基于的数组还要大的数组切片。代码清单2-1演示了如何基于一个数组的前5个元素创建一个数组切片。

代码清单2-1 slice.go

package main 
import "fmt" 
func main() { 
 // 先定义一个数组
 var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10} 
 // 基于数组创建一个数组切片
 var mySlice []int = myArray[:5] 
 fmt.Println("Elements of myArray: ") 
 for _, v := range myArray { 
 fmt.Print(v, " ") 
 } 
 fmt.Println("\nElements of mySlice: ") 
 for _, v := range mySlice { 
 fmt.Print(v, " ") 
 } 
 fmt.Println() 
}

运行结果为：

Elements of myArray: 
1 2 3 4 5 6 7 8 9 10 
Elements of mySlice: 
1 2 3 4 5

Go语言支持用myArray[first:last]这样的方式来基于数组生成一个数组切片，而且这个用法还很灵活，比如下面几种都是合法的。

基于myArray的所有元素创建数组切片：

mySlice = myArray[:]

基于myArray的前5个元素创建数组切片：

mySlice = myArray[:5]

基于从第5个元素开始的所有元素创建数组切片：

mySlice = myArray[5:]

• 直接创建

并非一定要事先准备一个数组才能创建数组切片。Go语言提供的内置函数make()可以用于灵活地创建数组切片。下面的例子示范了直接创建数组切片的各种方法。

创建一个初始元素个数为5的数组切片，元素初始值为0：

mySlice1 := make([]int, 5)

创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：

mySlice2 := make([]int, 5, 10)

直接创建并初始化包含5个元素的数组切片：

mySlice3 := []int{1, 2, 3, 4, 5}

当然，事实上还会有一个匿名数组被创建出来，只是不需要我们来操心而已。

2. 元素遍历

操作数组元素的所有方法都适用于数组切片，比如数组切片也可以按下标读写元素，用len()函数获取元素个数，并支持使用range关键字来快速遍历所有元素。

传统的元素遍历方法如下:

for i := 0; i <len(mySlice); i++ { 
 fmt.Println("mySlice[", i, "] =", mySlice[i]) 
}

使用range关键字可以让遍历代码显得更整洁。range表达式有两个返回值，第一个是索引，第二个是元素的值：

for i, v := range mySlice { 
 fmt.Println("mySlice[", i, "] =", v) 
}

对比上面的两个方法，我们可以很容易地看出使用range的代码更简单易懂。

3. 动态增减元素

可动态增减元素是数组切片比数组更为强大的功能。与数组相比，数组切片多了一个存储能力（capacity）的概念，即元素个数和分配的空间可以是两个不同的值。合理地设置存储能力的值，可以大幅降低数组切片内部重新分配内存和搬送内存块的频率，从而大大提高程序性能。

假如你明确知道当前创建的数组切片最多可能需要存储的元素个数为50，那么如果你设置的存储能力小于50，比如20，那么在元素超过20时，底层将会发生至少一次这样的动作——重新分配一块“够大”的内存，并且需要把内容从原来的内存块复制到新分配的内存块，这会产生比较明显的开销。给“够大”这两个字加上引号的原因是系统并不知道多大才是够大，所以只是一个简单的猜测。比如，将原有的内存空间扩大两倍，但两倍并不一定够，所以之前提到的内存重新分配和内容复制的过程很有可能发生多次，从而明显降低系统的整体性能。但如果你知道最大是50并且一开始就设置存储能力为50，那么之后就不会发生这样非常耗费CPU的动作，从而达到空间换时间的效果。

数组切片支持Go语言内置的cap()函数和len()函数，代码清单2-2简单示范了这两个内置函数的用法。可以看出，cap()函数返回的是数组切片分配的空间大小，而len()函数返回的是数组切片中当前所存储的元素个数。

代码清单2-2 slice2.go

package main 
import "fmt" 
func main() { 
 mySlice := make([]int, 5, 10) 
 fmt.Println("len(mySlice):", len(mySlice)) 
 fmt.Println("cap(mySlice):", cap(mySlice)) 
}

该程序的输出结果为：

len(mySlice): 5 
cap(mySlice): 10

如果需要往上例中mySlice已包含的5个元素后面继续新增元素，可以使用append()函数。
下面的代码可以从尾端给mySlice加上3个元素，从而生成一个新的数组切片：

mySlice = append(mySlice, 1, 2, 3)

函数append()的第二个参数其实是一个不定参数，我们可以按自己需求添加若干个元素，甚至直接将一个数组切片追加到另一个数组切片的末尾：

mySlice2 := []int{8, 9, 10} 
// 给mySlice后面添加另一个数组切片
mySlice = append(mySlice, mySlice2...)

需要注意的是，我们在第二个参数mySlice2后面加了三个点，即一个省略号，如果没有这个省略号的话，会有编译错误，因为按append()的语义，从第二个参数起的所有参数都是待附加的元素。因为mySlice中的元素类型为int，所以直接传递mySlice2是行不通的。加上省略号相当于把mySlice2包含的所有元素打散后传入。

上述调用等同于：

mySlice = append(mySlice, 8, 9, 10)

数组切片会自动处理存储空间不足的问题。如果追加的内容长度超过当前已分配的存储空间（即cap()调用返回的信息），数组切片会自动分配一块足够大的内存。

4. 基于数组切片创建数组切片

类似于数组切片可以基于一个数组创建，数组切片也可以基于另一个数组切片创建。下面的例子基于一个已有数组切片创建新数组切片：

oldSlice := []int{1, 2, 3, 4, 5} 
newSlice := oldSlice[:3] // 基于oldSlice的前3个元素构建新数组切片

有意思的是，选择的oldSlicef元素范围甚至可以超过所包含的元素个数，比如newSlice可以基于oldSlice的前6个元素创建，虽然oldSlice只包含5个元素。只要这个选择的范围不超过oldSlice存储能力（即cap()返回的值），那么这个创建程序就是合法的。newSlice中超出oldSlice元素的部分都会填上0。

5. 内容复制

数组切片支持Go语言的另一个内置函数copy()，用于将内容从一个数组切片复制到另一个数组切片。如果加入的两个数组切片不一样大，就会按其中较小的那个数组切片的元素个数进行复制。下面的示例展示了copy()函数的行为：

slice1 := []int{1, 2, 3, 4, 5} 
slice2 := []int{5, 4, 3} 
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置

map

在C++/Java中，map一般都以库的方式提供，比如在C++中是STL的std::map<>，在C#中是Dictionary<>，在Java中是Hashmap<>，在这些语言中，如果要使用map，事先要引用相应的库。而在Go中，使用map不需要引入任何库，并且用起来也更加方便。

map是一堆键值对的未排序集合。比如以身份证号作为唯一键来标识一个人的信息，则这个map可以定义为代码清单 2-3所示的方式。

代码清单2-3 map1.go

package main 
import "fmt" 
// PersonInfo是一个包含个人详细信息的类型
type PersonInfo struct { 
 ID string
 Name string
 Address string
} 
func main() { 
var personDB map[string] PersonInfo 
 personDB = make(map[string] PersonInfo) 
 // 往这个map里插入几条数据
 personDB["12345"] = PersonInfo{"12345", "Tom", "Room 203,..."} 
 personDB["1"] = PersonInfo{"1", "Jack", "Room 101,..."} 
 // 从这个map查找键为"1234"的信息
 person, ok := personDB["1234"]
 // ok是一个返回的bool型，返回true表示找到了对应的数据
 if ok { 
 fmt.Println("Found person", person.Name, "with ID 1234.") 
 } else { 
 fmt.Println("Did not find person with ID 1234.") 
 } 
}

上面这个简单的例子基本上已经覆盖了map的主要用法，下面对其中的关键点进行细述。

1. 变量声明

map的声明基本上没有多余的元素，比如：

var myMap map[string] PersonInfo

其中，myMap是声明的map变量名，string是键的类型，PersonInfo则是其中所存放的值类型。

2. 创建

我们可以使用Go语言内置的函数make()来创建一个新map。下面的这个例子创建了一个键类型为string、值类型为PersonInfo的map:

myMap = make(map[string] PersonInfo)

也可以选择是否在创建时指定该map的初始存储能力，下面的例子创建了一个初始存储能力为100的map:

myMap = make(map[string] PersonInfo, 100)

创建并初始化map的代码如下：

myMap = map[string] PersonInfo{ 
 "1234": PersonInfo{"1", "Jack", "Room 101,..."}, 
}

3. 元素赋值

赋值过程非常简单明了，就是将键和值用下面的方式对应起来即可：

myMap["1234"] = PersonInfo{"1", "Jack", "Room 101,..."}

4. 元素删除

Go语言提供了一个内置函数delete()，用于删除容器内的元素。下面我们简单介绍一下如何用delete()函数删除map内的元素：

delete(myMap, "1234")

上面的代码将从myMap中删除键为“1234”的键值对。如果“1234”这个键不存在，那么这个调用将什么都不发生，也不会有什么副作用。但是如果传入的map变量的值是nil，该调用将导致程序抛出异常（panic）

5. 元素查找

在Go语言中，map的查找功能设计得比较精巧。而在其他语言中，我们要判断能否获取到一个值不是件容易的事情。判断能否从map中获取一个值的常规做法是：

(1) 声明并初始化一个变量为空；

(2) 试图从map中获取相应键的值到该变量中；

(3) 判断该变量是否依旧为空，如果为空则表示map中没有包含该变量。

这种用法比较啰唆，而且判断变量是否为空这条语句并不能真正表意（是否成功取到对应的值），从而影响代码的可读性和可维护性。有些库甚至会设计为因为一个键不存在而抛出异常，让开发者用起来胆战心惊，不得不一层层嵌套try-catch语句，这更是不人性化的设计。在Go语言中，要从map中查找一个特定的键，可以通过下面的代码来实现：

value, ok := myMap["1234"] 
if ok { // 找到了
 // 处理找到的value 
}

判断是否成功找到特定的键，不需要检查取到的值是否为nil，只需查看第二个返回值ok，这让表意清晰很多。配合:=操作符，让你的代码没有多余成分，看起来非常清晰易懂。

更多编程相关知识，请访问：编程教学！！

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