Go语言--基础语法笔记

###

换了工作，好久没有添加新文章了，本来是想更新到github上的，想想还是在博客里放着，感觉以前的文章都没有很仔细，都只是问题处理的记录，

以后想新加一些整理的笔记也好

###

主要内容

2.1变量

2.2数据类型

2.3数据类型相互转换

2.4指针

2.5变量生命期

2.6字符串应用

2.7枚举

2.8类型别名

2.1变量

2.1.1 声明变量

功能：存储用户的数据

注意：变量必须经过声明才能开始使用

变量声明格式：

标准格式

var 变量名变量类型

以关键字var开头，后置变量类型，行尾无线分号

package main

import ("fmt")

func main() {

     var a int

     var b string

     var c []float32

     var d func() bool

     var e struct{

        x int

     }

}

批量格式

使用var关键字和括号

package main

import ("fmt")

func main() {

     var (

        a int

        b string

        c []float32

        d func() bool

        e struct{

            x int

        }

     )

}

2.1.2 初始化变量

整型和浮点型变量默认值：0
字符串变量的默认值空字符串
布尔型默认值为bool
切片、函数、指针变量的默认值为nil

1.标准格式

var 变量名变量类型 = 表达式

var hp int = 100

2.编译器推导的类型

var hp1 = 100

标准格式基础上，省略int，编译器推导

var attack = 40

var defence = 20

var damageRate float32 = 0.17

var damage = float32(attack-defence) * damageRate

fmt.Println(damage)

// 3.4

3.短变量声明并初始化

hp := 100

注意：变量已经被声明过了，再次声明并赋值，使用短变量声明会编译报错

var p string

p := '123'

fmt.Println(p)

// 错误信息：no new variables on left side of :=(44.4)

// var p 声明了p变量， p := '123' 会再次声明并赋值

hp3 := 50

fmt.Println(hp3)

2.1.3 多个变量同时赋值

顺序：从左到右

var a int = 100

var b int = 200



a, b = b, a

fmt.Println(a, b) //200 100

2.1.4 匿名变量

匿名变量用一个"_"下滑线表示

只需要在变量声明的地方，用下划线代替即可

package main

import ("fmt")

func main() {

    a1, _ := getData()

    _, b1 := getData()

    fmt.Println(a1, b1)

}



type IntSlice []int

// 编写一个len方法，提供切片的长度

func (p IntSlice) Len() int { return len(p)}

// 根据提供i,j元素索引,两个元素进行比较，返回比较结果

func (p IntSlice) Less(i, j int) bool { return p[i] < p[j]}

// 根据提供i,j元素索引,交换两个元素的值

func (p IntSlice) Swap(i, j int)      { p[i], p[j] = p[j], p[i]}



func getData() (int, int) {

    return 200, 100

}

2.2 数据类型

2.2.1 整型

两种：长度 int8 int16 int32 int64 无符号 uint8 uint16 uint32 uint64

2.2.2 浮点型

两种：float32和float64

fmt.Println("hello world")

fmt.Printf("%f\n", math.Pi)

fmt.Printf("%.2f\n", math.Pi)

2.2.3 布尔型

注意：go不允许将整型类型转换为布尔型, 无法参与数值运算，也无法跟其他类型进行转换

var n bool

fmt.Println( int(n) * 2 )

//cannot convert n (type bool) to type int

2.2.4 字符串

用双引号括起来的内容就是为字符串的内容

  str := "hello world string"

  ch := "中文"

  fmt.Println(str, ch)

    //hello world string 中文

字符串转义符

符合说明

\r 回车

\n 换行符

\t 制表符

' 单引号

" 双引号

\ 双斜杠
```
fmt.Println( "str := \"c:\\Go\\bin\\go.exe\" ")

str := "c:\Go\bin\go.exe"
```
　　
字符串实现基于utf-8编码
定义多行字符串

符合	说明
\r	回车
\n	换行符
\t	制表符
'	单引号
"	双引号
\	双斜杠

const longstr = `

    第一行

    第二行

    \r\n

    。。。

    `

    fmt.Println(longstr)

    //第一行

    //第二行

    //\r\n

    //。。。



    const codeTemplate = ` // Generated by github.com/davyxu/cellnet/protoc-gen-msg

    // DO NOT EDIT!{{range.Protos}}

    // Source:{{.Name}} {{end}}

    package {{.PackageName}}

    {{if gt .TotalMessages 0}}

    import (

        "github.com/davyu/cellnet"

        "reflect"

        _ "github.com/davyxu/cellnet/codec/pb"

    )

    {{end}}

    func init() {

        {{range .Protos}}

        //{{.Name}}{{range .Messages}}

        cellnet.RegisterMessageMeta("pb", "{{.FullName}}")

        reflect.TypeOf((*{{.Name}})(nil)).Elem(), {{.MsgID}}) {{end}}

        {{end}}

    }

    `

    fmt.Println(codeTemplate)

