golang 基础01

缺乏、安全感 2022-12-04 07:46 229阅读 0赞

### 1.启动 ###

必须是main包下面，才能执行main方法。

package main
    
    import (
    	"fmt"
    )
    
    func main(){
    	fmt.Println("hello world !!!")
    }

### 2.基本参数使用 ###

func baseUse(){
    	//泛型赋值
    	var c = 5 + 6
    	//推断赋值
    	sum := 6 + 6
        
        //打印
    	fmt.Println("sum = ", 66)
    	fmt.Printf("数字c = %d \n", c) //占位符拼接
        
        //协程阻塞2秒
        time.Sleep(2 * time.Second)
    
    	//开启一个协程调用
    	go add(6)
    
        //函数返回多个值
    	var one, two = addTwo(2,3)
    	fmt.Println(two, one)
    
    	var one2, _ = addTwo(2,3)
    	fmt.Println("可以用下划线代替变量", one2)
    
    	//获取当前时间戳(秒)
    	second := time.Now().Unix()
    	fmt.Println("当前时间",second)
    }
    
    //a传入参数，int传入类型，int返回参数类型
    func add(a int) int{
    	return a + 1
    }
    
    //多个返回值
    func addTwo(a int,b int) (int,string){
    	return a + b, "求和"
    }

### 3.包结构 ###

项目内第一个路径必须是 src

main、user、value是指包名称

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1NDE4NTE4_size_16_color_FFFFFF_t_70][]

本包内调用

package main
    
    import (
    	"time"
    )
    
    /**
    main 是可执行程序的包
    go里面所有程序都在一个包里面
    相同包，程序之间相互可直接调用
    不同包，需要引用其他包才能调用
    */
    func getMessage(a int,b int) string{
    	//线程睡眠2秒
    	time.Sleep(2 * time.Second)
    	sum := a + b
    	str := string(sum) + "同包名下可以直接调用"
    	return str
    }

调用其他包(方法函数名开头必须大写)

package user
    
    import (
    	"time"
    )
    
    /**
    包
    包名与文件夹名一致（允许不一致）
    同一个包下，所有文件的名字是一致的
    大写开头的方法或变量，可以被其他包使用
    
    导入外部包，一个或多个外部包，go get ，支持github,bitbucket,google code
    1.下载远程安装包
    2.go install 安装远程包, 会在gopath 中的 pkg中
    
    	大写开头函数名是可被其他包调用
    	小写开头函数名只能是本包调用
     */
    func Add(a int, b int)  {
    	time.Sleep(2 * time.Second)
    	sum := b + a
    	return sum
    }

package main
    
    import (
    	"base/user" 
    	m "base/user" //导入可以用别名
    	"fmt"
    	. "frame" //下面FrameTime()， 可以直接使用，不用名称
    )
    
    func main(){
        FrameTime()    
    
    	var name = getMessage(6,6)
    	fmt.Println(name )
    
        var sum= user.Add(6,6)
        fmt.Println(sum)
    
        var sum2= m.Add(100,200)
        fmt.Println(sum2)
    }

### 4.打包 直接运行二进制文件 （windos） ###

1.  环境变量 GOPATH设置成当前项目 D:\\golang项目\\GolangStude
2.  cmd进入到项目跟目录下 -o是打包到指定目录下
3.  go build -o src/ src/main/run003.go 
4.  执行生成的二进制文件验证 main.exe （就算里面有其他包调用，也是只打包这个）
5.  找到 main.exe 双击(只需要编译main包，其他引用会自动导入)

**idea 打包**

1.添加项目

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1NDE4NTE4_size_16_color_FFFFFF_t_70 1][]

2. 配置运行参数

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1NDE4NTE4_size_16_color_FFFFFF_t_70 2][]

### 5.协程，管道使用 ###

package user
    
    import (
    	"time"
    )
    
    //把结果输出到管道
    func Add(a int, b int, c chan int)  {
    	time.Sleep(2 * time.Second)
    	sum := b + a
    	c <- sum
    	c <- 999
    }

