Golang语法

变量定义

变量定义语法

  • 使用var关键字,可放在函数内,也可放在包内
// var + 变量名 + 数据类型(有默认值)
var a int
var b string = "string"
// 通过赋值自动判断类型
var c = true
// 集中定义
var (
    x = 1
    y = 2
)
  • 使用:=定义变量,只能在函数内使用
// := 用于赋初值
a, b := 1, 2

内建变量类型(builtin)

  • bool, string
  • (u)int, (u)int8, (u)int16, (u)int32, (u)int64, uintptr
  • byte, rune
  • float32, float64, complex64, complex128

强制类型转换

Golang要求强制类型转换,无隐式转换

a, b := 3, 4
var c int
c = int(math.Sqrt(float64(a * a + b * b)))

常量

使用const关键字定义常量,const数值可作为各种类型使用。

// 不确定类型
const a = 3
var b float64
b = a
// 合并定义
const (
    c = 1
    d = 2
)

枚举

const (
    spring = 0
    summer = 1
    autumn = 2
    winter = 3
)
// iota用在取值为0的const变量,后续变量依次加1
const (
    spring = iota
    summer
    autumn
    winter
)

变量定义要点

  • 变量类型写在变量名之后
  • 编译器可以推测变量类型
  • Golang没有char,使用rune
  • 原生支持复数类型

分支

if

const filename = "abc.txt"
contents, err := ioutil.ReadFile(filename)
if err != nil {
    fmt.Println(err)
} else {
    fmt.Println(contents)
}

// 可以在if条件中赋值,赋值变量的作用域在if语句中
if contents, err := ioutil.ReadFile(filename); err != nil {
    fmt.Println(err)
} else {
    fmt.Println(contents)
}

switch

switch后可以没有表达式,case结束后自动break,通过fallthrough不使用自动break。

func grade(score int) {
    grade := ""
    switch {
    case score < 0:
        panic(fmt.Sprintf("Wrong score: %d\n", score))
    case score < 60:
        grade = "C"
    case score < 80:
        grade = "B"
    case score < 90:
        grade = "A"
    case score < 100:
        // 自动break,除非出现fallthrough
        fallthrough
    case score >= 100:
        grade = "S"
    }
    fmt.Println(grade)
}

循环

for条件没有括号,没有while。

func convertToBin(n int) string {
    result := ""
    for ; n > 0; n /= 2 {
        lsb := n % 2
        result = strconv.Itoa(lsb) + result
    }
    return result
}

func printFile(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        panic(err)
    }

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        fmt.Println(scanner.Text())
    }
}

func forever() {
    // while true
    for  {
        fmt.Println("forever")
    }
}

函数

  • 函数声明的顺序为:关键字,函数名,参数,返回类型,函数体。
  • 函数允许有多个返回值,并能在函数体内拿到返回值。
  • 函数可以作为另一个函数的参数
  • 函数支持可变参数列表
func div(a, b int) (q, r int) {
    // q = a / b
    // r = a % b
    // return
    return a / b, a % b
}

// 使用_抛弃返回值
a, _ := div(12, 7)

// 使用另一个函数作为参数
func apply(operation func(a, b int), a, b int) {
    operation(a, b)
}
// 使用匿名函数
apply(func(a, b int) {
    fmt.Println(a, b)
}, 1, 2)

// 可变参数列表
func sum(numbers ...int) int {
    s := 0
    for i := range numbers {
        s += numbers[i]
    }
    return s
} 

指针

Golang只有值传递一种方式。

// 使用指针操作
func change(pa *int) {
    *pa++
}
a := 5
change(&a)

func swap(x, y *int) {
    *x, *y = *y, *x
}

数组

数组长度写在类型之前,[10]int和[20]int是不同的类型。数组是值复制。

var arr1 [5]int
arr2 := [3]int{1, 3, 5}
arr3 := [...]int{2, 4, 6}
var arr4 [4][5]int

遍历数组

