Go语言基本语法

Posted 2023-01-04 知其黑、受其白

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go语言基本语法相关的知识，希望对你有一定的参考价值。

阅读目录

Go语言变量的声明（使用var关键字）
Go语言变量的初始化
Go语言多个变量同时赋值
Go语言匿名变量（没有名字的变量）
Go语言变量的作用域
- 局部变量
- 全局变量
- 形式参数
Go语言复数 complex
Go语言bool类型（布尔类型）
Go语言字符串
- 定义字符串
- 字符串拼接符 “+”
- 字符串实现基于 UTF-8 编码
- 定义多行字符串
- Go语言字符串截取（获取字符串的某一段字符）
- Go语言实现修改字符串
- Go语言字符串拼接（连接）
- Go语言fmt.Sprintf（格式化输出）
- Go语言Base64编码—电子邮件的基础编码格式
Go语言字符类型（byte 和 rune）
- UTF-8 和 Unicode 有何区别？
Go语言数据类型转换
Go语言指针
- 指针地址和指针类型
- 指针获取指针指向的值
- 使用指针修改值
- 示例：使用指针变量获取命令行的输入信息
- 创建指针的另一种方法 new() 函数
Go语言变量的生命周期
Go语言常量和 const 关键字
- iota 常量生成器
- 无类型常量
Go语言关键字与标识符简述
- 关键字
- 标识符
Go语言运算符的优先级
Go语言中字符串转换包 strconv
- 1、string与int类型的转换
- - （1）Atoi()函数字符串类型的整数转换为 int 类型
  - （2）Itoa() 函数将 int 类型数据转换为字符
- 2、Parse系列函数
- 3、Format系列函数
- 4、其他
- - （1）isPrint() 判断 Unicode 字符
  - （2）CanBackquote()

Go语言变量的声明（使用var关键字）

Go语言是静态类型语言，因此变量（variable）是有明确类型的，编译器也会检查变量类型的正确性。

在数学概念中，变量表示没有固定值且可改变的数。

但从计算机系统实现角度来看，变量是一段或多段用来存储数据的内存。

声明变量的一般形式是使用 var 关键字：

var name type

其中，var 是声明变量的关键字，name 是变量名，type 是变量的类型。

需要注意的是，Go语言和许多编程语言不同，它在声明变量时将变量的类型放在变量的名称之后。

这样做的好处就是可以避免像C语言中那样含糊不清的声明形式，例如：int* a, b; 。其中只有 a 是指针而 b 不是。如果你想要这两个变量都是指针，则需要将它们分开书写。

而在 Go 中，则可以和轻松地将它们都声明为指针类型：

var a, b *int

Go语言的基本类型有：

bool
string
int、int8、int16、int32、int64
uint、uint8、uint16、uint32、uint64、uintptr
byte // uint8 的别名
rune // int32 的别名代表一个 Unicode 码
float32、float64
complex64、complex128 内建函数

当一个变量被声明之后，系统自动赋予它该类型的零值：int 为 0，float 为 0.0，bool 为 false，string 为空字符串，指针为 nil 等。

所有的内存在 Go 中都是经过初始化的。

变量的命名规则遵循骆驼命名法，即首个单词小写，每个新单词的首字母大写，例如：numShips 和 startDate 。

标准格式

Go语言的变量声明的标准格式为：

var 变量名 变量类型

变量声明以关键字 var 开头，后置变量类型，行尾无须分号。

简短格式

除 var 关键字外，还可使用更加简短的变量定义和初始化语法。

名字 := 表达式

需要注意的是，简短模式（short variable declaration）有以下限制：

1、定义变量，同时显式初始化。
2、不能提供数据类型。
3、只能用在函数内部。

和 var 形式声明语句一样，简短变量声明语句也可以用来声明和初始化一组变量：

i, j := 0, 1

func main() 
   x:=100
   a,s:=1, "abc"

