循环结构控制、包函数的使用

最新推荐文章于 2024-07-18 11:18:19 发布
最新推荐文章于 2024-07-18 11:18:19 发布
阅读量236 收藏 2
点赞数 4
分类专栏： Golang 文章标签： golang go 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44048140/article/details/124389845
版权

前言

这里总结的Golang 笔记只适合有点编程基础的人看，比如Java

循环

循环是一段在程序中只出现一次，但可能会连续运行多次的代码。 循环中的代码会运行特定的次数，或者是运行到特定条件成立时结束循环，或者是针对某一集合中的所有项目都运行一次。

for

for循环是一个循环控制结构，可以执行指定次数的循环。

	for init; condition; post { }
    for condition { }
    for { }

for使用

	for i := 0; i < 10; i++{
		for j := 0; j < 10; j++{
			fmt.Println(i)
		}
	}

while实现

Golang中是没有while的，但是可以通过for去实现while这个功能。

	var j = 0
	for j < 10{
		fmt.Printf("%d ", j)
		j++
	}

do…while实现

GoLang中也没有do…while的，也是可以通过for去实现do…while 这个功能。

	var k = 0
	for {
		fmt.Printf("%d ", k)
		if k >= 10 {
			break
		}
		k++
	}

break

这里的意思是for可以一直循环的执行，如果k>= 10的时候它会跳出这个循环，否则的话可以一直执行。

	var k = 0
	for {
		fmt.Printf("%d ", k)
		if k >= 10 {
			break
		}
		k++
	}

label使用

golang中可以和label一起使用，更加容易进行流程控制。注意：这里不建议使用，因为很容易造成流程控制混乱

label1:
	for i := 0; i < 10; i++{
		for j := 0; j < 10; j++{
			fmt.Println(i)
			if j == 2{
				break label1
			}
		}
	}

在这里插入图片描述
从如下的结果可以看出j==2的时候直接跳出双层的for循环了。如果单纯的使用break只能跳出内层的for循环，第二次还是进入内层for循环。

continue

continue是可以进行流程控制，意为跳过本次执行，不影响下次循环执行，也不跳出循环。

	for i:=0; i<10; i++{
		if i == 2{
			continue
		}
		fmt.Println("i:", i)
	}

在这里插入图片描述
从如上结果看出，仅跳过本次执行（i == 2）

goto介绍

  • go语言的goto可以无条件地转移到程序中指定的行。
  • goto语句通常与条件语句配合使用，可以用来实现条件的转移，跳出循环体等功能。
  • goto一般不建议使用，以免造成程序流程的混乱，使维护程序的难度变大。
package main

import "fmt"

func main() {
	fmt.Println("1")
	goto label1
	fmt.Println("2")
	fmt.Println("3")
	fmt.Println("4")
	fmt.Println("5")
	label1:
	fmt.Println("6")
	fmt.Println("7")
}

在这里插入图片描述

包使用

  • 在引用别的包的函数时候需要注意的是，函数名必须是大写，大写是公有的可以被其他包引用，小写是私有不能被其他包使用。

  • 包名与文件夹不一一对应，但是尽量保证二者是一一对应的，一般都是小写的。

  • 在同一个包下，不能有相同的函数名（也不能有相同的全局变量名）。

  • 如果你要编译成一个可执行文件，就需要将包名声明为main。

  • 基本数据类型和数组都是值传递的，进行值拷贝，在函数内修改不会影响原来的值。
    在这里插入图片描述
    这个是包结构如何使用其他go文件中的变量
    main.go

package main

import (
	"fmt"
	"../utils"  // 当前目录
)

func main() {
	fmt.Println(utils.Age)
}

utils.go

package utils

var(
	Age = 10
)

函数

介绍

函数声明包含一个函数名，参数列表， 返回值列表和函数体。如果函数没有返回值，则返回列表可以省略。函数从第一条语句开始执行，直到执行return语句或者执行函数的最后一条语句。在go中函数也是一种数据类型，可以赋值给一个变量，则该变量就是一个函数类型的变量了，通过该变量可以对函数进行调用。使用函数可以减少代码的冗余，更加容易维护。

函数的结构

func  函数名(形参列表) (返回值列表){
​	代码块
​	return 返回值列表
}

参数

