IDEA 配置Go环境，编写Golang代码,学习笔记（一）

2023-10-31

Hello,各位小伙伴们，又有一段时间没有更新了，老哥呢，最近去外面面试，发现Java已经是卷得不能在卷了，老哥没有办法，只能另辟蹊径，去卷Go，现在可以说又回到原点了。

诶，世事无常，大肠包小肠。

跟着Jessica老哥学习Golang

搭建Go环境
- golang语法

搭建Go环境

1、老哥这篇文章，需要读者有一定的编程基础，一些基本的语法我不会讲，节省篇幅。还望见谅

2、windows下载，Golang 官方下载地址
在这里插入图片描述

3、下载完成以后，安装，选择一个合适的位置，环境变量可以配置一下，现在最新的版本好像已经默认帮你配置好了，可以通过命令查看是否配置完成,然后输入以下两行命令

GO111MODULE golang最新的模块化编程

GOPROXY golang的代理，很多插件在国外Github上面，我们设置一个镜像拉取，方便一些

D:\>go version
go version go1.18.4 windows/amd64

D:\>go env -w GO111MODULE=on

D:\>go env -w GOPROXY=https://goproxy.io,direct

4、启动IDEA，在settings里面搜索 plugins,安装Go插件
在这里插入图片描述
5、如果搜不到，可能是你的IDEA插件源没有更新，去这里修改

6、新建一个项目gostudy,没有配置Go的安装路径需要配置一下

7、最好放在src目录下

8、进入工程以后，我们需要设置一下控制台输出，按住ctrl+shift+A,如果按不了，可能是快捷键冲突了，需要你们把输入法、其他无关软件先退出再试一下，为了控制台输出更加清晰，没有多余的内容，找到go.run.process.with.pty这个属性，取消勾选

在这里插入图片描述
9、新建一个test包，然后编写代码

10、如果无法打印，可以在IDEA终端，输入 go init mod +你的项目名字，最后再次测试打印

D:\Learning\Go\project\src\gostudy>go mod init gostudy

golang语法

1、在go语言里面，有main函数的包，包名是main，其他的包则使用当前文件上一级包作为包名

2、需要使用api，用到的是导入,IDEA会自动完成

3、声明变量可以使用 var xxx = 666，也可以使用 var xxx int =666,也可以使用 xxx := 666,需要注意的是，变量声明在函数中必须使用，如果不使用，就会报错，常量不会

3A、常量使用 const关键字

5、字符串有专门的Api，strings 做各种判断，如果用到截取，需要把字符串当成一个数组，从哪里截取到哪里

6、使用对象，需要用到 type struct 关键字

struct 等同于 java 的class

package main

import (
	"fmt"
	"strings"
)

const Logo = "Jessica老哥学习Go"

func main() {
	//1、打印数组
	arr1 := [...]int {11,26,3}
	fmt.Print(arr1[1])
	//换行
	fmt.Println()

	//2、循环遍历
	for i := 0; i < 10; i++ {
		fmt.Print(i," ")
	}
	fmt.Println()

	//3、字符串判断、截取
	var str="hello world"
	fmt.Print(strings.Contains(str, "h"))
	fmt.Println()
	fmt.Print(str[0:4])
	fmt.Println()

	//3A、对象tostring
	user1 := User{"Jessica,",26}
	fmt.Print(user1)
	fmt.Println()

	//5、构造函数打印对象
	user2 := NewUser("666", 18)
	fmt.Print(user2.name)
	fmt.Println()

	//6、调用一个方法
	fmt.Print(test())
}


func test() string  {
	return "你好呀"
}

type User struct {
	name string
	age int
}

func NewUser(name string, age int) *User {
	return &User{name: name, age: age}
}

7、如果我们需要查看一个对象的类型，或者打印这个对象，可以使用以下代码

package main

import "fmt"

func main() {
    /**
	格式化输出
     */

	//1、数据类型
	dept := Dept{"张三", 15}
    fmt.Printf("%T",dept.name)
    //换行
	fmt.Println()

	//2、输出dept对象
	fmt.Printf("%v",dept)
	fmt.Println()

	//3、输出包名和类名+对象数据
	fmt.Printf("%#v",dept)

}