for i := 0; i < len(arr3); i++ {
    fmt.Println(arr3[i])
}

for i := range arr3 {
    fmt.Println(arr3[i])
}

// 按下标和值遍历
for i, v := range arr3 {
    fmt.Println(i, v)
}

切片

数组切片相当于数据的一个视图,可以通过切片改变数组的值。

func updateSlice(s []int) {
    s[0] = 100
}

func main() {
    array := [...]int{0, 1, 2, 3, 4, 5, 6, 7}
    s1 := array[2:6]
    s2 := array[2:]
    s3 := array[:6]
    s4 := array[:]
    fmt.Println(s1, s2, s3, s4) // [2 3 4 5] [2 3 4 5 6 7] [0 1 2 3 4 5] [0 1 2 3 4 5 6 7]

    updateSlice(s2)
    fmt.Println(s2) // [100 3 4 5 6 7]
    updateSlice(s3)
    fmt.Println(s3) // [100 1 100 3 4 5]
    
    // 切片扩展
    s5 := s3[6:8]
    fmt.Println(s5)
    
    // 添加元素
    s6 := append(s5, 8)
    fmt.Println(s6, array)
    fmt.Println(array[:8])
    
    // 通过make创建切片
    // 长度为10的切片
    x := make([]int, 10)
    // 长度为10,容量为16的切片
    y := make([]int, 10, 16)

    // 拷贝数组元素
    copy(x, y)

    // 截取数组元素
    z := append(x[:2], x[3:]...)
}

切片底层维护了一个数组,ptr指向切片的首个元素,len表示切片的长度,cap表示底层数组的从ptr到最末的元素数量。切片可以向后扩展,不可向前扩展。切片添加元素如果会超过底层数组的cap,Golang会分配更大的底层数组(原容量*2进行扩展),由于值传递的关系,必须接收append方法的返回值。

map

通过map[K]v的形式定义map。除了slice、map、function的内建类型和struct类型都可以作为map的key。

m := map[string]string{
        "name": "wch",
        "age":  "23",
    }
    
m2 := make(map[string]int)

// 无序遍历map
for k, v := range m {
    fmt.Println(k, v)
}

// map读值
name := m["name"]


// 判断key是否存在
grade, exist := m["grade"]

// 删除
delete(m, "name")

rune

Golang的rune相当于java的char,中文字符在Golang中占3个字节,使用 utf8.RuneCountInString 获取字符数,用 len 获取字节长度,使用 []byte 获取字节。

s := "学习Golang!"
fmt.Println(s)

// ch是rune类型,中文字符占3个字节
for i, ch := range s {
    fmt.Printf("(%d %X) ", i, ch)
}
fmt.Println()

fmt.Println("rune count in string:", utf8.RuneCountInString(s))

bytes := []byte(s)
for len(bytes) > 0 {
    ch, size := utf8.DecodeRune(bytes)
    bytes = bytes[size:]
    fmt.Printf("size= %d, rune=%c\n", size, ch)
}

for i, ch := range []rune(s) {
    fmt.Printf("(%d %c)", i, ch)
}
fmt.Println()

面向对象

Golang仅支持封装,不支持继承和多态,没有class,只有struct,通过struct来定义对象。

type treeNode struct {
    value       int
    left, right *treeNode
}

func createNode(value int) *treeNode {
    return &treeNode{value: value}
}

func main() {
    // 通过多种方式声明对象
    var root treeNode
    root = treeNode{value: 0}
    root.left = &treeNode{}
    root.right = &treeNode{1, nil, nil}
    root.right.left = new(treeNode)
    root.right.right = createNode(3)
}

Golang支持显式定义方法接收者,值/指针接收者均可接收值/指针。当需要改变内容或结构过大时需要使用指针接收者,值接收者是Golang特有的

// 指定方法接收者
func (node treeNode) print() {
    fmt.Println(node.value)
}

func (node *treeNode) setValue(value int) {
    node.value = value
}