因为简洁和灵活的特点，简短变量声明被广泛用于大部分的局部变量的声明和初始化。

var 形式的声明语句往往是用于需要显式指定变量类型地方，或者因为变量稍后会被重新赋值而初始值无关紧要的地方。

Go语言变量的初始化

每个变量会初始化其类型的默认值，例如：

1、整型和浮点型变量的默认值为 0 和 0.0。
2、字符串变量的默认值为空字符串。
3、布尔型变量默认为 bool。
4、切片、函数、指针变量的默认为 nil。

当然，依然可以在变量声明时赋予变量一个初始值。

变量初始化的标准格式

var 变量名 类型 = 表达式

例如，游戏中，玩家的血量初始值为100。可以这样写：

var hp int = 100

这句代码中，hp 为变量名，类型为 int，hp 的初始值为 100。

上面代码中，100 和 int 同为 int 类型，int 可以认为是冗余信息，因此可以进一步简化初始化的写法。

编译器推导类型的格式

在标准格式的基础上，将 int 省略后，编译器会尝试根据等号右边的表达式推导 hp 变量的类型。

var hp = 100

等号右边的部分在编译原理里被称做右值（rvalue）。

下面是编译器根据右值推导变量类型完成初始化的例子。

package main

import "fmt"

func main() 
	var attack = 40
	var defence = 20
	var damageRate float32 = 0.17
	var damage = float32(attack-defence) * damageRate
	fmt.Println(damage) // 3.4

代码说明如下：

1、第 1 和 2 行，右值为整型，attack 和 defence 变量的类型为 int。

2、第 3 行，表达式的右值中使用了 0.17。
编译器会尽量提高精确度，以避免计算中的精度损失。
所以这里如果不指定 damageRate 变量的类型，Go语言编译器会将 damageRate 类型推导为 float64，我们这里不需要 float64 的精度，所以需要强制指定类型为 float32。

3、第 4 行，将 attack 和 defence 相减后的数值结果依然为整型，使用 float32() 将结果转换为 float32 类型，再与 float32 类型的 damageRate 相乘后，damage 类型也是 float32 类型。

提示：damage 变量的右值是一个复杂的表达式，整个过程既有 attack 和 defence 的运算还有强制类型转换。

4、第 5 行，输出 damage 的值。

短变量声明并初始化

var 的变量声明还有一种更为精简的写法，例如：

hp := 100

这是Go语言的推导声明写法，编译器会自动根据右值类型推断出左值的对应类型。

注意：由于使用了 :=，而不是赋值的 =，因此推导声明写法的左值变量必须是没有定义过的变量。

若定义过，将会发生编译错误。

如果 hp 已经被声明过，但依然使用 := 时编译器会报错，代码如下：

// 声明 hp 变量
var hp int

// 再次声明并赋值
hp := 10

编译报错如下：no new variables on left side of :=

意思是，在 “:=” 的左边没有新变量出现，意思就是 “:=” 的左边变量已经被声明了。

短变量声明的形式在开发中的例子较多，比如：

conn, err := net.Dial("tcp","127.0.0.1:8080")

net.Dial 提供按指定协议和地址发起网络连接，这个函数有两个返回值，一个是连接对象（conn），一个是错误对象（err）。

如果是标准格式将会变成：

var conn net.Conn
var err error
conn, err = net.Dial("tcp", "127.0.0.1:8080")

因此，短变量声明并初始化的格式在开发中使用比较普遍。

注意：在多个短变量声明和赋值中，至少有一个新声明的变量出现在左值中，即便其他变量名可能是重复声明的，编译器也不会报错，代码如下：

conn, err := net.Dial("tcp", "127.0.0.1:8080")
conn2, err := net.Dial("tcp", "127.0.0.1:8080")

上面的代码片段，编译器不会报 err 重复定义。

Go语言多个变量同时赋值

编程最简单的算法之一，莫过于变量交换。

交换变量的常见算法需要一个中间变量进行变量的临时保存。

