golang GO语言学习笔记(3)

目录

一、循环

1.for循环

 （1）for condition {}

（2）for init {}

2.循环嵌套

3.break语句

（1） 用于循环语句中跳出循环，并开始执行循环之后的语句。

（2） break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。

（3）在多重循环中，可以用标号 label 标出想 break 的循环

 4.continue 语句

(1)for 循环中，执行 continue 语句会触发 for 增量语句的执行。

 (2)在多重循环中，可以用标号 label 标出想 continue 的循环。

5.goto 语句

二、函数

1.函数定义与调用

 2.函数返回多个值

 3.值传递与引用传递

(1)值传递：

(2)引用传递：

4.函数作为另外一个函数的实参

5.闭包

6.方法

一、循环

1.for循环

 （1）for condition {}

package main

import "fmt"

func main() {

//1.for condition语句

sum := 0

for i := 1; i <= 10; i++ {

sum += i

}

fmt.Println(sum) //累加1~10

}

（2）for init {}

package main

import "fmt"

func main() {

Strings := []string{"google", "golang"}

for m, n := range Strings {

fmt.Println(m, n)

}

}

2.循环嵌套

package main

import "fmt"

func main() {

//2.循环嵌套：找到1-30内的素数

var i, j int

for i = 2; i < 30; i++ {

for j = 2; j <= i/j; j++ {

if i%j == 0 {

break

}

}

if j > (i / j) {

fmt.Println(i, "是一个素数")

}

}

}

3.break语句

        Go 语言中 break 语句用于以下两方面：

（1） 用于循环语句中跳出循环，并开始执行循环之后的语句。

//3.1 break跳出循环

var a int = 10

for a < 20 {

fmt.Println("a的值：", a)

a++

if a == 15 {

break

}

}

}

（2） break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。

（3）在多重循环中，可以用标号 label 标出想 break 的循环

package main

import "fmt"

func main() {

//3.2 break label标出想break的循环

// 不使用标记

fmt.Println("---- break ----")

for i := 1; i <= 3; i++ {

fmt.Printf("i: %d\n", i)

for i2 := 11; i2 <= 13; i2++ {

fmt.Printf("i2: %d\n", i2)

break

}

}

// 使用标记

fmt.Println("---- break label ----")

re:

for i := 1; i <= 3; i++ {

fmt.Printf("i: %d\n", i)

for i2 := 11; i2 <= 13; i2++ {

fmt.Printf("i2: %d\n", i2)

break re

}

}

}

 4.continue 语句

        Go 语言的 continue 语句 有点像 break 语句。但是 continue 不是跳出循环，而是跳过当前循环执行下一次循环语句。

(1)for 循环中，执行 continue 语句会触发 for 增量语句的执行。

package main

import "fmt"

func main() {

//4.1 continue语句,不是跳出循环，而是跳过当前循环执行下一次循环语句

a := 10

for a < 20 {

a++

if a == 15 {

continue

}

fmt.Println("a的值为:", a)

}

}

 (2)在多重循环中，可以用标号 label 标出想 continue 的循环。

package main

import "fmt"

func main() {

//4.2 使用continue+label标出想 continue 的循环

// 不使用标记

fmt.Println("---- continue ---- ")

for i := 1; i <= 3; i++ {

fmt.Printf("i: %d\n", i)

for i2 := 11; i2 <= 13; i2++ {

fmt.Printf("i2: %d\n", i2)

continue

}

}

// 使用标记

fmt.Println("---- continue label ----")

re:

for i := 1; i <= 3; i++ {

fmt.Printf("i: %d\n", i)

for i2 := 11; i2 <= 13; i2++ {

fmt.Printf("i2: %d\n", i2)

continue re

}

}

}

5.goto 语句

        Go 语言的 goto 语句可以无条件地转移到过程中指定的行。

       goto 语句通常与条件语句配合使用。可用来实现条件转移， 构成循环，跳出循环体等功能。

package main

import "fmt"

func main() {

//5.goto语句可以无条件地转移到过程中指定的行

/* 定义局部变量 */

var a int = 10

/* 循环 */

LOOP:

for a < 20 {

if a == 15 {

/* 跳过迭代 */

a = a + 1

goto LOOP

}

fmt.Printf("a的值为 : %d\n", a)

a++

}

}

二、函数

1.函数定义与调用

        Go 语言最少有个 main() 函数。

        你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。

函数定义解析：

* func：函数由 func 开始声明

* function_name：函数名称，参数列表和返回值类型构成了函数签名。

* parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。

* return_types：返回类型，函数返回一列值。return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。

* 函数体：函数定义的代码集合。

package main

import "fmt"

func main() {

var a int = 98

var b int = 99

var c int = max(a, b)

fmt.Println("a,b两个数的最大值为：", c)

}

func max(num1, num2 int) int {

/* 声明局部变量 */

var result int

if num1 > num2 {

result = num1

} else {

result = num2

}

return result

}

 2.函数返回多个值

package main

import "fmt"

func main() {

x := "hello"

y := "world"

fmt.Println("交换前的x与y分别为：", x, y)

x, y = swap(x, y)

fmt.Println("交换后的x与y分别为：", x, y)

}