func main() {
    node := treeNode{}
    node.setValue(100)
    node.print()
    
    pNode := &node
    pNode.setValue(101)
    pNode.print()
}

封装

Golang的可见性(针对包)使用首字母来控制,首字母大写表示public,首字母小写表示private。每个目录都是一个包,main包包含可执行入口。为结构定义的方法必须放在同一个包内,可以是不同的文件。Golang提供了两种扩展系统类型和已封装类型的方法:

  • 定义别名:通过type为已有类型定义一个别名,针对新的结构体进行扩展。
type Queue []int

func (q *Queue) Push(v int) {
    *q = append(*q, v)
}

func (q *Queue) Pop() int {
    head := (*q)[0]
    *q = (*q)[1:]
    return head
}

func (q *Queue) IsEmpty() bool {
    return len(*q) == 0
}
  • 使用组合:定义新的结构体,其中一个成员是需要扩展的类型的指针。
type EnhanceNode struct {
    node *Node
}

func (enhanceNode *EnhanceNode) PostOrder() {
    if nil == enhanceNode || nil == enhanceNode.node {
        return
    }

    left := EnhanceNode{enhanceNode.node.Left}
    right := EnhanceNode{enhanceNode.node.Right}

    left.PostOrder()
    right.PostOrder()
    enhanceNode.PostOrder()
}

GOROOT、GOPATH、go get

GOROOT一般为下载的sdk路径,GOPATH为用户可定义的路径,用户源码和通过go get命令下载的第三方库在GOPATH的src目录下。
gopm是go get的镜像工具,通过 go get -g -v github.com/gpmgo/gopm 下载gopm。

// 下载
gopm get -g -v Golang.org/x/tools/cmd/goimports
// 更新
gopm get -g -v -u Golang.org/x/tools/cmd/goimports
// 安装到GOPATH的bin目录
go install Golang.org/x/tools/cmd/goimports

接口

接口的实现是隐式的,只要实现接口的方法。

duck typing

“像鸭子走路,像鸭子叫(长得像鸭子),那么就是鸭子”,意为描述事物的外部行为而非内部结构。严格说go属于结构化类型系统,类似duck typing。

接口变量里有什么

  • 接口自带指针
  • 接口变量同样采用值传递,几乎不需要使用接口的指针
  • 指针接收者只能以指针的方式使用,值接收者都可以
  • interface{}可以代表任何类型
  • 定义接口
type Retriever interface {
    Get(url string) string
}

func download(r Retriever) string {
    return r.Get("http://www.baidu.com")
}
  • 实现接口
type Retriever struct {
    UserAgent string
    Timeout   time.Duration
}

func (r *Retriever) Get(url string) string {
    resp, err := http.Get(url)
    if nil != err {
        panic(err)
    }

    result, err := httputil.DumpResponse(resp, true)
    resp.Body.Close()

    if nil != err {
        panic(err)
    }

    return string(result)
}
  • 调用接口
var r Retriever
r = &real.Retriever{
    UserAgent: "Mozilla/5.0",
    Timeout:   time.Minute,
}
fmt.Println(download(r))

// Type Assertion
if retriever, ok := r.(*real.Retriever); ok {
    fmt.Printf("%T %v\n", retriever, retriever)
}
  • 接口组合
type HttpExecute interface {
    Retriever
    Poster
}

函数式编程

  • 函数是一等公民:参数,变量,返回值都可以是函数。
  • 高阶函数:函数的参数可以是函数
  • 函数->闭包
func adder() func(int) int {
    sum := 0
    return func(i int) int {
        sum += i
        return sum
    }
}

func main() {
    // f中不仅是一个函数,还有对变量sum的引用
    f := adder()
    for i := 0; i < 10; i++ {
        fmt.Println(f(i))
    }
}

错误处理和资源管理

defer

用于指定在函数结束之前执行,可以用于关闭文件、释放锁等。