用传统方法编写变量交换代码如下：

var a int = 100
var b int = 200
var t int

t = a
a = b
b = t

fmt.Println(a, b)

在计算机刚发明时，内存非常“精贵”。

这种变量交换往往是非常奢侈的。

于是计算机“大牛”发明了一些算法来避免使用中间变量：

var a int = 100
var b int = 200

a = a ^ b
b = b ^ a
a = a ^ b

fmt.Println(a, b)

这样的算法很多，但是都有一定的数值范围和类型要求。

到了Go语言时，内存不再是紧缺资源，而且写法可以更简单。
使用 Go 的 “多重赋值” 特性，可以轻松完成变量交换的任务：

var a int = 100
var b int = 200

b, a = a, b

fmt.Println(a, b)

running...
200 100

多重赋值时，变量的左值和右值按从左到右的顺序赋值。

多重赋值在Go语言的错误处理和函数返回值中会大量地使用。

例如使用Go语言进行排序时就需要使用交换，代码如下：

package main

type IntSlice []int

func (p IntSlice) Len() int 
	return len(p)

func (p IntSlice) Less(i, j int) bool 
	return p[i] < p[j]

func (p IntSlice) Swap(i, j int) 
	p[i], p[j] = p[j], p[i]


func main()

代码说明如下：
1、将 IntSlice 声明为 []int 类型。
2、为 IntSlice 类型编写一个 Len 方法，提供切片的长度。
3、根据提供的 i、j 元素索引，获取元素后进行比较，返回比较结果。
4、根据提供的 i、j 元素索引，交换两个元素的值。

Go语言匿名变量（没有名字的变量）

在编码过程中，可能会遇到没有名称的变量、类型或方法。

虽然这不是必须的，但有时候这样做可以极大地增强代码的灵活性，这些变量被统称为匿名变量。

匿名变量的特点是一个下画线 “_”，“_” 本身就是一个特殊的标识符，被称为空白标识符。

它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。

使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。

例如：

func GetData() (int, int) 
    return 100, 200

func main()
    a, _ := GetData()
    _, b := GetData()
    fmt.Println(a, b)

代码运行结果：

100 200

GetData() 是一个函数，拥有两个整型返回值。

每次调用将会返回 100 和 200 两个数值。

代码说明如下：

a, _ 只需要获取第一个返回值，所以将第二个返回值的变量设为下画线（匿名变量）。
_, b 第一个返回值的变量设为匿名变量。

匿名变量不占用内存空间，不会分配内存。
匿名变量与匿名变量之间也不会因为多次声明而无法使用。

Go语言变量的作用域

一个变量（常量、类型或函数）在程序中都有一定的作用范围，称之为作用域。

了解变量的作用域对我们学习Go语言来说是比较重要的，因为Go语言会在编译时检查每个变量是否使用过，一旦出现未使用的变量，就会报编译错误。

如果不能理解变量的作用域，就有可能会带来一些不明所以的编译错误。

根据变量定义位置的不同，可以分为以下三个类型：
1、函数内定义的变量称为局部变量。
2、函数外定义的变量称为全局变量。
3、函数定义中的变量称为形式参数。

局部变量

在函数体内声明的变量称之为局部变量，它们的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。

局部变量不是一直存在的，它只在定义它的函数被调用后存在，函数调用结束后这个局部变量就会被销毁。

【示例】下面的 main() 函数中使用到了局部变量 a、b、c。

package main
import (
    "fmt"
)
func main() 
    //声明局部变量 a 和 b 并赋值
    var a int = 3
    var b int = 4
    
    //声明局部变量 c 并计算 a 和 b 的和
    c := a + b
    fmt.Printf("a = %d, b = %d, c = %d\\n", a, b, c)

全局变量

在函数体外声明的变量称之为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，当然，不包含这个全局变量的源文件需要使用 “import” 关键字引入全局变量所在的源文件之后才能使用这个全局变量。

全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。

【示例】

