GO语言学习笔记(3)

大王算法

已于 2024-03-23 17:03:42 修改

阅读量965

点赞数 7

文章标签：学习笔记 golang

于 2024-01-28 13:02:14 首次发布

本文链接：https://blog.csdn.net/fanyun_01/article/details/135894067

版权

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

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

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

4.continue 语句

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

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

一、循环

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

大王算法

关注

7
点赞
踩
26

收藏

觉得还不错? 一键收藏
打赏
0
评论
GO语言学习笔记(3)

Go 语言最少有个 main() 函数。你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。函数定义解析：* func：函数由 func 开始声明* function_name：函数名称，参数列表和返回值类型构成了函数签名。* parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
复制链接

扫一扫