一.基本介绍

Go中文文档: https://www.topgoer.com/
官方Go练习指南: https://tour.go-zh.org/welcome/1
Golang标准库文档: https://studygolang.com/pkgdoc

二.编写HelloWorld

项目目录

一般语言是没有规定的项目结构，Go语言在这方面做了规定，为了保持一致性，做到统一、规则化比较明确

--demo--bin--pkg--src--project01--project02

• bin存放编译后的可执行文件
• pkg存放编译后的包文件
• src存放项目源文件，多个项目则分多个文件夹

代码

package mainimport "fmt"func main() {fmt.Println("Hello world")
}

1. go文件的后缀是 .go
2. package main
   表示：该hello.go文件所在的包是main，每个文件都必须归属一个包
3. import “fmt”
   表示：引入一个包，包名fmt，引入后，即可使用该包的函数，例如：fmt.Println
4. func main(){}
   func 是一个关键字，表示后面是一个函数，mian代表是一个主函数，即程序的入口

编译执行

1. 进入到文件目录，执行go build，执行完成后生成执行文件hello.exe，执行exe文件即可看到效果

go build hello.go
.\hello.go

2. 直接编译并运行

go run hello.go

执行流程

go build、go run

1. 如果先编译成可执行文件，则把执行文件拷贝到其他没有go环境的机器，也可以直接执行
2. 如果是源文件，则要执行的机器上也必须有go开发环境，否则无法执行
3. 下图中可以看出，源文件1KB，编译后的执行文件为2046KB，这是因为，编译时，编译器会将程序依赖运行的库文件包含在可执行文件中，所以执行文件变大了很多
   

三.包,变量和函数

1.包

每个 Go 程序都是由包构成的。

程序从 main 包开始运行。

按照约定，包名与导入路径的最后一个元素一致。例如，“math/rand” 包中的源码均以 package rand 语句开始。

package mainimport ("fmt""math/rand"
)func main() {fmt.Println("My favorite number is", rand.Intn(100))
}

2.导入

此代码用圆括号组合了导入，这是“分组”形式的导入语句。
当然你也可以编写多个导入语句

package mainimport ("fmt""math"
)
/* 等同于上面的组合导入import "fmt"import "math"*/func main(){fmt.Printf("7的平方根为: %g\n",math.Sqrt(7))
}

3.导出名

在 Go 中，如果一个名字以大写字母开头，那么它就是已导出的。例如，Pizza 就是个已导出名，Pi 也同样，它导出自 math 包。

pizza 和 pi 并未以大写字母开头，所以它们是未导出的。

在导入一个包时，你只能引用其中已导出的名字。任何“未导出”的名字在该包外均无法访问。

package mainimport ("fmt""math"
)func main() {fmt.Println(math.Pi)
}

4.函数

函数可以没有参数或接受多个参数。
在本例中，add 接受两个 int 类型的参数。
注意类型在变量名 之后。

package mainimport "fmt"func add(x int, y int) int {return x + y
}//当连续两个或多个函数的已命名形参类型相同时，除最后一个类型以外，其它都可以省略
func add2(x, y int) int {return x + y
}func main() {fmt.Println(add(2, 16))fmt.Println(add(18, 16))
}

函数可以返回任意数量的返回值。
swap 函数返回了两个字符串。

package mainimport "fmt"func swap(x, y string) (string, string) {return y, x
}func main() {a, b := swap("hello", "world")fmt.Println(a, b)
}

5.命名返回值

package main
import "fmt"//没有参数的 return 语句返回已命名的返回值。也就是 直接 返回
func split(sum int) (x, y int){x = sum * 4 / 9y = sum - xreturn
}func main(){fmt.Println(split(17))
}

6.变量

var 语句用于声明一个变量列表，跟函数的参数列表一样，类型在最后。

就像在这个例子中看到的一样，var 语句可以出现在包或函数级别。

package mainimport "fmt"var c, python, java boolfunc main() {var i intfmt.Println(i, c, python, java)
}

变量声明可以包含初始值，每个变量对应一个。

如果初始化值已存在，则可以省略类型；变量会从初始值中获得类型。

package mainimport "fmt"var i, j int = 1, 2func main() {var c, python, java = true, false, "no!"fmt.Println(i, j, c, python, java)
}

在函数中，简洁赋值语句 := 可在类型明确的地方代替 var 声明。

