Golang 学习记录

Golang 学习记录

[toc]

特殊点

分组定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 单独导入
import "fmt"
import "math"
// 分组导入
import (
4"fmt"
"math"
)

// 同样适用于声明和定义
var (
4i int
ok bool = true
)
const (
4str string = "Hello"
cmx complex64 = 10 + 2i
)

命名

1
2
3
// 导出的方法、变量必须是首字母大写
math.pi // cannot refer to unexported name math.pi
math.Pi // 3.141592653589793

Go的多线程

  • GoRoutine go f(x)表示在新的线程中执行f(x),但fx的求值都是在当前线程。

  • 信道是带有类型的管道,你可以通过它用信道操作符 <- 来发送或者接收值。

    1
    2
    3
    ch := make(chan int)  //创建信道
    ch <- v // 将 v 发送至信道 ch。
    v := <-ch // 从 ch 接收值并赋予 v。

概览

函数

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
// 函数的参数和返回值需要显式声明类型
func add(a, b int) int {
return a + b
}
// 函数的返回值也可以提前指定
func power(x, n int) (z int) {
i, z := 0, 1 // 短变量声明,自动判断类型
for ;i < n; i++ {
z *= x
}
4return
}

/*
* 基本函数
*/
for {}
// 相当于 while {}
func pow(x, n, lim float64) float64 {
4if v := math.Pow(x, n); v < lim {
// v仅在当前结构体内有效
44return v
4}
4return lim
}
// Go 自动提供了在这些语言中每个 case 后面所需的 break 语句。 除非以 fallthrough 语句结束,否则分支会自动终止。 Go 的另一点重要的不同在于 switch 的 case 无需为常量,且取值不必为整数。
switch os := runtime.GOOS; os {
4case "darwin":
44fmt.Println("macOS.")
4case "linux":
44fmt.Println("Linux.")
4default:
44fmt.Printf("%s.\n", os)
}

// defer 语句会将函数推迟到外层函数返回之后执行。
func main() {
4defer fmt.Println("world")
4fmt.Println("hello")
}
/*
hello
world
*/
// defer 栈:后进先出
func main() {
4for i := 0; i < 10; i++ {
44defer fmt.Println(i)
4}
4fmt.Println("done")
}
/*
done 9 8 7 6 5 4 3 2 1 0
*/

// 内置接口
type Stringer interface { String() string }
// fmt包将通过String方法打印值

// 错误
type error interface { Error() string }

// Image接口
type Image interface {
ColorModel() color.Model
Bounds() image.Rectangle
At(x, y int) color.Color
}

组件

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
// 结构体
type Vertex struct {
4X int
4Y int
}
func main() {
4v := Vertex{1, 2}
fmt.Println(v) // {1, 2}
4fmt.Println(v.X) // 1
}

// 方法:带特殊接受者参数的函数
// 例:为自定义类型写方法
type iFloat float64
func (f iFloat) Abs() float64 {
if f < 0 {
return -f
} else {
return f
}
}
// 使用指针接受者来修改原本的值
func (v *Vertex) Add(i int) {
v.X = v.X + i
v.Y = v.Y + i
}
v.Add(5) // 对于指针接受者,Go会自动转换成(&v).Add(5)
p := &v // 对于值的接受者,也可以传递指针,Go会自动转换成(*p).Add(5)

// 接口:接口类型的变量可以保存任何实现了这些方法的值。
type I interface {
Method()
}
// 接口内部包含了值和具体方法的元组
=> (value, type)
// 例
type Text struct {
S string
} // 定义一个结构体
// 隐式实现接口
func (t *Text) Method() {
fmt.Println(t.S)
}
var i I
i = &Text{"text"}
fmt.Println("%v, %T", i, i) // 输出:&{hh}, *main.Text
// 空接口:用来保存任何类型的值
var i interface{} // (<nil>, <nil>)
i = 42 // (42, int)
i = "yes" // (yes, string)
// 接口类型判断
tmp := i.(int) // 表示获取i中int类型的值并赋值给t。如果i中类型不是int,则会引发panic
tmp, ok := i.(string) // 如果i保存了string类型的值,ok=true。否则tmp=0,ok=false

// Read方法
// io 包指定了 io.Reader 接口,它表示从数据流的末尾进行读取。
func (T) Read(b []byte) (n int, err error) {}
// Read 用数据填充给定的字节切片并返回填充的字节数和错误值。在遇到数据流的结尾时,它会返回一个 io.EOF 错误。

基本类型

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
bool: true false
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // uint8 的别名
rune // int32 的别名
// 表示一个 Unicode 码点
float32 float64
complex64 complex128
/*
* 类型转换
*/
var i int = 37
var f float64 = float64(i)
/*
* 数组
*/
var a [10]int

未完待续,持续学习中...
打赏
  • 版权声明: 本博客所有文章除特别声明外,均采用 Apache License 2.0 许可协议。转载请注明出处!

请我喝杯咖啡吧~

支付宝
微信