函数定义时指出，函数定义时有参数，该变量可称为函数的形参。形参就像定义在函数体内的局部变量。但当调用函数，传递过来的变量就是函数的实参，函数可以通过两种方式来传递参数：

  • 值传递：指在调用函数时将实际参数复制一份传递到函数中，这样在函数中如果对参数进行修改，将不会影响到实际参数。
func swap(num1 int, num2 int)  {
	tmp := num1
	num1 = num2
	num2 = tmp
}
  • 引用传递：是指在调用函数时将实际参数的地址传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。（这里其实也可以理解是值传递，根本不是引用传递，知识拷贝了一份这个地址 然后使用*ptr 去修改这个值）。
func swap(num1 *int, num2 *int)  {
	tmp := *num1
	*num1 = *num2
	*num2 = tmp
}

多个参数如何传递

  func myfunc(args ...int) {    //0个或多个参数
  }

  func add(a int, args…int) int {    //1个或多个参数
  }

  func add(a int, b int, args…int) int {    //2个或多个参数
  }

注意：其中args是一个slice，我们可以通过arg[index]依次访问所有参数,通过len(arg)来判断传递参数的个数.

返回值

"_"标识符，用来忽略函数的某个返回值，Go 的返回值可以被命名，并且就像在函数体开头声明的变量那样使用。返回值的名称应当具有一定的意义，可以作为文档使用。没有参数的 return 语句返回各个返回变量的当前值，相当于java之中void返回，可以去操作一些全局变量，或者引用类型。直接返回语句仅应当用在像下面这样的短函数中。在长的函数中它们会影响代码的可读性。

func cal(num1 int, num2 int) (int, int)  {
	add := num1 + num2
	sub := num1 - num2
	return add, sub
}

命名返回参数可看做与形参类似的局部变量，最后由 return 隐式返回

func add(x, y int) (z int) {
    z = x + y
    return
}

如上代码示例1返回值有两个的时候，当不想使用哪个值的时候可以使用’_'占位符赋值，这里需要注意的是必须保证顺序。

函数类型

在golang之中其实可以理解函数也是一种数据类型，可以给函数传递函数进行使用，也可以去声明函数等操作。

package main

import "fmt"

type myfunc func(int, int) int // 使用函数别名的功能

func main() {
	var num1 = 10
	var num2 = 20
	// 向cal传递add函数
	result := cal(add, num1, num2)
	fmt.Println(result)
}

// 进行相加的操作
func add(num1 int, num2 int) int {
	return num2 + num1
}

// 向函数中传递一个函数
func cal(function func(int, int) int, num1 int, num2 int) int {
	return function(num1, num2)
}

// 使用函数别名
func calus(function myfunc, num1 int, num2 int) int {
	return function(num1, num2)
}

// 预先将两个返回值已经定义好，接受返回值的时候还是要按顺序接收
func cals(num1 int, num2 int) (sum int, sub int) {
	sum = num1 + num2
	sub = num2 - num1
	return // 返回值这里也不需要明确的指定返回什么
}

匿名函数

匿名函数由一个不带函数名的函数声明和函数体组成。匿名函数的优越性在于可以直接使用函数内的变量，不必声明。

func main()  {
	getAdd := func(a, b int) int{
		return a + b
	}
	fmt.Println(getAdd(1,2))
}

闭包

闭包是由函数及其相关引用环境组合而成的实体(即：闭包=函数+引用环境)。个人理解：在函数1内部的一个函数2引用了他外部变量（函数1中）构成闭包。

// 函数返回的类型 func(int) int
func AddUpper() func(int) int{
	var n = 10
	return func(i int) int {
		n = n + i
		return n
	}
}

func main() {
	// 这里相当于f是一个func(int) int的函数类型
	f := AddUpper() // 这里的f可以理解java语言中对象，每个对象中n对外是私有的所以f1 中的n 和 f2中的n没有任何关系。
	fmt.Println(f(1)) // 11
	fmt.Println(f(2)) // 13
}

通过如上的代码和输出结果可以看出：f可以理解java语言中对象，f对应的函数之中n永远是哪一个所以结果11、13。但是如果f1:= AddUpper()、f2:= AddUpper() 这种情况下是可以进行两个n是不相干的。

defer介绍

