基础语法

基本介绍（HelloWorld）

Go 是一个开源的编程语言，它能让构造简单、可靠且高效的软件变得容易。

语言特色

• 简洁、快速、安全
• 并行、有趣、开源
• 内存管理、数组安全、编译迅速

Go 语言用途

Go 语言被设计成一门应用于搭载 Web 服务器，存储集群或类似用途的巨型中央服务器的系统编程语言。 对于高性能分布式系统领域而言，Go 语言无疑比大多数其它语言有着更高的开发效率。它提供了海量并行的支持，这对于游戏服务端的开发而言是再好不过了。

HelloWorld

package main
import "fmt"
// main函数主要入口函数 
func main() { 
    fmt.Println("HelloWorld") 
}   

变量

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。

1、标准定义

//var 名称 类型 
var Name string 
//var 名称 类型 = 数据 
var Name string = ""

2、类型推断

//var 名称 = 数据 
var Name = ""

3、简便定义

//只在函数中才可以定义 
//名称 := 数据 
Name := ""

4、同时定义多个变量

//var 变量名1,变量名2 = 数据1, 数据2 
var Name1, Name2 = "", "" 
// 变量名1,变量名2 := 数据1, 数据2 
Name1, Name2 := "", "" 
//var 变量名1,变量名2 数据类型 = 数据1, 数据2 
var Name1, Name2 string = "", ""

常量

1、标准定义

//const 名称 类型 = 数据 
const Name string =""

2、类型推断

//const 名称 = 数据 
const Name = ""

3、同时定义多个变量

//var 变量名1,变量名2 = 数据1, 数据2 
const Name1, Name2 = "", "" 
//var 变量名1,变量名2 数据类型 = 数据1, 数据2 
const Name1, Name2 string = "", ""

判断（ifelse）

常量是一个简单值的标识符，在程序运行时，不会被修改的量。 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。

1、普通使用

var num int 
if num > 0 { 
    //内容 
} else {
    //内容 
}

2、连续使用

var num int 
if num > 0 { 
    //内容 
} else if num == 0 {
    //内容 
}else{
    //内容 
}

循环

go中只有for循环没有其他循环

1、for{}死循环

num := 0 
for { 
    num++ 
    if num > 10 {
        break 
    } 
}

2、条件循环

num := 0 
for num < 10 { 
    num++ 
}

3、递增循环

for num := 0; num < 10; num++ { 

}

goto循环

num := 0 
LOOP:for { 
    num++ 
    if num = 10 {
        goto LOOP
    } 
}

Switch

case内的方法体中不需要添加break也可跳出Switch

1、正常使用

num := 0
switch num { 
    case 1:{ 
        fmt.Println("1") 
    } 
    case 2:{ 
        fmt.Println("2") 
    } 
    case 3: 
        fmt.Println("3") 
        fmt.Println("==") 
    case 4: 
        fmt.Println("4") 
    default: 
        fmt.Println("default") 
    }

2、代替ifelse

num := 10 
switch { 
    case num < 10: 
        println("10") 
    case num < 20: 
        println("20") 
    default: 
        println("default") 
    }

数组

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整型、字符串或者自定义类型。

相对于去声明 number0, number1, ..., number99 的变量，使用数组形式 numbers[0], numbers[1] ..., numbers[99] 更加方便且易于扩展。

数组元素可以通过索引（位置）来读取（或者修改），索引从 0 开始，第一个元素索引为 0，第二个索引为 1，以此类推。

定义数组

//var 名称 [数量]类型 
var list [5]int
//修改数组内的数值 
list[4] = 10
//名称 :=[数量]类型{数据1,数据2,数据3,....} 
//不得超过最大数量 
list :=[5]int{1,2,3,4,5}

定义二维数组

var list [5][5]int 
list :=[5][5]int{ 
        {1,2,3,4,5}, 
        {1,2,3,4,5}, 
        {1,2,3,4,5}, 
        {1,2,3,4,5}, 
        {1,2,3,4,5}, 
    }