函数外的每个语句都必须以关键字开始（var, func 等等），因此 := 结构不能在函数外使用。

package mainimport "fmt"func main() {var i, j int = 1, 2k := 3c, python, java := true, false, "no!"fmt.Println(i, j, k, c, python, java)
}

7.基本类型

Go 的基本类型有

• bool
• string
• int int8 int16 int32 int64
• uint uint8 uint16 uint32 uint64 uintptr
• byte // uint8 的别名
• rune // int32 的别名 表示一个 Unicode 码点
• float32 float64
• complex64 complex128

int, uint 和 uintptr 在 32 位系统上通常为 32 位宽，在 64 位系统上则为 64 位宽。 当你需要一个整数值时应使用 int 类型，除非你有特殊的理由使用固定大小或无符号的整数类型。

package mainimport ("fmt""math/cmplx"
)var (ToBe   bool       = falseMaxInt uint64     = 1<<64 - 1z      complex128 = cmplx.Sqrt(-5 + 12i)
)func main() {fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)fmt.Printf("Type: %T Value: %v\n", z, z)
}

8.基本数据类型和String的转换

8.1 基本类型

通用：

%v 值的默认格式表示
%+v 类似%v，但输出结构体时会添加字段名
%#v 值的Go语法表示
%T 值的类型的Go语法表示 %% 百分号

布尔值：

%t 单词true或false

整数：

%b 表示为二进制
%c 该值对应的unicode码值
%d 表示为十进制
%o 表示为八进制
%q 该值对应的单引号括起来的go语法字符字面值，必要时会采用安全的转义表示
%x 表示为十六进制，使用a-f
%X 表示为十六进制，使用A-F
%U 表示为Unicode格式：U+1234，等价于"U+%04X"

浮点数与复数的两个组分：

%b 无小数部分、二进制指数的科学计数法，如-123456p-78；参见strconv.FormatFloat
%e 科学计数法，如-1234.456e+78
%E 科学计数法，如-1234.456E+78
%f 有小数部分但无指数部分，如123.456
%F 等价于%f
%g 根据实际情况采用%e或%f格式（以获得更简洁、准确的输出）
%G 根据实际情况采用%E或%F格式（以获得更简洁、准确的输出）

字符串和[]byte：

%s 直接输出字符串或者[]byte
%q 该值对应的双引号括起来的go语法字符串字面值，必要时会采用安全的转义表示
%x 每个字节用两字符十六进制数表示（使用a-f）
%X 每个字节用两字符十六进制数表示（使用A-F）

指针：

%p 表示为十六进制，并加上前导的0x

没有%u。整数如果是无符号类型自然输出也是无符号的。类似的，也没有必要指定操作数的尺寸（int8，int64）。

宽度通过一个紧跟在百分号后面的十进制数指定，如果未指定宽度，则表示值时除必需之外不作填充。精度通过（可选的）宽度后跟点号后跟的十进制数指定。如果未指定精度，会使用默认精度；如果点号后没有跟数字，表示精度为0。举例如下：

%f: 默认宽度，默认精度
%9f 宽度9，默认精度
%.2f 默认宽度，精度2
%9.2f 宽度9，精度2
%9.f 宽度9，精度0

8.2 转换

使用 fmt.Sprintf 和 strconv 进行转换

package mainimport ("fmt""strconv"
)func main() {sprintfTest()strconvTest()stringToDef()
}// 使用fmt.Sprintf进行转换
func sprintfTest() {var a int = 1var b float64 = 1.2var c bool = falsevar d byte = 'c'var str stringstr = fmt.Sprintf("%d", a)fmt.Printf("str type %T str=%q\n", str, str)str = fmt.Sprintf("%f", b)fmt.Printf("str type %T str=%q\n", str, str)str = fmt.Sprintf("%t", c)fmt.Printf("str type %T str=%q\n", str, str)str = fmt.Sprintf("%c", d)fmt.Printf("str type %T str=%q\n", str, str)
}// 使用strconv包的函数
func strconvTest() {var a int = 1var b float64 = 1.2var c bool = falsevar str stringstr = strconv.FormatInt(int64(a), 10)fmt.Printf("str type %T str=%q\n", str, str)str = strconv.FormatFloat(b, 'f', 10, 64)fmt.Printf("str type %T str=%q\n", str, str)str = strconv.FormatBool(c)fmt.Printf("str type %T str=%q\n", str, str)
}// String类型转基本数据类型
func stringToDef() {var a string = "1"var aa int64aa, _ = strconv.ParseInt(a, 10, 64)fmt.Printf("str type %T str=%v\n", aa, aa)var b string = "1.2"var bb float64bb, _ = strconv.ParseFloat(b, 64)fmt.Printf("str type %T str=%v\n", bb, bb)var c string = "false"var cc boolcc, _ = strconv.ParseBool(c)fmt.Printf("str type %T str=%v\n", cc, cc)
}

