1
2
3
4
5
6
7
8
gopath目录

gopath目录就是我们存储我们所编写源代码的目录.该目录下有三个字目录:src, bin, pkg.
src--->里面每一个子目录,就是一个包.包含Go的源码文件
pkg--->编译后生成的,包含目标文件
bin--->生成可执行文件

1
2
3
4
5
6
7
8
9
10
GOPATH环境变量
把我们自己存放go语言的目录告诉计算机就可了
新建一个环境变量,然后告诉计算机
步骤
1.新建一个文件加,'goprojects',这个就是存放我们自己开发的程序
2.仿照go官方目录,创建'src(目录,用于存放go语言程序的源码)' 
				  'pkg(目录,用于存放引用其他第三方的程序代码)' 
				  'bin(目录,用于存放编译后的二进制文件(可执行文件))'

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main
import ("fmt")

func main(){
    //声明两个变量m,n,类型为int,用于存放操作数
    var m, n int
    
    fmt.Print("请输入第一个操作数:")
    fmt.Scan(&m)
    fmt.Print("请输入第二个操作数:")
    fmt.Scan(&n)
    
    //Scan函数会从标准输入流读取数据,然后存放在m,n变量中.这里采用引用传递参数(加上&符号,获取变量内存的地址),以保证函数调用后m,n变量能引用到所读的内容
    
    r1 := m + n
    r2 := m - n
    r3 := m * n
    r4 := m / n
    
    //使用 := 运算符可以直接向新变量赋值,不需要var关键字声明
    
    fmt.Printf("%d + %d = %dn", m, n, r1)
    
}

1
2
%

1
2
3
4
//计算5的立方
result := math.Pow(5, 3)
fmt.Printf("5的3次方: %dn",int(result))

1
2
3
4
5
6
7
8
var (
	m int8 = 12
	n int8 = 6
   )

将变量m, n进行与运算
result := m & n

1
2
3
4
5
1 1 0 0       //12
0 1 1 0       //6
---------------------
0 1 0 0       //4

1
2
3
4
var a uint8 = 220
var b uint8 = 89
var c = a | b

1
2
3
4
5
1 1 0 1 1 1 0 0       //220
0 1 0 1 1 0 0 1       //89
----------------------------
1 1 0 1 1 1 0 1       // 221

1
2
100101

1
2
01101

1
2
3
4
5
6
7
8
var n uint8=27     00011011
var r = ^n         11100100 -->228
27+228=255,即uint8数据类型的最大值

var g uint16=150   0000000010010110
var q = ^g         1111111101101001  -->65385
150+65385=65535,即uint16数据类型的最大值

1
2
3
4
5
通用公式:
c = -(n + 1)
7 ----> -8
-6 ---->  5

1
2
3
4
10011101 >>3  结果:00010011
10101001 <<2      10100100
另外注意有符号位的移位

1
2
3
4
5
6
不相等返回1,相等返回0
var x uint8 = 0b_1011_1101           1 0 1 1 1 1 0 1
var y uint8 = 0b_1110_0001           1 1 1 0 0 0 0 1
r = x ^ y                           ------------------
									 0 1 0 1 1 1 0 0

1
2
3
4
5
例如,要将11011111最右边三位变为0,代码如下:
var k uint8 = 0b_11011111
var r = k &^ 0b_00000111
结果为:11011000

1
2
import <包所在的路径>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main

import (
	."GoProjects/src/demo/test01"   // 如果被导入包内的成员不会与当前代码的成员名称冲突,还可以直接把某包中的成员名称合并到当前文件中.
									// 实现方法用句点(.)作为被导入包的别名
									
	mu "GoProjects/src/demo/test02"  // 如果觉得包名太长,输入时不方便,可以起别名
)
func main() {

	StartPlay()
	StopPlay()

	mu.Play()
	mu.Pause()

}

1
2
3
4
5
6
7
8
package test

import "fmt"

func init()  {
	fmt.Println("part1 - 初始化")
}

1
2
3
4
5
6
7
8
package test

import "fmt"

func init()  {
	fmt.Println("part1 - 初始化")
}

