一、Go基础知识入门
1、go语言介绍
2、go开发环境搭建
2.1、go的安装
-
go下载地址：All releases - The Go Programming Language，windows选择下载go1.20.2.windows-amd64.msi文件。
-
双击go1.20.2.windows-amd64.msi，点击"Next"，然后勾选同意，再点击"Next"。
-
选择Go的安装位置，这里我选择了"D:\0-software\0-develop\10-GO\1-go1.20.2"。再点击"Next"。
-
点击"Install"进行安装。然后点击"Finish"就安装完成了。
2.2、go的环境变量配置
-
此电脑->右键"属性"->"高级系统设置"->"环境变量"
-
在系统变量里面添加：
-
变量名：GOPATH
变量值：D:\0-software\0-develop\10-GO\1-go1.20.2
-
在Path里面添加：%GOPATH%\bin
-
然后打开cmd，输入"go version"，打印下图所示，说明环境变量配置成功。
goLand的安装、配置
-
goLand下载地址：GoLand by JetBrains: More than just a Go IDE，安装过程省略。
-
新建go工程时，选择Go，不要选择Go(GOPATH)，早期的GoLand比如2020版本的才选择Go(GOPATH)。
2.3、go开发之hello-world
-
点击"File"->"new"->"Go File"，编辑文件名为"Hello"
-
可以看到默认会有一个package包名。每一个go的源码文件都要指定包名。并且只有package是main的代码才会运行。
-
func表示函数的意思。
-
注意：Go语言的Hello World你想要运行的话要注意：
-
包名必须叫main
-
函数名也必须叫main
-
同一个目录下只能有一个func main()
-
-
点击绿色的三角按钮执行。
-
还可以通过另外一种方式运行：
-
进入到Hello.go所在目录文件夹
-
然后执行go build .\Hello.go，这样可以将Hello.go编译成可执行文件。
-
然后执行：.\Hello.exe，就可以执行了。
-
如果想省略编译过程直接执行，可以输入：
go run .\Hello.go
这样就不会编译生成Hello.exe文件，而且还会执行。
-
3、变量和常量
3.1、如何定义变量
package main
import "fmt"
// 全局变量和局部变量(定义在main外面的变量都是全局变量)
//var sex = "male"
//var ok bool = true
// 简洁方式定义全局变量
var (
sex = "male"
ok = true
age = 18
)
//局部变量定义了就必须使用，不使用会报错；全局变量定义了之后可以不使用，不会报错。
func main() {
//go是静态语言，静态语言和动态语言相比，定义变量差异很大
//1、变量必须想定义后使用 2、变量必须有类型 3、变量类型定下来之后不能改变
//定义变量的方式
//方式一：var variableName variableType
var name string
name = "旺财"
//演示：变量类型定下来之后不能改变
//name = 1
fmt.Print(name)
/*
方式二：var variableName = variableValue
可以省略variableType，因为go可以通过variableValue进行类型推断。
*/
var name2 = "小强"
fmt.Print(name2)
/*
方式三：variableName := variableValue
这种平时用的比较多
*/
//var age = 1
age := 1
fmt.Print(age)
//go语言中局部变量定义了但是不使用，是不行的。
//2、多变量定义
//2、多变量定义
//2.1、同时在一行里面定义3个string类型的变量
var user1, user2, user3 string
fmt.Print(user1, user2, user3)
//2.2、同时在一行里面定义3个变量，并且初始化。
var user4, user5, user6 = "小强", "旺财", 1
fmt.Print(user4, user5, user6)
/*
注意：
变量必须先定义再使用
go语言是静态语言，要求变量的类型和赋值类型一致
局部变量名不能冲突；全局变量和局部变量的变量名可以重复，这种情况下，局部变量的优先级高。
简洁变量定义不能用于全局变量(方式三：variableName := variableValue)
变量是有零值的
局部变量定义了就必须使用，不使用会报错；全局变量定义了之后可以不使用，不会报错。
*/
}3.2、常量的定义和使用
package main
import "fmt"
func main() {
//常量，定义的时候就指定的值，不能修改。
//常量定义的时候全部大写。多个单词中间加下划线。
const PI1 float32 = 3.1415926535897932384626 //显式定义
const PI2 = 3.1415926535897932384626 //隐式定义
// 同时定义多个常量
const (
UNKNOWN = 1
FEMALE = 2
MALE = 3
)
// 同时定义多个常量,并且支持类型定义。
const (
X int = 1
Y
S = "abc"
Z
M
)
fmt.Println(X, Y, S, Z, M)
/*
1、常量类型只可以定义bool、数值(整数、浮点数和复数) 和 字符串；
2、不曾使用的常量，没有强制使用的要求；
3、显式指定类型的时候，必须确保常量 左右值类型一致。
4、常量在定义的时候如果没有设置类型和值的话，它就用前面的类型和值。
*/
}代码执行结果：
从打印结果可以看出，Y没有定义类型和值，但是Y可以使用前面X的类型和值。M也是同样的道理。
3.3、iota的使用细节
package main
import "fmt"
func main() {
//iota，特殊常量，可以认为是一个可以被编译器修改的常量。
const (
ERR1 = iota + 1
ERR2
ERR3
ERR4 = "abc"
ERR5
ERR6 = 100
ERR7 = iota
)
const (
ERRNEW1 = iota
)
fmt.Println(ERR1, ERR2, ERR3, ERR4, ERR5, ERR6, ERR7)
fmt.Println(ERRNEW1)
/*
如果中断了iota那么必须显式的恢复，后续会自动递增。
自增类型默认是int类型
iota能简化const类型的定义
每次出现const的时候，iota初始化为0
*/
}代码运行结果：
3.4、匿名变量的定义和用途
package main
func a() (int, bool) {
return 0, false
}
func main() {
//匿名变量：就是一个下划线
var _ int
//r1, ok := a()
_, ok := a()
/*
如果我接下来只想使用ok，不想使用r1，根据Go的局部变量定义规定的，定义了就必须使用，那我就必须在下面被迫的加一个多余的打印r1的代码。
有什么好办法吗？
这时，匿名变量就登场了。可以使用"_"代替r1，这样在下面可以不用也不会报错了。
*/
if ok {
//打印
}
}
3.5、变量的作用域
package main
import "fmt"
// 全局变量：任何一个函数都可以使用这个变量
var globalVariable = "旺财"
func main() {
//变量的作用域
//局部变量
localVariable := "小强"
fmt.Print(localVariable)
{
//局部变量
localVariable2 := "张三"
fmt.Print(localVariable2)
}
//在局部变量作用域外部打印该变量会报错
//fmt.Print(localVariable2)
}
4、go的基础数据类型
4.1、数值、浮点数和字符类型
package main
import "fmt"
func main() {
//基础数据类型
//var a int8
//var b int16
//var c int32
//var d int64
//var ua uint8
//var ub uint16
//var uc uint32
//var ud uint64
动态类型，用的时候就会知道，用起来挺麻烦的
//var e int
//
类型转换需要强转才行
//a = int8(b)
//
//var f1 float32
//var f2 float64
//
//f1 = 3
//f2 = 3.14
//主要是用来存放英文字符的
var c byte
c = 'a' + 1
fmt.Println(c) //值是98
fmt.Printf("c=%c", c) //打印的是 c=b
c1 := 97
fmt.Println()
fmt.Printf("c1=%c", c1) //打印的是 c=a
//也是字符，主要是用来存放中文字符的
var c2 rune
c2 = '旺'
fmt.Println()
fmt.Printf("c=%c", c2) //打印的是 c=旺
//字符串
var name string
name = "My name is Peter Parker,I am a Super Hero. I don't like the Criminals."
fmt.Println()
fmt.Println(name)
}
运行结果：
bool类型
布尔型的值只可以是常量 true 或者 false。一个简单的例子：var b bool = true
数值型
-
整数型
可以简单讲解一下二进制和位数的关系，以及int和uint的关系
-
int8 有符号 8 位整型 (-128 到 127) 长度：8bit
-
int16 有符号 16 位整型 (-32768 到 32767)
-
int32 有符号 32 位整型 (-2147483648 到 2147483647)
-
int64 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
-
uint8 无符号 8 位整型 (0 到 255) 8位都用于表示数值：
-
uint16 无符号 16 位整型 (0 到 65535)
-
uint32 无符号 32 位整型 (0 到 4294967295)
-
uint64 无符号 64 位整型 (0 到 18446744073709551615)
-
浮点型
-
float32 32位浮点型数
-
float64 64位浮点型数
其他
-
byte 等于 uint8
-
rune 等于 int32
-
uint 32 或 64 位
字符
Golang中没有专门的字符类型，如果要存储单个字符(字母)，一般使用byte来保存。 字符串就是一串固定长度的字符连接起来的字符序列。Go的字符串是由单个字节连接起来的。也就是说对于传统的字符串是由字符组成的，而Go的字符串不同，它是由字节组成的。
package main
import (
"fmt"
)
func main() {
var a byte
a = 'a'
//输出ascii对应码值 。。 这里说明一下什么是ascii码
fmt.Println(a)
fmt.Printf("a=%c", a)
}字符常量只能使用单引号括起来，例如：var a byte = ‘a’ var a int = ‘a’
package main
import (
"fmt"
)
func main() {
var a byte
a = "a"
//输出ascii对应码值 。。 这里说明一下什么是ascii码
fmt.Println(a)
fmt.Printf("a=%c", a)
}字符本质是一个数字， 可以进行加减乘除
package main
import (
"fmt"
"reflect"
)
func main() {
a := 'a'
//这里注意一下 1. a+1可以和数字计算 2.a+1的类型是32 3. int类型可以直接变成字符
fmt.Println(reflect.TypeOf(a+1))
fmt.Printf("a+1=%c", a+1)
}字符串
字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。
4.2、基本类型的转换
package main
import (
"fmt"
"strconv"
)
func main() {
//基本类型转换
//int和int相互转换
var a int8 = 12
//var b = uint8(a)
//fmt.Print(b)
//float转int
//var f float32 = 3.14
//var c = int32(f)
//fmt.Println(c) //打印的是3
//int转float
//var f64 = float64(a)
//fmt.Println(f64) //打印的是12
//定义别名
type IT int //类型要求很严格
var c = IT(a)
fmt.Println(c)
//字符串转数字
var istr = "12"
myint, err := strconv.Atoi(istr)
if err != nil {
fmt.Println("convert erro")
}
fmt.Println(myint)
//数字转字符串
var myi = 32
fmt.Println(strconv.Itoa(myi))
}type 关键字：
在 Go 语言中，type 关键字常被我们用来创建新的结构体。同样的，type 也可以用来创建其它的用户自定义类型。在创建新类型时，有类型别名和类型定义两种方式，你知道它们的区别吗？
1、type 关键字
对于使用过 Go 语言的人，相信对type关键字都不陌生，它可以帮助我们定义结构体或接口：
type Student struct{
}
type Man interface {
Name()
} 在使用 type 定义结构体时，我们可以把它看作是基于struct{}类型定义了一个新的类型Student。
其实，除了用于创建新类型，type还有创建类型别名的作用。
2、类型别名 vs 类型定义
基于一个类型创建一个别名，称之为类型别名 (alias)。
基于一个类型创建一个新类型，称之为类型定义 (definition)。
type Int1 = int // 类型别名，Int1 是 int 类型的别名
type Int2 int // 类型定义，Int2 是新类型它们之间的区别是什么呢？
以上述定义的Int1和Int2为例，我们可以用int类型的变量初始化Int1类型，因为Int1只是int类型的一个别名。
但如果我们用一个int类型的变量初始化Int2类型时，对Int2类型的初始化会报错，因为Int2是一个新的类型。
type Int1 = int // 类型别名，Int1 是 int 类型的别名
type Int2 int // 类型定义，Int2 是新类型
var i int = 0
var i1 Int1 = i
var i2 Int2 = i // error 不过，Int1类型和Int2类型都可以用相应类型的字面量来初始化。
type Int1 = int // 类型别名，Int1 是 int 类型的别名
type Int2 int // 类型定义，Int2 是新类型
var i1 Int1 = 0
var i2 Int2 = 04.2.1、简单的转换操作
valueOfTypeB = typeB(valueOfTypeA)
代码块1
// 浮点数
a := 5.0
// 转换为int类型
b := int(a)
//Go允许在底层结构相同的两个类型之间互转。例如：
// IT类型的底层是int类型
type IT int
// a的类型为IT，底层是int
var a IT = 5
// 将a(IT)转换为int，b现在是int类型
b := int(5)
// 将b(int)转换为IT，c现在是IT类型
c := IT(b)
var a int32 = 1
var b int64 = 3
b = int64(a)
fmt.Println(a, b)
/*
不是所有数据类型都能转换的，例如字母格式的string类型"abcd"转换为int肯定会失败
低精度转换为高精度时是安全的，高精度的值转换为低精度时会丢失精度。例如int32转换为int16，float32转换为int
这种简单的转换方式不能对int(float)和string进行互转，要跨大类型转换，可以使用strconv包提供的函数
*/4.2.2、strconv
Itoa和Atoi
int转换为字符串：Itoa()
println("a" + strconv.Itoa(32)) // a32string转换为int：Atoi()(表示 alphanumeric to integer)是把字符串转换成整型数的一个函数
i,_ := strconv.Atoi("3")
println(3 + i) // 6
// Atoi()转换失败
i,err := strconv.Atoi("a")
if err != nil {
println("converted failed")
}
//由于string可能无法转换为int，所以这个函数有两个返回值：第一个返回值是转换成int的值，第二个返回值判断是否转换成功。4.3、format进行格式化转换
Parse类函数
Parse类函数用于转换字符串为给定类型的值：ParseBool()、ParseFloat()、ParseInt()、ParseUint()。
b, err := strconv.ParseBool("true")
f, err := strconv.ParseFloat("3.1415", 64)
i, err := strconv.ParseInt("-42", 10, 64)
u, err := strconv.ParseUint("42", 10, 64)ParseInt()和ParseUint()有3个参数：
func ParseInt(s string, base int, bitSize int) (i int64, err error)
func ParseUint(s string, base int, bitSize int) (uint64, error)说明：
-
bitSize参数表示转换为什么位的int/uint，有效值为0、8、16、32、64。当bitSize=0的时候，表示转换为int或uint类型。例如bitSize=8表示转换后的值的类型为int8或uint8。 -
base参数表示以什么进制的方式去解析给定的字符串，有效值为0、2-36。当base=0的时候，表示根据string的前缀来判断以什么进制去解析：0x开头的以16进制的方式去解析，0开头的以8进制方式去解析，其它的以10进制方式解析。
Format类函数
将给定类型格式化为string类型：FormatBool()、FormatFloat()、FormatInt()、FormatUint()。
s := strconv.FormatBool(true)
s := strconv.FormatFloat(3.1415, 'E', -1, 64)
s := strconv.FormatInt(-42, 16) //表示将-42转换为16进制数，转换的结果为-2a。
s := strconv.FormatUint(42, 16) 第二个参数base指定将第一个参数转换为多少进制，有效值为2<=base<=36。当指定的进制位大于10的时候，超出10的数值以a-z字母表示。例如16进制时，10-15的数字分别使用a-f表示，17进制时，10-16的数值分别使用a-g表示。
FormatFloat()参数众多：
func FormatFloat(f float64, fmt byte, prec, bitSize int) stringbitSize表示f的来源类型（32：float32、64：float64），会据此进行舍入。
fmt表示格式：‘f’（-ddd.dddd）、‘b’（-ddddp±ddd，指数为二进制）、‘e’（-d.dddde±dd，十进制指数）、‘E’（-d.ddddE±dd，十进制指数）、‘g’（指数很大时用’e’格式，否则’f’格式）、‘G’（指数很大时用’E’格式，否则’f’格式）。
prec控制精度（排除指数部分）：对’f’、‘e’、‘E’，它表示小数点后的数字个数；对’g’、‘G’，它控制总的数字个数。如果prec 为-1，则代表使用最少数量的、但又必需的数字来表示f。
4.4、运算符和表达式
4.4.1、算数运算符
-
-
-
/ %(求余) ++ –
-
-
4.4.2、关系运算符
== != > < >= <=
4.4.3、逻辑运算符
| && | 所谓逻辑与运算符。如果两个操作数都非零，则条件变为真 |
|---|---|
| || | 所谓的逻辑或操作。如果任何两个操作数是非零，则条件变为真 |
| ! | 所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真，那么逻辑非操后结果为假 |
这个和python不一样，python中使用 and or来连接
package main
import "fmt"
func main() {
var a bool = true
var b bool = false
if ( a && b ) {
fmt.Printf("第一行 - 条件为 true\n" )
}
if ( a || b ) {
fmt.Printf("第二行 - 条件为 true\n" )
}
/* 修改 a 和 b 的值 */
a = false
b = true
if ( a && b ) {
fmt.Printf("第三行 - 条件为 true\n" )
} else {
fmt.Printf("第三行 - 条件为 false\n" )
}
if ( !(a && b) ) {
fmt.Printf("第四行 - 条件为 true\n" )
}
}4.4.4、位运算符
位运算符对整数在内存中的二进制位进行操作。 下表列出了位运算符 &, |, 和 ^ 的计算：
| P | Q | P & Q | P | Q | P ^ Q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
假定 A = 60; B = 13; 其二进制数转换为： A = 0011 1100 B = 0000 1101
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001 Go 语言支持的位运算符如下表所示。假定 A 为60，B 为13：
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与。 | (A & B) 结果为 12, 二进制为 0000 1100 |
| | | 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或 | (A | B) 结果为 61, 二进制为 0011 1101 |
| ^ | 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 | (A ^ B) 结果为 49, 二进制为 0011 0001 |
| << | 左移运算符"<<“是双目运算符。左移n位就是乘以2的n次方。 其功能把”<<“左边的运算数的各二进位全部左移若干位，由”<<"右边的数指定移动的位数，高位丢弃，低位补0。 | A << 2 结果为 240 ，二进制为 1111 0000 |
| >> | 右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 | |
| 其功能是把">>“左边的运算数的各二进位全部右移若干位，”>>"右边的数指定移动的位数。 | A >> 2 结果为 15 ，二进制为 0000 1111 |
package main
import "fmt"
func main() {
var a uint = 60 /* 60 = 0011 1100 */
var b uint = 13 /* 13 = 0000 1101 */
var c uint = 0
c = a & b /* 12 = 0000 1100 */
fmt.Printf("第一行 - c 的值为 %d\n", c )
c = a | b /* 61 = 0011 1101 */
fmt.Printf("第二行 - c 的值为 %d\n", c )
c = a ^ b /* 49 = 0011 0001 */
fmt.Printf("第三行 - c 的值为 %d\n", c )
c = a << 2 /* 240 = 1111 0000 */
fmt.Printf("第四行 - c 的值为 %d\n", c )
c = a >> 2 /* 15 = 0000 1111 */
fmt.Printf("第五行 - c 的值为 %d\n", c )
}4.4.5、赋值运算符
下表列出了所有Go语言的赋值运算符。
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，将一个表达式的值赋给一个左值 | C = A + B 将 A + B 表达式结果赋值给 C |
| += | 相加后再赋值 | C += A 等于 C = C + A |
| -= | 相减后再赋值 | C -= A 等于 C = C - A |
| *= | 相乘后再赋值 | C *= A 等于 C = C * A |
| /= | 相除后再赋值 | C /= A 等于 C = C / A |
| %= | 求余后再赋值 | C %= A 等于 C = C % A |
| <<= | 左移后赋值 | C <<= 2 等于 C = C << 2 |
| >>= | 右移后赋值 | C >>= 2 等于 C = C >> 2 |
| &= | 按位与后赋值 | C &= 2 等于 C = C & 2 |
| ^= | 按位异或后赋值 | C ^= 2 等于 C = C ^ 2 |
| |= | 按位或后赋值 | C |= 2 等于 C = C | 2 |
package main
import "fmt"
func main() {
var a int = 21
var c int
c = a
fmt.Printf("第 1 行 - = 运算符实例，c 值为 = %d\n", c )
c += a
fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c )
c -= a
fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c )
c *= a
fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c )
c /= a
fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c )
c = 200;
c <<= 2
fmt.Printf("第 6行 - <<= 运算符实例，c 值为 = %d\n", c )
c >>= 2
fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c )
c &= 2
fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c )
c ^= 2
fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %d\n", c )
c |= 2
fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %d\n", c )
}4.4.6、其他运算符
此处讲解一下什么是地址
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 返回变量存储地址 | &a; 将给出变量的实际地址。 |
| * | 指针变量。 | *a; 是一个指针变量 |
package main
import "fmt"
func main() {
var a int = 4
var b int32
var c float32
var ptr *int
/* 运算符实例 */
fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b );
fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );
/* & 和 * 运算符实例 */
ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */
fmt.Printf("a 的值为 %d\n", a);
fmt.Printf("*ptr 为 %d\n", *ptr);
}4.4.7、运算符优先级
有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。下表列出了所有运算符以及它们的优先级，由上至下代表优先级由高到低
| 优先级 | 分类 | 运算符 | 结合性 |
|---|---|---|---|
| 1 | 逗号运算符 | , | 从左到右 |
| 2 | 赋值运算符 | =、+=、-=、*=、/=、 %=、 >=、 <<=、&=、^=、|= | 从右到左 |
| 3 | 逻辑或 | || | 从左到右 |
| 4 | 逻辑与 | && | 从左到右 |
| 5 | 按位或 | | | 从左到右 |
| 6 | 按位异或 | ^ | 从左到右 |
| 7 | 按位与 | & | 从左到右 |
| 8 | 相等/不等 | ==、!= | 从左到右 |
| 9 | 关系运算符 | <、<=、>、>= | 从左到右 |
| 10 | 位移运算符 | <<、>> | 从左到右 |
| 11 | 加法/减法 | +、- | 从左到右 |
| 12 | 乘法/除法/取余 | *（乘号）、/、% | 从左到右 |
| 13 | 单目运算符 | !、*（指针）、& 、++、–、+（正号）、-（负号） | 从右到左 |
| 14 | 后缀运算符 | ( )、[ ]、-> | 从左到右 |
当然，你可以通过使用括号来临时提升某个表达式的整体运算优先级。
package main
import "fmt"
func main() {
var a int = 20
var b int = 10
var c int = 15
var d int = 5
var e int;
e = (a + b) * c / d; // ( 30 * 15 ) / 5
fmt.Printf("(a + b) * c / d 的值为 : %d\n", e );
e = ((a + b) * c) / d; // (30 * 15 ) / 5
fmt.Printf("((a + b) * c) / d 的值为 : %d\n" , e );
e = (a + b) * (c / d); // (30) * (15/5)
fmt.Printf("(a + b) * (c / d) 的值为 : %d\n", e );
e = a + (b * c) / d; // 20 + (150/5)
fmt.Printf("a + (b * c) / d 的值为 : %d\n" , e );
}5、字符串基本操作
5.1、rune和字符串长度
package main
import "fmt"
func main() {
//5.1节 rune和字符串长度
//长度计算
name := "lvxiaosha学go"
fmt.Println(len(name))
//将字符串类型的name转换为切片，然后就可以for循环了。
bytes := []byte(name)
fmt.Println(len(bytes))
//因为 len() 传入 返回字符串所占的字节 ，而中文转 utf8 编码后占 3 字节，英文占 1 字节。所以上面两个输出结果都是：9 + 3 + 2 = 14
//如果我们想得到字符长度，而不是字节长度，就需要转为 切片 后再计算长度。
runes := []rune(name)
fmt.Println(len(runes)) // 10
}运行结果：
5.2、转义符
package main
import "fmt"
func main() {
//5.2节转义符
//想在字符串中打印双引号
//方法1：使用反斜线加双引号(\")
name := "\"吕小傻\""
fmt.Println(name)
//方法2：使用Tab键上面的那个键(`)，注意不是单引号(')。
//这个和python中的三引号("""xxx""")里面可以随便写内容类似。
//我们大多数使用的都是这个方法。
name2 := `"吕小傻"`
fmt.Println(name2)
}转义符
| 转义字符 | 意义 | ASCII码值（十进制） |
|---|---|---|
| \n | 换行(LF) ，将当前位置移到下一行开头 | 010 |
| \r | 回车(CR) ，将当前位置移到本行开头 | 013 |
| \t | 水平制表(HT) （跳到下一个TAB位置） | 009 |
| \\ | 代表一个反斜线字符’’\’ | 092 |
| \’ | 代表一个单引号（撇号）字符 | 039 |
| \" | 代表一个双引号字符 | 034 |
| \? | 代表一个问号 | 063 |
5.3、格式化输出
package main
import (
"fmt"
"strconv"
)
func main() {
//5.3节格式化输出
userName := "吕小傻"
address := "山东省青岛市"
age := 18
mobile := "13624558575"
fmt.Println("用户名："+userName, "地址："+address, "年龄："+strconv.Itoa(age), "电话："+mobile) //这种拼接方式极难维护
fmt.Printf("用户名:%s,地址:%s,年龄:%d,电话:%s\r\n", userName, address, age, mobile) //这种方式更常用，但是性能没有上一种好。
userMessage := fmt.Sprintf("用户名:%s,地址:%s,年龄:%d,电话:%s", userName, address, age, mobile)
fmt.Println(userMessage)
var ages []int = []int{1, 2, 3}
agesMessage := fmt.Sprintf("年龄:%#v", ages)
fmt.Println(agesMessage)
}
缺省格式和类型
| 格式化后的效果 | 动词 | 描述 |
|---|---|---|
| [0 1] | %v |
缺省格式 |
| []int64{0, 1} | %#v |
go语法打印 |
| []int64 | %T |
类型打印 |
整型(缩进, 进制类型, 正负符号)
| 格式化后的效果 | 动词 | 描述 |
|---|---|---|
| 15 | %d |
十进制 |
| +15 | %+d |
必须显示正负符号 |
| ␣␣15 | %4d |
Pad空格(宽度为4，右对齐) |
| 15␣␣ | %-4d |
Pad空格 (宽度为4，左对齐) |
| 1111 | %b |
二进制 |
| 17 | %o |
八进制 |
| f | %x |
16进制，小写 |
字符(有引号, Unicode)
Value: 65 (Unicode letter A)
| 格式化后的效果 | 动词 | 描述 |
|---|---|---|
| A | %c |
字符 |
| ‘A’ | %q |
有引号的字符 |
| U+0041 | %U |
Unicode |
| U+0041 ‘A’ | %#U |
Unicode 有引号 |
浮点(缩进, 精度, 科学计数)
Value: 123.456
| 格式化后的效果 | 动词 | 描述 |
|---|---|---|
| 1.234560e+02 | %e |
科学计数 |
| 123.456000 | %f |
十进制小数 |
字符串or 字节slice (引号, 缩进, 16进制)
Value: "cafe"
| 格式化后的效果 | 动词 | 描述 |
|---|---|---|
| cafe | %s |
字符串原样输出 |
| ␣␣cafe | %6s |
宽度为6，右对齐 |
5.4、高性能字符串拼接-string.builder
package main
import (
"fmt"
"strconv"
"strings"
)
func main() {
//5.4节 高性能字符串拼接-string.builder
userName := "吕小傻"
address := "山东省青岛市"
age := 18
mobile := "13624558575"
var builder strings.Builder
builder.WriteString("用户名:")
builder.WriteString(userName)
builder.WriteString(",地址:")
builder.WriteString(address)
builder.WriteString(",年龄:")
builder.WriteString(strconv.Itoa(age))
builder.WriteString(",电话:")
builder.WriteString(mobile)
response := builder.String()
fmt.Println(response)
}
运行结果：
5.5、字符串的比较
package main
import "fmt"
func main() {
//5.5节 字符串的比较
a := "hello"
b := "hello"
fmt.Println(a == b)
fmt.Println(a != b)
//字符串的大小比较
fmt.Println(a > b)
}
5.6、字符串操作常用方法
package main
import (
"fmt"
"strings"
)
func main() {
//5.6节 字符串操作常用方法
//strings常用方法
//是否包含
name := "My name is Peter Parker,I am a Super Hero.I don't like the Criminals."
fmt.Println(strings.Contains(name, "Peter Parker"))
//字符串长度
runes := []rune(name)
fmt.Println(len(runes))
//查询字符串出现的次数
fmt.Println(strings.Count(name, "a"))
//分割字符串
fmt.Println(strings.Split(name, ","))
//字符串是否包含前缀，是否包含后缀。
fmt.Println(strings.HasPrefix(name, "My"))
fmt.Println(strings.HasSuffix(name, "Criminals."))
//查询子串出现的位置
fmt.Println(strings.Index(name, "Peter Parker"))
fmt.Println(strings.IndexRune(name, []rune(name)[17]))
//字符串替换
fmt.Println(strings.Replace(name, "Peter Parker", "Super Man", 1)) // 1表示只替换第一个
fmt.Println(strings.Replace(name, "Peter Parker", "Iron Man", -1)) // -1表示全部替换
//大小写转换
fmt.Println(strings.ToLower("Peter Parker"))
fmt.Println(strings.ToUpper("Peter Parker"))
//去掉字符串左右两边的特殊字符，下面的方法表示，只要字符串两边出现了"#"或"$"，就去掉。
//除了strings.Trim，还有strings.TrimLeft和strings.TrimRight方法
fmt.Println(strings.Trim("$#Peter #Parker#", "#$"))
}
运行结果：
6.1、if条件判断
package main
import "fmt"
/*
*
if 布尔表达式 {
逻辑
}
*/
func main() {
//6.1节 if条件判断
age := 18
country := "中国"
//简单的if条件判断，布尔表达式的括号省略
if age < 18 {
fmt.Println("未成年")
}
//复杂的if条件判断，布尔表达式的括号不能省略
if (age < 18) && (country == "中国") {
fmt.Println("未成年")
} else if age == 18 {
fmt.Println("刚刚成年")
} else {
fmt.Println("成年了")
}
}
6.2、for循环基础用法
package main
import (
"fmt"
)
/*
* go语言中只有for循环，没有while循环。
* for init; condition; post {
* //do something
* }
*/
func main() {
//6.1节 for循环基础用法
//标准写法
for i := 0; i < 3; i++ {
fmt.Println(i)
}
//初始变量在循环外面定义
var j int
for ; j < 3; j++ {
fmt.Println(j)
}
// init; condition; post 都没有，就等效与while(true)
//var k int
//for {
// //睡眠2秒
// time.Sleep(2 * time.Second)
// fmt.Println(k)
// k++
//}
// 可以将post部分放到循环体里面
var m int
for m < 3 {
fmt.Println(m)
m++
}
}
6.3、for循环打印九九乘法表
package main
import "fmt"
/*
* 6.3节 for循环打印九九乘法表
* for循环打印九九乘法表
*/
func main() {
//遍历，处理第几行
for y := 1; y <= 9; y++ {
//遍历，处理第几列。
for x := 1; x <= y; x++ {
fmt.Printf("%d * %d = %d\t", x, y, x*y)
}
fmt.Println()
}
}
运行结果:
6.4、for range的循环用法
package main
import (
"fmt"
)
/*
* 6.4节 for range的循环用法，主要用于 字符串、数组、切片、map、channel
*/
func main() {
name := "My name is Peter Parker."
//for index, value := range name {
// fmt.Printf("%d, %c\r\n", index, value)
//}
for _, value := range name {
fmt.Printf("%c\r\n", value)
}
/*
* 字符串 字符串的索引(key) 字符串对应的索引的字符值的拷贝(index),因为是字符串值的拷贝，所以在字符串循环时是改不了原字符串的 如果不写key,那么index返回的是索引
* for index := range name {
* fmt.Printf("%c\r\n", index)
* }
*
* 数组 数组的索引 索引的对应值的拷贝 如果不写key,那么value返回的是索引
* 切片 切片的索引 索引的对应值的拷贝 如果不写key,那么value返回的是索引
* map 字符串的索引(key) value 返回的是 key 对应值的拷贝 如果不写key,那么value返回的是map的值
* channel value 返回的是 channel 接受的数据
*/
//下面这种方式循环字符串时会出现中文乱码
name2 := "哈哈哈"
for index := range name2 {
fmt.Printf("%c\r\n", name2[index])
}
//下面这种方式循环字符串时，就不会出现中文乱码
name3 := "哈哈哈"
for _, value := range name3 {
fmt.Printf("%c\r\n", value)
}
}
6.5、for循环的continue和break语句
package main
import (
"fmt"
"time"
)
func main() {
index := 0
for {
time.Sleep(1 * time.Second)
index++
//如果index等于5，就直接进入下一次循环，不执行下面的代码。
if index == 5 {
continue
}
fmt.Println(index)
if index > 10 {
//退出循环
break
}
}
}
6.6、goto语句的基本用法
package main
import "fmt"
/*
* 6.6节 goto语句的基本用法
* goto语句可以让我们的代码跳到指定的代码块中运行，灵活性很强。但是开发中不建议使用。
*
* goto语句可以实现程序的跳转，goto语句使用场景最多的是程序的错误处理，也就是说当程序出现错误的时候统一跳转到相应的标签处，统一处理。
*/
func main() {
for i := 0; i < 5; i++ {
for j := 0; j < 5; j++ {
if j == 2 {
goto over
}
fmt.Println(i, j)
}
}
over:
fmt.Println("over")
}
运行结果：
6.7、switch语法
package main
import "fmt"
/*
* 6.7节 switch语句 比if语句执行性能更高一些，而且代码更整洁。
* switch var1 {
* case val1:
* ...
* case val2:
* ...
* case val3:
* ...
* default:
* ...
*
* var1变量可以是任意的变量类型
*/
func main() {
//中文的星期几，输出对应的英文
day := "星期三"
switch day {
case "星期一":
fmt.Println("Monday")
case "星期二":
fmt.Println("Tuesday")
case "星期三":
fmt.Println("Wednesday")
case "星期四":
fmt.Println("Thursday")
case "星期五":
fmt.Println("Friday")
case "星期六":
fmt.Println("Saturday")
case "星期日":
fmt.Println("Sunday")
default:
fmt.Println("Unknown")
}
//还有更灵活的switch用法
score := 95
switch {
case score < 60:
fmt.Println("E")
case score >= 60 && score < 70:
fmt.Println("D")
case score >= 70 && score < 80:
fmt.Println("C")
case score >= 80 && score < 90:
fmt.Println("B")
case score >= 90 && score < 100:
fmt.Println("A")
default:
fmt.Println("Unknown")
}
//还有可以这样用switch
count := 90
switch count {
case 60, 70, 80:
fmt.Println("Ordinary")
case 90:
fmt.Println("Excellent")
default:
fmt.Println("Unknown")
}
}
运行结果：
跳转链接：
下一篇：二、容器、go编程思想