9.零值

没有明确初始值的变量声明会被赋予它们的 零值。

零值是：

• 数值类型为 0，
• 布尔类型为 false，
• 字符串为 “”（空字符串）。

package mainimport "fmt"func main() {var i intvar f float64var b boolvar s stringfmt.Printf("%v %v %v %q\n", i, f, b, s)
}

10.类型转换

package mainimport ("fmt""math"
)func main() {var x, y int = 3, 4var f float64 = math.Sqrt(float64(x * x + y * y))var z uint = uint(f)fmt.Println(x, y, f, z)typeChange()typeChange2()
}//Go 在不同类型的项之间赋值时需要显式转换
func typeChange() {var i int = 42var f float64 = float64(i)//隐式转换会失败// var f float64 = ivar u uint = uint(f)fmt.Println(i, f, u)
}func typeChange2() {i := 42f := float64(i)u := uint(f)fmt.Println(i, f, u)
}

11.类型推导

在声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var = 表达式语法），变量的类型由右值推导得出。

当右值声明了类型时，新变量的类型与其相同：

var i int
j := i // j 也是一个 int

不过当右边包含未指明类型的数值常量时，新变量的类型就可能是 int, float64 或 complex128 了，这取决于常量的精度：

i := 42           // int
f := 3.142        // float64
g := 0.867 + 0.5i // complex128

package main
import "fmt"//在声明一个变量而不指定其类型时（即使用不带类型的 := 语法或 var = 表达式语法），变量的类型由右值推导得出
func main() {v := 42fmt.Printf("v is of type %T\n", v)typesIs()typesIs2()
}func typesIs(){var i intj := ifmt.Printf("j的类型为%T\n", j)
}func typesIs2() {i := 42           // intf := 3.142        // float64g := 0.867 + 0.5i // complex128fmt.Printf("i的类型为%T\n", i)fmt.Printf("f的类型为%T\n", f)fmt.Printf("g的类型为%T\n", g)
}

12.常量

常量的声明与变量类似，只不过是使用 const 关键字。
常量可以是字符、字符串、布尔值或数值。
常量不能用 := 语法声明。

package mainimport "fmt"const Pi = 3.14func main() {const World = "世界"fmt.Println("Hello", World)fmt.Println("Happy", Pi, "Day")const Truth = truefmt.Println("Go rules?", Truth)
}

13.数值常量

数值常量是高精度的 值。

一个未指定类型的常量由上下文来决定其类型。

再尝试一下输出 needInt(Big) 吧。

（int 类型最大可以存储一个 64 位的整数，有时会更小。）

（int 可以存放最大64位的整数，根据平台不同有时会更少。）

package mainimport "fmt"const (// 将 1 左移 100 位来创建一个非常大的数字// 即这个数的二进制是 1 后面跟着 100 个 0Big = 1 << 100// 再往右移 99 位，即 Small = 1 << 1，或者说 Small = 2Small = Big >> 99
)func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {return x * 0.1
}func main() {fmt.Println(needInt(Small))fmt.Println(needFloat(Small))fmt.Println(needFloat(Big))
}

14.值类型和引用类型

14.1 值类型和引用类型的说明

1. 值类型
   1、基本数据类型：int32系列，float系列，string，bool，数组，结构体struct
   2、通常在栈区分配

2. 引用类型
   1、引用类型：指针，slic切片，map，管道chan，interface
   2、通常在堆区，分配空间

14.2 值类型和引用类型的使用特点

1. 值类型: 变量直接存储值,内存通常在栈中分配
2. 引用类型: 变量存储的是一个地址,这个地址对应的空间才真正存储数据(值),内存通常在堆中分配,当没有任何变量引用这个地址时,该地址对应的数据空间就变成为一个垃圾,由GC来回收.

