20分钟学会go基本语法
一、常见的五种变量声明方式
1、***种声明一个变量
var a int (a的默认值为0)
2、 第二种声明一个变量
var a int =10 (初始化了一个值结变量a, 值为10)
3、 第三种声明一个变量
var a=10 (初始化时省去了数据类型，通过值确定变量数据类型)
4、 第四种声明一个变量
a:=10 (省去var关键字和数据类型，这种也是常用写法)
5、 第五种一次声明多个变量
var (
e int = 10
f bool = true
)
声明全局变量时，前三种可用。以上声明具体事例如下：
二、Const与iota声明使用
1、声明一个const变量
const a int=10 (常量值不可以修改)
2、结合iota声明多个const变量
const(
A=10+iota
B
C
)
iota默认值为0，每行的iota值都针对累加1，A=10, B=11, C=12
以上具体事例如下：
三、函数多个返回值的三种写法
具体事例如下：
四、导入包
使用import关键字导入包
1、 单行导入
import “包目录”
2、 多行导入
import（
“包目录1”
“包目录2”
…
）
3、 给导入包定义别名，如：
import _ “fmt” （匿名别名）
import a “fmt” (别名为a)
import . “fmt” （导入全部fmt包中方法，不需要fmt点方法调用）
五、指针使用
1、什么是指针
指针变量指向了一个值的内存地址，* 号用于指定变量是作为一个指针
2、用一个例子说明指针使用，如使两个变量值互换，如下：
六、defer语句的使用
defer在一个函数执行完后在执行，相当于net里的finally函数。事例如下：
七、数组与动态数组(slice)
1、定义固定数组
var myArray [5]int (默认值0)
myArray:=[5]int{1,2} (前两个数组值分别是1,2 后三个数组值为0)
2、定义动态数组(slice)
myArray:=[]int{} (空数组)
myArray:=[]int{1,2,3} (数组长度为3)
myArray:=make([]int,3) (通过make分配一个长度为3的数组)
说明：动态数组在传参上是引用传递
3、遍历数组
for index,value:=range myArray{
fmt.Println(“index=”,index,”value=”,value)
}
4、 slice切片的追加
var numbers=make([]int,3,4) (数组长度为3，容量为4)
numbers=append(numbers,1) (向数组中添加了一个元素1，数组里的值为：0,0,0,1)
numbers=append(numbers,2) (数组里的值为：0,0,0,1,2 数组容量是在原来的基础上扩展一陪变成了8)
5、 slice切片的截取
numbers:=[]int{1,2,3}
numbers1:= numbers[0:2] (在numbers数组中从0位取两个数据，numbers1数组中的值 为1,2)
八、Map的声明与使用
1、第一种声明一个map类型
var map1 map[string]string (key是string , value是string)
map1=make(map[string]string,10) (用make给map分配数据空间)
2、第二种声明一个map类型
map1:=make(map[int]string) (key是int, value是string)
map1[1]=”sz”
map1[2]=”gz”
3、第三种声明一个map类型
map1:=map[string]string{
“one”:”sz”,
“two”:“gz”,
}
4、map遍历，添加、删除和修改操作
map1 := map[string]string{
"one": "sz",
"two": "gz",
}
map1["three"] = "hn" //添加
delete(map1, "two") //删除
map1["one"] = "cs" //修改
for _, val := range map1 { //遍历
fmt.Println("city val=", val)
}九、struct定义和使用
十、面向对象封装与继承
1、go中对象是用struct表示
总结：类名、属性名、方法名*字母大写表示对外可以访问，否则只能本包内访问
2、类的继承
3、面向对象的多态实现(子类实现父类所有接口)
十一、通用万能类型
1、 interface{} 空接口万能数据类型
func show(info interface{}){ //接收任何数据类型
fmt.Println(info)
}
func main(){
show(“hello”) //传string类型
show(10) //传int类型
}
十二、反射reflect用法
func reflectInfo(a interface{}){
fmt.Println(“type is ”,reflect.TypeOf(a)) //反射获取类型
fmt.Println(“value is ”,reflect.ValueOf(a) ) //反射获取值
}
func reflectObj(obj interface{}){
objType:=obj.TypeOf(obj)
objValue:=obj.ValueOf(obj)
for i:=0;i<objType.NumField();i++{ //获取对象里的字段
field:=objType.Field(i)
value:=objValue.Field(i).interface()
fmt.Printf(“%s %v=%v\n”,field.Name,field.Type,value)
}
}
十三、JSON序列化与反序列化
type Animal struct {
Name string `json:"name""` //定义JSON字段名称
Color string `json:"color"`
Age int `json:"age"`
}
func main() {
animal := Animal{"dog", "white", 5}
jsonStr, err := json.Marshal(animal) //将结构体序列化成JSON
if err != nil {
fmt.Println("json.Marshal error ", err)
return
}
fmt.Printf("jsonStr = %s\n", jsonStr)
dogAnimal := Animal{}
json.Unmarshal(jsonStr, &dogAnimal) //将JSON反序列化成结构体
fmt.Println("json.Unmarshal dogAnimal name=", dogAnimal.Name)
}十四、创建goroutine
func newTask() {
i := 0
for {
i++
fmt.Println("i=", i)
time.Sleep(1 * time.Second) //防止程序执行过快，睡1秒
}
}
func main() {
go newTask() //创建一个线程执行,不影响主线程往下执行
j := 0
for {
j++
fmt.Println("j=", j)
time.Sleep(1 * time.Second) //防止程序执行过快，睡1秒
}
}
十五、channel定义与使用
func main() {
channel := make(chan int) //定义一个int类型 channel
go func() {
defer fmt.Println(" go func end")
fmt.Println("goroutime .....")
channel <- 100 //往channel里写入数据
}()
num := <-channel //往channel里读出数据
fmt.Println("c=", num)
}
免责声明：本站所有内容及图片均采集来源于网络，并无商业使用，如若侵权请联系删除。
上一篇：干货 | Go语言学习方法总结