func swap(x, y string) (string, string) {

x, y = y, x

return x, y

}

 3.值传递与引用传递

(1)值传递：

        值传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。

package main

import (

"fmt"

)

func main() {

x := "hello"

y := "world"

fmt.Println("交换前的x与y分别为：", x, y)

swap(x, y)

fmt.Println("交换后的x与y分别为：", x, y)

}

//值传递

func swap(x, y string) string {

var temp string

temp = x

x = y

y = temp

return temp

}

(2)引用传递：

        引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

package main

import (

"fmt"

)

func main() {

//var a int = 98

//var b int = 99

//var c int = max(a, b)

//fmt.Println("a,b两个数的最大值为：", c)

x := "hello"

y := "world"

fmt.Println("交换前的x与y分别为：", x, y)

swap(&x, &y)

fmt.Println("交换后的x与y分别为：", x, y)

}

//func max(num1, num2 int) int {

// /* 声明局部变量 */

// var result int

//

// if num1 > num2 {

// result = num1

// } else {

// result = num2

// }

// return result

//}

值传递

//func swap(x, y string) string {

// var temp string

// temp = x

// x = y

// y = temp

// return temp

//}

//引用传递

func swap(x, y *string) string {

var temp string

temp = *x

*x = *y

*y = temp

return temp

}

4.函数作为另外一个函数的实参

        Go 语言中同时有函数和方法。一个方法就是一个包含了接受者的函数，接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。

package main

import (

"fmt"

)

/* 定义结构体 */

type Circle struct {

radius float64

}

func main() {

var c1 Circle

c1.radius = 10.00

fmt.Println("圆的面积 = ", c1.getArea())

}

//该 method 属于 Circle 类型对象中的方法

func (c Circle) getArea() float64 {

//c.radius 即为 Circle 类型对象中的属性

return 3.14 * c.radius * c.radius

}

结果：

圆的面积 = 314

5.闭包

        go 支持return是函数，相当于（递归函数的意思，一层层返回）

        闭包：外层函数里有内层函数，内层函数调用外层函数局部变量（外层函数参数或者定义的变量），并且该外层函数的返回值就是其内层函数，该内层函数和外层函数的局部变量称为闭包结构。

局部变量的生命周期发生改变，过去是随函数结束而销毁。

现在是内层函数需要调用变量，所以变量没有销毁

func main() {

a := info()//返回值是匿名函数，即 a = fun1

fmt.Println("%T\n",a)//返回是匿名函数地址0x10937b0，相当于一个函数

v1 := a()

fmt.Println(v1)//值是1

v2 :=a()

fmt.Println(v2)//值是2

fmt.Println(a())//值是3

/* 调用同一个info()的i变量，i的地址是同一个*/

b :=info()

v3 :=b()

fmt.Println(v3)//值是1

/* 调用另一个info()的i变量，i的地址变了*/

}

func info() func() int{

i:=0

fun1 := func() int{

i++

return i

}

return fun1

或：

return func() int {

i++

return i

}

}

6.方法

        方法其实就是一个函数，在 func 这个关键字和方法名中间加入了一个特殊的接收器类型。接收器可以是结构体类型或者是非结构体类型。接收器是可以在方法的内部访问的。

下面就是创建一个方法的语法。

package main

import (

"fmt"

)

type Employee struct {

name string

salary int

currency string

}

/*

displaySalary() 方法将 Employee 做为接收器类型

*/

func (e Employee) displaySalary() {

fmt.Printf("Salary of %s is %s%d", e.name, e.currency, e.salary)

}

func main() {

emp1 := Employee {

name: "Sam Adolf",

salary: 5000,

currency: "$",

}

emp1.displaySalary() // 调用 Employee 类型的 displaySalary() 方法

}

        在上面程序的第 16 行，我们在 Employee 结构体类型上创建了一个 displaySalary 方法。displaySalary()方法在方法的内部访问了接收器 e Employee。在第 17 行，我们使用接收器 e，并打印 employee 的 name、currency 和 salary 这 3 个字段。

        在第 26 行，我们调用了方法 emp1.displaySalary()。

        程序输出：Salary of Sam Adolf is $5000。

 参考资料：

https://answer.baidu.com/answer/land?params=5Ci7lQf2307pdyzyqKmEbPxMMkbKoT%2BT2ZMzOZw6PnnxdlD8WUaIZGOS8KInzYvSu%2FfiW%2Bnpz2dkcQIDYV%2BWaSB0pmKTmnGys%2FEI6qf%2FTX1PAaI%2F%2B%2BzAZuQXBKE6%2BDwcY0q5G0%2F%2FRzfPCDyAEFAGvUNW7oxgnmzI4cIC6AMZeUu5U9WGgj2TZP9R2rlURYSq&from=dqa&lid=db0f7830002c9a73&word=go%E6%96%B9%E6%B3%95%E5%92%8C%E5%87%BD%E6%95%B0%E7%9A%84%E5%8C%BA%E5%88%AB

推荐链接