package main
import "fmt"
//声明全局变量
var c int
func main() 
    //声明局部变量
    var a, b int
    //初始化参数
    a = 3
    b = 4
    c = a + b
    fmt.Printf("a = %d, b = %d, c = %d\\n", a, b, c)

Go语言程序中全局变量与局部变量名称可以相同，但是函数体内的局部变量会被优先考虑。

package main
import "fmt"
//声明全局变量
var a float32 = 3.14
func main() 
    //声明局部变量
    var a int = 3
    fmt.Printf("a = %d\\n", a)

运行结果如下所示：a = 3

形式参数

在定义函数时函数名后面括号中的变量叫做形式参数（简称形参）。形式参数只在函数调用时才会生效，函数调用结束后就会被销毁，在函数未被调用时，函数的形参并不占用实际的存储单元，也没有实际值。

形式参数会作为函数的局部变量来使用。

【示例】func sum(a, b int) int 定义了形式参数 a 和 b。

package main
import (
    "fmt"
)
//全局变量 a
var a int = 13
func main() 
    //局部变量 a 和 b
    var a int = 3
    var b int = 4
    fmt.Printf("main() 函数中 a = %d\\n", a)
    fmt.Printf("main() 函数中 b = %d\\n", b)
    c := sum(a, b)
    fmt.Printf("main() 函数中 c = %d\\n", c)

func sum(a, b int) int 
    fmt.Printf("sum() 函数中 a = %d\\n", a)
    fmt.Printf("sum() 函数中 b = %d\\n", b)
    num := a + b
    return num

运行结果如下所示：

main() 函数中 a = 3
main() 函数中 b = 4
sum() 函数中 a = 3
sum() 函数中 b = 4
main() 函数中 c = 7

Go语言复数 complex

在计算机中，复数是由两个浮点数表示的，其中一个表示实部（real），一个表示虚部（imag）。

Go语言中复数的类型有两种：

complex128（64 位实数和虚数）
complex64（32 位实数和虚数）

其中 complex128 为复数的默认类型。

复数的值由三部分组成 RE + IMi，其中 RE 是实数部分，IM 是虚数部分，RE 和 IM 均为 float 类型，而最后的 i 是虚数单位。

声明复数的语法格式如下所示：

var name complex128 = complex(x, y)

其中 name 为复数的变量名，complex128 为复数的类型，“=”后面的 complex 为Go语言的内置函数用于为复数赋值，x、y 分别表示构成该复数的两个 float64 类型的数值，x 为实部，y 为虚部。

上面的声明语句也可以简写为下面的形式：

name := complex(x, y)

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

通过 imag(z) 获得该复数的虚部，也就是 y。

【示例】使用内置的 complex 函数构建复数，并使用 real 和 imag 函数返回复数的实部和虚部：

package main

import "fmt"

func main() 
	var x complex128 = complex(1, 2) // 1+2i
	var y complex128 = complex(3, 4) // 3+4i
	fmt.Println(x * y)               // "(-5+10i)"
	fmt.Println(real(x * y))         // "-5"
	fmt.Println(imag(x * y))         // "10"

如果大家对复数的运算法则不是很了解，可以查阅《复数运算法则》，其中详细的讲解了复数的加减乘除操作。

《复数运算法则》
https://baike.baidu.com/item/复数运算法则/2568041?fr=aladdin

复数也可以用 == 和 != 进行相等比较，只有两个复数的实部和虚部都相等的时候它们才是相等的。

Go语言内置的 math/cmplx 包中提供了很多操作复数的公共方法，实际操作中建议大家使用复数默认的 complex128 类型，因为这些内置的包中都使用 complex128 类型作为参数。

Go语言bool类型（布尔类型）

一个布尔类型的值只有两种：

true
false

if 和 for 语句的条件部分都是布尔类型的值，并且 == 和 < 等比较操作也会产生布尔型的值。