2.2.5 字符

字符串中每一个元素都叫字符两种：一种为uint8类型 或是 byte类型 代表ascll码的一个字符另一种为rune类型，代表一个UTF-8类型,实际为int32 用于处理中文、日文等复合字符使用fmt.Printf 中“%T”输出变量实际类型，可用于查看byte和rune类型

var a byte = 'a'

fmt.Printf("%d %T\n", a, a)

var b rune = '中'

fmt.Printf("%d %T\n", b, b)

//97 uint8

//20013 int32

2.2.7 切片 -- 能动态分配的空间

一个拥有相同类型元素的可变长的序列

var name []T

T 代表切片元素类型，即可以整型、浮点型、布尔型、切片、map、函数等

t := make([]int, 5)

t[0] = 1

t[1] = 2

t[3] = 3

fmt.Println(t)

//[1 2 0 3 0]

str1 := "hello world"

fmt.Println(str1[6:])

//world

2.3 转换不同的数据类型

格式：

T(表达式) 输出各数值范围

package main



import (

    "fmt"

    "math"

)



func main() {

    fmt.Println("int8 range:", math.MinInt8, math.MaxInt8)

    fmt.Println("int16 range:", math.MinInt16, math.MaxInt16)

    fmt.Println("int32 range:", math.MinInt32, math.MaxInt32)

    fmt.Println("int64 range:", math.MinInt64, math.MaxInt64)

    int8 range: -128 127

    int16 range: -32768 32767

    int32 range: -2147483648 2147483647

    int64 range: -9223372036854775808 9223372036854775807



    //初始化一个32位整型值

    var a1 int32 = 1047483647

    fmt.Printf("int32: 0x%x %d\n", a1, a1)

    //nt32: 0x3e6f54ff 1047483647

    //int32 转为 int16, 发生数值截断

    b1 := int16(a1)

    fmt.Printf("a1 int16: 0x%x %d\n", b1, b1)

    //a1 int16: 0x54ff 21759

    //将常量保存为float32类型

    var c float32 = math.Pi

    //转为int类型，浮点数发生精度丢失

    fmt.Println(int(c))

    //3

}

2.4 指针

两个核心：

一种是类型指针，允许对这个指针类型的数据进行修改。传递数据使用使用指针，而无须拷贝数据类型指针不能进行偏移和运算

二种是切片，由指向起始元素的原始指针、元素数量和容量组成

2.4.1 认识指针地址和指针类型

每个变量在运行时都会被内存分配一个地址，这个地址代表变量在内存中的位置使用“&”操作符放在变量前面对变量进行“取地址”操作格式：

     ptr := &variable   //variable的类型为T

其中v代表被取地址的变量，被取地址的variable使用ptr变量进行接收，ptr的类型为“T”,称作T的指针类型。“”代表指针

package main



import (

    "fmt"

    "math"

)



func main() {

    var cat int = 1

    var str2 string = "banana"

    fmt.Printf("%p, %p\n", &cat, &str2)

}

    //0xc00004e0e8, 0xc0000421f0 为cat,str2取地址后的指针值

注意：变量、指针和地址三种的关系是：每个变量都拥有地址，指针的值就是地址

2.4.2 从指针获取指针指向的值

对变量“&”取地址操作后获得这个变量的指针，对指针使用“*”操作，就是指针取值

package main



import (

    "fmt"

    "math"

)

func main() {

    var house = "Malibu Point 10880, 90265"

    // 对字符串取地址，ptr1类型为*string

    ptr1 := &house

    // 打印ptr类型

    fmt.Printf("ptr1 类型：%T\n", ptr1)

    // 打印ptr指针地址

    fmt.Printf("ptr1 地址：%p\n", ptr1)

    // 对指针进行取值操作

    value := *ptr1

    // 取值后类型

    fmt.Printf("value 类型：%T\n", value)

    // value值

    fmt.Printf("value：%s\n", value)

}

// ptr1 类型：*string

// ptr1 地址：0xc000042200

// value 类型：string

// value：Malibu Point 10880, 90265

总结：

取地址“&”和取值“”是一对互补操作符，“&”取地址，"&"根据地址取出地址指向的值

1.对变量进行其地址（&）操作，可获得这个变量的指针变量

2.指针变量的值是指针地址

3.对指针变量进行取值（）操作，可以获得指针变量指向的原变量的值

2.4.3 使用指针修改值

x, y := 1,2

package main



import (

    "fmt"

    "math"

)



func main() {

    //错误示例

    swap1(&x, &y)

    fmt.Println("x: ",x, "y：", y)

    //x:  1 y:  2

    //正确

    swap(&x, &y)

    fmt.Println("x: ", x, "y: ",y)

    //x:  2 y:  1

}

