(go的使用教程)(大疆go4使用教程)

一、常见的五种变量声明方式

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)

}