一元操作符!对应逻辑非操作，因此 !true 的值为 false，更复杂一些的写法是 (!true==false) ==true，实际开发中我们应尽量采用比较简洁的布尔表达式，就像用 x 来表示x==true。

var aVar = 10

aVar == 5  // false
aVar == 10 // true
aVar != 5  // true
aVar != 10 // false

Go语言对于值之间的比较有非常严格的限制，只有两个相同类型的值才可以进行比较，如果值的类型是接口（interface），那么它们也必须都实现了相同的接口。

如果其中一个值是常量，那么另外一个值可以不是常量，但是类型必须和该常量类型相同。

如果以上条件都不满足，则必须将其中一个值的类型转换为和另外一个值的类型相同之后才可以进行比较。

布尔值可以和 &&（AND）和 ||（OR）操作符结合，并且有短路行为，如果运算符左边的值已经可以确定整个布尔表达式的值，那么运算符右边的值将不再被求值，因此下面的表达式总是安全的：

s != "" && s[0] == 'x'

其中 s[0] 操作如果应用于空字符串将会导致 panic 异常。

因为 && 的优先级比 || 高（&& 对应逻辑乘法，|| 对应逻辑加法，乘法比加法优先级要高），所以下面的布尔表达式可以不加小括号：

if 'a' <= c && c <= 'z' ||
    'A' <= c && c <= 'Z' ||
    '0' <= c && c <= '9' 
    // ...ASCII字母或数字...

布尔值并不会隐式转换为数字值 0 或 1，反之亦然，必须使用 if 语句显式的进行转换：

i := 0
if b 
    i = 1

如果需要经常做类似的转换，可以将转换的代码封装成一个函数，如下所示：

// 如果b为真，btoi返回1；如果为假，btoi返回0
func btoi(b bool) int 
    if b 
        return 1
    
    return 0

数字到布尔型的逆转换非常简单，不过为了保持对称，我们也可以封装一个函数：

// itob报告是否为非零。
func itob(i int) bool  
	return i != 0

Go语言中不允许将整型强制转换为布尔型，代码如下：

var n bool
fmt.Println(int(n) * 2)

编译错误，输出如下：

cannot convert n (type bool) to type int

布尔型无法参与数值运算，也无法与其他类型进行转换。

Go语言字符串

一个字符串是一个不可改变的字节序列，字符串可以包含任意的数据，但是通常是用来包含可读的文本，字符串是 UTF-8 字符的一个序列（当字符为 ASCII 码表上的字符时则占用 1 个字节，其它字符根据需要占用 2-4 个字节）。

UTF-8 是一种被广泛使用的编码格式，是文本文件的标准编码，其中包括 XML 和 JSON 在内也都使用该编码。由于该编码对占用字节长度的不定性，在Go语言中字符串也可能根据需要占用 1 至 4 个字节，Go语言这样做不仅减少了内存和硬盘空间占用，同时也不用像其它语言那样需要对使用 UTF-8 字符集的文本进行编码和解码。

字符串是一种值类型，且值不可变，即创建某个文本后将无法再次修改这个文本的内容，更深入地讲，字符串是字节的定长数组。

定义字符串

可以使用双引号 "" 来定义字符串，字符串中可以使用转义字符来实现换行、缩进等效果，常用的转义字符包括：

\\n：换行符
\\r：回车符
\\t：tab 键
\\u 或 \\U：Unicode 字符
\\\\：反斜杠自身

一般的比较运算符（==、!=、<、<=、>=、>）是通过在内存中按字节比较来实现字符串比较的，因此比较的结果是字符串自然编码的顺序。

字符串所占的字节长度可以通过函数 len() 来获取，例如 len(str)。

字符串的内容（纯字节）可以通过标准索引法来获取，在方括号 [ ] 内写入索引，索引从 0 开始计数：

字符串 str 的第 1 个字节：str[0]。
第 i 个字节：str[i - 1]。
最后 1 个字节：str[len(str)-1]。

