Welche Arten von Go-Sprache gibt es?

Zu den Arten der Go-Sprache gehören Boolescher Wert (bool), Ganzzahl (int8, byte, int16 usw.), Gleitkomma (float32, float64), komplexe Zahl (complex64, complex128), Zeichenfolge, Zeichen, Fehlertyp, Zeiger, Arrays, Slices, Wörterbücher, Kanäle, Strukturen, Schnittstellen. Der Gleitkommatyp verwendet den IEEE-754-Standardausdruck; eine komplexe Zahl besteht tatsächlich aus zwei reellen Zahlen (dargestellt durch Gleitkommazahlen in Computern), eine für den Realteil und eine für den Imaginärteil.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Typen der Go-Sprache

Die Go-Sprache verfügt über die folgenden integrierten Grundtypen:

• Boolescher Typ: bool.

• Integer-Typ: int8, byte, int16, int, uint, uintptr usw.

• Gleitkommatypen: float32, float64.

• Pluraltypen: complex64, complex128.

• String: String.

• Charaktertyp: Rune.

• Fehlertyp: Fehler.

Darüber hinaus unterstützt die Go-Sprache auch die folgenden zusammengesetzten Typen:

• Pointer (Zeiger)

• Array (Array)

• Slice (Slice)

• Wörterbuch (Karte )

• Channel (chan)

• Structure (struct)

• Interface (interface)

Zusätzlich zu diesen Grundtypen kapselt Go auch die folgenden Typen:

int , uint und uintptr usw. . Diese Typen zeichnen sich durch eine einfache Handhabung aus, allerdings kann der Benutzer keine Annahmen über die Länge dieser Typen treffen. Für die reguläre Entwicklung reicht es aus, int und uint zu verwenden. Es ist nicht erforderlich, Typen mit explizit angegebenen Längen wie int8 zu verwenden, um Portierungsschwierigkeiten zu vermeiden. [Verwandte Empfehlungen: Go-Video-Tutorial

Boolescher Typ

Die Go-Sprache verwendet den boolschen Typ, um Daten vom booleschen Typ nur zwei Werte zu deklarieren: true

Bitte beachten Sie Die Antwort lautet:

• Go erlaubt keine Umwandlung von Ganzzahlen in boolesche Typen.

• Der Standardwert von Variablen vom Typ Boolean ist falsch.

• Boolesche Typen können nicht an numerischen Operationen teilnehmen und können nicht in sie konvertiert werden andere Typen

Der boolesche Typ in der Go-Sprache ist im Grunde derselbe wie in anderen Sprachen. Das Schlüsselwort ist ebenfalls bool und kann vordefinierten true und false zugewiesen werden. Der Beispielcode lautet wie folgt: rreee

Der boolesche Typ kann keine anderen Typen akzeptieren. Die Zuweisung unterstützt keine automatische oder erzwungene Typkonvertierung. Die folgenden Beispiele sind einige falsche Verwendungen, die zu Kompilierungsfehlern führen können:

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

integer

integer ist der grundlegendste Datentyp in allen Programmiersprachen. Die Go-Sprache unterstützt diese in Tabelle 2-1 gezeigten Ganzzahltypen.

1. Das folgende Beispiel führt beispielsweise automatisch zu einem Kompilierungsfehler:

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

Der Kompilierungsfehler ähnelt:

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

Die Verwendung einer erzwungenen Typkonvertierung kann diesen Kompilierungsfehler beheben:

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

Natürlich müssen Entwickler bei der erzwungenen Typkonvertierung auf den Verlust der Datengenauigkeit achten, der durch das Abschneiden der Datenlänge (z. B. das Erzwingen einer Gleitkommazahl in eine Ganzzahl) und einen Werteüberlauf (wenn der Wert den Wertebereich überschreitet) verursacht wird des konvertierten Zieltyps).

Typkonvertierung

In der Go-Sprache gibt es nur eine starke Typkonvertierung, keine implizite Konvertierung. Diese Syntax kann nur verwendet werden, wenn die Konvertierung zwischen zwei Typen unterstützt wird. Die Syntax von Zwang lautet wie folgt:

Das Beispiel lautet wie folgt:

2. Numerische Operationen

Die Go-Sprache unterstützt die folgenden regulären Ganzzahloperationen : + , -, *, / und %

Addition, Subtraktion, Multiplikation und Division werden nicht im Detail erklärt. Es muss gesagt werden, dass % die Restoperation ist, genau wie in der Sprache C, zum Beispiel:

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/166997848093462Welche%20Arten%20von%20Go-Sprache%20gibt%20es?" title="166997848093462Welche Arten von Go-Sprache gibt es?" alt="Welche Arten von Go-Sprache gibt es?"></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 <p>Go语言还提供了一个<strong>关键字range</strong>，<strong>用于便捷地遍历容器中的元素</strong>。当然，<strong>数组也是range的支持范围</strong>。上面的遍历过程可以简化为如下的写法：</p><pre class="brush:php;toolbar:false">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><p>使用range关键字可以让遍历代码显得更整洁。range表达式有两个返回值，第一个是索引，第二个是元素的值：</p>
<pre class="brush:php;toolbar:false">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，这让表意清晰很多。配合:=操作符，让你的代码没有多余成分，看起来非常清晰易懂。

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

Das obige ist der detaillierte Inhalt vonWelche Arten von Go-Sprache gibt es?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!