type Dept struct {
	name string
	age int
}

8、数组的遍历和条件判断

package main

import (
	"fmt"
)

func main() {
	arr := [...]int{11, 2, 10}

	arr1 := []int{111, 22, 100}

	//数组遍历方式一
	for i := 0; i < len(arr); i++ {
		fmt.Print(arr[i], " ")
	}
	//换行
	fmt.Println()

	//数组遍历方式二，_表示占位符，也可以用index，
	//如果使用了具体的值，必须使用
	for _, value := range arr {
		fmt.Print(value," ")
	}
	fmt.Println()

	//3、动态数组(切片)遍历
	for _, value := range arr1 {
	    fmt.Print(value," ")
	}
    fmt.Println()
	
	//3A、条件判读 if elseif
	for i := 0; i <= 5; i++ {
		if i%3 == 0 {
			fmt.Print(i, " ")
		} else if i == 5 {
			fmt.Print("等于5，需要停止了")
			break
		}
		//继续下一次循环
		continue
	}
	fmt.Println()

	//5、条件判断 switch case
	i :=2
	switch  i {
	case 1:
		fmt.Print("1")
	case 2:
		fmt.Println("2")
		//后面不符合条件的也会打印
		//fallthrough
	case 3:
		fmt.Println("3")
	}

}

9、动态数组（切片）

package main

import "fmt"

func main() {
   //切片
	var dArr= [] int {3,6,9}
	//取出所有
	fmt.Print(dArr[:]," ")
	fmt.Println()

    //取出一个区间
	fmt.Print(dArr[0:2])
	fmt.Println()

	//因为是动态数组，所以可以CRUD
	//新增
	createArr := append(dArr, 22)
	fmt.Print(createArr)
	fmt.Println()

	//修改
	dArr[0]=30
	fmt.Print(dArr)
	fmt.Println()

	//删除,[3 6 9],删除是这样做的，它先截取0到1的数组，不包括1，然后截取2到后面的数组
	//再拼接到一个新的数组，实现删除
	deleteArr := append(dArr[:1], dArr[2:]...)
	fmt.Print(deleteArr)
	fmt.Println()

	//查询
	for _, value := range dArr {
		fmt.Print(value," ")
	}
	fmt.Println()

	//深拷贝,修改数组dArr2 会同时修改dArr
	//小知识：map slice interface channel 默认是深拷贝
	var dArr2=dArr
	dArr2[0]=300
	fmt.Print(dArr," ")
	fmt.Print(dArr2)
	fmt.Println()

    //浅拷贝,创建一个空数组，需要使用make命令分配地址
	var dArr3 = make([]int,len(dArr))
	//copy 前面表示你要拷贝的新数组，后面是之前的数组
    copy(dArr3, dArr)
	dArr3[0]=3000
	fmt.Print(dArr, " ")
	fmt.Print(dArr3)
}

10、map 存储 key-value数据，查找和遍历

package main

import "fmt"

func main() {
	map1()
	map2()
	map3()
}

func map1()  {
	var m1 = make(map[string]string)
	m1["name"]="tom"
	m1["age"]="20"
    fmt.Print(m1)
	fmt.Println()
}

func map2()  {
	var m2=map[string]string {"name":"Jessica","age":"18"}
	fmt.Println(m2)
}

func map3()  {
	m3 := map[string]int{"id":111,"pid":11,"ppid":1}
	//取出单个key
	fmt.Println(m3["id"])

	//取出所有的key和value
	for index, value := range m3 {
		fmt.Println(index,value)
	}

}

11、函数 func
① golang里面有三种函数，普通函数、匿名函数、写在结构体的函数(闭包)（struct）

② 不允许函数重载

③不允许嵌套普通函数，但是可以嵌套匿名函数

④函数是一个值，可以将函数赋值给一个变量

⑤函数可以作为一个参数传递给另外一个变量

⑥函数的返回值可以是一个函数

package main

import "fmt"

