Go语言基础篇（实操）（涵盖部分细节）

1.安装环境

（1）直接官网下载go语言基础包，如果太慢可选择go语言中文网

（2）配置环境变量，GOROOT，GOPATH注意大写，GOROOT为Go语言的安装目录，GOPATH为自己的工作空间（可自己定义）建议在工作空间下新建pkg，src，bin目录方便以后架构

安装完毕后使用cmd运行go version或者go env检测是否安装完成

2.变量的定义

package main

import "fmt"
func main()  {
	var jemaes string ="五六七"
	name :="Bb"
	l :="name"
	print(jemaes)
	fmt.Printf("%T,%s\n",name,name)
	fmt.Printf("%T,%s\n",l,l)
}

1，使用var定义变量，其中:=表示系统自动检索变量类型以及赋值 如果name已经使用则无法进行:=操作

2，可使用_省略不需要使用的变量

3，%T与%s表示占位符详细请参见Go语言格式化占位符-golang 格式化占位符-golang 输出格式化-golang Printf()格式化-嗨客网 (haicoder.net)https://haicoder.net/golang/golang-printf.html#:~:text=Go%E8%AF%AD%E8%A8%80%E7%9A%84%E6%A0%BC%E5%BC%8F%E5%8C%96,%E4%BB%A5%E5%8F%8A%E5%85%B6%E5%AE%83%E6%A0%87%E8%AE%B0%E7%AD%89%E3%80%82

4，&变量名，表示打印变量的内存地址

5，a,b=b,a可直接交换变量的值

6，常量使用const定义

const t = "556"
	const (
		name0 = iota
		name1 = iota
		name3
		name4
		name5 = iota

	)

常量由于无法改变会直接判断类型并且赋值，iota：GO语言中的计数单位，如上图不论const中的变量赋不赋值iota都会往上增加直到下一个增长域

7，算术运算符：+-*/%，++，--

8，逻辑运算符以及比较运算符：==，!=，<，>，<=，>=，&&，！，||

9，位运算符：<<，>>，&，|，^

&：我和你1结果才为1

|：我或你1结果才为1

^：我和你不同为1

特别注意位运算符：只运算进制

name :=13
 //00001101
 lastname :=67
 //01000011

 //name1:=name|lastname
 //         01001111
 
 //lastname=lastname<<2
 
 //name=name<<2
 fmt.Printf("%d,二进制表示，%b\n",name,name)
 fmt.Printf("%d,二进制表示，%b\n",lastname,lastname)

	//fmt.Printf("%d,二进制表示，%b",name1,name1)

2.常用语句

1，if语句

 if  name!= lastname {
  fmt.Printf("输出")
 }

嵌套if

if  name!= lastname {
  fmt.Printf("输出一次")
  if name == lastname {
   fmt.Printf("不会输出的语句块")
  }
 }

2，switch语句：

name:="TOM"
	switch name {
	case "TOM":
		fmt.Printf("输出\n")
		fallthrough
	case " ":
		fmt.Printf("使用fallthrough穿透输出")
	default:
		fmt.Printf("都不满足的输出")
	}

注意：fallthrough穿透的使用，ps：不论下一个条件满不满足，该条件中的语句都会执行

3，for循环语句

（1）输出乘法口诀表

for i := 1; i < 10; i++ {
		for j := 9; j >=i ; j-- {
			t:=i*j
			fmt.Printf("%d*%d=%d  ",i,j,t)
		}
		fmt.Printf("\n")
	}

（2）遍历字符串和切片

name2:="tom的夏天"
	for i, i2 := range name2 {
		//下标
		fmt.Printf("%d",i)
		//转字符输出
		fmt.Printf("%c",i2)
	}

name3:=[]int{5,6,7}
	for i2 := range name3 {
		fmt.Printf("%d",name3[i2])

	}

（3）break与continue

break退出所有的循环，continue只退出当前循环段

3.函数

（1）函数的声明与调用

//这里先定义多个传参以及返回值的函数
	println(namelast(1, 3))

func namelast(a,b int) (int,int)  {

	return a+b,a-b
}

ps：注意区分传参时的值传递与引用的区别

引用传递：通常发生在切片,map,以及对象中，直接将内存的引用传递过去进而直接修改内存中的值

值传递：基本数据常用到，复制一份到函数中，并没有修改实际内存中的值，除非将值返回

（2）可变参数

可变参数：

first("tom的夏天",5,6,7)

func first(b string,a ...int)  {
	fmt.Printf("\n%s\n",b)
	for i, i2 := range a {
		fmt.Printf("%d",i)
		fmt.Printf("%d",i2)
	}

ps：可变参数的位置只能是最后一个

（3）递归函数：

函数之间互相调用的情况，通常会有一个值来控制递归的中断

ir(5)

func ir(a int)  {
	a--
	if a<0 {
		fmt.Printf("递归条件成功了")
		return
	}else {
		ir(a)
	}
}

（4）defer延迟执行

get1()
defer get2()
defer get3()

ps：如有多个延迟执行代码，会反向执行，先进后出

（5）匿名函数以及函数的自我调用

e:=func(a int) (int){
	fmt.Printf("\n%d\n",a)
	return a
}(3)

fmt.Printf("%d",e)

（6）函数式编程

import "fmt"
func main() {

name:=thred
//此时name也就是函数了
//print(name())
//再传递函数
	println(second(name)(6))

}
func second(a func() int) func(int) int{
b:=a()
fmt.Printf("%d",b)
return func(b int) int {
	return b+1
}
}
func thred() (int) {
	//fmt.Printf("被当作参数的函数")
	return 6
}

这里演示了参数为函数以及返回为函数时的情况

（7）闭包结构

func main() {

	a:=name()
	r1:=a
	fmt.Printf("%d\n",r1())
	fmt.Printf("%d\n",r1())


	b:=name()
	t1:=b;
	fmt.Printf("%d\n",t1())
	fmt.Printf("%d\n",t1())

	fmt.Printf("%d\n",r1())


}


func name() func() int {
	b:=1
	fun:=func() int {
		b++
	return b
	}
return fun
}

fmt.Printf("%d\n",name()())
	fmt.Printf("%d\n",name()())
	fmt.Printf("%d\n",name()())

当一个内层函数访问外层函数的局部变量时，局部变量会因为内存函数的创建而创建。

在实际开发中尽量避免