需要注意的是，这种转换方案只对纯 ASCII 码的字符串有效。

注意：获取字符串中某个字节的地址属于非法行为，例如 &str[i]。

字符串拼接符 “+”

两个字符串 s1 和 s2 可以通过 s := s1 + s2 拼接在一起。将 s2 追加到 s1 尾部并生成一个新的字符串 s。

可以通过下面的方式来对代码中多行的字符串进行拼接：

str := "Beginning of the string " + "second part of the string"

提示：因为编译器会在行尾自动补全分号，所以拼接字符串用的加号“+” 必须放在第一行末尾。

也可以使用 “+=” 来对字符串进行拼接：

s := "hel" + "lo,"
s += "world!"
fmt.Println(s) //输出 “hello, world!”

字符串实现基于 UTF-8 编码

Go语言中字符串的内部实现使用 UTF-8 编码，通过 rune 类型，可以方便地对每个 UTF-8 字符进行访问。

当然，Go语言也支持按照传统的 ASCII 码方式逐字符进行访问。

定义多行字符串

在Go语言中，使用双引号书写字符串的方式是字符串常见表达方式之一，被称为字符串字面量（string literal），这种双引号字面量不能跨行，如果想要在源码中嵌入一个多行字符串时，就必须使用`反引号，代码如下：

const str = `第一行
第二行
第三行
\\r\\n
`
fmt.Println(str)

代码运行结果：

第一行
第二行
第三行
\\r\\n

反引号 `，是键盘上 1 键左边的键，两个反引号间的字符串将被原样赋值到 str 变量中。

在这种方式下，反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

多行字符串一般用于内嵌源码和内嵌数据等，代码如下：

const codeTemplate = `// Generated by github.com/davyxu/cellnet/
protoc-gen-msg
// DO NOT EDIT!range .Protos
// Source: .Nameend
package .PackageName
if gt .TotalMessages 0
import (
    "github.com/davyxu/cellnet"
    "reflect"
    _ "github.com/davyxu/cellnet/codec/pb"
)
end
func init() 
    range .Protos
    // .Namerange .Messages
    cellnet.RegisterMessageMeta("pb",".FullName", reflect.TypeOf((*.Name)(nil)).Elem(), .MsgID)    end
    end

`

这段代码只定义了一个常量 codeTemplate，类型为字符串，使用 ` 定义，字符串的内容为一段代码生成中使用到的 Go 源码格式。

在 ` 间的所有代码均不会被编译器识别，而只是作为字符串的一部分。

Go语言计算字符串长度—len() 和 RuneCountInString()

Go 语言的内建函数 len()，可以用来获取：

切片
字符串
通道（channel）等的长度。

下面的代码可以用 len() 来获取字符串的长度。

tip1 := "genji is a ninja"
fmt.Println(len(tip1)) // 16

tip2 := "忍者" // 6
fmt.Println(len(tip2))

len() 函数的返回值的类型为 int，表示字符串的 ASCII 字符个数或字节长度。

输出中第一行的 16 表示 tip1 的字符个数为 16。
输出中第二行的 6 表示 tip2 的字符格式，也就是“忍者”的字符个数是 6，然而根据习惯，“忍者”的字符个数应该是 2。

这里的差异是由于 Go 语言的字符串都以 UTF-8 格式保存，每个中文占用 3 个字节，因此使用 len() 获得两个中文文字对应的 6 个字节。

如果希望按习惯上的字符个数来计算，就需要使用 Go 语言中 UTF-8 包提供的 RuneCountInString() 函数，统计 Uncode 字符数量。

下面的代码展示如何计算UTF-8的字符个数。

fmt.Println(utf8.RuneCountInString("忍者")) // 2
fmt.Println(utf8.RuneCountInString("龙忍出鞘,fight!")) // 11

一般游戏中在登录时都需要输入名字，而名字一般有长度限制。

考虑到国人习惯使用中文做名字，就需要检测字符串 UTF-8 格式的长度。

