1.Go的基本语法 - 函数、数组、接口

hello_fracong

于 2024-04-09 16:42:47 发布

阅读量521

点赞数 1

分类专栏： Go 文章标签： golang 开发语言后端

本文链接：https://blog.csdn.net/m0_37356874/article/details/137512145

版权

Go 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

本文详细介绍了Go语言中的函数概念，包括入参和出参、匿名函数、函数定义为变量、实体类方法、递归、数组（固定长度、动态长度、索引值、多维、作为函数参数等）、接口以及相关操作，如数组的截取、追加、拷贝和range遍历。

摘要由CSDN通过智能技术生成

1.函数

1.1.入参和出参

package main
import (
	"fmt"
)

func main() {
	a, b := test16("test1", "test2")
	fmt.println(a, b)
}

func test16(a string, b string) (string, string) {
	return a, b
}

结果：

test1 test2

说明：
和java不同的是， go语言的出参可以返回多个数据，并可以类型不同

1.2.匿名函数及传参

package main
import (
	"fmt"
)

func main() {
	println(test17()("a"))
}

func test17() func(param string) string {
	return func(param string) string {
		return param + "---test"
	}
}

结果：

a---test

说明：
main方法中， test17()返回的是方法名称，后面才括号才是用于调用其中的匿名函数。

1.3.函数定义为变量

package main
import (
	"fmt"
)
func main() {
	test18()
}
func test18() {
	func_test := func() string {
		return "123"
	}
	println(func_test())
}

结果：

1.4.给实体类定义方法

func main() {
	var t TestValue
	t.value = 20
	println(fmt.Sprint("the value is ", t.test19())) // 根据实体类去调用方法
}

type TestValue struct {// 实体类
	value int
}

// 给实体类定义方法
func (t TestValue) test19() int {
	return t.value * 2
}

结果：

the value is 40

1.5.递归函数

func test36() {
	fmt.Println(digui(0))
}

func digui(num int) int {
	if num > 31 {
		return num
	}
	num += 3
	return digui(num)
}

结果：

2.数组

2.1.指定长度的数组

func test20() {
	var array1 = [5]int{1, 2, 3, 4, 5}
	for i := 0; i < len(array1); i++ {
		println(array1[i])
	}
	println("------")
	array2 := [5]int{5, 4, 3, 2, 1}
	for i := 0; i < len(array2); i++ {
		println(array2[i])
	}
}

结果：

1
2
3
4
5
------
5
4
3
2
1

2.2.自动计算长度的数组

func test20() {
	array3 := [...]int{5, 4, 3, 2, 1}
	for i := 0; i < len(array3); i++ {
		println(array3[i])
	}
}

结果：

2.3.指定索引的值的数组

func test20() {
	array4 := [...]int{2: 5, 4: 7}
	for i := 0; i < len(array4); i++ {
		println(array4[i])
	}
}

结果：

说明：指定索引为2 和4的值，其他未指定值的索引，默认为0。

2.4.二维数组

func test20() {
	array5 := [3][2]int{{1, 2}, {3, 4}, {5, 6}}
	for i := 0; i < len(array5); i++ {
		var item_array = array5[i]
		for j := 0; j < len(item_array); j++ {
			println(array5[i][j])
		}
	}
}

结果：

说明：第一个数是指整个数组的最大长度为3, 里面数组的最大长度为2。

2.5.多维数组

func test20() {
	array6 := [3][2][3]int{{{1, 2, 3}, {4, 5, 6}}, {{7, 8, 9}, {10, 11, 12}}, {{13, 14, 15}, {16, 17, 18}}}
	for i := 0; i < len(array6); i++ {
		for j := 0; j < len(array6[i]); j++ {
			for k := 0; k < len(array6[i][j]); k++ {
				println(array6[i][j][k])
			}
		}
	}
}

结果：

2.6.数组作为函数形参

2.6.1.指定长度的数组

package main
import (
	"fmt"
)

func main() {
	array7 := [3]int{1, 2, 3}
	test21(array7)
}

func test21(array7 [3]int) {
	for i := 0; i < len(array7); i++ {
		println(array7[i])
	}
}

1
2
3

2.6.2.未指定长度的数组

