Go语言基础语法学习笔记[3]



数组：

声明：

var variable_name [SIZE]variable_type

注意：数组长度是固定不能改变的

一维数组举例：

var arr1 [10]int

arr1[0] = 10

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

var arr3 = [...]int{1,2,3,4,5,6}

fmt.Println(arr1, arr2, arr3)

var n, m int = arr2[4], arr3[2]

fmt.Println(n, m)

多维数组声明：

var variable_name[SIZE1][SIZE2]...[SIZEN] variable_type

二维数组初始化举例：

var arr = [2][3]int {{1, 2, 3}, {4, 5, 6}}

数组传参：

func CalcAverage(nums []float32, len int) float32 {

    var totalfloat32 = 0

    for i := 0;i < len; i++ {

        total +=nums[i]

    }

    return total/ float32(len)

}

var nums = []float32{1,2,7,4,19}

fmt.Println(CalcAverage(nums, 5))

多维数组传参：

func CalcMax(nums [][]int, len1 int, len2 int) []int {

    var maxL int= 0;

    var maxValint = 0;

    for i := 0;i < len1; i++ {

        total :=0;

        for j :=0; j < len2; j++ {

           total += nums[i][j]

        }

        ifmaxVal < total {

            maxL= i

           maxVal = total

        }

    }

    returnnums[maxL]

}

var arr = [][]int {

    {1, 2, 3},

    {4, 5, 6}}

fmt.Println(CalcMax(arr, 2, 3))
 

指针：

声明：

var var_name *var-type

空指针：nil

指针的指针：

var a int = 10

var ptr *int = &a

var pptr **int = &ptr

fmt.Println(a, *ptr, **pptr)

函数传参：

var a, b int = 1, 2

func (x, y *int) {

    var temp int= *x

    *x = *y

    *y = temp

} (&a, &b)

fmt.Println(a, b)
 

结构体：

定义：

type struct_variable_type struct{
   member definition;
   member definition;
   ...
   member definition;

}

variable_name :=structure_variable_type {value1, value2...valuen}

访问结构体成员使用“.”运算符，结构体指针访问结构体成员也使用“.”运算符

例如：

type Student struct {

    name string

    id int

}

 

func GetStudentInfo(s *Student) {

   fmt.Println("name: ", s.name)

   fmt.Println("id: ", s.id)

}

 

s1 := Student {"Daniel", 1}

var s2 Student

var s2ptr *Student = &s2

s2ptr.name = "Peter"

s2ptr.id = 2

GetStudentInfo(&s1)

GetStudentInfo(s2ptr)

 

切片（Slice）：

定义切片：

var sliceName []type

var sliceName []type = make([]type,len)

sliceName := make([]type, len)

sliceName := make([]type, len,capacity)

初始化举例：

var arr = [10]int{1,2,3,4,5,6,7,8,9,10}

fmt.Println(arr)   // [1 2 3 4 5 6 7 8 9 10]

var slice1 []int

fmt.Println(slice1)   // []

var slice2 []int = make([]int, 10)

fmt.Println(slice2)   // [0 0 0 0 0 0 0 0 0 0]

slice3 := make([]int, 10)

fmt.Println(slice3)   // [0 0 0 0 0 0 0 0 0 0]

slice4 := make([]string, 5, 10)

fmt.Println(slice4)   // [   ]

slice5 := []int{1,2,3}

fmt.Println(slice5)   // [1 2 3]

slice6 := arr[:]

fmt.Println(slice6)   // [1 2 3 4 5 6 7 8 9 10]

slice7 := arr[2:6]

fmt.Println(slice7)   // [3 4 5 6]

slice8 := arr[2:]

fmt.Println(slice8)   // [3 4 5 6 7 8 9 10]

slice9 := arr[:6]

fmt.Println(slice9)   // [1 2 3 4 5 6]

使用len()和cap()方法可以分别获得切片目前的长度和容量（总大小）：

var l, c int = len(slice4), cap(slice4)

fmt.Println(l, c)

切片的默认值为nil，长度为0

使用append()和copy()方法可以追加新元素或者拷贝切片内容：

var slice10 []int = make([]int, 10)
copy(slice10, slice9)   //
将slice9的全部元素拷贝到slice10（从slice10第一个位置开始写入）

fmt.Println(slice10)

for i := 0; i < len(slice9); i++ {
   slice10 =append(slice10, slice9[i])   
//追加一个元素

}

fmt.Println(slice10)
slice10 = append(slice10, 1, 2, 3, 4)   //
追加多个元素
 

范围（Range）：

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

使用range遍历数组或切片：

names := []string{"Daniel","Stone", "Iran"}

for index, value := range names {

   fmt.Println(index, value)

}

Output:

0 Daniel

1 Stone

2 Iran

使用range遍历map键值对儿：

kvs := map[string]int{"a" : 1, "b": 2}

for k, v := range kvs {

   fmt.Println(k, v)

}

枚举字符串，返回index和unicode编码：

for index, unicode := range "Hello World" {

   fmt.Println(index, unicode)

}
 

键值对儿集合（Map）：

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。 map的默认值为nil。

定义：

var map_variablemap[key_data_type]value_data_type

map_variable =make(map[key_data_type]value_data_type)

实例：

keys := []string{"a", "b","c", "d"}

values := []int{1, 2, 3, 4}

kvs := make(map[string]int)

for i := 0; i < len(keys); i++ {

    kvs[keys[i]]= values[i]

}

for k, _ := range kvs {

    if k =="c" {
       delete(kvs, k)   //
使用delete(mapName,keyName)删除某个键值对儿

    }

}

fmt.Println(kvs)

 

递归函数：

定义：

func recursion() {

   recursion()

}

实例：

func factorial(x int) int {

    if x < 0{

        return-1

    }

    if x == 0 {

        return 1

    } else {

        return x* factorial(x-1)

    }

}
 

接口（interface）：

定义：
/*定义接口 */

type interface_name interface {

   method_name1[return_type]

   method_name2[return_type]

   method_name3[return_type]

   ...

   method_namen[return_type]

}

 
/*定义结构体 */

type struct_name struct {

   /* variables*/

}

 
/*实现接口方法 */

func (struct_name_variable struct_name) method_name1()[return_type] {
  /*
方法实现 */

}

...

func (struct_name_variable struct_name) method_namen()[return_type] {
  /*
方法实现*/

}
 

错误处理：

error接口定义：

type error interface {

   Error() string

}

使用errors.New返回一个错误信息：

import "errors"

msg, err := func() (string, error) {

    return"Error msg", errors.New("This is a test error")

} ()

fmt.Println(err, msg)

重载error接口，定义自己的error：

type MyError struct {

    errorMsgstring

    errorCodeint

}

 

func (err MyError) Error() string {

    returnfmt.Sprintf("Error Msg: %s ErrorCode: %d", err.errorMsg, err.errorCode)

}

 

func ThrowAnError() error {

    var errMyError

    err.errorMsg= "test message"

   err.errorCode = 99

    return err

}

var err error = ThrowAnError()

fmt.Println(err)