由于最近想自学区块链搭建的知识，所以先入门了Go语言，以下是一些笔记，在适当位置会对我比较熟悉的Java语言做一个比较，加深记忆；
一、Go语言的特点
1. 运行效率高，开发高效，部署简单；
2. 语言层面支持并发，易于利用多核实现并发；
3. 内置runtime（作用：性能监控，GC等）；
4.简单易学，丰富的标准库，强大的网络库；
5.内置强大的工具（gofmt），跨平台编译，内嵌C支持；
二、Go语言的应用
1.服务器编程，如处理日志，数据打包，虚拟机处理，文件系统等
2.分布式系统，数据库代理器，中间件等；
3.网络编程，web应用，Api应用
4.云平台
三、Go语言命令行工具介绍
四、Go语言基础语法
1. 关键字、标识符、注释、基础结构
| Go语言关键字 | ||||
| break | default | func | interface | select |
| case | defer | go | map | struct |
| chan | else | goto | package | switch |
| const | fallthrought | if | range | type |
| continue | for | import | return | var |
| Go标识符 | |||||
| append | bool | byte | cap | close | complex |
| complex64 | complex128 | uint16 | copy | false | float32 |
| float64 | imag | int | int8 | int16 | uint32 |
| int32 | int64 | iota | len | make | new |
| nil | panic | uint64 | println | real | |
| recover | string | TRUE | uint | uint8 | uintprt |
// 单行注释
/*
多行注释
*/2.基础结构详解
//程序第一行一定要package开头，声明所属的包
package main
//导入引用
import "fmt"
//常量定义,类型放在变量名后
const NAME string = "test"
//全局变量的声明与赋值
var a string = "eanam"
//一般类型声明
type TestInt int
//结构声明
type Learn struct{
}
//接口声明
type ILearn interface{
}
//函数定义
func LearnGo() {
}
//main函数
func main() {
}3. package的用法
（1）package是最基本的分发单位和工程管理中依赖关系的体现；
（2）每个Go语言源代码文件开头都拥有一个package声明，表示源码文件所属的代码包
（3）要生成Go语言可执行程序，必须要有main的package包，并且该包下有main()函数
（4）同一个路径下只能存在一个package，一个package可以拆成多个源文件组成
4. import的用法
（1）import语句可以导入源代码文件所依赖的package包
（2）不得导入源代码文件中没有用到的package，否则Go语言编译器会报编译错误
//格式1：
import "A"
import "B"
//格式2：
import （
"A"
"B"
）5. import的原理
（1）如果一个main导入其他包，包将按顺序导入；
（2）如果导入的包中有依赖其他包（包B），会首先导入B包，然后初始化B包中的常量和变量，最后如果B包中有init，会自动执行init();
（3）所有包导入完成后才会对main中常量和变量进行初始化，然后执行main中的init函数（如果存在），最后才执行main函数；
（4）如果一个包被导入多次则该包只会被导入一次；
6. import 别名、“.”、“_”
（1）将导入的包命名为另一个容易记忆的别名；
（2）“.”的含义是：“.”标识的包导入后，调用该包函数时可以省略前缀包名；
（3）“_”的含义是：导入该包，但不导入整个包，而是执行该包中的init函数，因此无法通过包名来调用包中的其他函数。使用“_”操作往往是为了注册包内的引擎，让外部可以方便地使用。
//演示
import(
alias "fmt" //alias.Print()
. "fmt" //Print()
_ "fmt"
)7. Go语言的数据类型
（1）数值类型、字符类型和布尔型
| 数值类型 | ||||||
| 整型 | 1 | uint8 | 无符号8位整型（0到255） | |||
| 2 | uint16 | 无符号16位整型（0到65535） | ||||
| 3 | uint32 | 无符号32位整型（0到4294967295） | ||||
| 4 | uint46 | 无符号64位整型（18446744073709551615） | ||||
| 5 | int8 | 有符号8位整型（-128到127） | ||||
| 6 | int16 | 有符号16位整型（-32768到32767） | ||||
| 7 | int32 | 有符号32位整型（-2147483648到2147483647） | ||||
| 8 | int64 | 有符号64位整型 | ||||
| 浮点型 | 1 | float32 | 32位浮点型数 | |||
| 2 | float64 | 64位浮点型数 | ||||
| 3 | complex32 | 32位实数和虚数 | ||||
| 4 | complex128 | 64位实数和虚数 | ||||
| 其他数值类型 | 1 | byte | 类似uint8 | |||
| 2 | rune | 类似int32 | ||||
| 3 | uint | 32位或64位 | ||||
| 4 | int | 与uint一样大小 | ||||
| 5 | uintptr | 无符号整型用于存放一个指针 | ||||
（2）派生类型
| 派生类型 | ||
| 指针类型 | Pointer | |
| 数组类型 | ||
| 结构化类型 | struct | |
| Channel类型 | chan | |
| 函数类型 | func | |
| 切片类型 | slice | |
| 接口类型 | interface | |
| Map类型 | map | |
（3）类型零值和类型别名
A. 类型零值不是空值，而是某个变量被声明后的默认值，一般情况下，值类型的默认值为0，布尔型默认值为
false，string默认值为空字符
B. 我们可以对类型设置别名，如下：
type alias int（4）类型所占存储大小
五、Go语言变量概念
1. 变量与常量
//变量声明：初始化与赋值
/*
单个变量的声明与赋值
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关键词，局部变量可以省略
特殊变量下划线"_"
*/
/*
变量的类型转换：
1）Go中不存在隐式转换，类型转换必须是显式的；
2）类型转换只能发生在两种兼容类型之间；
3）类型转换格式：<变量名称> [:]= <目标类型>(<需要转换的变量>)
*/
//变量可见性规则
/*
1）大写字母开头的变量的可导出，也就是其他包可以读取的，是公共变量
2）小写字母开头的就是不可导出，是私有变量
*/
//常量：常量声明与iota的使用
/*
1) 常量定义形式：
显式：const identifier [type] = value
隐式：const identifier = value(通常叫无类型常量)
2）常量类型范围
目前只支持布尔型、数字型（整数型、浮点型和复数）和字符串型；不支持派生类型
3）特殊常量iota的用法
iota在const关键字出现时将被重置为0
const组合声明时每增加一行常量声明将使iota计数一次（同一行iota一样）
iota常见使用法：
1）跳值使用法
const(
a = iota
b = iota
c int = iota
_
//可省略iota
d
)
2）插队使用法
const(
a = iota
b = iota
c int = iota
k = 2.14
//可省略iota
d = iota
)
3）表达式隐式使用法
如果没有显示赋值，则会继承上一个表达式的右式
4）单行使用法
*/六、Go语言运算符
（1）算术运算符（++、--只能放在变量后面）
（2）关系运算符
（3）逻辑运算符
（4）按位运算符
（5）赋值运算符
七、Go语言控制语句
（1）条件语句： if-else语句
package main
import "fmt"
func main() {
a := 2
if a > 0{
if a > 3{
fmt.Println("a > 3")
}
fmt.Println("a > 0")
}else {
fmt.Println("a < 0")
}
}（2）选择语句：switch语句
package main
import "fmt"
func main() {
a := 2
//演示简单匹配
switch a {
case 1:
fmt.Println(" a is 1")
case 2:
fmt.Println(" a is 2")
case 3:
fmt.Println(" a is 3")
default:
fmt.Println(" a is not in range")
}
//演示type-switch
var b interface{}
b = 3.14
switch b.(type) {
case int:
fmt.Println("b is int")
case float64:
fmt.Println("b is float64")
default:
fmt.Println("unsuitable type")
}
}
（3）循环语句：for语句
package main
import (
"fmt"
)
func main() {
//无限循环
for {
fmt.Println("this is unlinited circle")
}
//简单用法
for i := 0; i < 10;i++{
fmt.Println("--------",i)
//time.Sleep(1*time.Second)
}
//实现佛reach效果
a := []string{"banana","peach","apple"}
for key,value := range a{
fmt.Println(key,"-",value)
}
}
（4）goto、break、continue
package main
import (
"fmt"
"time"
)
func main() {
var j = 0
i := 0
/*
goto跳到指定步骤
无限循环打印：this is code 1
*/
goto Three
fmt.Println("demo is start")
One:
fmt.Println("this is code 1")
time.Sleep(1*time.Second)
goto One
/*break停止当前循环
打印两次break demo
*/
for {
fmt.Println("break demo")
i++
if i == 2 {
fmt.Println("doing break")
break
}
}
/*continue结束本次循环，直接进入下一轮循环
不打印continue demo2，
*/
Three:
for {
j++
if j == 2 {
fmt.Println("doing continue")
continue
}
fmt.Println("continue demo",j)
time.Sleep(1*time.Second)
}
}