关键词：

前言

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

• 循环
• • for
  • • for使用
    • while实现
    • do...while实现
  • break
  • • label使用
  • continue
  • goto介绍
• 包使用
• 函数
• • 介绍
  • 参数
  • • 多个参数如何传递
  • 返回值
  • 函数类型
  • 匿名函数
  • 闭包
  • defer介绍
  • 常见函数
  • • 字符串函数
    • 时间函数
    • init函数

循环

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

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([]byte97, 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方法代码块

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

控制结构(scala)(代码片段)

...变。valfilename=if(!args.isEmpty)args(0)else"default.txt"while循环Scala的While循环和其他语言没多大差别。有wh 查看详情

流程控制(代码片段)

...语句操作。分支结构：根据条件判断执行哪些语句操作。循环结构：根据循环初始条件和终结要求，执行循环体内的操作。分支结构Java提供两种分支结构：if和switch。其中if语句使用布尔表达式或者是布尔值进行判断来进行分支... 查看详情

循环控制结构程序（初学者）(代码片段)

循环结构是程序中一种很重要的结构，其特点是在给定条件成立时，反复执行某程序段，直到条件不成立为止。给定的条件称为循环条件，反复执行的程序段称为循环体。C语言提供了多种循环语句，可以组成各种不同形式的循... 查看详情

基本控制结构(代码片段)

文章目录基本控制结构选择结构描述复杂的条件循环结构计数循环基本控制结构选择结构单分支双分支多分支 注意流程图关系运算符左结合<><=>=优先级大于==!=非0为真0为假描述复杂的条件逻辑运算符&&AND ||OR !... 查看详情

第3章控制循环语句(代码片段)

...用场景和作用break的使用场景：在选择结构switch语句中在循环语句中离开使用场景的存在是没有意义的break的作用：跳出单层循环1.1.2代码案例十八packagecom.itheima_07;/**break:中断的意思*使用场景：*A:switch语句中*B:循环中*注意：*离... 查看详情

[算法竞赛入门]第二章_循环结构程序设计(代码片段)

第2章循环结构程序设计【学习内容相关章节】2.1for循环2.2循环结构程序设计2.3文件操作2.4小结与习题【学习目标】（1）掌握for循环的使用方法；（2）掌握while循环的使用方法；（3）学会使用计算器和累加器；（4）学会用输出... 查看详情

golang中结构体struct(代码片段)

...f1a;Golang学习【day1】变量、类型Golang学习，指针，循环控制相关循环结构控制、包函数的使用异常处理、数组老奶奶可以看懂的切片老奶奶可以看懂系列之—Golang的Map映射结构体Struct面向对象Golang与Java面向对象区别Struct... 查看详情

golang中结构体struct(代码片段)

...f1a;Golang学习【day1】变量、类型Golang学习，指针，循环控制相关循环结构控制、包函数的使用异常处理、数组老奶奶可以看懂的切片老奶奶可以看懂系列之—Golang的Map映射结构体Struct面向对象Golang与Java面向对象区别Struct... 查看详情

流程控制结构(代码片段)

...程序从两条或多条路径中选择一条去执行　　　 3）循环结构：程序在满足一定条件的基础上，重复执行一段代码　　2、if函数　　　　语法：if(表达式1,表达式2,表达式3)　　　　执行顺序：如果表达式1成立，则if函数返回... 查看详情

matlab的流程控制(代码片段)

...现用户对程序流程的控制。MATLAB的程序路程控制主要包括循环控制和条件选择控制。循环控制结构for循环结构for循环结构的格式为：for循环变量=向量表达式 循环体语句end该循环结构的执行方式为：从向量表达式的第一列开始，... 查看详情

学习python之条件循环和包(代码片段)

学习Python之条件、循环和包python条件控制语句if-elseif-else小技巧python循环语句1.while循环2.for-in循环3.for与range()函数4.break和continuepython项目结构1.模块2.包3.模块导入(1).import导入(2).from-import导入(3).import*(4).__init__.py文件(5).模块内置属... 查看详情

mysql流程控制(代码片段)

...IFNULL()、NULLIF()、ISNULL()函数的使用MySQLIF()函数的使用分支结构之IFIFNULL()函数的使用NULLIF()函数的使用ISNULL()函数的使用case函数实操案例示例1示例2MySQL流程控制IF()、IFNULL()、NULLIF()、ISNULL()函数的使用MySQLIF()函数的使用SELECTIF(TRUE,&# 查看详情

mysql流程控制(代码片段)

...IFNULL()、NULLIF()、ISNULL()函数的使用MySQLIF()函数的使用分支结构之IFIFNULL()函数的使用NULLIF()函数的使用ISNULL()函数的使用case函数实操案例示例1示例2MySQL流程控制IF()、IFNULL()、NULLIF()、ISNULL()函数的使用MySQLIF()函数的使用SELECTIF(TRUE,&# 查看详情

python入门之控制结构-循环结构——第4关：迭代器(代码片段)

任务描述迭代器就是用来循环访问一系列元素。迭代器不仅可以迭代序列也可以迭代不是序列但是表现出序列行为的对象。本关的任务是让读者理解与学会使用迭代器相关知识迭代器的优点迭代器访问与for循环访问非常相似࿰... 查看详情

控制循环结构(代码片段)

...xff0c;提供了continue，break，return3个关键字用来控制循环结构。使用break结束循环某些时候需要在某种条件出现时强制终止循环，而不是等到循环条件为false时才推出循环。此时，可以使用break来完成这个功能，bre... 查看详情

python顺序选择循环使用(代码片段)

格式化输出顺序选择循环结构简单使用查看某个模块、内置函数或者某个对象使用帮助help([module|object.ways])格式化输出将代码按照指定格式输出：%对字符串进行格式化，\用来做转义格式符：%c:显示字符的ASCII码%d,%i:显示十进制整... 查看详情

python基础之控制结构(代码片段)

....代码块与缩进2.条件语句2.1if语句2.2if语句的嵌套2.3断言3.循环3.1while循环3.2for循环3.3中断循环4.控制语句综合嵌套5.列表解析式Python基础相关链接0.学习目标Python是简洁、易学、面向对象的编程语言。它不仅拥有强大的原生数据类... 查看详情

scala中的控制结构(代码片段)

　　所谓的内建控制结构是指编程语言中可以使用的一些代码控制语法，如Scala中的if,while,for,try,match,以及函数调用等。需要注意的是，Scala几乎所有的内建控制结构都会返回一个值，这是由于函数式编程语言被认为是... 查看详情