提示

我的 Go 语言入门之路也是曲曲折折，不过经过两三次学习又放下，放下重捡起的过程之后，终于能有一些小积累，现在的感受，想想其实跟 Linux 命令，shell 脚本是一个道理，一开始各种死记硬背，不需要理解太多，这也是需要的阶段，再到后来的掌握方法，只记得大概，再到后来彻底不再记，用好百度谷歌即可。 说到底就一句话，要多听，多看，多写，多练，多交流，无他，唯求手熟耳！ 以下学习笔记是学习过程中整理，大多参考如下两位老师：

• Mike 江 (opens new window)
• 李文周 (opens new window)

通过观看他们的视频以及博客，算是系列性的将 go 语言基础内容串了下来，再次感谢二位！

接下来进入个人整理笔记分享，只为以后回头翻看方便。

Go 语言中包含了大量用于处理 Go 语言代码的命令和工具。其中，go 命令是最常用的一个，它有许多参数可以使用，如下所示：

• build：用于编译给定的代码包或 Go 语言源码文件及其依赖包。
  • go build -o "xx.exe" :编译成 xx.exe 文件
• clean：用于清除执行其他 go 命令后遗留的目录和文件。
• doc：用于执行 godoc 命令以打印指定代码包。
• env：用于打印 Go 语言环境信息。
• fix：用于执行 go tool fix 命令以修正给定代码包的源码文件中包含的过时语法和代码调用。
• fmt：用于执行 gofmt 命令以格式化给定代码包中的源码文件。
• get：用于下载和安装给定代码包及其依赖包（提前安装 git 或 hg）。
• list：用于显示给定代码包的信息。
• run：用于编译并运行给定的命令源码文件。
• install：编译包文件并编译整个程序。
• test：用于测试给定的代码包。
• tool：用于运行 go 语言的特殊工具。
• version：显示当前安装的 go 语言的版本信息。

1，包的概念

• 1，和 Python 一样，把相同功能的代码放到一个目录，称之为包。
• 2，包可以被其他包引用。
• 3，main 包是用来生成可执行文件，每个程序有且只有一个 main 包。
• 4，包的主要用途是提高代码的可复用性。

输出一个 hello world。

//1)go语言以包作为管理单位
//2)每个文件必须先声明包
//3)程序必须有一个main包（重要）

package main

//go语言以双斜杠作为注释的标识
/*
	这是块注释
	可以多段注释
*/

import "fmt"

//入口函数，有且只有一个
func main() { //左括号必须与函数名同行，否则会报错
	//打印
	//“hello go"打印到屏幕，Println()会自动换行
	//调用函数，大部分都需要导入包
	fmt.Println("hello go") //go语言结尾没有分号
	fmt.Println("hello haha")
}

2，变量的声明。

package main

import "fmt" //导入就必须使用，否则会报错

func main() {
	/*
			1,声明格式 var 变量名 类型，变量声明了，必须使用，否则会报错
		    2，只是声明而没有赋值的变量，默认值为0
			3，同一个{}当中，变量名是唯一的，不能重复
	*/
	var a int
	fmt.Println("a = ", a)

	//4,可以同时声明多个变量，方式如后： var b,c int，多个变量用逗号隔开

	a = 10
	fmt.Println("a = ", a)

	//5,变量的初始化，声明变量的同时赋值
	var b int = 10 //初始化，声明变量时，同时赋值
	b = 20
	fmt.Println("b = ", b)

	//6,自动推导类型，必须初始化，程序通过初始化的值确定类型（常用）
	c := 30
	fmt.Printf("c type is %T\n", c)

}

3，printf 和 println 的区别。

package main

import "fmt"

func main() {
	a := 10

	fmt.Println("a = ", a) //一段一段处理，自动加换行

	fmt.Printf("a = %d\n", a) //格式化输出，把a的内容放在%d的位置，也就是将"a = 10\n"这个字符串输出到屏幕，”\n带边换行符“

	b := 20
	c := 30
	fmt.Println("a = ", a, ",b = ", b, ",c = ", c)
	fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}