go user.Add(100,200,pipe) 这里使用 go开启一个协程异步调用

这里获取管道内容时，会阻塞等待结果

func main(){
    	//管道使用
    	var pipe chan int
    	pipe = make(chan int, 2)   	//创建一个int的管道 可存储2个参数
    	go user.Add(100,200,pipe)
    	userSum1 := <- pipe			//获取管道信息，每次取一个 (会等待协程的执行结果,会阻塞在这里)
    	fmt.Println("userSum1", userSum1)
    	userSum2 := <- pipe
    	fmt.Println("userSum2", userSum2)
    }

###  6.服务器启动调用 ###

main启动的时候依次调用，依赖的包下的所有init函数

package user
    
    import (
    	"fmt"
    	"time"
    )
    
    func init()  {
    	fmt.Println("执行user初始化")
    }
    
    //把结果输出到管道
    func Add(a int, b int, c chan int)  {
    	time.Sleep(2 * time.Second)
    	sum := b + a
    	c <- sum
    	c <- 999
    }

### 7.select ###

select 会随机检测条件，如果有满足则执行并退出，否则一直检测。

package main
    
    import (
    	"log"
    
    	"github.com/robfig/cron"
    )
    
    //每分钟执行一次
    func main()  {
    	i := 0
    	c := cron.New()
    	spec := "0 */1 * * * *"
    	c.AddFunc(spec, func() {
    		i++
    		log.Println("execute per second", i)
    	})
    	c.Start()
    	select {}
    }

select + for 组成一直检查功能，知道满足退出条件

func main() {
    
        ch := make(chan int)
        c := 0
        stopCh := make(chan bool)
    
        go Chann(ch, stopCh)
    
        for {
            select {
            case c = <-ch:
                fmt.Println("Recvice", c)
                fmt.Println("channel")
            case s := <-ch:
                fmt.Println("Receive", s)
            case _ = <-stopCh:
                goto end
            }
        }
    end:

### 8、指针 ###

/*
    指针：(用于管理我们的内存)存储的是另一个变量的地址
    &var
    值类型：整数、浮点数、bool、array、string、struct，分配在栈中
    引用类型：指针、slice、map、chan、interface
    */
    func RunPointer() {
    	var intValue1 int = 100
    	var pointer1 *int = &intValue1
    
    	fmt.Printf("intValue1的值=%d, 地址=%v\n", intValue1, &intValue1)
    	//指针的值是上个变量的地址，地址是自己的新地址
    	fmt.Printf("pointer1的值=%v, 地址=%v\n", pointer1, &pointer1)
    
    	//通过指针修改变量的值
    	*pointer1 = 50
    	fmt.Printf("pointer1的值=%v, 指针绑定的变量值=%v, 原始参数的值=%v\n", pointer1, *pointer1, intValue1)
    }

9、结构体string方法（方便打印指针）

type teacher struct {
    	High int32
    	Sex  int32
    }
    
    func (t *teacher) String() string {
    	return fmt.Sprintf("{High:%d,Sex:%d}", t.High, t.Sex)
    }
    
    func main() {
    	// 结构体指针的数组2
    	arr2 := []*teacher{
    		&teacher{High: 170, Sex: 17},
    		&teacher{High: 180, Sex: 18},
    	}
    	fmt.Println(arr2)
    }

10、不同进制，number间可直接判断

func main() {
    	num1 := 0x50 // 80
    	num80 := 80
    	fmt.Println(num1 == num80) // true
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1NDE4NTE4_size_16_color_FFFFFF_t_70]: /images/20221123/b64da7d20df24970b2aec911ab495c44.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1NDE4NTE4_size_16_color_FFFFFF_t_70 1]: /images/20221123/c2e2ceb372fb4ba287ff3578e0c94e56.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1NDE4NTE4_size_16_color_FFFFFF_t_70 2]: /images/20221123/8d51bfff05074b548421280cbad3a5c4.png