func tryDefer() {
    // 在函数借结束之前执行
    defer fmt.Println("execute last...")
    defer fmt.Println("execute before last...")
    fmt.Println("execute")
}

panic

  • 停止当前函数执行
  • 一直向上返回,执行每一层的defer
  • 如果没有遇见recover,程序退出

recover

  • 仅在defer调用中使用
  • 获取panic的值
  • 如果无法处理,重新panic
func tryRecover() {
    defer func() {
        r := recover()
        if err, ok := r.(error); ok {
            fmt.Println("error:", err)
        } else {
            panic(fmt.Sprintf("unknown error: %v", r))
        }
    }()

    panic(errors.New("this is an error"))
}

测试

测试格式

  • 测试文件与待测试代码放在同一目录下
  • 测试文件名以 _test.go 结尾
  • 测试函数名为 TestXxxTest_xxx 的格式,使用其它类型测试,如性能测试则函数名为BenchmarkXxx 或 ```Benchmark_xxx`` 的格式

传统测试

  • 传统测试数据与逻辑混在一起
  • 传统测试的出错信息不明确
  • 传统测试一旦出错测试即全部结束

表格驱动测试

  • 测试代码
func calcTriangle(a, b int) int {
    return int(math.Sqrt(float64(a*a + b*b)))
}
  • 表格驱动测试
    分离了测试数据和测试逻辑,明确了出错信息,可以部分失败。
func TestCalcTriangle(t *testing.T) {
    tests := []struct{ a, b, c int }{
        {3, 4, 5},
        {5, 12, 13},
        {8, 15, 18},
    }

    for _, tt := range tests {
        if actual := calcTriangle(tt.a, tt.b); actual != tt.c {
            t.Errorf("calcTriangle(%d %d); got %d; expected %d", tt.a, tt.b, actual, tt.c)
        }
    }
}

性能测试

执行b.N次,由Golang决定具体次数,测试完成后在控制台打印执行次数和平均执行时间。

func BenchmarkTriangle(b *testing.B) {
    x, y, z := 8, 15, 17
    for i := 0; i < b.N; i++ {
        actual := calcTriangle(x, y)
        if actual != z {
            b.Errorf("calcTriangle(%d %d); got %d; expected %d", x, y, actual, z)
        }
    }
}

测试命令行工具

# 测试命令
go test
# 代码覆盖率测试
go test -cover
# 生成代码测试覆盖率文件
go test -coverprofile c.out
# 代码覆盖率测试html
go tool cover -html=c.out
# 性能测试
go test -bench .
# 生成性能报告
go test -bench . -cpuprofile cpu.out

文档

Golang提供 go doc 命令查看由注释组成的文档,通过 godoc -http :6060 命令在本地6060端口生成html文档。在test文件中建立名为 ExampleXxx_xxx 的函数,通过特定格式生成代码实例文档。

func ExampleQueue_Pop() {
    queue := Queue{}
    queue.Push(1)
    fmt.Println(queue.Pop())

    // Output:
    // 1
}

go routine

协程Coroutine

  • 轻量级“线程”
  • 非抢占式多任务处理,由协程主动交出控制权
  • 编译器/解释器/虚拟机层面的多任务
  • 多个协程可能在一个或多个线程上运行

goroutine定义

  • 调用任何函数前只需加上 go 关键字就可以交给调度器执行
  • 不需要在定义时区分是否为异步函数
  • 调度器会在合适的点进行切换(I/O、select、channel、等待锁、函数调用等),或手动调用 runtime.Gosched() 进行切换
  • 使用race来检测数据访问冲突, go run -race xxx.go

channel

相对于通过共享内存来通信,channel通过通信来共享内存。

  • chanel可以作为参数传递
  • 可以设置channel的buffer
  • 发送方负责关闭channel,接收方通过可以通过 range 判断channel是否传递完毕

使用select进行调度

select可以用来监听IO操作,可以同时监听多个channel的消息状态。

你可能感兴趣的:(Golang语法)