// 交换函数

func swap(a, b *int) {

    // 取a的指针的值，赋给临时变量t

    t := *a

    //取b指针的值，赋值给a指针指向的变量

    *a = *b

    //a指针的值赋值给b指针指向的变量

    *b = t

}



// 错误示例

func swap1(a, b *int) {

    b, a = a, b

}

2.4.5 创建指针的另一种方法--new（）函数

new(类型)

str3 := new(string)

*str3 = "ninja"

fmt.Println(*str3)

fmt.Println(str3)

//ninja

//0xc000042230

2.6 字符串应用

2.6.1 计算机字符串长度 -- len()

go 语言字符串都是以UTF-8格式保存,每个中文占用3个字符

tip1 := "genji is a ninja"

fmt.Println(len(tip1))

// 16

tip2 := "忍者无敌"

fmt.Println(len(tip2))

//12

// 使用RuneCountInString()统计Uncode字符数量

fmt.Println(utf8.RuneCountInString("忍者"))

总结

ASCII字符串长度使用len()函数
Unicode字符串长度使用utf8.RuneCountInString()函数

2.6.2 遍历字符串 -- 获取每个字符串

两种写法

遍历每一ASCII字符，使用for循环遍历

theme := "阻击 start"



    for i := 0; i < len(theme); i++ {



        fmt.Printf("ascii: %c %d\n", theme[i], theme[i])



    }

    // ascii: é 233

    // ascii: • 152

    // ascii: » 187

    // ascii: å 229

    // ascii: • 135

    // ascii: » 187

    // ascii:   32

    // ascii: s 115

    // ascii: t 116

    // ascii: a 97

    // ascii: r 114

按Unicode字符遍历字符串

  for _, s := range theme {



        fmt.Printf("Unicode %c %d\n", s, s)



    }



    // Unicode 阻 38459

    // Unicode 击 20987

    // Unicode   32

    // Unicode s 115

    // Unicode t 116

    // Unicode a 97

    // Unicode r 114

    // Unicode t 116

总结:

ASCII字符串遍历直接使用下标
Unicode字符串遍历使用for range

2.6.3 获取字符串的某一段字符

string.Index() 在字符串中搜索另一个子串

tracer := "努力拥抱每一天，不断成长"

comma := strings.Index(tracer, "每一天")

posi := strings.Index(tracer[comma:], "成长")



fmt.Println(comma, posi, tracer[comma+posi:])



 // 12 18 成长

总结：

strings.Index：正向搜索子字符串
string.LastIndex: 反向搜索自字符串

搜索的起始位置可以通过切片偏移制作

2.6.4 修改字符串

go语言无法直接修改每一个字符元素，只能通过重新构造新的字符串并赋值给原来的字符串变量

angel := "Hero nerver die"



arrayBytes := []byte(angel)



for i := 5; i <= 10; i++ {



     arrayBytes[i] = '-'



}



fmt.Println(arrayBytes)



// [72 101 114 111 32 45 45 45 45 45 45 32 100 105 101]



fmt.Println(string(arrayBytes))



 // Hero ------ die

总结

Go语言的字符串是不可以改变的
修改字符串时,可以将字符串转换为[]byte进行修改
[]byte 和string 可以通过强制类型转换互换

2.6.5 连接字符串

可以使用加号“+”连接可以使用类似于StringBuilder的机制连接，更高效

hamer := "GO GO GO"

sickle := "You Can"



// 声明字节缓冲



var stringBuilder bytes.Buffer



// 将字符串写入缓冲区



stringBuilder.WriteString(hamer)



stringBuilder.WriteString(sickle)



//将缓冲以字符串形式输出



fmt.Println(stringBuilder.String())



// GO GO GOYou Can

bytes.Buffer可以缓冲并写入各种字节数组，字符串也是一种字符串数组，使用writeString()
将需要连接的字符串，通过bytes.Buffer声明缓冲stringBuilder调用WriteString()方法写入里面，
再通过stringBuilder.String()方法将缓冲转换为字符串

2.6.6 格式化

写法： fmt.Sprintf(格式化样式，参数列表)

格式化样式：字符串形式，格式化动词以%开头

参数列表：多个参数以逗号分隔，个数必须与格式化中样式个数一一对应

 var progress = 2

    var target = 8



    // 两参数格式化

    title := fmt.Sprintf("以完成%d个任务，还差%d个就完成", progress, target)



    fmt.Println(title)

    // 以完成2个任务，还差8个就完成



    pi := math.Pi



    // 按数值本身格式输出

    variant := fmt.Sprintf("%v %v %v", "月球基地", pi, true)

    fmt.Println(variant)

    // 月球基地 3.141592653589793 true



    profile := &struct {

        Name string

        HP   int

    }{

        Name: "stat",

        HP: 150,

    }



    fmt.Printf("使用'%%+v' %+v\n", profile)

    fmt.Printf("使用'%%#v' %#v\n", profile)

    fmt.Printf("使用'%%T' %T\n", profile)



    // 使用'%+v' &{Name:stat HP:150}

    // 使用'%#v' &struct { Name string; HP int }{Name:"stat", HP:150}

    // 使用'%T' *struct { Name string; HP int }