4，多重赋值与匿名变量。

多重赋值的代码如下：

package main

import (
	"fmt"
)

func main() {
	//多变量传统赋值方式
	/*
		a := 10
		b := 20
		c := 30
		fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
	*/

	//可以直接写成如下方式
	/*
		a, b, c := 10, 20, 30
		fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
	*/

	//交换两个变量的值得传统方式
	/*
		a, b := 10, 20
		var tmp int
		tmp = a	//创建一个临时变量，然后把a的值存起来，然后利用临时变量进行过渡
		a = b
		b = tmp
		fmt.Printf("a = %d, b = %d\n", a, b)
	*/

	//而在go当中，可以用如下方式表示
	i, j := 10, 20
	i, j = j, i	//直接交换两者的位置即可
	fmt.Printf("i = %d, j = %d\n", i, j)
}

匿名变量的代码如下：

package main

import "fmt"

//go函数可以返回多个值，简单写法如下

func test() (a, b, c int) {
	return 1, 2, 3
}

func main() {
	var a, b, c int
	a, b, c = test() //表示将上边定义的test函数值赋给abc。
	fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)

	//而如果此时只想要部分值，而非全部的，可以使用匿名变量‘_’
	//'_'匿名变量，表示丢弃数据不处理，匿名变量匹配函数多返回值时，很有优势
	//比如我只想要b的值，可以用如下方式：

	_, b, _ = test()
	fmt.Printf("b = %d\n", b)
}

5，常量的使用。

package main

import "fmt"

func main() {
	/*
		变量：是指程序运行期间，可以改变的量。变量声明的关键词是var。
		常量：是指程序运行期间，不能变量的量。常量声明的关键词是const。
	*/
	const a int = 10
	//a = 20 //err,a已被定义为常量，不能更改
	fmt.Println("a = ", a)

	//常量也可以使用自动推导类型来定义
	//但是不能使用:=的方式，否则会报错。
	const b = 10 //不能使用:=
	fmt.Println("b = ", b)

	const c = 10.2
	fmt.Printf("c type is %T\n", c) //%T表示变量的类型
}

6，多个不同类型的变量或常量的定义

package main

import (
	"fmt"
)

func main() {
	//不同类型变量的定义

	/*传统方式
	var a int = 1
	var b float64 = 2.0
	*/

	//另一种方式
	//	var (
	//		a int = 1
	//		b float64 =2.0
	//	)

	//其实类型可以省略，程序自动推导
	var (
		a = 10
		b = 3.14
	)
	fmt.Println("a = ", a)
	fmt.Println("b = ", b)

	//不同类型的常量的定义

	//传统方式
	//	const i int = 10
	//	const j float64 = 3.14
	//注释某段的快捷键，选中代码，按Ctrl+ /

	//另一种方式
	//	const (
	//		i int     = 10
	//		j float64 = 3.14
	//	)

	//其实类型可以省略，程序自动推导
	const (
		i = 10
		j = 3.14
	)
	fmt.Println("i = ", i)
	fmt.Println("j = ", j)

}

7，iota 枚举。

package main

import "fmt"

func main() {
	// 1，iota的功能是常量生成器，每隔一行，自动累加1
	// 2，iota给常量赋值使用

	const (
		a = iota //1
		b = iota //2
		c = iota //3
	)
	fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)

	//3，多个iota时，可以只写一个。效果与上边的一样
	const (
		a1 = iota
		b1
		c1
	)
	fmt.Printf("a1 = %d, b1 = %d, c1 = %d\n", a1, b1, c1)

	//4，iota再次遇到cost，将会重置为0
	const d = iota //0
	fmt.Println("d =", d)

	//5，如果在同一行，那么值都一样
	const (
		i          = iota
		j1, j2, j3 = iota, iota, iota
		k          = iota
	)
	fmt.Printf("i = %d, j1 = %d, j2 = %d, j3 = %d, k = %d\n", i, j1, j2, j3, k)
}