数组:
声明:
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)