四.指针

Go 拥有指针。指针保存了值的内存地址。

类型 *T 是指向 T 类型值的指针。其零值为 nil。

var p *int

& 操作符会生成一个指向其操作数的指针。

i := 42
p = &i

*操作符表示指针指向的底层值。

package mainimport "fmt"func main() {i, j := 42, 2701p := &i         // 指向 ifmt.Println(*p) // 通过指针读取 i 的值*p = 21         // 通过指针设置 i 的值fmt.Println(i)  // 查看 i 的值p = &j         // 指向 j*p = *p / 37   // 通过指针对 j 进行除法运算fmt.Println(j) // 查看 j 的值
}

五.运算符

1.键盘输入语句

调用fmt的fmt.Scanln() 和 fmt.Scanf()

package mainimport "fmt"func main() {// scanlnTest()scanfTest()
}func scanlnTest() {var name stringvar age bytevar sal float32var isPass boolfmt.Println("输入姓名:")fmt.Scanln(&name)fmt.Println("输入年龄:")fmt.Scanln(&age)fmt.Println("输入薪资:")fmt.Scanln(&sal)fmt.Println("是否通过考试:")fmt.Scanln(&isPass)fmt.Println("姓名:", name, "年龄:", age, "薪资:", sal, "是否通过考试:", isPass)
}func scanfTest() {var name stringvar age bytevar sal float32var isPass boolfmt.Println("请输入你的姓名, 年龄, 薪资, 是否通过考试, 使用空格隔开")fmt.Scanf("%s %d %f %t", &name, &age, &sal, &isPass)fmt.Println("姓名:", name, "年龄:", age, "薪资:", sal, "是否通过考试:", isPass)
}

2.进制

对于整数有4种表示方式

1. 二进制: 0,1 满2进1 在golang中不能直接使用二进制来表示一个整数,它沿用了c的特点
2. 十进制: 0-9, 满10进1
3. 八进制: 0-7 满8进1 以数字0开头
4. 十六进制:0-9 及 A-F 满16进1 以0x或0X开头表示 此处的A-F不区分大小写

2.1 其他进制转十进制

2.1.1 二进制转十进制

规则：从最低位开始（右边的），将每个位上的数提取出来，乘以2的（位数-1）次方，然后求和

1011 = 1 * 2 ^ 0 + 1 * 2^1 + 0 * 2 ^ 2 + 1* 2 ^ 3 = 11

2.1.2八进制转十进制

规则：从最低位开始（右边的），将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和

0123 = 3 * 8 ^ 0 + 2 * 8^1 + 1 * 8 ^ 2 = 83

2.1.2十六进制转十进制

规则：从最低位开始（右边的），将每个位上的数提取出来，乘以8的（位数-1）次方，然后求和

0X34A= 10 * 16 ^ 0 + 4 * 16^1 + 3 * 16 ^ 2 = 842

2.2 十进制转其他进制

2.2.1 十进制转二进制

规则：将改数不断除以2，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制

2.2.2 十进制转八进制

规则：将改数不断除以8，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制

2.2.3 十进制转十六进制

规则：将改数不断除以16，直到商为0为止，然后将每步得到的余数倒过来，就是对应的二进制

请将356转成16进制：

2.3 二进制转八进制，十六进制

2.3.1 二进制转八进制

规则： 将二进制每三位一组（从低位开始组合），转成对应的八进制数即可。（因为三位数字的二进制最多可以表示为7）

请将二进制11010101转成八进制：

11010101 = 11 010 101 = 3 2 5 = 0325

2.3.2 二进制转十六进制

规则： 将二进制每四位一组（从低位开始组合），转成对应的十六进制数即可。（因为四位数字的二进制最多可以表示为15）

请将二进制11010101转成十六进制：

11010101 = 1101 0101 = 13 5 = 0XD5

2.4 八进制，十六进制转二进制

2.4.1 八进制转二进制

规则：将八进制每1位，转成对应的1个三位的二进制数即可

请将0237转成二进制
0237 = 10 011 111 = 10011111

2.4.2 十六进制转二进制

规则：将十六进制每1位，转成对应的1个四位的二进制数即可

请将0X237转成二进制
0X237 = 10 0011 0111 = 1000110111

2.5 原码反码补码

2.6 位运算和移位运算符