package main
import (
	"fmt"
)

func main() {
	array8 := []int{1, 2, 3, 4}
	test22(array8)
}

func test22(array8 []int) {
	for i := 0; i < len(array8); i++ {
		println(array8[i])
	}
}

结果：

2.7.数组作形参：指针数组

2.7.1.指定数组长度

package main
import (
	"fmt"
)

func main() {
	array9 := [6]int{6, 5, 4, 3, 2, 1}
	test23V1(array9)
	fmt.Println("no point value: ", array9)
	test23V2(&array9) //指针传参， 使用&
	fmt.Println("point value: ", array9)
}

func test23V1(array9 [6]int) {
	for i := 0; i < len(array9); i++ {
		array9[i] = array9[i] * 3
	}
}

func test23V2(array9 *[6]int) { //指针传参， 作为ie形参的时候使用*， 并在调用的时候， 使用括号包括起来
	for i := 0; i < len(*array9); i++ {
		(*array9)[i] = (*array9)[i] * 3
	}
}

结果：

no point value:  [6 5 4 3 2 1]
point value:  [18 15 12 9 6 3]

说明：
当指定数组长度之后，不使用指针传参的，则原始的数组数据未发生变化，使用指针传参，原始数组数据发生改变

2.7.2.未指定数组长度

package main
import (
	"fmt"
)

func main() {
	array10 := []int{6, 5, 4, 3, 2, 1}
	test23V3(array10)
	fmt.Println("no point value: ", array10)
	test23V4(&array10) //指针传参， 使用&
	fmt.Println("point value: ", array10)
}

func test23V3(array10 []int) {
	for i := 0; i < len(array10); i++ {
		array10[i] = array10[i] * 3
	}
}

func test23V4(array10 *[]int) { //指针传参， 作为ie形参的时候使用*， 并在调用的时候， 使用括号包括起来
	for i := 0; i < len(*array10); i++ {
		(*array10)[i] = (*array10)[i] * 3
	}
}

结果：

no point value:  [18 15 12 9 6 3]
point value:  [54 45 36 27 18 9]

说明：
当未指定数组长度之后，不管使不使用指针传参的，原始数组的数据都发生改变。

2.8.数组的截取

func test29() {
	a := []int{1, 2, 3, 4, 5, 6}
	b := a[1:3]
	fmt.Printf("b value is %d\n", b)
}

结果：

b value is [2 3]

2.9.数组的追加

func test30() {
	a := []int{1}
	b := append(a, 2, 3, 4)
	fmt.Printf("b value is %d\n", b)
}

结果：

b value is [1 2 3 4]

2.10.数组的拷贝

func test31() {
	a := []int{1， 2, 3, 4}
	var b = make([]int, len(a), (cap(a))*2)
	copy(b, a)
	fmt.Printf("a value is %, b value is %d %d\n", a, b)
}

结果：

a value is [1 2 3 4], b value is [1 2 3 4]

2.11.数组的range遍历

func test32() {
	a := []int{1, 2, 3, 4, 5}
	for index, value := range a {
		fmt.Printf("index is %d, value is %d\n", index, value)
	}
	print("--------------------------\n")
	for index := range a {
		fmt.Printf("index is %d\n", index)
	}
	print(("--------------------------\n"))
	for _, value := range a {
		fmt.Printf("value is %d\n", value)
	}
}

结果：

index is 0, value is 1
index is 1, value is 2
index is 2, value is 3
index is 3, value is 4
index is 4, value is 5
--------------------------
index is 0
index is 1
index is 2
index is 3
index is 4
--------------------------
value is 1
value is 2
value is 3
value is 4
value is 5

3.接口

type Calculate interface {
	calculate() int
}

type Cal1 struct {
	num1 int
	num2 int
}

func (c1 Cal1) calculate() int {
	return c1.num1 * c1.num2
}

type Cal2 struct {
	num int
}

func (c2 Cal2) calculate() int {
	return c2.num * 10
}

func test38() {
	var a Calculate

	a = Cal1{num1: 10, num2: 5}
	println("Cal1 result is ", a.calculate())

	a = Cal2{num: 10}
	println("Cal2 result is ", a.calculate())
}