1
2
3
4
5
6
7
8
9
package main

import _ "GoProjects/src/test"   //使用import语句导入test包时,为其分配一个由下划线作为别名.此做法的作用:test包仅仅执行初始化代码,而不会导入其成员.此方法会使init函数被调用

func main() {
	

}

1
2
3
4
5
若将项目代码放在GOPATH目录(源码位于src子目录下)之外,在使用import语句导入包时,可以使用相对路径
import ../test       //父级目录下的test目录
import ../../test    //父级的父级目录下的test目录
import ./test        //当前目录下的test目录

1
2
3
4
5
6
7
8
9
10
package abc

func Min(a, b int) int{

}

func min_it(a, b int) int {

}

1
2
3
4
5
6
7
8
type person struct{

}

type Person struct{

}

1
2
3
4
5
<变量名>  :=  <变量值>

f := "xyz"   --->string
z := 1.5e7   --->float64

1
2
3
4
var a,b,c = 10,20,30
简约写法:
x, y, z := "test", 5, 0.02

1
2
3
4
func test() (string, string, int){
	return "abc","xyz",10000
}

1
2
3
4
r1,r2,r3 := test()
fmt.Println("函数的返回值为: ")
fmt.Printf("r1: %vnr2: %vnr3: %vn", r1,r2,r3)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//declare three variables     var关键字 +" "+ (变量声明)
var(
	k = 0.0001
	j = 0.0021
	m int16 = 5530
	)

//declare three constants
const (
	XldFirst = "F"
	XldSecong = "G"
	XldThird = "H"
	)

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "fmt"

var x = "EFG"

func main(){
	//此处覆盖外部变量x
	var x = "XYZ"
	fmt.Println(x)
}

1
2
3
4
	1. 包含 0 个字符: 空字符串
	1. 包含 1 个字符: 与rune类型表达式相同,但数据类型不同
	1. 包含一个以上的字符:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main

import (
		"unsafe"
		"fmt"
		)
		
 var ( 
 		n1 uint8 = 122
 		n2 uin16 = 2000
 		n3 uin32 = 53530020
 		n4 uint64 = 4.33e+5
 		n5 uint = 99977723
		 )
		 
//调用unsafe包中的Sizeof函数,获取变量所占用的内存大小

fmt.Printf("8位无符号整数: %dn",unsafe.Sizeof(n1))     //1
.                                                     //2
.
.

1
2
3
4
5
6
7
8
9
10
11
12
package main

import (
		"fmt"
		"time"
		)

func main(){
    var n = time.Now()
    fmt.println(n)
}

1
2
3
4
5
6
7
8
iota是golang语言的常量计数器,只能在常量的表达式中使用。

iota在const关键字出现时将被重置为0(const内部的第一行之前)，const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。

使用iota能简化定义，在定义枚举时很有用。

1
2
3
//2021年12月2号 22:34:01
var thedate = time.Date(2021,time.December,2,22,34,1,0,time.Local)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
Duration类型代码声明如下:
type Duration int64
以64位整数为基础.		"Duration"表示的是"时间段"------两个时间点之差
Duration类型以纳秒为单位
const (
	Nanosecond Duration = 1
	Microsecond = 1000 * Nanosecond
	Millisecond = 1000 * Microsecond
	Second =      1000 * Millisecond
	Minute =      60 * Second
    Hour =        60 * Minute  
)

eg:
a := 25 * time.Second   // 25秒

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
package main
import ("fmt"
		"math/rand"
		"time")

func main()  {
	//创建新的Timer实例
	var timer = time.NewTimer(5 * time.Second)
	//创建一个通道实例,用于标识任务已完成
	var completed = make(chan bool)
	//退出main函数时关闭通道
	defer close(completed)


	//在新的协程执行任务
	go func()  {
		//随机生成任务所需的时间
		//作用是模拟任务所消耗的时间
		rand.Seed(time.Now().Unix())
		var thelong = rand.Intn(10)
		//暂停当前协程
		time.Sleep(time.Duration(thelong) * time.Second())
		//发送信号,表示任务已完成
		completed <- true
	}()

	//判断任务是顺利完成了还是超时了
	select {
	case <- completed:
		fmt.Println("任务已完成")
	case <- timer.C:
		fmt.Println("任务超时")
	}

}		

