本文档为Go语言初学者提供了一套简洁实用的学习指南，涵盖了Go语言的基本命令、语法、数据类型、变量常量定义、运算符及控制语句等内容。
没有继承的OO，强一致类型，Interface但是不需要显示申明(Duck Type)，Function 和Method，没有异常处理(Error is value)，基于首字母的可访问特性，不用的Import或者变量引起编译错误，完整而卓越的标准库包......go语言的 这些特点，是不是激发了你的兴趣呢，go语言作为一门新兴的语言，以其独有的特点受到很多人的青睐，笔者将自己在学习go语言的过程中的笔记整理下来，作为一个最基本的入门资料，希望对想学习go语言的0基础的人有所帮助。
作者：MrCtrlc 时间：2018
*********************************
第一章：go语言基本命令
go build 用于编译源码文件、代码包、依赖包
go run 可以编译并运行go 源码文件
go get 命令主要是用来动态获取远程代码包的
第二章：go语言基础语法
【注释形式】
//单行注释
/* ... ...*/多行注释
注意：一般用单行注释较多
【程序基本结构】
常量声明：const +大写的常量名字+类型名字=...
变量声明：var +小写的变量名字+类型名字=...
类型别名：type 别名 类型
结构体： type 名字 struct{}
接口： type I名字 interface{}
函数定义：func 名字（）{}
main函数：func main(){}
【packeg的用法】
package是最基本的分发单位和工程管理中依赖关系的体现
每个go语言的源代码文件的开头都拥有一个package声明，表示源码文件所属的代码包，要注意的是每个目录下的go文件最好都是一个包名字，且这个名字和目录名字一样。
要生成go语言可执行程序，必须要有main的package包，且必须在该包下有main（）函数
同一个路径下只能存在一个package，一个package可以拆成多个源文件组成，源文件就是所说的go文件，也就是一个包里面有多个go文件。
【import的用法】
import语句可以导入源码文件所依赖的package包；
不得导入源码文件中没有用到的package，否则go语言编译器会报编译错误
import语法格式有两种：
第一种：
import “package1”
import “package2”
import “package3”
...
第二种：
import （
“package1”
“package2”
“package3”
....
【import 的基本原理】
如果一个main导入其他包，包将被顺序导入
如果导入的包中以来其他包（包B），会首先导入B包，然后初始化B包中的常量与变量，最后如果B中有init，会自动执行initial（）；
所有包到入完成之后才会对main中常量和变量进行初始化，然后执行main中的init函数（如果存在），最后执行main函数；
如果一个包被导入多次则该包只会被导入一次；
【import别名，".","_"】
别名操作的含义是：将导入的包命名为另一个容易记忆的别名
点（.）操作的含义是：点（.）标识的包导入后，调用该包中函数时可以省略前缀包名；
下划线（_）操作的含义是：导入该包，但不导入整个包，而是执行该包中的init函数，因此无法通过包名来调用包中其他的函数。使用下划线（_）操作往往是为了注册包里的引擎，让外部可以方便地使用；
第三章：go语言数据类型
【数据类型】
数值类型，字符类型和布尔类型；
派生类型；
类型零值和类型别名
类型所占存储大小
【数值类型】
整形、浮点型、复数、字符串、和布尔型
数据内存的出现是为了把数据分成所需内存大小不同的数据，编程的时候需要用大数据的时候才需要申请大内存，就可以充分利用内存。
布尔的值只可以是常量true或者false
字符串类型string，统一编码为“UTF-8”.
uint8；无符号8位整型
uint16；无符号16位整型
uint32；无符号32位整型
uint64；无符号64位整型
int8；有符号8位整型
int16；有符号16位整型
int32；有符号32位整型
int64；有符号64位整型
float32 32位浮点型数
float64 84位浮点型数
complex64 32位实数和虚数
complex128 64位实数和虚数
byte 类似uint8
rune 类似int32
uint 32位或64位（具体大小根据每个计算机的操作系统大小来定）
int 与uint一样大小
uintptr 无符号整型，用于存放一个指针
【派生类型】
指针类型（pointer）
数组类型
结构化类型（struct）
Channel类型（chan）
函数类型（func）
切片类型（slice）
接口类型（interface）
Map类型（map）
【类型零值和类型别名】
类型零值不是空值，而是某个变量被声明后的默认值，一般情况下，值类型默认值为0，布尔型默认值为false，string默认值为空字符串（就是什么也没有）；
我们可以对类型设置别名，但是别名和原数据类型的类型不一样，比如说type 别名 int16 （这时用别名定义的变量和用int16定义的变量不可以一起运算，而全部用别名定义的变量可以）
第四章 go语言变量和常量
【单个变量的声明和赋值】
1.变量的声明格式：var<变量名称>[变量类型]
2.变量的赋值格式：<变量名称>=<值，表达式，函数等>
3.声明和赋值同时进行：var<变量名称>[变量类型]=<值，表达式，函数等>
4.分组声明格式：
var（
i int
j float32
name string
)
同一行声明多个变量和赋值：var a,b,c int =1,2,3 或者a,b:=1,2
全局变量的声明必须使用var关键字，局部变量则可以省略
特殊变量下划线"_"，相当于一个装数据的垃圾桶
go中不存在隐式转换，类型转换必须是显式的
类型转换只能发生在两种兼容类型之间
类型转换格式：<变量名称>[：]=<目标类型>（<需要转换的变量>）
大写字母开头的变量是可导出的，也就是其他包可读取的，是公用变量：
小写字母开头的就是不可导出的，是私有变量
var a,b,c int =1,2,3 可以变成 var a,b,c =1,2,3 （省略类型） 还可以变成 a,b,c ：=1,2,3（省略掉var）
不过要注意的是：var只能在函数体内做局部变量时省略，而数据类型都可以省略
"_"相当于一个垃圾桶，把不要的值丢到垃圾桶里
【常量的声明和赋值】
常量的定义充形式上可分为显示和隐式：
显示：const identifier [type] =value
隐式 ：const identifier =value（通常叫无类型常量）
常量可以提使用内置表达式定义：如：len（），unsafe.Sizeof（）等
常量范围目前只支持布尔型、数字型、（整数型、浮点型和复数）和字符串型
常量可以一次多行声明并赋值：
Const(
cat string ="cat"
dog ="dog"
)
常量也可以单行声明并赋值：
const apple，banana string=”红色“，”白色“
const a,b=1,"你好"(隐式声明常量会自动识别数据类型)
UTF8每个汉字占三个字节大小
【特殊常量iota的使用】
iota在const关键字出现时将被重置为0；
const中每新增一行常量声明将使iota计数一次，注意是一行，一行声明多个常量也只增加一次
iota常见使用方法：
1.跳值使用法：
2.插队使用法：
3.表达式隐式使用法
4.单行使用法
iota只能在常量定义时候使用，不可以在别的函数里使用
【iota跳值使用法】
原来的定义：
const（
a=iota//a=0
b=iota//b=1
c=iota//c=2
)
如果想将c变为3，可以用"_"（变量声明的时候它相当于垃圾桶，常量iota使用的时候它具有使iota加1的功能）
const（
a=iota//a=0
b=iota//b=1
_
c=iota//c=3
)
【插队使用法】
const（
a=iota//a=0
b=2
c=iota//c=1
)
就是说不连续用iota赋值，中间插入另外的常量，这就是插队使用法
【表达式隐式使用法】
const（
a=iota*2//a=0
b //b自动被赋值为iota*2==1*2==2
c //b自动被赋值为iota*2==2*2==4
)
没有赋值表达式的时候，会被自动赋值为上面遇到的第一个表达式
【单行使用法】
const（
a,b=iota，iota+3//a=0,b==0+3==3
c,d //c=iota==1,d=iota+3==1+3==4
f=iota //f==iota==2
)
注意是每一行，iota只加1，不管这一行声明了多少常量
第五章：go语言运算符
+ 添加两个操作数 A+B
- 从第一个操作数中减去第二个操作数
* 将两个操作数相乘
/ 将分子除以分母
% 模数运算符，整数除法的余数 B%A
++ 增加（递增）运算符，将整数值加一 A++
-- 相减（递减）运算符，将整数值加一 A--
注意：在go语言中，++和--只能在后边用
== 检查两个操作数的值是否相等，如果相等，条件为真。
！= 检查两个操作数的值是否相等，如果不想等，则条件为真。
> 检查左操作数的置是否大于右操作数的值。如果是，则条件为真。
< 检查左操作数的置是否小于右操作数的值。如果是，则条件为真。
>= 检查左操作数的置是否大于或等于右操作数的值。如果是，则条件为真。
<= 检查左操作数的置是否小于或等于右操作数的值。如果是，则条件为真。
&& 逻辑与运算符。如果两个操作数都不为零，则条件为真。
|| 逻辑或运算符。如果两个操作数中的任何一个非零，则条件变为真。
！ 逻辑非运算符。用于反转其操作数的逻辑状态。如果条件为真，则逻辑非运算符将为假。
& 按位与:都为1则结果为1;
| 按位或:有一个为1结果为1;
^ 按位异或:对应位不同数值时结果为1
<< 左移: 把数整体向左移动;
>> 右移:把数整体向右移动;
= 表达式的值赋给一个左值
+= 相加后再赋值
-= 相减后再赋值
*= 相乘后再赋值
/= 相除后再赋值
%= 求余后再赋值
<<= 左移后再赋值
>>= 右移后再赋值
&= 按位与后再赋值
^= 按位异或后再赋值
|= 按位或后再赋值
第六章：go语言控制语句流程
if..else..条件语句：
func main (){
a:=3
if a>1{
fmt.printf(a:"a是大于1的！")
if a<4{
fmt.printf(a:"a是小于4的！")
}
注意：这里与其他语言不同的是条件没有括号
switch选择语句：
func main(){
var a interface{}
a=32
switch a.(type){
case int:
fmt.printf(a:"类型为整数")
case string:
fmt.printf(a:"类型为字符串")
default:
fmt.printf(a:"都不是！")
}
}
for控制语句：
func main(){
for{
fmt.printf(a:"你好\n")
time.Sleep(1*time.second)
}
}
注意：这时候无限循环，每隔一秒打印一次
func main(){
for i:=1;i<=10;i++{
fmt.printf(a:"你好\n")
time.Sleep(1*time.second)
}
}
注意：这时候打印十次，每隔一秒打印一次
func main(){
a:=[]string{“红色”，“蓝色”，“白色”}
for key,value:=range a{
fmt.printf(a:"key的值为\n")
fmt.printf(key)
fmt.printf(a:"\n")
fmt.printf(a:"value的值为\n")
fmt.printf(value)
fmt.printf(a:"\n")
}
}
注意：这样实现了遍历，key为下标，如果用不上下标，那就用"_"代替key
goto：
func main(){
goto one
fmt.printf(a:"代码块一\n")
one：
fmt.printf(a:"这是代码块二\n")
}
}
注意：这时候只会打印”这是代码块一“
break：终止当前循环
continue：跳出本次循环，执行下一个循环
结束语：以上内容为笔者根据学习过程中的记录加上自己的理解整理出的一个简单的笔记，其他部分的内容将会持续更新。
扫一扫
1611
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