package mainimport "fmt"func main() {var a int = 1 >> 2 // 0000 0001 => 0000 0000 => 0fmt.Println(a)b := -1 >> 2 //1111 1111 => 1111 1111 => -1fmt.Println(b)c := 1 << 2 // 0000 0001 => 0000 0100 => 4fmt.Println(c)d := -1 << 2 //1000 0001 => 1000 0100 => -4fmt.Println(d)
}

六. 程序流程控制

6.1 if

Go 的 if 语句与 for 循环类似，表达式外无需小括号 ( ) ，而大括号 { } 则是必须的。

package mainimport ("fmt""math"
)func sqrt(x float64) string {if x < 0 {return sqrt(-x) + "i"}return fmt.Sprint(math.Sqrt(x))
}func main() {fmt.Println(sqrt(2), sqrt(-4))
}

同 for 一样， if 语句可以在条件表达式前执行一个简单的语句。

该语句声明的变量作用域仅在 if 之内。

package mainimport ("fmt""math"
)func pow(x, n, lim float64) float64 {if v := math.Pow(x, n); v < lim {return v}return lim
}func main() {fmt.Println(pow(3, 2, 10),pow(3, 3, 20),)
}

6.2 if 和 else

在 if 的简短语句中声明的变量同样可以在任何对应的 else 块中使用。

（在 main 的 fmt.Println 调用开始前，两次对 pow 的调用均已执行并返回其各自的结果。）

package mainimport ("fmt""math"
)func pow(x, n, lim float64) float64 {if v := math.Pow(x, n); v < lim {return v} else {fmt.Printf("%g >= %g\n", v, lim)}// 这里开始就不能使用 v 了return lim
}func main() {fmt.Println(pow(3, 2, 10),pow(3, 3, 20),)
}

6.3 switch

switch 是编写一连串 if - else 语句的简便方法。它运行第一个值等于条件表达式的 case 语句。

Go 的 switch 语句类似于 C、C++、Java、JavaScript 和 PHP 中的，不过 Go 只运行选定的 case，而非之后所有的 case。 实际上，Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。 除非以 fallthrough 语句结束，否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量，且取值不必为整数。

package mainimport ("fmt""runtime"
)func main() {fmt.Print("Go runs on ")switch os := runtime.GOOS; os {case "darwin":fmt.Println("OS X.")case "linux":fmt.Println("Linux.")default:// freebsd, openbsd,// plan9, windows...fmt.Printf("%s.\n", os)}
}

6.3.1 没有条件的 switch

没有条件的 switch 同 switch true 一样。

这种形式能将一长串 if-then-else 写得更加清晰。

package mainimport ("fmt""time"
)func main() {t := time.Now()switch {case t.Hour() < 12:fmt.Println("Good morning!")case t.Hour() < 17:fmt.Println("Good afternoon.")default:fmt.Println("Good evening.")}
}

6.3.2 switch穿透

fallthrough : switch穿透,如果在case语句块后加fallthrough ,则会执行下一个case,也叫switch穿透

//输出结果为: 当前值为10 当前值为20
func fallthroughTest() {var i int = 10switch i {case 10:fmt.Println("当前值为10")fallthroughcase 20:fmt.Println("当前值为20")case 30:fmt.Println("当前值为30")default:fmt.Println("无匹配")}
}

6.4 for

Go 只有一种循环结构：for 循环。

基本的 for 循环由三部分组成，它们用分号隔开：

初始化语句：在第一次迭代前执行
条件表达式：在每次迭代前求值
后置语句：在每次迭代的结尾执行
初始化语句通常为一句短变量声明，该变量声明仅在 for 语句的作用域中可见。

一旦条件表达式的布尔值为 false，循环迭代就会终止。

package mainimport "fmt"func main() {sum := 0for i := 0; i < 10; i++ {sum += i}fmt.Println(sum)
}

初始化语句和后置语句是可选的。

package mainimport "fmt"func main() {sum := 1for ; sum < 1000; {sum += sum}fmt.Println(sum)
}

6.4.1无限循环

如果省略循环条件，该循环就不会结束，因此无限循环可以写得很紧凑。
通常搭配break使用,来跳出循环

package mainfunc main() {for {}
}

6.4.2 for - range

func test2() {var textString string = "Hello world 你好"for index, val := range textString {fmt.Printf("index=%d val=%c \n", index, val)}
}