1. 关键字 defer 用于注册延迟调用。
2. 这些调用直到 return 前才被执。一般情况是作为释放资源使用（关闭文件、数据库连接、网络连接等）。
3. 多个defer语句从上到下一次放入栈中，执行的时候出栈。
4. defer语句中的变量，在defer声明时就决定了。

func main() {
	test(10, 20)
}

func test(num1 int, num2 int) int {
	defer fmt.Println("num1:", num1)// 如果下面进行赋值等变更的操作，这里值的结果不受任何影响
	defer fmt.Println("num2:", num2)
	sum := num1+num2
  	  num1++
        num2++
	fmt.Println("sum:", sum)
	return sum
}
// 输出的结果： sum: 30 num2: 20 num1: 10

从如上的输出结果之中可以看出，上面的介绍，从上到下入栈，输出出栈。

常见函数

字符串函数

常见的字符串处理函数一般都在 “strconv”，"strings"这两个包之中。

import (
	"fmt"
	"strconv"
	"strings"
)

func main() {
	var str = "hello world"
  	  // 字符串的长度
	fmt.Println(len(str))

	// 遍历字符串
	num := []rune(str)
	for i:=0; i<len(num); i++ {
		fmt.Printf("%c", num[i])
	}
	fmt.Println()
	fmt.Printf("%T\n", num)

	// 字符串转化为整数
	val, err := strconv.Atoi("123")
	if err!=nil {
		fmt.Println("转换异常")
	}else{
		fmt.Println("转换成功的值为：", val)
	}
	fmt.Printf("%T\n", val)

	// 整数转换为字符串
	strs := strconv.Itoa(123)
	fmt.Println(strs)
	fmt.Printf("%T\n", strs)

	// 字符串转化为 []byte
	var bytes = []byte("hello")
	fmt.Printf("%v\n", bytes)

	// byte转换为字符串
	str1 := string([]byte{97, 98, 99})
	fmt.Println(str1)

	// 获取一个数的二进制
	var i = 10
	j := strconv.FormatInt(int64(i), 2)
	fmt.Println(j)

	// 判断一个字符串中是否包含另外一个字符串
	var str2 = "hello world"
	var str3 = "world"
	flag := strings.Contains(str2, str3)
	fmt.Println(flag)

	// 判断字符串中包含几个char
	nums:=strings.Count("chinese", "e")
	fmt.Println("包含e的个数:", nums)

	//不区分大小写去比较
	flags := strings.EqualFold("abc", "ABC")
	fmt.Println(flags)

	// 返回子串第一次出现的字符串中的位置,找不到返回-1
	indexs := strings.Index("abcdadsadas", "ad")
	fmt.Println(indexs)

	// 返回子串出现在字符串最后的位置
	lastIndex:=strings.LastIndex("addadadadada", "da")
	fmt.Println("最后出现的位置:", lastIndex)

	// 将子串替换成另外的子串最后一个参数是n个old替换为new
	var str4 = "hello go go"
	str4 = strings.Replace(str4, "go", "go语言", 1)
	fmt.Println(str4)

	// 将字符串拆分为字符数组
	arr := strings.Split("hello,world,go,语言", ",")
	for i:=0; i<len(arr); i++{
		fmt.Println(arr[i])
	}
	fmt.Println(len(arr))

	// 字符串进行大小写转换
	var str5 = "sdaAdasfFC"
	str6 := strings.ToUpper(str5)
	str7 := strings.ToLower(str5)
	fmt.Println("转换为大写：", str6, "转换为小写：", str7)

	// 去掉字符串左右两边的空格
	str8 := strings.TrimSpace(" sdd  dssds  d   ")
	fmt.Println(str8)

	// 去掉字符串左右两边指定的字符串 Trimleft TrimRight 去掉左边、右边指定的字符串
	str9 := strings.Trim("hell!", "!")
	fmt.Println(str9)

	// 判断字符串是以什么开头、结尾
	flag2 := strings.HasPrefix("hello", "h")
	flag3 := strings.HasSuffix("hello", "o")
	fmt.Println(flag2, flag3)
}

时间函数

package main

import (
	"fmt"
	"time"
)