base64编码解码示例

package main



import (

    "fmt"

    "encoding/base64"

)



func main() {



    // 需要处理的字符串

    message := "Away from keyboard. https://golang.org/"



    // 编码消息, 传入的字符串需转为字节数组，才能供这个函数使用

    encodeMessage := base64.StdEncoding.EncodeToString([]byte(message))

    // 输出编码完成的消息

    fmt.Println(encodeMessage)

    // 解码消息

    data, err := base64.StdEncoding.DecodeString(encodeMessage)

    // 出错处理



    if err != nil {

        fmt.Println(err)

    } else {

        fmt.Println(string(data))

    }



    // QXdheSBmcm9tIGtleWJvYXJkLiBodHRwczovL2dvbGFuZy5vcmcv

    // Away from keyboard. https://golang.org/





}

2.7 枚举

2.7.1 枚举 -- 一组常量值

  // 使用iota模拟枚举

  type Weapon int

   const (

       Arrow Weapon = iota // 开始生成枚举值,默认为0

        Shuriken

       SniperRifle

       Rifle

       Blower

   )

   // 输出所有枚举值

    fmt.Println(Arrow, Shuriken, SniperRifle, Rifle, Blower)

   var weapon Weapon = Blower

    fmt.Println(weapon)

    // 0 1 2 3 4

    //

2.7.2 枚举--将枚举值转换为字符串

package main

import ("fmt")



// 声明芯片类型

type ChipType int



const (

    None ChipType = iota

    GPU

    CPU

)



func (c ChipType) String() string {



    switch c {

    case None:

        return "None"

    case GPU:

        return "GPU"

    case CPU:

    return "CPU"



     }

    return "N/A"



}



func main() {

    // 输出CPU的值并以整型格式显示

    fmt.Printf("%s %d", CPU, CPU)

    //CPU 2

}

2.8 类型别名

2.8.1 区分类型别名与类型定义

类型别名的写法：

type TypeAlias = Type

类型别名规定：

TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型

// 将NewInt定义为int类型

type NewInt int

// 将int取一个别名叫IntAlias

type IntAlias = int



// 将a声明为一个NewInt类型

var alias_a NewInt

fmt.Printf("a type: %T\n", alias_a)

// a type: main.NewInt



// 将a2声明为IntAlias类型

var alias_a2 IntAlias

fmt.Printf("a2 type: %T\n", alias_a2)

 // a2 type: int

2.8.2 非本地类型不能定义方法

不能为不在同一个包中声明的类型定义方法，即不能为在其他包声明的类型在本地包中定义方法

package main



import ("time")



// 2.8.2

// 定义time.Duration 的别名为MyDuration

type MyDuration = time.Duration



// 为MyDuration 添加一个函数

func (m MyDuration) EasySet(a String) {

}



func main() {

}

//# 2-base/2.2-data_type

//.\data_type.go:51:6: cannot define new methods on non-local type time.Duration

//.\data_type.go:51:31: undefined: String

//exit status 2

//Process exiting with code: 1

2.8.3 在结构体成员嵌入时使用别名

package main



import (

    "fmt"

    "reflect"

)



// 定义商标结构

type Brand struct {



}

// 为商标结构添加Show()方法

func (t Brand) Show() {



}



// 为Brand定义一个别名

type FakeBrand = Brand

// 定义车辆结构，嵌入商标结构

type  Vehicle struct {

    Brand

    FakeBrand

}



func main() {



    // 声明变量 a 为车辆类型

    var a Vehicle

    // 指定调用FakeBrand的Show

    a.FakeBrand.Show()

    // 取a的类型反射对象

    ta := reflect.TypeOf(a)



    // 遍历a的所有成员

    for i := ; i < ta.NumField(); i++ {

        // ta 成员信息

        f := ta.Field(i)

        // 打印成员的字段名和类型

        fmt.Printf("FieldName: %v, FieldType: %v\n", f.Name, f.Type.Name())

    }



    // FieldName: Brand, FieldType: Brand

    // FieldName: FakeBrand, FieldType: Brand





}

总结：

FakeBrand是Brand的一个别名，在Vehicel中嵌入FakeBrand和Brand，Vehicel的类型会以名字的方式保留在Vehicle的成员中
FakeBrand和Brand 都有Show()方法, 调用时必须制定调用谁的, a.FakeBrand.Show()