1
2
3
4
func AreaFun(w, h int) int {
	return w * h
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//无输入参数,有返回值
func getANumber() float32 {
	return 0.00121
}

//有输入参数,无返回值
func setInt(x int){
	...
}

//无输入参数,无返回值
func hello(){
	...
}

1
2
3
4
func add(x, y int16) int16{
	...
}

1
2
var result = add(19, 54)

1
2
3
4
func getThreeInt() (int, int, int){
	return 100, 1001, 2002

1
2
3
4
var a, b, c = getThreeInt()

var a,_,_ = getThreeInt()  //only need the first value

1
2
3
4
5
6
7
8
9
10
11
func getSomeStrings() (a, b string){
    //为命名地返回值赋值
    a = "Part1"
    b = "Part2"
    //必须使用return语句让函数返回
    return
}

//调用如下:
var s1, s2 = getSomeStrings()

1
2
3
4
5
6
7
8
9
10
11
12
func test3(args ...float32){
    n := len(args)
    fmt.Printf("nn可变参数的个数: %dn",n)
    //打印元素
    if n>0 {
        fmt.Println("参数内容:")
        for _,val := range args{
            fmt.Printf("%f",val)
        }
    }
}

1
2
3
4
var myfun = func (x, y int) int{
    return x*x + y*y
}

1
2
3
//因为函数没有名称,所以在调用时需要通过变量myfun来访问
res : = myfun(2, 4) 

1
2
3
4
func (who string){
    fmt.Prinf("Hello, %sn",who)
}("Jack")

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main

import "fmt"

func main() {

	//创建新的通道对象
	var ch = make(chan byte)

	go func() {
		fmt.Println("新协程")
		//向通道对象发送数据
		ch<-1
	}()

	//从通道对象接收数据
	<-ch
	fmt.Println("主协程")
}

1
2
3
4
5
6
7
var k string = "check"
if strings.Contains(k,"ch"){
	fmt.Printf("字符串 %s 中包含chn", k)
} else {
	fmt.Printf("字符串 %s 中不包含chn", k)
}

1
2
3
4
5
6
7
8
9
10
var mode = 1
	switch mode {
	case 0:
		fmt.Println("关机状态")
	case 1:
		fmt.Println("开机状态")
	case 2:
		fmt.Println("待机状态")
	}

1
2
3
4
5
6
var x interface{} = "hello"
actvalue := x.(string)
变量 x 声明为interface{}类型(空白接口类型,可兼容任意类型),成为具有动态类型的变量.随后赋给他的实际值string类型,它将动态引用一个string实例. x.(string)表达式完成类型断言,并把变量x引用的值转换成string类型,赋值给actvalue变量.虽然在运行阶段变量x和actvalue的值相同,但他们的数据类型不同
var x interface{} = ......
var actvalue string = .....

1
2
3
4
5
6
7
8
9
10
11
var c interface{} = 12
	switch v := c.(type) {
	case string:
		fmt.Printf("字符串 : %sn", v)
	case uint8:
		fmt.Printf("无符号整数 : %dn", v)
	case int:
		fmt.Printf("有符号整数 : %dn", v)

	}

1
2
3
4
5
6
7
8
9
10
11
12
n := 58
	switch  {
	case n<100:
		fmt.Println("该值小于100")
	case n<80:
		fmt.Println("该值小于80")
	case n<50:
		fmt.Println("该值小于50")
	case n<30:
		fmt.Println("该值小于30")
	}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
n := 58
	switch  {
	case n<100:
		fmt.Println("该值小于100")
		fallthrough
	case n<80:
		fmt.Println("该值小于80")
		// fallthrough
	case n<50:
		fmt.Println("该值小于50")
	case n<30:
		fmt.Println("该值小于30")
	}

1
2
3
4
5
6
var q = 1
	for q <= 10 {
		fmt.Printf("q 的当前值为: %dn",q)
		q++
	}

1
2
3
4
for [初始化子句] ; [条件子句] ; [更新子句] {
    ......
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
for i := 0; i < 12; i += 2 {
		fmt.Print(i," ")
	}
	fmt.Println()

	var cc = 'a'
	for ; cc <= 122 ; cc++ {
		fmt.Printf("%c", cc)
	}
	fmt.Println()
	//变量cc是rune类型(表示单个字符), 他是int32类型的别名,所以执行cc++运算并不会报错,122是z的ASCII码
	
	for x := 'Z'; x >= 65; {
		fmt.Printf("%c",x)
		x--
	}

1
2
3
4
5
6
var str string = "天生我才必有用"
	for i, x := range str{
		fmt.Printf("%2d --------> %cn",i, x)
	}
	fmt.Print(len(str))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
var arr = [5]float32{
		1.00085,
		7.001,
		0.0095,
		205.33,
		0.213,
	}
	for index, element := range arr{
		fmt.Printf("[%d]: %fn", index, element)
	}
	
结果:
[0]: 1.000850
[1]: 7.001000
[2]: 0.009500
[3]: 205.330002
[4]: 0.213000

1
2
3
4
for index := range arr {
		fmt.Printf("[%d]: %fn",index, arr[index])
	}

1
2
3
4
for _,element := range arr{
	...
}

1
2
3
4
5
var m = map[rune]string{'a':"at", 'b':"bee", 'c':"cut"}
for key, value := range m {
	fmt.Printf("[%c]: %sn", key, value)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
	//创建通道对象的实例
	var ch = make (chan int)

	//启动新的协程
	go func() {
		//当前代码退出该范围时关闭通道对象
		defer close(ch)

		//向通道发送内容
		ch <- 1
		ch <- 2 
		ch <- 3
		ch <- 4 
		ch <- 5
		ch <- 6
	}()

	//从通道对象中读出所有值
	for  v := range ch {
		fmt.Printf("从通道对象中读出: %dn", v)
	}

1
2
3
4
5
6
7
for a := 10; a > 0; a-- {
		if a == 6 || a == 5 || a == 4 {
			continue
		}
		fmt.Println(a)
	}

1
2
3
4
5
6
7
for a := 10; a > 0; a-- {
		if a == 6 || a == 5 || a == 4 {
			break
		}
		fmt.Println(a)
	}

1
2
3
4
5
6
7
8
9
10
11
12
	var str = "uvwxyz"
	if len(str) >= 3 {
		goto L1
	} else {
		goto L2
	}

L1:
	fmt.Println("字符串的长度符合要求")
L2:
	fmt.Println("字符串的长度不足3字节")

1
2
3
4
5
6
L1:
	fmt.Println("字符串的长度符合要求")
	return
L2:
	fmt.Println("字符串的长度不足3字节")

1
2
3
4
type myType1 ......
type myType2 ......
type myType3 ......

1
2
3
4
5
6
type (
	myType1 ......
	myType2 ......
	myType3 ......
)

1
2
3
4
5
6
7
type name string

var a string = "abcde"
var b name = "abcde"
fmt.Printf("变量a的类型: %Tn",a)
fmt.Printf("变量b的类型: %Tn",b)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//结构体
type car struct{
	id uint
	color uint32
}

//接口
type sender interface {
	writeTo(d string, len int, msg string)
}

//函数
type otherFunc func(x float32) float32

1
2
3
4
5
var x rune = 'H'
var y int32 = 72

fmt.Printf("x和y的值相等吗? %t",x == y)  //true

1
2
3
4
5
6
7
8
type person struct {
	name string
	age uint8
	weight float32
	height float32
	gender uint8
}

1
2
3
4
5
6
7
type Student Struct {
	StdID uint
	Name string
	Age uint8
	email string   //eamil字段只能在当前包中使用
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
type fileInfo struct {
    name string
    size uint64
    isSysFile bool
    createTime int64
}

    //为字段分配默认值
	var x fileInfo
	//输出字段的值
	fmt.Printf("文件名: %+vn", x.name)           //  %+v 打印结构体时，会添加字段名
	fmt.Printf("文件大小: %dn", x.size)		  //  %d      十进制表示
	fmt.Printf("是否为系统文件: %tn", x.isSysFile)//  %t          true 或 false。
	fmt.Printf("创建时间: %sn", time.Unix(x.createTime,0))//%s      输出字符串表示（string类型或[]byte)

1
2
3
4
var x = fileInfo{}

x := fileInfo{}

1
2
3
var px *fileInfo                          //nil
fmt.Printf("文件名: %sn", px.name)        //错误

1
2
3
4
5
6
var y fileInfo
y.name = "dmd.txt"
y.isSysFile = false
y.size = 6955236
y.createTime = time.Date(2022, 1, 22, 14, 57, 0, 0, time.Local).Unix()

1
2
var g = fileInfo{ name:"abc.txt", size:128880, ....}

1
2
3
4
5
6
K := fileInfo {
	name: "dex.txt",
	size: 3006265,
	createTime: time.Date(2020, 1 ,1, 23, 15, 4 ,0 ,time.Local).Unix()
}

1
2
var z = fileInfo{"text.dat",1172362,true,time.Now().Unix()}

1
2
3
var c = fileInfo{"text.dll",1172362,true,time.Now().Unix()}
var pc *fileInfo = &c

1
2
var pc *fileInfo = &fileInfo{"text.dl",1172362,true,time.Now().Unix()}

1
2
3
4
5
6
7
8
type test struct {
    
}

func (o test) doSomething() string{
    return "do nothing"
}

1
2
3
var n test 
s := n.doSomething()

1
2
3
4
func (o *test) doSomething2() string{
	return "do nothind - 2"
}

1
2
3
4
type demo struct {
	data int
}

1
2
3
4
5
6
7
8
func (x demo) setIntV1(n int){
    x.data = n
}

func (x *demo) setIntV2(n int){
    x.data = n
}

1
2
var a = demo{data:100}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
//情况一: 非指针类型接收demo实例
fmt.Println("---------------传递demo实例的副本--------------------")
fmt.Printf("调用setIntV1方法前,data字段的值: %dn", a.data)
//调用setIntV1方法
a.setIntV1(200)
fmt.Printf("调用setIntV1方法后,data字段的值: %dnn", a.data")
           
//情况二: 以指针类型接收demo实例
fmt.Println("---------------传递demo实例的内存地址--------------------")
fmt.Printf("调用setIntV2方法前,data字段的值: %dn", a.data)
//调用setIntV2方法
a.setIntV2(200)
fmt.Printf("调用setIntV2方法后,data字段的值: %dnn", a.data")

1
2
3
4
type <接口名称> interface {
	<方法列表>
}

1
2
3
4
5
6
type task interface {
	start()
	stop() uint16
	timeout(long int64) bool
}

1
2
3
4
5
type runner interface{
	getContext(key string) (uint64, bool)
	getContext(key int) (uint8, bool)
}

1
2
3
4
5
type musicHub interface {
    play(track uint)(stat int)
    _(title string) int                 //方法名称无效
}

1
2
3
4
5
6
7
8
9
10
type test interface {
	sendMessage(head, body string) int
}

func main() {
	var ix test
	fmt.Printf("接口类型变量的默认值: %v",ix)

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
type Locker interface {
	Lock() uint16
	Unlock(id uint16)
}

//下面两个结构体均实现了Locker接口
type interLocker struct {
	lockID uint16
}

func (l *interLocker) Lock() uint16 {
	l.lockID++
	fmt.Printf("系统已锁定")
	return l.lockID
}

func (l *interLocker) Unlock(id uint16) {
	if id!=l.lockID {
		fmt.Println("锁定标识不匹配")
		return
	}
	fmt.Println("系统已解锁")
}

type custLocker struct{
	locked bool
}
func (l *custLocker) Lock() uint16{
	fmt.Println("线程已锁定")
	return 0
}
func (l *custLocker) Unlock(id uint16){
	fmt.Println("线程已解锁")
}