golang 基础01

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是指包名称

 本包内调用

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.添加项目

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
}