1.函数
1.1.入参和出参
go
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
}结果：
go
test1 test2说明：
和java不同的是， go语言的出参可以返回多个数据， 并可以类型不同
1.2.匿名函数及传参
go
package main
import (
"fmt"
)
func main() {
println(test17()("a"))
}
func test17() func(param string) string {
return func(param string) string {
return param + "---test"
}
}结果：
go
a---test说明：
main方法中， test17()返回的是方法名称， 后面才括号才是用于调用其中的匿名函数。
1.3.函数定义为变量
go
package main
import (
"fmt"
)
func main() {
test18()
}
func test18() {
func_test := func() string {
return "123"
}
println(func_test())
}结果：
go
1231.4.给实体类定义方法
go
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
}结果：
go
the value is 401.5.递归函数
go
func test36() {
fmt.Println(digui(0))
}
func digui(num int) int {
if num > 31 {
return num
}
num += 3
return digui(num)
}结果：
go
332.数组
2.1.指定长度的数组
go
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])
}
}结果：
go
1
2
3
4
5
------
5
4
3
2
12.2.自动计算长度的数组
go
func test20() {
array3 := [...]int{5, 4, 3, 2, 1}
for i := 0; i < len(array3); i++ {
println(array3[i])
}
}结果：
go
5
4
3
2
12.3.指定索引的值的数组
go
func test20() {
array4 := [...]int{2: 5, 4: 7}
for i := 0; i < len(array4); i++ {
println(array4[i])
}
}结果：
go
0
0
5
0
7说明：指定索引为2 和4的值， 其他未指定值的索引，默认为0。
2.4.二维数组
go
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])
}
}
}结果：
go
1
2
3
4
5
6说明：第一个数是指整个数组的最大长度为3, 里面数组的最大长度为2。
2.5.多维数组
go
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])
}
}
}
}结果：
go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
182.6.数组作为函数形参
2.6.1.指定长度的数组
go
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])
}
}
go
1
2
32.6.2.未指定长度的数组
go
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])
}
}结果：
go
1
2
3
42.7.数组作形参：指针数组
2.7.1.指定数组长度
go
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
}
}结果：
go
no point value: [6 5 4 3 2 1]
point value: [18 15 12 9 6 3]说明：
当指定数组长度之后，不使用指针传参的， 则原始的数组数据未发生变化， 使用指针传参， 原始数组数据发生改变
2.7.2.未指定数组长度
go
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
}
}结果：
go
no point value: [18 15 12 9 6 3]
point value: [54 45 36 27 18 9]说明：
当未指定数组长度之后，不管使不使用指针传参的， 原始数组的数据都发生改变。
2.8.数组的截取
go
func test29() {
a := []int{1, 2, 3, 4, 5, 6}
b := a[1:3]
fmt.Printf("b value is %d\n", b)
}结果：
go
b value is [2 3]2.9.数组的追加
go
func test30() {
a := []int{1}
b := append(a, 2, 3, 4)
fmt.Printf("b value is %d\n", b)
}结果：
go
b value is [1 2 3 4]2.10.数组的拷贝
go
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)
}结果：
go
a value is [1 2 3 4], b value is [1 2 3 4]2.11.数组的range遍历
go
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)
}
}结果：
go
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 53.接口
go
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())
}结果：
go
Cal1 result is 50
Cal2 result is 100