切片

Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片("动态数组")，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

1、定义切片

//var 名称 = make([]类型,初始空间大小) 
var list = make([]int,3) 
//var 名称 []类型 = make([]类型,初始空间大小) 
var list []int=make([]int,3)

2、类型推断

//名称 := make([]类型,初始空间大小) 
list := make([]int,3) 
//名称 := []类型{数据1,数据2,数据3,....} 
list := []int{1,2,3}

3、切片添加数据

//变量=append(切片, 数据1,数据2,数据3,....) 
list=append(list,1,2,3 )

4、切片截取

//变量 = 切片[起始:结束+1] 
list1 := list[0:5]

map的使用

Map 是一种无序的键值对的集合。

Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，遍历 Map 时返回的键值对的顺序是不确定的。

在获取 Map 的值时，如果键不存在，返回该类型的零值，例如 int 类型的零值是 0，string 类型的零值是 ""。

Map 是引用类型，如果将一个 Map 传递给一个函数或赋值给另一个变量，它们都指向同一个底层数据结构，因此对 Map 的修改会影响到所有引用它的变量。

定义

//定义 
//var 名称 = make(map[类型]类型) 
var maps = make(map[string]int) 

// var 名称 map[类型]类型 = make(map[类型]类型) 
var maps map[string]int=make(map[string]int) 

//var 名称 = map[类型]类型{key1:value1,key2:value2,key3:value3,....} 
var maps = map[string]string{"张三":"1","李四":"2"} 

//名称 := map[类型]类型{key1:value1,key2:value2,key3:value3,....} 
maps := map[string]string{"张三":"1","李四":"2"} 

//名称 := make(map[类型]类型) 
maps :=make(map[string]int)

//存值 
//变量[key]=数据 
maps["张三"]=10 
maps["李四"]=10 

//取值 
//数据,ok=变量[key] 
v,ok:=maps["张三"] 

//删除 
//delete(变量,key) 
delete(maps,"张三")

range的使用

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。

maps := map[string]string{"张三":"1","李四":"2"} 
for k,v := range maps{ 
    fmt.Println(k,v) 
} 

list := []int{1,2,3} 
for i,num := range list{ 
    fmt.Println(i,num) 
}

函数

函数是基本的代码块，用于执行一个任务。

函数定义

// fun 名称 (变量1 类型,变量2 类型) (类型,类型){ 
//} 
// fun 名称 (变量1 类型,变量2 类型) 类型{ 
//} 
func Add(a int , b int) int { 
    return a+b 
} 
func main() { 
    Add(1,2) 
}

指针

Go 语言中指针是很容易学习的，Go 语言中使用指针可以更简单的执行一些任务。

接下来让我们来一步步学习 Go 语言指针。

我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

func Add(a *int) { 
    *a=*a+10 
} 
//变量->指针(&) 
//指针->变量(*) 
func main() { 
    num :=10 Add(&num) 
}

结构体的使用

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

//结构体的使用 
type Person struct { 
    Name string 
    Age string 
} 
func main() { 
    a :=Person{Name: "", Age: ""} 
    b :=Person{"", ""} 
    c :=Person{Name: ""} 
    d :=Person{Age: ""} 
    e := Person{} 
    e.Age="12" 
    d.Age="12" 
}

结构体的方法

//结构体的方法 
type Person struct { 
    Name string 
    Age string 
} 

func (receiver Person) Add1() {
    //不可修改结构体的值 
} 

func (receiver *Person) Add2() { 
    //可以修改结构体的值 
} 

func main() {

}

错误处理

//错误处理 
type Person struct { 
    Name string 
    Age string 
} 
func (receiver Person) Add1() (int,error){ 
    return 0,errors.New("错误") 
} 
func (receiver *Person) Add2() (int,error) { 
    return 10,nil 
} 
func main() { 
    n,err:=Person{}.Add1() 
    n,_:=Person{}.Add2() 
}