go语言学习之路 go语言入门经典

转载

mob64ca140caeb2 2024-08-13 16:27:36

文章标签 go语言学习之路 go golang 匿名函数初始化 文章分类 Go语言后端开发

go语言语法入门

1.源文件

源码采用UTF-8编码,对Unicode支持良好
在文件头部用package声明所属包的名称
左大括号{必须和函数声明或者控制结构放在同一行
go语句最后的分号可省，出现分号的典型位置是for循环或类似之处

2.变量

声明单个变量

var name type是声明单个变量的语法
如果变量未被赋值，Go 会自动地将其初始化，赋值该变量类型的零值（Zero Value）
这是对C语言的优化

如C语言
int* a,b; a是指针，b不是，如果两者都是指针，必须要在b前重复一个*
而go语言
var a,b *int a,b都是指针

声明变量并初始化

var name type = initialvalue 的语法用于声明变量并初始化。

支持类型推断

var name = initialvalue根据初始化值推断类型

声明多个变量

var name1, name2 type = initialvalue1, initialvalue2
不同类型的变量

var (  
        name1 = initialvalue1
        name2 = initialvalue2
        name3 type
      )

简短声明

name:=initialvalue
要求1：:=操作符左边的所有变量都有初始值

name,age:="kyl"就会报错，因为age没有赋值

要求2：:=操作符左边至少有一个变量是未声明的

强类型

不允许某一类型的变量赋值为其他类型的值

定义变量后要使用，否则会报错

var a int//声明单个变量
    var b int=10//声明变量并初始化
    var c="hello"//类型推断
    d:=1.5//简短声明

3.`if`语句

go 中的条件表达式不需要像C语言括起来
if 和else 后面的大括号不可省略，即使只有一条语句
else 不可单独成行，必须要跟在if的右括号的后面，else if同理
if 和条件间支持定义一个变量，但是变量只在条件块中有效

if a > b {
     c = a
    } else {
        c = b
    }
    if d := 50; d > 60 {
        fmt.Println("pass")
    } else {
        fmt.Println("fail")
    }

4.输入语句

使用fmt.Scanln()获取输入/使用fmt.Scanf()获取输入

var name string
    var age int
    var num int
    //使用fmt.Scanln()
    fmt.Println("input your name")
    fmt.Scanln(&name) //莫忘取地址符号
    fmt.Println("input your age")
    fmt.Scanln(&age)
    //使用fmt.Scanf()
    fmt.Println("input your num")
    fmt.Scanf("%d", &num)
    fmt.Printf("名字是%v，年龄是%v，序号是%d\n", name, age, num)

5.`switch`分支结构

case 后面可以带多个表达式，用分号隔开
case 语句块不需要写break , 因为默认会有,即在默认情况下，当程序执行完case 语句块后，就直接退出该switch 控制结构。
case/switch 后是一个表达式( 即：常量值、变量、一个有返回值的函数等都可以)
case 后的各个表达式的值的数据类型，必须和switch 的表达式数据类型一致
case 后面的表达式如果是常量值(字面量)，则要求不能重复
switch 后也可以不带表达式，类似if --else 分支来使用
如果在case 语句块后增加fallthrough, 则会继续执行下一个case，而不去判断下一个case的表达式是否为true,也叫switch 穿透

var month int
    fmt.Println("input month")
    fmt.Scanln(&month)
    switch month {
    case 3, 4, 5:
        fmt.Println("spring")
    case 6, 7, 8:
        fmt.Println("summer")
    case 9, 10, 11:
        fmt.Println("autumn")
    case 12, 1, 2:
        fmt.Println("winter")
    default:
        fmt.Println("input error!")
    }

input month
12
winter
input month
13
input error!
input month
5
spring

//switch后可以不带表达式，类似if-else来使用
    var age int
    fmt.Println("input age")
    fmt.Scanln(&age)
    switch {
    case age == 10:
        fmt.Println("age==10")
    case age == 20:
        fmt.Println("age==20")
    default:
        fmt.Println("no match")
    }

    //对范围的选择
    var score int
    fmt.Println("input score")
    fmt.Scanln(&score)
    switch {
    case score >= 90://case后也可以对范围进行判断
        fmt.Println("great")
    case score >= 80:
        fmt.Println("good")
    case score >= 60:
        fmt.Println("ok")
    default:
        fmt.Println("bad")
    }

    switch time.Now().Weekday() {//需要使用time包
    case time.Saturday, time.Sunday:
        fmt.Println("it's the weekend")
    default:
        fmt.Println("it's a weekday")
    }

    switch t := time.Now();true{//tru如果省略，默认为true；但‘;’不能少
    case t.Hour() < 12:
        fmt.Println("it's before noon")
    default:
        fmt.Println("it's after noon")
    }

    //fallthrough
    var num int
    switch num {
    case 1:
        fmt.Println("ok1")
        fallthrough //默认只能穿透一层
    case 2:
        fmt.Println("ok2")
        fallthrough
    case 3:
        fmt.Println("ok3")
    default:
        fmt.Println("no match")
    }

6.循环

方式一：（与c相同）

for循环变量初始化; 循环条件; 循环变量迭代{
循环操作(语句)
}

方式二：（相当于c中的while）

for 循环判断条件{
//循环执行语句
}
将变量初始化和变量迭代写到其它位置

方式三：（需要配合break使用）

for {
//循环执行语句
}

package main

    import(
        "fmt"
        "time"
        "math/rand"
    )
    func main(){
        count:=0
        for{
            rand.Seed(time.Now().UnixNano())
            n:=rand.Intn(100)+1
            //fmt.Println("n=",n)
            count++
            if(n==50){//莫忘大括号
                break
            }
        }
        fmt.Println("生成50需要的次数：",count)
    }

package main

    import (
        "fmt"
    )
    //打印九九乘法表
    func main(){
        var num  int=9
        for i:=1;i<=num;i++{
            for j:=1;j<=i;j++{
                fmt.Printf("%v * %v =%v \t",j,i,j*i)
            }
            fmt.Println()
        }	
    }

package main

    import (
        "fmt"
    )

    func main(){
        str:="a song 雪花飘飘，北风啸啸"
        for i,v:=range str{
            fmt.Printf("%d %c\n",i,v)
            //可以看出utf-8中汉字占3个字节
        }
    }

7.函数

多返回值

func 函数名（形参列表）（返回值列表）{
执行语句…
return 返回值列表
}

package main

    import (
        "fmt"
    )

    func z(x,y int)(int,int){
        s1,s2:=x,y
        for t:=x%y;t!=0;t=x%y{
            x=y
            y=t
        }
        return y,s1*s2/y
    }

    func main(){
        fmt.Println(z(16,24))
    }

8 48

给每个返回值命名

就像形参一样，将每个返回值具体到变量上，这样就可以对返回的变量赋值。

package main

    import (
        "fmt"
    )

    //返回两个数的和与差
    func ans(a, b int) (int, int) {
        return a + b, a - b
    }
    //给返回值命名
    func ans1(a,b int)(mul,div ,rem int){
        mul=a*b
        div=a/b
        rem=a%b
        return
    }
    func main() {
        a, b := 5, 8
        fmt.Println(ans(a, b))
        fmt.Println(ans1(a,b))
    }

13 -3
40 0 5

多返回值模型促进了”comma-ok”模式

package main

    import (
        "fmt"
    )

    func main(){
        arr:=[3]int{5,6,7}
        if v,ok:=get(2,arr);ok{
            fmt.Println(v)
        }
    }
    func get(i int,arr [3]int)(int,bool){
        if i<0||i>len(arr){
            return 0,false
        }
        return arr[i],true
    }

7

匿名函数

匿名函数不能作为顶级函数，而只能放在其他函数的函数体中，也就是说它必须有一个外层函数
在定义匿名函数时就直接调用，这种方式匿名函数只能调用一次
将匿名函数赋给一个变量(函数变量)，再通过该变量来调用匿名函数

package main

    import (
        "fmt"
    )

    func main(){
        fmt.Println(func(a,b int) int{
            return a+b
        }(15,16))//声明匿名函数时调用

        f1:=func(a,b int) int{
            return a+b
        }//声明一个匿名函数，并直接赋给函数类型变量f
        fmt.Println(f1(1,6))

        f:=func(a,b int) int{
            return a+b
        }(1,16)//将匿名函数返回值赋给变量
        fmt.Println(f)
    }

31
7
17

闭包

匿名函数被称为闭包，原因在于匿名函数通过某种方式使其可见范围超出了其定义的范围。
go为声明匿名函数提供了简单的语法，像许多动态语言一样，这些匿名函数在它们被定义的范围内创建了词法闭包
函数返回一个匿名函数，而匿名函数使用了自身的外部变量，匿名函数与这个变量共同形成闭包

实例一

package main

    import (
        "fmt"
        "strings"
    )
    //传入文件名，无后缀名的添加后缀名
    func main() {
        f2 := makeSuffix(".jpg")
        fmt.Println("处理后=", f2("winter"))
        fmt.Println("处理后=", f2("summer.jpg"))

    }
    func makeSuffix(suffix string) func(string) string {
        return func(name string) string {
            if !strings.HasSuffix(name, suffix) {
                return name + suffix
            }
            return name
        }
    }
    //与传统方式的不同在于，传统方法需要每次都传入后缀名
    //而使用闭包返回的函数保留着后缀名，可以反复使用

处理后= winter.jpg
处理后= summer.jpg

实例二

package main

    import (
        "fmt"
    )

    func main() {
        f := squares()
        fmt.Println(f()) // "1"
        fmt.Println(f()) // "4"
        fmt.Println(f()) // "9"
        fmt.Println(f()) // "16"
    }

    // squares返回一个匿名函数。
    // 该匿名函数每次被调用时都会返回下一个数的平方。
    func squares() func() int {
        var x int
        return func() int {
            x++
            return x * x
        }
    }

1
4
9
16

实例三

package main

    import "fmt"

    func main() {
        add5 := makeAdder(5)//5+y
        add36 := makeAdder(36)//36+y
        fmt.Println(add5(add36(1)))
        sub5 := makeSuber(5)//5-y
        sub36 := makeSuber(36)//36-y
        fmt.Println(sub5(sub36(1)))
    }
    func makeAdder(x int) func(int) int {
        return func(y int) int { return x + y }
        //引用了外部变量X
    }
    func makeSuber(x int) func(int) int {
        return func(y int) int { return x - y }
        //引用了外部变量x，此x与makeAdder的x不同
    }

42
-30

回调函数

函数可以作为其它函数的参数进行传递，然后在其它函数内调用执行，一般称之为回调

实例

package main

    import (
        "fmt"
    )

    func main(){
        callback(1,add)
        callback(1,sub)
        callback(5,mul)
        callback(5,div)
    }
    func add(a, b int) {
        fmt.Println(a, "+", b, "=", a+b)
    }
    func sub(a, b int) {
        fmt.Println(a, "-", b, "=", a-b)
    }
    func mul(a, b int) {
        fmt.Println(a, "*", b, "=", a*b)
    }
    func div(a, b int) {
        fmt.Println(a, "/", b, "=", a/b, "...", a%b)
    }
    func callback(y int, f func(int, int)) {
        f(y, 2)
    }

1 + 2 = 3
1 - 2 = -1
5 * 2 = 10
5 / 2 = 2 … 1

defer语句

延迟调用语句，无论函数执行是否出错，都确保结束前被调用
用于数据清理工作，保证代码结构清晰，避免遗忘

srcFile,err:=os.Open(srcName)
defer srcFile.Close()//关闭文件句柄，结构清晰，避免忘记关闭

实例

package main

    import (
        "fmt"
    )

    func main(){
        defer fmt.Println("雪花飘飘")
        defer fmt.Println("北风啸啸")
        fmt.Println("天地一片苍茫")
    }

天地一片苍茫
北风啸啸
雪花飘飘

8.异常处理机制

在默认情况下，当发生错误后(panic) ,程序就会退出（崩溃.）
内置函数panic，中断原有控制流，抛出一个异常流
内置函数recover，捕获到panic的异常值并恢复
recover仅在延迟函数中有效，即在defer语句中调用

实例

package main

    import (
        "fmt"
    )

    func main(){
        test01()
        fmt.Println("test01")
        test02()
        fmt.Println("test02")//没有输出
    }
    func test01(){
        defer func(){
             if err:=recover(); err !=nil{
                fmt.Println("err=",err)
            }
        }()//声明并调用
        num1:=10
        num2:=0
        res:=num1/num2
        fmt.Println("res=",res)
    }
    func test02(){
        num1:=10
        num2:=0
        res:=num1/num2
        fmt.Println("res=",res)//没有输出
    }

err= runtime error: integer divide by zero
test01
panic: runtime error: integer divide by zero
goroutine 1 [running]:
main.test02()
e:/file/golang/goproject/src/异常处理机制/main.go:27 +0x11
main.main()
e:/file/golang/goproject/src/异常处理机制/main.go:10 +0x8a
exit status 2

9.数组

定义、初始化

package main

    import (
        "fmt"
    )

    func main() {
        //数组
        var a [4]int                        //元素自动初始化为零
        var aa [4]int = [4]int{1, 2, 3, 4}  //定义并初始化数组aa
        var aaa [4]int = [4]int{1, 2, 3, 4} //定义并初始化数组aa
        b := [4]int{2, 5}                   //未提供初始值的元素自动初始化为零
        c := [4]int{5, 3: 10}               //可指定索引位置初始化
        d := [...]int{1, 2, 3}              //编译器按初始化值数量确定数组长度
        e := [...]int{10, 3: 100}           //支持索引初始化，但数组长度与此有关
        f := [...]int{
            5: 200,
            9: 10, 
            //这里需要汪意：如果分成多进行声明+初始化，
            //那么你需要在最后一行的最后加上','
        }
        fmt.Println(a) //可直接输出素组各个元素，比C方便
        fmt.Println(aa, aaa, b, c, d, e, f)
        //…表示不指定长度，长度由初始化列表决定，这种情况…不能省略，否则就成了切片
        //
    }

结构体数组

数组元素为结构体

实例

package main

import (
	"fmt"
)
type user struct{
	id   int
	name string
	age byte
}
func main(){
	brother :=[...]user{
		{1,"刘备",20},
		{2,"关羽",19},
		{3,"张飞",18},
	}
	fmt.Println(brother)
	fmt.Printf("%v\n%+v\n%#v",brother,brother,brother)
}

[{1 刘备 20} {2 关羽 19} {3 张飞 18}]
[{1 刘备 20} {2 关羽 19} {3 张飞 18}]
[{id:1 name:刘备 age:20} {id:2 name:关羽 age:19} {id:3 name:张飞 age:18}]
[3]main.user{main.user{id:1, name:“刘备”, age:0x14}, main.user{id:2, name:“关羽”, age:0x13}, main.user{id:3, name:“张飞”, age:0x12}}

注：%v%+v%#v区别

1.%v 只输出所有的值

2.%+v 先输出字段类型，再输出该字段的值

3.%#v 先输出结构体名字值，再输出结构体（字段类型+字段的值）

多维数组

…仅用在第一维
内置函数len和cap都可以返回第一维的长度

package main

    import "fmt"

    func main() {
        a := [2][2]int{{1, 2}, {3, 4}}
        b := [...][2]int{//...仅用在第一维
            {10, 20},
            3: {30, 40},
        }
        c := [...][2][2]int{
            {
                {1, 2},
                {3, 4},
            },
            {
                {10, 20},
                {30, 40},
            },//莫忘逗号
        }
        fmt.Printf("%v\n%v\n%v", a, b, c)
        //内置函数len和cap都可以返回第一维的长度
    }

[[1 2] [3 4]]
[[10 20] [0 0] [0 0] [30 40]]
[[[1 2] [3 4]] [[10 20] [30 40]]]

数组和指针

数组名字不代表数组的首地址

package main

    import (
        "fmt"
    )

    func main() {
        x, y := 10, 20
        a := [...]*int{&x, &y}
        q := a
        p := &a
        fmt.Println(a, p, q)
        fmt.Printf("%T,%v\n", a, a)
        fmt.Printf("%T,%v\n", q, q)
        fmt.Printf("%p %p %p\n", &a, &a[0], &q[0])
        fmt.Printf("%v %v %v\n", &a, &a[0], &q[0])
        fmt.Printf("%T,%p,%v,%v,%p\n", p, p, p, *p, &p)
    }

[0xc0000100a0 0xc0000100a8] &[0xc0000100a0 0xc0000100a8] [0xc0000100a0 0xc0000100a8]
[[2]*int,[0xc0000100a0 0xc0000100a8]
[[2]*int,[0xc0000100a0 0xc0000100a8]
0xc00003a1f0 0xc00003a1f0 0xc00003a200
&[0xc0000100a0 0xc0000100a8] 0xc00003a1f0 0xc00003a200
*[2]*int,0xc00003a1f0,&[0xc0000100a0 0xc0000100a8],[0xc0000100a0 0xc0000100a8],0xc000006028

数组和函数

package main

    import (
        "fmt"
    )

    func test(x [2]int){
        fmt.Printf("x:%p,%v\n",&x,x)
    }
    func main(){
        a:=[2]int {10,20}
        var b [2]int
        b=a//数组整体复制
        fmt.Printf("a:%p,%v\n",&a,a)
        fmt.Printf("b:%p,%v\n",&b,b)
        test(a)
        //&x!=&a，说明数组名不代表首地址，
        //赋值 和 传参 只复制全部元素
        //形参变化不影响实参
    }

a:0xc0000100a0,[10 20]
b:0xc0000100b0,[10 20]
x:0xc000010110,[10 20]

数组、指针和函数

package main

    import (
        "fmt"
    )
    func test(x *[2]int){
        x[1]+=100
        fmt.Printf("x:%p,%v\n",x,*x)
    }
    func main(){
        a:=[2]int{10,20}
        test(&a)
        fmt.Printf("a:%p,%v\n",&a,a)
    }

x:0xc0000100a0,[10 120]
a:0xc0000100a0,[10 120]

区分指针数组与数组指针

数组指针：var x *[2]int，x是指向数组的指针，即指向数组的首地址
指针数组：var y [2]*int，y是指针数组，即数组中每个元素都是指针

10.切片

切片基础

[ ]表示切片
切片是数组的一个引用，因此切片是引用类型，在进行传递时，遵守引用传递的机制。
切片是一个动态数组
make函数用来创建指定类型的对象，var 切片名[]type = make([]type, len, [cap])
make的方式实际上也会创建一个数组，但是不可见
cap()获取切片空间的大小
len()获得有效元素的个数
append()在切片有效元素末尾添加元素；如果超出容量限制，容量翻倍；这时，要把新地址赋给原切片
append的原型为：append([]interface{}, …interface{})

功能：表示可以为任何类型([]interface{})的切片追加0-n个元素(…interface{})，
如m.musics[index+1:]…含义就是把切片m.musics[index+1:]打散成一个一个的可追加的参数

package main

    import (
        "fmt"
    )

    func main(){
        x:=make([]int,0,5)//创建长度为0，容量为5的切片
        for i:=0;i<8;i++{
            x=append(x,i)//在切片的尾部添加数据，莫忘赋给x
        }	
        fmt.Println(x,len(x),cap(x))
        //如若超出容量限制时，容量自动翻倍
    }

[0 1 2 3 4 5 6 7] 8 10
//数组中元素有效长度容量

切片和数组

定义一个切片，然后让切片去引用一个已经创建好的数组，容量为数组的长度减去引用的元素的起始下标
切片初始化时var slice = arr[startIndex:endIndex] 说明：从arr 数组下标为startIndex，取到下标为endIndex 的元素(不含arr[endIndex])。
var slice = arr[0:end] 可以简写var slice = arr[:end]
var slice = arr[start:len(arr)] 可以简写： var slice = arr[start:]
var slice = arr[0:len(arr)] 可以简写: var slice = arr[:]

package main

    import (
        "fmt"
    )

    func main(){
        x:=[...]int{0,1,2,3,4,5,6,7,8,9}
        s1:=x[2:5]//s1包含2、3、4（不包含5）
        fmt.Println(s1)
        s2:=x[:6]//即x[0:6]
        fmt.Println(s2)
        s3:=x[4:]//即x[4:len(x)]
        fmt.Println(s3)
        s4:=x[:]//即x[0:len(x)]
        fmt.Println(s4)
        //fmt.Println(s1[5])
        for i,v:=range s1{//遍历
            fmt.Printf("%v:%v\n",i,v)
        }
        fmt.Println("len",len(s1),"cap",cap(s1))

        //利用切片可以修改在数组中对应的那部分元素的值
        s1[0]=5
        //但是切片只是指向数组的子集，修改不能超出切片范围
        //如s1[5]就不合法

        s1=append(s1,15,16)
        //但是可以利用通过给切片增加元素的方式更改值
        fmt.Println(s1)

    }

[2 3 4]
[0 1 2 3 4 5]
[4 5 6 7 8 9]
[0 1 2 3 4 5 6 7 8 9]
0:2
1:3
2:4
len 3 cap 8
[5 3 4 15 16]

切片拷贝

切片可以进行值的拷贝
切片之间可以传递

package main

    import (
        "fmt"
    )

    func main(){
        //切片是引用类型，可传递
        arr:=[...]int{1,2,3,4,5}
        slice0:=arr[:]
        slice1:=slice0
        slice0[0]=10
        fmt.Println("arr",arr)//arr [10 2 3 4 5]
        fmt.Println("slice0",slice0)//slice [10 2 3 4 5]
        fmt.Println("slice1",slice1)//slice1 [10 2 3 4 5]
        //切片和数组的值均改变

        //对切片拷贝
        var slice2[]int=[]int{1,2,3,4,5}
        var slice3=make([]int,10)//省略容量
        copy(slice3,slice2)
        slice3[0]=5
        fmt.Println("slice2",slice2)//slice2 [1 2 3 4 5]
        fmt.Println("slice3",slice3)//slice3 [5 2 3 4 5 0 0 0 0 0]
        //可见，两个数据空间是独立的，相互不影响

        var slice4[]int=[]int{1,2,3,4,5}
        var slice5[]int=make([]int,1)
        fmt.Println("slice5",slice5)//[0]
        copy(slice5,slice4)
        fmt.Println("slice5",slice5)//[1]

        a:=[...]int{5,6,7,8,9}
        var slice6[]int=a[2:]
        var slice7=make([]int,5)
        copy(slice7,slice6)
        slice7[1]=9
        fmt.Println("slice6",slice6)
        fmt.Println("slcie7",slice7)
    }

arr [10 2 3 4 5]
slice0 [10 2 3 4 5]
slice1 [10 2 3 4 5]
slice2 [1 2 3 4 5]
slice3 [5 2 3 4 5 0 0 0 0 0]
slice5 [0]
slice5 [1]
slice6 [7 8 9]
slcie7 [7 9 9 0 0]

11.map

var map 变量名 map[keytype]valuetype
声明不会分配内存，初始化需要make，分配内存后才能赋值和使用
可以声明的时候用{}初始化
map在使用前一定要make
make的key-value是无序的，所以每次遍历结果先后关系可能不一样
make的value可以相同
make的key不能相同，如果重复了，则以最后的key-value为准
map的key可以是很多中类型，通常为int,string但是slice,map,functio不可以，因为这几个不能用==来判断
map的value通常为数字，string，map，struct
map是无序的，如果要排序，可以对key进行排序，再根据key的值遍历输出

package main

    import (
        "fmt"
    )

    //字典类型
    func main() {
        gf := make(map[string]map[int]string)
        //如果key还没有，就是增加，如果key存在就是修改
        //可以先make再初始化，如gf
        //也可以直接初始化，如gf["萧峰"]
        gf["萧峰"] = map[int]string{0: "降龙十八掌", 1: "太祖长拳"}
        gf["段誉"] = map[int]string{0: "六脉神剑", 1: "凌波微步"}
        gf["虚竹"] = map[int]string{0: "小无相功", 1: "北冥神功"}

        //map遍历
        for name, kongfu := range gf { //字典是无序存储，每次遍历先后关系不同
            fmt.Printf("%s:", name)
            for _, kf := range kongfu {
                fmt.Printf("%s\t", kf)
            }
            fmt.Println()
        }

        //查找
        if p, ok := gf["萧峰"]; ok {
            fmt.Println(p)
        }

        //删除
        delete(gf, "段誉")
        fmt.Println(gf)

        //一次性的删除所有key
        //1.遍历所有的key，逐一删除
        //2.直接make一个新的空间
        gf=make(map[string]map[int]string)
        fmt.Println(gf)
    }

虚竹:小无相功北冥神功
萧峰:降龙十八掌太祖长拳
段誉:六脉神剑凌波微步
map[0:降龙十八掌 1:太祖长拳]
map[萧峰:map[0:降龙十八掌 1:太祖长拳] 虚竹:map[0:小无相功 1:北冥神功]]
map[]

12.对象与方法

go支持类似c++面对对象的风格
go提供了方法定义和调用他们的方式，因此语法并不笨拙
可以建立对象的同时初始化
通过内置函数new来建立对象，new返回一个指针
成员或方法首字母大写为public，小写为private
func和方法名之间指定了方法的接收者，即所属的对象，也是方法的第一个参数
方法如果想要更改对象中的值，那么第一个参数应设为指针类型，不然只是对对象的拷贝

package main

    import (
        "fmt"
        "math"
    )

    //Point 点类
    type Point struct {
        x, y float64
    }

    //Distance 计算距离
    func (p Point) Distance() float64 {
        return math.Sqrt(p.x*p.x + p.y*p.y)
    }
    //Change 修改
    func (p *Point) Change(){
        p.x=5.5
    }
    func main() {
        var p1 Point = Point{3, 4}
        var p2 *Point = new(Point) //通过内置函数new来建立对象
        p3 := new(Point)
        p3.Change()
        fmt.Println(p1.Distance(), p2, p3)
    }

5 &{0 0} &{5.5 0}

13.接口

如果几个对象间存在公共行为，而开发者想要抽象这种行为，那么就可以将这类行为定义为接口，并使用它。
接口本身不能创建实例,但是可以指向一个实现了该接口的自定义类型的变量
一个自定义类型只有实现了某个接口，才能将该自定义类型的实例(变量)赋给接口类型
空接口interface{} 没有任何方法，所以所有类型都实现了空接口, 即我们可以把任何一个变量
赋给空接口。

package main

    import (
        "fmt"
    )
    //Printer 定义接口
    type Printer interface{
        Print()//公共方法
        //无需显示给出实现类型
        //add other methods
        //没有数据字段
    }
    type camera struct{
        name string
        age byte
    }
    //实现接口，谁使用谁实现
    func (u camera) Print(){
        fmt.Println(u)
    }

    type goods struct{
        name string
        num,price byte
    }

    //实现接口，谁使用谁实现
    func(g goods)Print(){
        fmt.Println(g)
    }

    type computer struct{

    }

    func (c computer)working ( p Printer){//接受接口类型变量
        p.Print()
    }
    func main(){
        //usb插槽就是现实中的接口
        u:=camera{"Tom",18}
        u.Print()//像使用普通方法一样使用接口,接口的热插拔
        g:=goods{"bed",10,200}
        var ip Printer
        //定义接口变量ip 
        //只要对象实现了接口的全部方法，
        //就表示实现了该接口，
        //就可以赋值给接口变量
        ip=u
        ip.Print()
        ip=g
        ip.Print()
        g.name="sofa"
        g.Print()
        ip.Print()
        //当对象赋值给接口时，会发生拷贝。
        //接口内部存储的是指向这个复制品的指针，
        //无法修改其状态，也无法获取指针；
        com:=computer{}
        com.working(u)
        com.working(ip)
        com.working(g)
    }

14.继承

继承可以解决代码复用
当多个结构体存在相同的属性(字段)和方法时,可以从这些结构体中抽象出结构体,在该结构体中定义这些相同的属性和方法。
其它的结构体不需要重新定义这些属性(字段)和方法，只需嵌套一个 匿名结构体即可
当结构体和匿名结构体有相同的字段或者方法时，编译器采用就近访问原则访问，如希望访问
匿名结构体的字段和方法，可以通过匿名结构体名来区别

package main

    import (
        "fmt"
    )
    type user struct{
        name string
        age byte
    }
    //Output 定义方法
    func (u user)Output()string{
        return fmt.Sprintf("%+v\n",u)
    }

    type leader struct{
        user//匿名成员，可实现继承
        title string
    }
    func main(){
        var wo leader
        wo.user.name="kyl"//匿名成员有着和类型一样的名字
        wo.user.age=18
        //可以简化写法
        wo.name="fcl"
        wo.title="manager"
        var us=leader{user{"lzc",18},"dom"}//莫忘user
        //var us=user{"  ",91}
        fmt.Println(us)
    }

15.并发

进程就是程序在操作系统的一次执行过程，是系统进行资源分配和调度的基本单位
线程是进程的一个执行实例，是程序执行的最小单元，它是比进程更小的能独立运行的基本单位
一个程序至少有一个进程，一个进程至少有一个线程
并行与并发

并发：多个任务作用在一个cpu，在一个时间点上，只有一个任务在执行
并行：多个任务作用在多个cpu，在一个时间点上，多个任务在同时执行

package main

    import (
        "fmt"
        "time"
    )

    func main(){
        //非并发
        /*task1()
        task2()*/
        go task1()
        go task2()
        fmt.Println("hhhhhhhhhh")
        time.Sleep(time.Second*6)//如果没有这句话，没有输出，因为main执行太快
    }
    func task1(){
        for i:=0;i<5;i++{
            fmt.Println("hello")
            time.Sleep(time.Second)
        }
    }
    func task2(){
        for i:=0;i<5;i++{
            fmt.Println("world")
            time.Sleep(time.Second)
        }
    }

package main

    import (
        "fmt"
        "time"
    )

    func main() {
        go spinner(100*time.Millisecond)//计算的同时显示动画
        const n = 45
        fibN := fib(n) // slow
        fmt.Printf("\rFibonacci(%d) = %d\n", n, fibN)
    }

    func spinner(delay time.Duration) {
        for {
            for _, r := range `-\|/` {
                fmt.Printf("\r%c", r)
                time.Sleep(delay)
            }
        }
    }

    func fib(x int) int {
        if x < 2 {
            return x
        }
        return fib(x-1) + fib(x-2)
    }

16.通道

主线程在等待所有goroutine 全部完成的时间很难确定
如果主线程休眠时间长了，会加长等待时间，如果等待时间短了，可能还有goroutine 处于工作
状态，这时也会随主线程的退出而销毁
channle 本质就是一个数据结构-队列
数据是先进先出【FIFO : first in first out】
var 变量名 chan 数据类型
ch:=make(chan int)声明并初始化
ch:=make(chan int,10)带缓冲区的通道，容量是10
channel 是引用类型
channel必须初始化才能写入数据，即make后才能使用
管道是有类型的，只能放置特定类型的数据
channel的数据满了之后，不能再放入，除非取出数据，才可以继续放入
写入数据： channel变量名 <- 数据；向channel写入数据通常会导致程序堵塞，直到有其他goroutine来从这个通道中读取数据
读取数据： value := <- channel变量名；如果通道之前没有写入数据，那么从通道中读取数据也会导致程序堵塞，直到channel中被写入数据
关闭： close(channel变量名)‘关闭通道后不能再写入数据，但是仍然可以读取数据
无论怎样都不应该在接收端关闭通道，因为那样无法判断发送端是否还会向该通道发送值。
我们在发送端调用close关闭通道却不会对接收端接收该通道中已有的元素值产生任何影响。
遍历：支持for-range的方式进行遍历，但遍历前，channel需要关闭，如若不然，会出现deadlock报错

package main

    import (
        "fmt"
    )

    func consumer(data chan int, done chan bool) {
        for x := range data {//遍历前channel需要关闭
            fmt.Println("recv:", x)
        }
        done <- true//消费结束，向done通道写入true
    }

    //生产者
    func producer(data chan int) {
        for i := 0; i < 5; i++ {
            fmt.Println("send message", i)
            data <- i
            //写入数据
        }
        close(data)//莫忘关闭
    }
    func main() {
        //各个并发/行体之间如何通信
        //布尔通道
        done:=make(chan bool)//channel make后才能使用
        //整形通道
        data:=make(chan int)
        //启动生产者
        go producer(data)

        go consumer(data,done)

        <-done
        //阻塞，直到接受消费者发出的结束信号
    }

17.数据类型

布尔:bool

长度：1字节
取值范围：true,false
注意事项：不可以用数字代表true或false

整型：int/uint

根据运行平台可能为32位或64位
8位整型:int8/uint8

长度：1字节
取值范围：-128_127/0255

字节型：byte(uint别名)
16位整型：int16/uint16

长度：2字节
取值范围：-32768_32767/065535

32位整型：int32（rune）/uint32

长度：4字节
取值范围：-2^32/2~232/2-1/0~2^32-1

64位整型：int64/uint64

长度：8字节
取值范围：-2^64/2~264/2-1/0~2^64-1

浮点型：float32/float64

长度：4/8字节
小数位：精确到7/15小数位

复数：complex64/complex128

长度：8/16字节

能够保存指针的 32 位或 64 位整数型：uintptr
其它值类型：

array、struct、string

引用类型：

slice、map、chan

接口类型：inteface
函数类型：func
零值类型

零值并不等于空值，而是当变量被声明为某种类型后的默认值
通常情况下值类型的默认值为0，bool为false，string为空字符串“”

类型转换

Go中不存在隐式转换，所有类型转换必须显式声明

转换只能发生在两种相互兼容的类型之间

类型转换的格式
<ValueA> [:]= <TypeOfValueA>(<ValueB>)

rune 类型示例

package main

    import (
        "fmt"
    )

    func main(){
        var ch1 rune
        ch1='考'//int32
        ch2:='试'//int32
        str1:=string(ch1)+string(ch2)
        str2:=ch1+ch2
        fmt.Println(ch1,ch2)
        fmt.Printf("%T %T %c %c",ch1,ch2,ch1,ch2)
        fmt.Println(str1,str2)

        str3:="成功" 
        fmt.Printf("%T %T\n",str3[0],str3)
        for i,v:=range str3{
            fmt.Printf("%T %d %c\n",v,i,v)
        }
        fmt.Println("-----")
        for i:=0;i<len(str3);i++{
            fmt.Printf("%d %v %T\n",i,str3[i],str3[i])
        }
        fmt.Println("str3.len=",len(str3))
    }

32771 35797
int32 int32 考试考试 68568
uint8 string
int32 0 成
int32 3 功
-----
0 230 uint8
1 136 uint8
2 144 uint8
3 229 uint8
4 138 uint8
5 159 uint8
str3.len= 6

complex示例

package main

    import (
        "fmt"
        "math/cmplx"
    )

    func main() {
        //var comp complex128
        comp := 2 + 4i
        fmt.Printf("%T", comp) //默认128位
        r := real(comp)        //实部
        im := imag(comp)       //虚部
        fmt.Println("comp=", r, "+", im, "*i")
        c := cmplx.Sqrt(comp) //用于128位复数开方
        fmt.Println(c)
    }

complex128comp= 2 + 4 *i
(1.7989074399478673+1.1117859405028423i)

18.关键字

25个

var和const ：变量和常量的声明
var varName type 或者 varName : = value
package and import: 导入
func：用于定义函数和方法
return ：用于从函数返回
defer someCode ：在函数退出之前执行
go : 用于并行
select 用于选择不同类型的通讯
interface 用于定义接口
struct 用于定义抽象数据类型
break、case、continue、for、fallthrough、else、if、switch、goto、default 流程控制
chan用于channel通讯
type用于声明自定义类型
map用于声明map类型数据
range用于读取slice、map、channel数据

19.运算符

go中运算符均是从左向右结合
优先级

优先级运算符
7 ^ !
6 * / % << >> & &^
5 + - | ^
4 == != < <= >= >
3 <-
2 &&
1 ||

&^为清除标志位运算，从a上清除b 的标志位;
1、如果右侧是0，则左侧数保持不变
2、如果右侧是1，则左侧数一定清零
^作为一元运算符为按位取反，作为二元运算符为异或

package main

    import (
        "fmt"
    )

    func main(){
        var a uint8=5
        var b uint8=3
        fmt.Println(a&^b)//从a上清除b上的标准位
        fmt.Println(a^b)//按位异或
        fmt.Println(^a)//按位取反
        
		fmt.Println(0 &^ 0)
		fmt.Println(0 &^ 1)
		fmt.Println(1 &^ 0)
		fmt.Println(1 &^ 1)
    }

4
6
250
0
0
1
0

20.指针、++、–

Go虽然保留了指针，但与其它编程语言不同的是，在Go当中不支持指针运算（如p++）以及”->”运算符，而直接采用”.”选择符来操作指针目标对象的成员
操作符”&”取变量地址，使用”*”通过指针间接访问目标对象
默认值为 nil 而非 NULL
递增递减语句

在Go当中，++ 与 – 是作为语句而并不是作为表达式

21.常量

常量的值在编译时就已经确定
常量的定义格式与变量基本相同
等号右侧必须是常量或者常量表达式
常量表达式中的函数必须是内置函数
当操作数是常量时，一些运行时的错误也可以在编译时被发现，例如整数除零、字符串索引越界、任何导致无效浮点数的操作等。
一个常量的声明也可以包含一个类型和一个值，但是如果没有显式指明类型，那么将从右边的表达式推断类型。

const pi=3.14159//声明单个常量
const (
const (
    e  = 2.71828182845904523536028747135266249775724709369995957496696763
    pi = 3.14159265358979323846264338327950288419716939937510582097494459
)

如果不提供初值，则表示将使用上行的表达式

const (
    a = 1
    b
    c = 2
    d
)

fmt.Println(a, b, c, d) // "1 1 2 2"

itoa:常量计数器

常量声明可以使用iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。在一个const声明语句中，在第一个声明的常量所在的行，iota将会被置为0，然后在每一个有常量声明的行加一。

type Weekday int

const (
    Sunday Weekday = iota//默认为0
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)
const(
 today =iota//重置为0
)

iota与<<结合实现计算机存储单位的枚举

const (
		_ = iota//0
		KB ByteSize = 1 << (10*iota)//iota为1
		MB
		GB
		TB
		PB
		EB
		ZB
		YB
	)

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：hbase安装与测试实验报告 hbase基本操作实验结论

下一篇：FFmpegFrameRecorder推送音频 ffmpeg单独音频推流

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯

go语言学习之路 go语言入门经典

go语言学习之路 go语言入门经典

go语言语法入门

1.源文件

2.变量

声明单个变量

声明变量并初始化

支持类型推断

声明多个变量

简短声明

强类型

定义变量后要使用，否则会报错

3.if语句

4.输入语句

5.switch分支结构

6.循环

7.函数

多返回值

匿名函数

闭包

实例一

实例二

实例三

回调函数

实例

defer语句

实例

8.异常处理机制

实例

9.数组

定义、初始化

结构体数组

实例

多维数组

数组和指针

数组和函数

数组、指针和函数

10.切片

切片基础

切片和数组

切片拷贝

11.map

12.对象与方法

13.接口

14.继承

15.并发

16.通道

17.数据类型

18.关键字

19.运算符

20.指针、++、–

21.常量

51CTO博客

3.`if`语句

5.`switch`分支结构