Go语言 | 02 for循环及常用函数的使用
Posted “逛丢一只鞋”
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Go语言 | 02 for循环及常用函数的使用相关的知识，希望对你有一定的参考价值。
文章目录
前言
本以为Go语言和C语言相似度较高，但是在for循环的学习中，还是感觉有很多的不同， 因此做个学习记录
for & range函数
for语法
Go 语言的 For 循环有 3 种形式，只有其中的一种使用分号。
和 C 语言的 for 一样：
for init; condition; post
和 C 的 while 一样：
for condition
和 C 的 for(;😉 一样：
for
- init： 一般为赋值表达式，给控制变量赋初值；
- condition： 关系表达式或逻辑表达式，循环控制条件；
- post： 一般为赋值表达式，给控制变量增量或减量。
range是我之前在C语言开发中没怎么使用到过的
for使用
Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。
for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：
for key, value := range oldMap
newMap[key] = value
以上代码中的 key 和 value 是可以省略。
如果只想读取 key，格式如下：
for key := range oldMap
或者这样：
for key, _ := range oldMap
如果只想读取 value，格式如下：
for _, value := range oldMap
示例代码
package main
import "fmt"
var pow = []int1, 2, 4, 8, 16, 32, 64, 128
func main()
for i, v := range pow
fmt.Printf("2**%d = %d\\n", i, v)
以上实例运行输出结果为：
for 循环的 range 格式可以省略 key 和 value，如下实例：
package main
import "fmt"
func main()
map1 := make(map[int]float32)
map1[1] = 1.0
map1[2] = 2.0
map1[3] = 3.0
map1[4] = 4.0
// 读取 key 和 value
for key, value := range map1
fmt.Printf("key is: %d - value is: %f\\n", key, value)
// 读取 key
for key := range map1
fmt.Printf("key is: %d\\n", key)
// 读取 value
for _, value := range map1
fmt.Printf("value is: %f\\n", value)
以上实例运行输出结果为:
多次运行我们就可以发现就像之前说的，map的无序，这个后面会提到
range遍历
package main
import "fmt"
func main()
//这是我们使用 range 去求一个 slice 的和。使用数组跟这个很类似
nums := []int2, 3, 4
sum := 0
for _, num := range nums
sum += num
fmt.Println("sum:", sum)
//在数组上使用 range 将传入索引和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。
for i, num := range nums
if num == 3
fmt.Println("index:", i)
//range 也可以用在 map 的键值对上。
kvs := map[string]string"a": "apple", "b": "banana"
for k, v := range kvs
fmt.Printf("%s -> %s\\n", k, v)
//range也可以用来枚举 Unicode 字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
for i, c := range "go"
fmt.Println(i, c)
以上实例运行输出结果为：
sum: 9
index: 1
a -> apple
b -> banana
0 103
1 111
for循环嵌套
Go 语言允许用户在循环内使用循环。接下来我们将为大家介绍嵌套循环的使用。
以下为 Go 语言嵌套循环的格式：
for [condition | ( init; condition; increment ) | Range]
for [condition | ( init; condition; increment ) | Range]
statement(s);
statement(s);
以下实例使用循环嵌套来输出 2 到 100 间的素数：
实例
package main
import "fmt"
func main()
/* 定义局部变量 */
var i, j int
for i=2; i < 100; i++
for j=2; j <= (i/j); j++
if(i%j==0)
break; // 如果发现因子，则不是素数
if(j > (i/j))
fmt.Printf("%d 是素数\\n", i);
以上实例运行输出结果为:
2 是素数
3 是素数
5 是素数
7 是素数
11 是素数
13 是素数
17 是素数
19 是素数
23 是素数
29 是素数
31 是素数
37 是素数
41 是素数
43 是素数
47 是素数
53 是素数
59 是素数
61 是素数
67 是素数
71 是素数
73 是素数
79 是素数
83 是素数
89 是素数
97 是素数
break
Go 语言中 break 语句用于以下两方面：
- 用于循环语句中跳出循环，并开始执行循环之后的语句。
- break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。
- 在多重循环中，可以用标号 label 标出想 break 的循环。
break 语法格式如下：
break
make & map函数
make（集合）
Go语言提供的内置函数make()可以用于灵活地创建数组切片。
创建一个初始元素个数为5的数组切片，元素初始值为0：
mySlice1 := make([]int, 5)
创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：
mySlice2 := make([]int, 5, 10)
也可以选择是否在创建时指定该map的初始存储能力，创建了一个初始存储能力为100的map.
myMap = map[string] PersonInfo
"1234": PersonInfo"1", "Jack", "Room 101,...",
创建并初始化map的代码.
map（范围）
Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。
Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。
可以使用内建函数 make 也可以使用 map 关键字来定义 Map:
/* 声明变量，默认 map 是 nil */
var map_variable map[key_data_type]value_data_type
/* 使用 make 函数 */
map_variable := make(map[key_data_type]value_data_type)
如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对
package main
import "fmt"
func main()
var countryCapitalMap map[string]string /*创建集合 */
countryCapitalMap = make(map[string]string)
/* map插入key - value对,各个国家对应的首都 */
countryCapitalMap [ "France" ] = "巴黎"
countryCapitalMap [ "Italy" ] = "罗马"
countryCapitalMap [ "Japan" ] = "东京"
countryCapitalMap [ "India " ] = "新德里"
/*使用键输出地图值 */
for country := range countryCapitalMap
fmt.Println(country, "首都是", countryCapitalMap [country])
/*查看元素在集合中是否存在 */
capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 */
/*fmt.Println(capital) */
/*fmt.Println(ok) */
if (ok)
fmt.Println("American 的首都是", capital)
else
fmt.Println("American 的首都不存在")
以上实例运行结果为：
France 首都是 巴黎
Italy 首都是 罗马
Japan 首都是 东京
India 首都是 新德里
American 的首都不存在
delete() 函数
delete() 函数用于删除集合的元素, 参数为 map 和其对应的 key。实例如下：
实例
package main
import "fmt"
func main()
/* 创建map */
countryCapitalMap := map[string]string"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"
fmt.Println("原始地图")
/* 打印地图 */
for country := range countryCapitalMap
fmt.Println(country, "首都是", countryCapitalMap [ country ])
/*删除元素*/ delete(countryCapitalMap, "France")
fmt.Println("法国条目被删除")
fmt.Println("删除元素后地图")
/*打印地图*/
for country := range countryCapitalMap
fmt.Println(country, "首都是", countryCapitalMap [ country ])
以上实例运行结果为：
原始地图
India 首都是 New delhi
France 首都是 Paris
Italy 首都是 Rome
Japan 首都是 Tokyo
法国条目被删除
删除元素后地图
Italy 首都是 Rome
Japan 首都是 Tokyo
India 首都是 New delhi
Go语言函数
函数定义
函数是基本的代码块，用于执行一个任务。
Go 语言最少有个 main() 函数。
你可以通过函数来划分不同功能，逻辑上每个函数执行的是指定的任务。
函数声明告诉了编译器函数的名称，返回类型，和参数。
Go 语言标准库提供了多种可动用的内置的函数。例如，len() 函数可以接受不同类型参数并返回该类型的长度。如果我们传入的是字符串则返回字符串的长度，如果传入的是数组，则返回数组中包含的元素个数。
Go 语言函数定义格式如下：
func function_name( [parameter list] ) [return_types]
函数体
函数定义解析：
- func：函数由 func 开始声明
- function_name：函数名称，参数列表和返回值类型构成了函数签名。
- parameter list：参数列表，参数就像一个占位符，当函数被调用时，你可以将值传递给参数，这个值被称为实际参数。参数列表指定的是参数类型、顺序、及参数个数。参数是可选的，也就是说函数也可以不包含参数。
- return_types：返回类型，函数返回一列值。
- return_types 是该列值的数据类型。有些功能不需要返回值，这种情况下 return_types 不是必须的。
函数体：函数定义的代码集合。
以下实例为 max() 函数的代码，该函数传入两个整型参数 num1 和 num2，并返回这两个参数的最大值：
/* 函数返回两个数的最大值 */
func max(num1, num2 int) int
/* 声明局部变量 */
var result int
if (num1 > num2)
result = num1
else
result = num2
return result
函数调用
当创建函数时，你定义了函数需要做什么，通过调用该函数来执行指定任务。
调用函数，向函数传递参数，并返回值，例如：
package main
import "fmt"
func main()
/* 定义局部变量 */
var a int = 100
var b int = 200
var ret int
/* 调用函数并返回最大值 */
ret = max(a, b)
fmt.Printf( "最大值是 : %d\\n", ret )
/* 函数返回两个数的最大值 */
func max(num1, num2 int) int
/* 定义局部变量 */
var result int
if (num1 > num2)
result = num1
else
result = num2
return result
以上实例在 main() 函数中调用 max（）函数，执行结果为：
最大值是 : 200
函数返回多个值
Go 函数可以返回多个值，例如：
实例
package main
import "fmt"
func swap(x, y string) (string, string)
return y, x
func main()
a, b := swap("Google", "Runoob")
fmt.Println(a, b)
以上实例执行结果为：
Runoob Google
Go语言函数值传递值
传递是指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
默认情况下，Go 语言使用的是值传递，即在调用过程中不会影响到实际参数。
Go语言函数引用传递值
引用传递是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。
以下我们通过使用引用传递来调用 swap() 函数：
package main
import "fmt"
func main()
/* 定义局部变量 */
var a int = 100
var b int= 200
fmt.Printf("交换前，a 的值 : %d\\n", a )
fmt.Printf("交换前，b 的值 : %d\\n", b )
/* 调用 swap() 函数
* &a 指向 a 指针，a 变量的地址
* &b 指向 b 指针，b 变量的地址
*/
swap(&a, &b)
fmt.Printf("交换后，a 的值 : %d\\n", a )
fmt.Printf("交换后，b 的值 : %d\\n", b )
func swap(x *int, y *int)
var temp int
temp = *x /* 保存 x 地址上的值 */
*x = *y /* 将 y 值赋给 x */
*y = temp /* 将 temp 值赋给 y */
以上代码执行结果为：
交换前，a 的值 : 100
交换前，b 的值 : 200
交换后，a 的值 : 200
交换后，b 的值 : 100
Go语言函数作为实参
Go 语言可以很灵活的创建函数，并作为另外一个函数的实参。以下实例中我们在定义的函数中初始化一个变量，该函数仅仅是为了使用内置函数 math.sqrt()，实例为：
package main
import (
"fmt"
"math"
)
func main()
/* 声明函数变量 */
getSquareRoot := func(x float64) float64
return math.Sqrt(x)
/* 使用函数 */
fmt.Println(getSquareRoot(9))
以上代码执行结果为：
3
以上是关于Go语言 | 02 for循环及常用函数的使用的主要内容，如果未能解决你的问题，请参考以下文章