总结

ASCII 字符串长度使用 len() 函数。
Unicode 字符串长度使用 utf8.RuneCountInString() 函数。

Go语言遍历字符串—获取每一个字符串元素

遍历每一个ASCII字符

遍历 ASCII 字符使用 for 的数值循环进行遍历，直接取每个字符串的下标获取 ASCII 字符，如下面的例子所示。

theme := "狙击 start"
for i := 0; i < len(theme); i++ 
    fmt.Printf("ascii: %c  %d\\n", theme[i], theme[i])

程序输出如下：

ascii: ?  231
ascii:     139
ascii:     153
ascii: ?  229
ascii:     135
ascii: ?  187
ascii:    32
ascii: s  115
ascii: t  116
ascii: a  97
ascii: r  114
ascii: t  116

这种模式下取到的汉字“惨不忍睹”。由于没有使用 Unicode，汉字被显示为乱码。

按 Unicode 字符遍历字符串

theme := "狙击 start"
for _, s := range theme 
    fmt.Printf("Unicode: %c  %d\\n", s, s)

可以看到，这次汉字可以正常输出了。

总结

ASCII 字符串遍历直接使用下标。
Unicode 字符串遍历用 for range。

Go语言字符串截取（获取字符串的某一段字符）

获取字符串的某一段字符是开发中常见的操作，我们一般将字符串中的某一段字符称做子串（substring）。

下面例子中使用 strings.Index() 函数在字符串中搜索另外一个子串，代码如下：

package main

import (
	"fmt"
	"strings"
)

func main() 
	tracer := "死神来了, 死神bye bye"
	comma := strings.Index(tracer, ",")
	pos := strings.Index(tracer[comma:], "死神")
	fmt.Println(comma)
	fmt.Println(pos)
	fmt.Println(tracer[comma+pos:])

running...
12
2
死神bye bye

代码说明如下：

1、 strings.Index(tracer, ",") 尝试在 tracer 的字符串中搜索中文的逗号，返回的位置存在 comma 变量中，类型是 int，表示从 tracer 字符串开始的 ASCII 码位置。

strings.Index() 函数并没有像其他语言一样，提供一个从某偏移开始搜索的功能。

不过我们可以对字符串进行切片操作来实现这个逻辑。

2、tracer[comma:] 从 tracer 的 comma 位置开始到 tracer 字符串的结尾构造一个子字符串，返回给 string.Index() 进行再索引。

得到的 pos 是相对于 tracer[comma:] 的结果。

comma 逗号的位置是 12，而 pos 是相对位置，值为 3。

我们为了获得第二个“死神”的位置，也就是逗号后面的字符串，就必须让 comma 加上 pos 的相对偏移，计算出 15 的偏移，然后再通过切片 tracer[comma+pos:] 计算出最终的子串，获得最终的结果：“死神bye bye”。

总结

字符串索引比较常用的有如下几种方法：

strings.Index：正向搜索子字符串。
strings.LastIndex：反向搜索子字符串。
搜索的起始位置可以通过切片偏移制作。

Go语言实现修改字符串

注意：字符串是无法被修改的，只能复制原字符串，在复制的版本上修改。

方法1：转换为[]byte() 型，代表了 ASCII 码的一个字符。

方法2：转换为[]rune() 型，代表一个 UTF-8 字符，当需要处理中文、日文或者其他复合字符时，则需要用到 rune 类型。

方法3：新字符串代替原字符串的子字符串,用strings包中的strings.Replace()

以上是关于Go语言基本语法的主要内容，如果未能解决你的问题，请参考以下文章 
 Go语言和其他语言的不同之基本语法
 每天一点Go语言——Go语言语法基础及基本数据类型
 Go语言基本语法
 Go语言基本语法
 go语言学习笔记 — 基础 — 基本语法 — 常量与变量 — 变量作用域：能够使用变量的代码范围
 我的Go+语言初体验——Go+ 基本语法之 Switch