//go语言里面 参数值放前面，参数类型放后面
func sum(a int ,b int ) (result int)  {
	return a+b
}

//go语言暂时不支持三目运算符
func max(compare1 int,compare2 int)  int  {
	if compare1 >compare2{
		return compare1
	}else{
		return compare2
	}
}



//匿名函数
func _()  {
	var n1,n2,n3 =11,2,3
	n4,n5,n6 :=11,22,33

	fmt.Println(n1,n2,n3)
	fmt.Println(n4,n5,n6)

}

func hello(name string) string  {
	return name
}


func sayHello(name string, f func(n string) string)  string {
	 return f(name)
}

func calc(mtype string) (f func(a int, b int) int)  {
	if mtype =="+"{
		return sum
	}else {
		return max
	}
}


func main() {
	//有点接口和实例化的意思
	//f1相当于java的接口
	//max相当于java的实现类
	type f1 func(a int, b int) (result int)

	var ff f1 = sum
	fmt.Println(ff(1, 2))

	ff = max
	fmt.Println(ff(22, 33))

	//2、高阶函数调用一,函数作为参数传递
	fmt.Println(sayHello("你好呀", hello))

	//3、高阶函数调用二，函数作为返回值传递
	resultAdd := calc("+")(66, 34)
	fmt.Println(resultAdd)

    //3A、匿名函数,如果在函数的结尾，加了小括号，并且传了参数
    //等同于自己调用自己
	r :=func(a int, b int) int {
		if a *b == 9 {
			return 1
		}else {
			return 0
		}
	}(3,3)
	fmt.Println(r)

}

12、闭包函数，这个概念有点抽象，个人理解是函数作为返回值后，再次调用参数，它和高阶函数调用二很类似

package main

import "fmt"

//闭包,add不传参数，得到返回值是一个函数，向返回值函数传参是可以的
//如   f :=add()
//     f(10)
func add() func(y int) int  {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}

func main() {
	//1、闭包,不同返回值作用域不同
	f := add()
	fmt.Println(f(10))
	fmt.Println(f(20))
	fmt.Println()

	f1 :=add()
	fmt.Println(f1(20))
	fmt.Println(f1(30))
}

13、递归、defer、init

递归: 自己调用自己

defer: 延迟、逆序加载，先定义的后执行
用途:
① 关闭文件句柄
② 锁资源释放
③ 数据库连接释放

init: 初始化，在main函数前面执行
init 函数没有参数，没有返回值
init 函数可以有多个
init 函数自动执行，无法被调用

在golang语言里面，初始化顺序为变量初始化 -> init() ->main

package main

import "fmt"

//递归

//方式一
func f1(n int) int {
	var s  =1
	for i := 1; i <= n; i++ {
		s *=i
	}
	return s
}

//方式二
func  f2 (n int) int {
	if n==1 {
		return 1
	}else {
		return n * f2(n-1)
	}
}

//斐波那契数列 递归求和
func f3(n int) int {
	if n == 1 || n == 2 {
		return 1
	}
    // f3(4)+f3(3)
    // f3(3)+f3(2) + f(2)+f(1)
    //f3(2)+f3(1)+ f3(2) + f(2)+f(1) =1+1+1+1+1=5
	return f3(n-1) + f3(n-2)

}


//defer 先加载的后执行  会先执行b的值，再执行a的值
//如 defer a :=1
//   defer b :=2

func deferTest()  {
	fmt.Println("start...")

	defer fmt.Println("step1...")
	defer fmt.Println("step2...")
	defer fmt.Println("step3...")

	fmt.Println("end...")
}

var i int =initVar()

func init()  {
	fmt.Println("init1执行了...")
}

func init()  {
	fmt.Println("init2执行了...")
}

func initVar() int {
	fmt.Println("initVar...")
   return 1
}


func main() {
	fmt.Println(f1(6))
	fmt.Println(f2(6))
	fmt.Println(f3(5))

	deferTest()
}

在这里插入图片描述

14、最后，各位小伙伴们，麻烦给老哥一个点赞、关注、收藏三连好吗，你的支持是老哥更新最大的动力，谢谢！

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)