func main() {
	// 获取当前时间
	now := time.Now()
	fmt.Printf("当前时间为: %v\nnow的类型为: %T\n", now, now)
	// 获取年
	year := now.Year()
	fmt.Println(year)
	// 这一年过去多少天
	yearDay := now.YearDay()
	fmt.Println(yearDay)
	// 获取月
	month := now.Month()
	fmt.Println(month)
	// 获取日
	day := now.Day()
	fmt.Println(day)
	// 获取年月日 2021 November 27
	date, m, d := now.Date()
	fmt.Println(date,m,d)
	// 获取时
	hour := now.Hour()
	fmt.Println(hour)
	// 获取分
	minute := now.Minute()
	fmt.Println(minute)
	// 获取秒
	second := now.Second()
	fmt.Println(second)
	// 格式化输出,这里打印出你当前的时间
	fmt.Printf(now.Format("2006/01/02 15:04:05"))
}

init函数

每个源文件中都可以有一个init函数，init函数在main函数之前被调用。被go的运行框架优先于main调用。init函数一般的作用是被用来初始化等操作。

package main

import "fmt"

var test int = test1()

func test1() int {
	fmt.Println("test")
	return 90
}

func main() {
	fmt.Println("main")
}

func init()  {
	fmt.Println("init")
}

//执行的结果: test init main

注意：​如果导入包的话，那么优先进行加载包中变量，然后init方法其次是main中变量然后init的方法，剩下的常规执行顺序。

包变量-----包init----main变量----main中init----main方法代码块

如果文章内容有错误，还请大佬们指导，防止误人子弟。继续冲冲冲！

星际迷航‖
关注
  • 4
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
循环结构程序设计（总结）
weixin_61913353的博客
12-16 3756
循环结构是结构化程序设计中的基本结构之一。 C语言提供了for语句、while语句和do- while语句三种循环语句。 5.1引例 例5.1 例5.2 说明:while语句是三种循环结构之一，while后括号中的表达式称为循环条件，循环开始时，一定要保证循环条件为真。需要重复执行的语句精神了循环体。 5.2使用或一句循环实现循环结构 for语句是C语言提供的功能强大、使用广泛的一种循环结构，不仅可以解决循环次数未知的循环问题，特别适合解决循环次数已知的循环问题。 5.2.1 for语句的基本语法 for语
c++课程作业：程序控制结构
03-08
此外，他们还掌握了三种基本的程序控制结构——顺序结构、选择结构和循环结构，并通过实际编程练习提升了这些技能。 1. **基本数据类型**：C++中的基本数据类型包括整型（如int）、浮点型（如float和double）、字符...
Python之选择、循环结构与函数
qq_60381063的博客
02-02 1784
选择结构、循环结构与函数
C语言基础——循环结构
ld15353133609的博客
10-26 1万+
循环执行是循环结构的核心，表现为反复执行一个或一组操作。在编程中，如果想要从数据处理中发现循环执行，就要分析程序的执行结果与数据的处理过程。
Python:程序的分支、循环结构与函数的应用
weixin_61631131的博客
04-19 1237
Python程序的分支、循环结构与函数的应用
Python中的循环结构
m0_72557783的博客
08-12 6632
==有条件地重复地做一件事，每一次做的事情不同但类似。== 程序是为了解决实际问题的，==实际问题中存在着重复动作，那么程序中也应该有相应的描述，这就是循环。
For循环与函数
m0_69674158的博客
05-26 1673
目录 一：for循环 1.for循环 2.for循环注意点 3.break结束整个循环 4.continue结束本次循环，继续下一次循环 二：函数 1.函数定义 2.函数的作用 3.函数的调用 4.函数的参数 5.函数的返回值 6.匿名函数（没有名字的函数） 7.变量的提示 8.变量的作用域 一：for循环 1.for循环 1.概念：做重复的事情,通常和数字关联 2.for循环的基本结构(两个分号不可以省略) for(;;){} 3.for...
Python 入门之控制结构 - 循环结构
wangyongqi的博客
01-10 4750
第1关：While 循环与 break 语句 任务描述 程序的第三大结构是循环结构。在此结构中，通过一个判断语句来循环执行一个代码块，直到判断语句为假时跳出循环。循环语句分为while循环、for循环、循环嵌套和迭代器。循环语句中有一个语句break，通过这个语句可以跳出整个循环。 以下场景便模拟了循环结构与跳出循环的现实场景： 在一个工厂的流水线上每天需要加工零件100件，且每件零件所做的加工都是一样的，也就是说流水线每天要循环做相同的工作100次。但是如果在加工时突然停电，则流水线停止对后面所有零件的加
python数据结构之匿名函数lambda
柳小葱的博客
01-05 6030
????前面的章节，我们学习完了python的基本数据结构：基本数据类型、栈、队列、链表、递归、排序、搜索、树等，今天我们来学习匿名函数lambda，对往期内容感兴趣的同学可以参考????: python数据类型: python数据结构之数据类型. python的输入输出: python数据结构之输入输出、控制和异常. python数据结构之面向对象: python数据结构之面向对象. python数据结构之算法分析: python数据结构之算法分析. python数据结构之栈、队列和双端队列: pyth
python中的循环结构
qq_31974489的博客
03-06 1万+
Python中循环结构有两种类型，分别是：for（遍历循环）于while（无限循环），接下来对两种循环类型的使用与注意事项进行介绍。 一、遍历循环：for for 循环变量 in 遍历结构： # 即逐一取遍历结构中的元素赋值于循环变量 语句块 遍历结构可以是字符串、文件、range()函数或者其他组合数据类型。 组合数据类型： 序列类型 （字符串、元组、列表） 集合类型 （集合） 映射类型 （字典） 使用range函数进行次数的循环，但
C语言的控制结构（顺序结构、选择结构、循环结构）详解
热门推荐
kjl167的博客
01-08 3万+
C语言的三种控制结构一、顺序结构二、选择结构if语句switch语句三、循环结构for循环while循环do while循环 前言：程序由三种基本结构组成：顺序结构、选择结构、和循环结构，任何程序都由这3种基本结构组合而成。 优点：不会存在无规律的转向，可以使程序结构清晰，易于验证正确性且易于纠错。遵循这种方法 的程序设计就是结构化程序设计。 此处简单画出三种结构的执行流程图： 一、顺序结构 顺序结构：依照线性顺序依次执行，简单说就是从上到下依次执行 例如下面程序会依次输出1、2、3、4、5 #inclu
C语言循环结构程序设计编程题.pdf
07-13
在C语言中，循环结构是程序设计的...以上知识点是C语言循环结构程序设计的基本要素，通过解决这些编程题，开发者可以深入理解循环控制、条件判断、数学运算以及基本数据结构等概念，为更复杂的程序设计打下坚实基础。
47-流程控制-for循环结构的基本使用.rar
03-03
在“47-流程控制-for循环结构的基本使用”这个资源中，我们将深入探讨for循环的基本概念、语法以及实际应用。 首先，for循环是一种迭代机制，用于在满足特定条件的情况下重复执行一段代码块。它的基本语法通常包括...
Python的控制结构之For、While、If循环问题
09-16
本文主要探讨了Python中的三种核心控制结构：for循环、while循环和if/else语句。 首先，for循环是Python中最常用的迭代工具。它可以遍历任何序列（如列表、元组或字符串）以及其他可迭代对象。在Python中，`range()...
[沫忘录]Golang基础类型与语法
最新发布
m0_73027268的博客
07-18 268
golang基础
Go 语言返回组装数据
qq_51110402的博客
07-14 265
【代码】Go 语言返回组装数据。
golang小案例获取命令行的的参数并求得最大值
preserveXing的博客
07-15 220
这个案例是Golang理解os.Args的案例 场景就是: 当我们打包后 生成的.exe文件 执行exe肯定会出现哪些命令 例如 npm install app 这里的npm 就是npm .exe install app 就是我们要获取的参数 我们的案例: 编写go程序---->打包成exe--->执行exe--->添加命令行参数 一些数值---->求得最大化数值
解决 go 引用私有包，安装失败
Dreamy_LIN的博客
07-17 203
go mod tidy 或者 go run main.go 时，提示失败，例如 no such host（设置GOPRIVATE）或者 x509: certificate signed by unknown authority 之类的报错（设置GOINSECURE）
C++控制结构解析：函数调用与选择、循环结构
本文主要介绍了C++中的控制结构，包括函数调用语句、表达式语句、空语句、复合语句以及选择结构、循环结构中的各类语句。 在C++编程中，控制结构是编写程序逻辑的关键部分，它们决定了代码的执行顺序和条件。以下是...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值