Head First Go - 11接口

接口

一个接口是特定值预期具有的一组方法

如果一个类型包含接口中声明的所有方法，那么它可以在任何需要接口的地方使用，而不需要更多的声明

方法名称、参数类型(可能没有)和返回值(可能没有)都需要与接口中定义的一致。除了接口中列出的方法之外，类型还可以有更多的方法，但是它不能缺少接口中的任何方法，否则就不满足那个接口

一个类型可以满足多个接口，一个接口(通常应该)可以有多个类型满足它

type 接口名 interface {  
    funcA  
    funcB  
}

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
package main

import (
	"fmt"
)
//定义一个接口，有两个方法
type myInterface interface {
	outPut()
	outPutWithString(str string)
}

type myType int

func (m myType) outPut() {
	fmt.Println(m)
}

func (m myType) outPutWithString(str string) {
	fmt.Println(m, str)
}

type myAnotherType string

func (m myAnotherType) outPut() {
	fmt.Println(m)
}


func (m myAnotherType) outPutWithString(str string) {
	fmt.Println(m, str)
}

func main() {
	var intf myInterface

    //这两个类型恰好都满足这个接口，就可以赋值成功

	intf = myType(15)
	intf.outPut()

	intf = myAnotherType("aaa")
	intf.outPut() 
}

接口变量

接口变量和普通变量没什么区别，也可以当函数参数或返回值

如果一个类型声明了指针接收器方法，你就只能将那个类型的指针传递给接口变量

类型断言

可以通过类型断言将接口变量转换为它对应的类型变量

类型变量, bool = 接口变量.(类型)

bool等于true说明断言成功

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
package main

import (
	"fmt"
)

type myInterface interface {
	outPut()
}

type myType int

func (m myType) outPut() {
	fmt.Println(m)
}

type myAnotherType string

func (m myAnotherType) outPut() {
	fmt.Println(m)
}


func (m myAnotherType) outPutWithString(str string) {
	fmt.Println(m, str)
}

func testFunc(intf myInterface) {
	intf.outPut()
	another,ok := intf.(myAnotherType)
	if ok {
		another.outPutWithString("ok")
	} else {
		fmt.Println("type err")
	}
}

func main() {
	testFunc(myType(15))
	testFunc(myAnotherType("hhh"))
}

error接口

error是一个接口类型 

type error interface {  
       Error() string  
}

error类型像int或者string一样是一个“预定义标识符”，它不属于任何包。它是“全局块”的一部分，这意味着它在任何地方可用，不用考虑当前包信息

可以自定义满足error接口的类型

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

import (
	"fmt"
)

type myErrorType string

func (m myErrorType) Error() string {
	return string(m)
}

func main() {
	var err error //声明一个error接口变量

	err = myErrorType("wtf") //我们的类型方法满足error接口,可以赋值

	fmt.Println(err.Error())
}

stringer

fmt包定义了fmt.Stringer接口:允许任何类型决定在输出时如何展示

type Stringer interface {  
    String() string  
}

许多在fmt包中的函数都会判断传入的参数是否满足stringer接口，如果满足就调用String方法。这些函数包括Print、Println和Printf等

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

import (
	"fmt"
)

type myType string

func (m myType) String() string {
	return "--- " + string(m) + " ---"
}

func main() {
	value := myType("aaa")
	fmt.Println(value)
}

空接口

fmt.Println能接收任意类型,因为它声明了空接口Interface{}

Interface{}类型称为空接口，用来接收任何类型的值。不需要实现 任何方法来满足空接口，所以所有的类型都满足它

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
package main

import (
	"fmt"
)

type myType string

func (m myType) myTpyeFunc() {
	fmt.Println("myTypeFunc", m)
}

//空接口作为函数参数
func test(empty interface{}) {
	fmt.Println(empty)

	mt, ok := empty.(myType) //空接口无法调用任何方法,通过断言转换成对应的类型
	if ok {
		mt.myTpyeFunc()
	}
}

func main() {
	test(123)
	test(myType("abc"))
}

展开全文 >>

Head First Go - 10封装

封装

Go通过限制struct中成员是否能导出配合该strcut类型定义相关的方法实现封装

setter

setter方法是用来设置封装字段值的方法

setter方法需要指针接收器

setter方法通常被命名为setX, X为被设置字段的名称

getter

getter方法是用于获取封装字段的方法

getter方法通常被命名为X, X为被设置字段的名称 (一般习惯前面不加get)

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

import (
	"errors"
	"unicode/utf8"
)

type Abc struct {
	name string
}

func (a *Abc) SetName(name string) error {
	if utf8.RuneCountInString(name) > 20 {
		return errors.New("out of len")
	}

	a.name = name
	return nil
}

func (a *Abc) Name() string {
	return a.name
}

嵌入 struct

当子struct嵌入到父strcut,子struct未导出的字段不会被提升

当子struct嵌入到父strcut,子struct导出的方法会被提升

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 (
	"fmt"
	"abc"
)

type myType struct {
	abc.Abc
}

func main() {
	var st myType

	//Abc未导出的字段无法提升
	//fmt.Println(st.name) 

	//Abc导出的方法可以提升
	st.SetName("zeyu")
	fmt.Println(st.Name())
	//通过类型名访问也可以
	fmt.Println(st.Abc.Name())
}

注意当struct嵌入了多个子struct时，导出方法可能会有重名的情况,这时直接调用导出方法会无法编译通过,需要加上类型

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
//abc包中的Abc和def包中的Def都定义了setName()和Name()
package main

import (
	"fmt"
	"abc"
	"def"
	"log"
)

type myType struct {
	abc.Abc
	def.Def
}

func main() {
	var st myType

	//Abc未导出的字段无法提升
	//fmt.Println(st.name) 

	//Abc导出的方法可以提升

	//重名
	err := st.SetName("zeyu")
	if err != nil {
		log.Fatal(err)
	}

	//重名
	fmt.Println(st.Name())

    /*
    正确使用
    err := st.Abc.SetName("zeyu")
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println(st.Abc.Name())
    */

}
//./test.go:22:11: ambiguous selector st.SetName
//./test.go:27:16: ambiguous selector st.Name

展开全文 >>

Head First Go - 09定义类型

定义基础类型

1
2
type myTypeA float64
type myTypeB float64

虽然myTypeA,和myTypeB都是同一基础类型，但是不能把另一个类型的值赋给它

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

import "fmt"

type myTypeA float64
type myTypeB float64

func main() {
	var a myTypeA
	var b myTypeB

	a = 1.1 //基础类型可以直接赋值，不过最好也用转换
	b = 2.1

	fmt.Println(a)
	fmt.Println(b)

    //不能直接赋值,需要类型转换
	//a = b
	a = myTypeA(b)
}
  • 一个定义类型提供所有与基础类型相同的运算
  • 一个定义类型可以被用来与字面值一起用于运算
  • 但是定义类型不能用来与不同类型的值一起运算，即使它们是来自相同的基础类型

定义方法

可以为指定的类型定义方法

一旦方法被定义在了某个类型，它就能被该类型的任何值调用

func (接收器 类型) 函数名() { }

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

import "fmt"

type myTypeA float64

//将hello定义在了myTypeA上
func (m myTypeA) hello() {
	fmt.Println("hello", m)
}

func main() {
	var test myTypeA = 1.1
	test.hello()
}
  • 接收器的参数类似C++的this指针
  • 按照惯例，Go开发者通常使用一个字母作为名称——小写的接收器类型名称的首字母
  • 方法和类型必须定义在同一包中
  • Go使用接收器参数来代替self和this，self和this是隐含的，而Go显式地声明一个接收器参数

导出方法

就像其他的函数，方法名称以大写字母开头，则认为是导出的

指针类型的接收器参数

就像其他的参数一样，接收器参数接收一个原值的拷贝。如果你的方法需要修改接收器，你应该在接收器参数上使用指针类型，并且修改指针指向的值

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

import "fmt"

type myTypeA float64

func (m *myTypeA) helloA() {
	*m = 0
	fmt.Println("hello", *m)
}

func main() {
	var test myTypeA = 1.1
    /*
    不需要修改方法的调用。当你用一个非指针的变量调用一个需要指针的接收器的方法的时候，Go会自动为你将非指针类型转换为指针类型。同样指针类型也会自动转换为非指针类型，如果你调用一个要求值类型的接收器，Go会自动帮你获取指针指向的值，然后传递给方法
    */
	test.helloA()
}

其他

你需要将值保存在变量中，允许Go能得到一个指向它的指针

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
package main

import "fmt"

type myTypeA float64


func (m *myTypeA) hello() {
	*m = 0
	fmt.Println("hello", *m)
}

func (m myTypeA) hi() {
	fmt.Println("hi", m)
}

func main() {
	var test myTypeA = 15
	fmt.Println(&test)
	test.hi()
	test.hello()

	myTypeA(15).hi()
	//myTypeA(15).hello() cannot take the address of myTypeA(15) 
	//fmt.Println(&myTypeA(15)) cannot take the address of myTypeA(15) 
}

展开全文 >>

Head First Go - 08struct

struct

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

import "fmt"

func main() {
	var myStruct struct {
		num int
		str string
	}

	fmt.Printf("%#v\n", myStruct)

	myStruct.num = 5
	fmt.Println(myStruct.num)
}

定义类型

type 类型名 基础类型

不要使用一个已经存在的类型名称作为变量的名称

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

import "fmt"

type myType struct {
	name string
}

func main() {
	var st myType
	st.name = "zeyu"

	fmt.Println(st.name)
}

指针访问struct字段

使用点运算符在struct指针和struct上都可访问字段

这里和C就有区别了，C取普通struct变量的成员用.,取指向struct的指针变量指向的成员要用->,Go可以都用.

如果函数需要修改struct或者struct过大，应该向函数传递，返回指针

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

import "fmt"

type myType struct {
	name string
}

func main() {

	var st myType
	st.name = "zeyu"

	var pointer *myType = &st

	fmt.Println((*pointer).name)
	fmt.Println(pointer.name)
}

struct 导出

定义类型的名称首字母必须大写才能导出该类型

struct字段的名称首字母必须大写才能导出该字段

1
2
3
4
type MyType struct {
	Name string//能导出
	age int//不能导出
}

struct 字面量

和映射差不多

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

import "fmt"

type myType struct {
	name string
	age int
}

func main() {
	st := myType{name : "aaa", age: 15}
	fmt.Println(st.name)
}

struct 嵌入

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"

type stb struct {
	b int
}

type sta struct {
	a int
	sub stb 
}

func main() {
	st := sta{a: 1}

	st.sub = stb{b : 15} //直接填充整个子struct
	fmt.Println(st.sub.b)

	st.sub.b = 100 //给子strcut成员赋值
	fmt.Println(st.sub.b)

	ta := sta{a: 10, sub: stb{b: 15}} //直接赋值嵌套结构体
	fmt.Println(ta.sub.b)
}

匿名struct

一个内部struct使用匿名字段的方式存储在了外部的struct中，这被称为嵌入了外部struct。嵌入struct的字段被提升到了外部struct，可以像访问外部struct的字段一样访问它们

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
package main

import "fmt"

type stb struct {
	b int
}

type sta struct {
	a int
	stb //只写类型名 
}

func main() {
	st := sta{a: 1}
    //当你声明一个匿名字段时，你可以使用字段类型名称作为字段名称
	st.stb = stb{b : 15}
	fmt.Println(st.stb.b)

	st.stb.b = 100
	fmt.Println(st.stb.b)

    //可以像访问外部字段一样访问嵌入的strcut字段
	st.b = 50
	fmt.Println(st.b)
}

展开全文 >>

Head First Go - 07映射

映射

映射可以使用任意类型的键(只要这个类型可以使用==来比较)

var testMap map[keyType]valueType

与切片一样，声明一个映射变量并不会自动创建一个映射，你需要调用make函数

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

import "fmt"

func main() {
	var testMap map[int]string //声明一个映射变量
	testMap = make(map[int]string) //创建一个映射变量

	testMap[0] = "aaa"
	fmt.Println(testMap[0])
}

映射字面量

map[keyType]valueType{ k1:v1, k2:v2 }

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

import "fmt"

func main() {
	emptyMap := map[int]string{} //空映射
	testMap := map[int]string{1:"aaa", 2:"bbb"} 
	fmt.Println(emptyMap)
	fmt.Println(testMap)
}

映射零值

就像跟切片一样，映射变量的零值是nil。如果你声明了一个映射变量但是未赋值，它的值是nil。那意味着没有映射存在来增加键或者值。如果你尝试这么做，会产生一个panic。但是nil的切片可以通过append内置函数被赋值

如果你访问一个没有赋值过的key，你会得到一个value对应的零值

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

import "fmt"

func main() {
	var nilMap map[int]string
	emptyMap := map[int]string{}

	fmt.Printf("%#v\n", emptyMap)
	fmt.Printf("%#v\n", nilMap)
	fmt.Printf("%#v\n", emptyMap[1])
}

区分赋值为0和零值

访问映射键的时候可选地获取第2个布尔类型的值。如果这个键已经被赋过值，那么返回true，否则返回false

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

import "fmt"

func main() {
	myMap := map[int]string{1:"aaa", 2:"bbb"}

	val1, oK := myMap[1]
	fmt.Println(val1, oK)

	val3, oK := myMap[3]
	fmt.Println(val3, oK)
}

delete

通过内置函数delete删除映射的一个value

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

import "fmt"

func main() {
	testMap := map[string]string{"test" :"testVal"}

	val, ok := testMap["test"]
	fmt.Println(ok,val)

	delete(testMap, "test")

	_, ok = testMap["test"]
	fmt.Println(ok)
}

遍历映射

可以使用for key,value := range遍历映射,映射的遍历是无序的

展开全文 >>

Head First Go - 06切片

切片

切片是Go的数据结构,底层基于数组实现，可以理解为数组的视图,和python切片使用差不多

切片不用指定数组大小，其他与声明数组变量语法相同

切片通过make()去创建切片的类型和长度

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

import "fmt"

func main() {
	var mySlice []int;	//声明切片
	mySlice = make([]int, 3) //创建三个整形的切片

	testSlice := make([]string,2) //短变量声明

	mySlice[0] = 0;
	testSlice[0] = "aaa";

	fmt.Println(mySlice[0])
	fmt.Println(testSlice[0])
}

切片字面量

和数组字面量差不多,而且不用调用make,也不用声明长度

1
testSlice := []string{"aaa", "bbb"}

切片运算符

和python一样(Go索引不能有负数,不能像Python一样反着切)underlyingArray[i:j]作为切片的运算符，生成的切片实际上包含元素underlyingArray[i]到元素underlyingArray[j-1]

  • 切片运算符默认需要两个索引。如果你忽略了开始的索引，0(数组的第一个元素)会被使用
  • 如果你忽略了结束的索引，从底层数组的开始索引到数组结尾之间的所有元素都会被包含到结果切片中
  • 因为切片是底层数组的视图,修改底层数组的值也会影响切片,修改切片的值也会因影响底层数组,所以一般使用make或切片字面量创建切片，这样就不用关心底层数组
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main

import "fmt"

func main() {

	testArr := [4]string{
			"aaa",
			"bbb",
			"ccc",
			"ddd",
		}

	testSlice := testArr[0:2]

	for _,value := range testSlice {
		fmt.Println(value)
	}
}

append

append可以给切片添加元素，

切片的底层数组并不能增长大小。如果数组没有足够的空间来保存新的元素，所有的元素会被拷贝至一个新的更大的数组，并且切片会被更新为引用这个新的数组。但是由于这些场景都发生在append函数内部，无法知道返回的切片与传入append函数的切片是否具有相同的底层数组。如果你保留了两个切片，会导致一些非预期的错误,所以我们调用append函数，惯例是将函数的返回值赋给你传入的那个切片变量

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

import "fmt"

func main() {

	s1 := []string{"s1", "s1"}		
	s2 := append(s1, "s2", "s2")
	s3 := append(s2, "s3", "s3")
	s4 := append(s3, "s4", "s4")

	s4[0] = "wtf"

	fmt.Println(s1)
	fmt.Println(s2)
	fmt.Println(s3)
	fmt.Println(s4) //s3 s4切片共用一个底层数组
	
	//正常使用
	s5 := []string{"s5", "s5"}
	s5 := append(s5, "s6", "s6")
}

切片零值

不像数组，切片变量自己也有0值:nil。一个没有赋值的切片变量 值为nil

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

import "fmt"

func main() {
	var s1[]string //声明一个没有赋值的切片变量,初始值为nil
	s2 := []string{} //这个切片已经赋值了,底层是长度为0的数组
	s3 := make([]string, 0) //这个切片已经赋值了,底层是长度为0的数组
	
	fmt.Printf("%#v\n", s1)//nil
	fmt.Printf("%#v\n", s2) 
	fmt.Printf("%#v\n", s3) 

	fmt.Println(len(s1))
	fmt.Println(len(s2))
	fmt.Println(len(s3))
}

可变长参数

可变长参数函数的最后一个参数接收一个切片类型的变长参数，这个切片可以被函数当作普通切片来处理

如果我们不提供变长参数，它不会返回错误，函数会收到一个空的切片

仅仅函数定义中的最后一个参数可以是可变长参数,不能把它放到必需参数之前

让含有可变长参数的函数接受切片,可以在传入的切片变量后增加省略号(…)

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

import (
	"fmt"
	"reflect"
)

func test(val ...int) {
	fmt.Println(reflect.TypeOf(val))
	fmt.Println(val)
}

func main() {
	test(1, 2, 3)
	slice := []int{1, 2, 3}
	test(slice...) //可变参数直接接收一个切片
}

展开全文 >>

Head First Go - 05数组

数组定义

创建数组时，它所包含的所有值都初始化为数组所保存类型的零值

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

import "fmt"

func main() {
	var arr [3]string
	arr[0] = "aaa"
	arr[1] = "bbb"
	fmt.Println(arr[0])
	fmt.Println(arr[1])
	fmt.Println(arr[2])

}

数组字面量

可以用数组字面量初始化数组

数组变量=[n]类型{ , , , }

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() {
	var arr [3]string = [3]string{ //字面量可以换行，但是要在每一项前使用 ,
        "aaa",
		"bbb",
		"ccc",
        }

	test := [3]int{1, 2}

	fmt.Println(arr[0])
	fmt.Println(arr[1])
	fmt.Println(arr[2])

	fmt.Println(test[1])
	fmt.Println(test[2])

    fmt.Println(arr) // Println可以直接打印数组
    fmt.Printf("%#v", arr) //打印数组字面量

}

访问数组元素

数组下标越界会导致panic

  • 可以使用len()获取数组长度

    1
    2
    3
    for i := 0; i < len(arr); i++ {
    	fmt.Println(arr[i])
    }

  • 使用for ... range关键字

1
2
3
for index, value := range arr { //index返回下标，value下标对应值
	fmt.Println(index, value)
}

函数返回数组

这里和C不太一样，Go可以直接返回一个数组，而不是指针

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

import "fmt"

func returnArr() ([3]int, error) {
	return [3]int{1, 2, 3}, fmt.Errorf("wtf")
}

func main() {
	arr, _ := returnArr()

	for _, value := range arr {
		fmt.Println(value)
	}
}

其他

读文件

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
package main

import (
	"bufio"
	"fmt"
	"log"
	"os"
)

func main() {
	file, err := os.Open(os.Args[1]) //从argv读取文件路径
	if err != nil {
		log.Fatal(err)
	}

	scanner := bufio.NewScanner(file)
	for scanner.Scan() { //从文件逐行读取，一直循环到文件末尾，返回false
		fmt.Println(scanner.Text())
	}

	err = file.Close()
	if err != nil {     //如果关闭文件失败
		log.Fatal(err)
	}

	if scanner.Err() != nil { //如果扫描文件失败
		log.Fatal(scanner.Err())
	}
}

展开全文 >>

Head First Go - 04包

Go工作区

  • bin，保存已编译的二进制可执行程序
  • pkg，保存已编译的二进制包文件
  • src，保存Go的源代码

在src中，每个包的代码都位于它自己单独的子目录中。按照惯例，子目录名应该与包名相同

导出包

import的是src下的路径,src下同一级目录只能有一个package,但是可以创建子目录嵌套package(使用域名和路径来确保包导入路径是唯一的)

  • 包名应全部为小写
  • 如果含义相当明显，名称应该缩写(如fmt)
  • 如果可能的话，应该是一个词。如果需要两个词，不应该用下划线分隔，第二个词也不应该大写(strconv包就是一个例子)
  • 导入的包名可能与本地变量名冲突，所以不要使用包用户可能也 想使用的名称(例如，如果fmt包被命名为format，那么导入该包的任何人如果把一个局部变量也命名为format，则将面临冲突的风险)
  • 导出的函数首字母大写

常量

  • 使用const关键字而不是var关键字
  • 必须在声明常量时赋值;不能像变量那样以后赋值
  • 变量有:=短变量声明语法，但是常量没有等效的语法

const rc = 5 可以省略类型

与变量和函数一样，名称以大写字母开头的常量是可导出的

go install

go install + main package的目录

可执行文件被安装到工作目录下bin子目录

发布

例如 (https://github.com/headfirstgo/greeting)

用包所在的URL部分来命名每个子目录

go get 下载和安装包

1
go get github.com/headfirstgo/greeting

文档

go doc 导入路径

go doc 导入路径 函数名

go doc解析的是代码注释(包注释+函数注释)

  • 注释应该是完整的句子
  • 包注释应以Package开头，后跟包名,注释一般放在package关键字之前
  • 函数注释应以它们描述的函数的名称开头,注释一般放在函数之前

本地html文档

1
2
sudo apt install golang-golang-x-tools
godoc -http=:6060

网站打开http://localhost:6060/pkg/看到机器上安装的所有包的列表

展开全文 >>

Head First Go - 03函数

函数

函数定义和调用

func 函数名(参数名 类型) 返回类型 {
return
}

Go不像C++有缺省参数,如果希望调用函数来接受参数，必须在函数声明中声明一个或多个参数，包括每个参数的类型。所传递的参数的数量和类型必须始终与规定的参数的数量和类型相匹配，否则将出现编译错误

Go要求带返回类型的函数结尾必须有return

目前没有发现Go中的函数必须要声明,函数定义的顺序不影响函数使用

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

import (
	"fmt"
)

func main() {
	noReturn()
	rc := haveReturn()
	fmt.Println("rc=", rc)
}

func noReturn() {
	fmt.Printf("no return\n")
}

func haveReturn() int {
	fmt.Printf("have return\n")
	return 0
}


多个返回值

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

import (
	"fmt"
	"log"
)

func abc(num int) (rc int, err error) { //返回值可以写变量名称方便阅读代码，多个返回值必须加括号
	if num > 5 {
		return 0, nil
	}
	return -1, fmt.Errorf("bad num")
}

func main() {

	rc, err := abc(7)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("rc=%d\n", rc)
}

指针

和C差不多，只不过C声明变量时类型在变量名称前面(int* rc),Go类型在变量名称后面(var rc *int), *的位置也相反

Go是一种“值传递”语言,函数形参从函数调用中接收实参的副本

在Go中，返回一个指向函数局 部变量的指针是可以的。即使该变量不在作用域内，只要你仍然拥有指针，Go将确保你仍然可以访问该值

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

import (
	"fmt"
)

func retPointer() *int {
	val := 5
	return &val
}

func main() {
	var rc *int = retPointer()
	fmt.Println(*rc)
}

Printf Sprintf

和C差不多

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

import (
	"fmt"
)

func main() {

	fmt.Printf("A float: %f\n", 3.1415)			//浮点
	fmt.Printf("An integer: %d\n", 15)			//整数
	fmt.Printf("A string: %s\n", "hello")			//字符串
	fmt.Printf("A boolean: %t\n", false)			//bool
	fmt.Printf("Values: %v %v %v\n", 1.2, "\t", true)	//任意类型
	fmt.Printf("Values: %#v %#v %#v\n", 1.2, "\t", true)	//任意类型，按代码中显示的格式进行格式化
	fmt.Printf("Types: %T %T %T\n", 1.2, "\t", true)	//返回值的类型
	fmt.Printf("Percent sign: %%\n")			//返回%
}

展开全文 >>

Head First Go - 02条件和循环

调用方法

值.方法名(参数) 类比调用另一个包的函数 包.函数(参数)

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

import (
	"fmt"
	"strings"
	"time"
)

func main() {
	var now time.Time = time.Now() //time.Now()返回time.Time类型
	var year int = now.Year() //time.Time有一个方法 Year 通过now变量调用
	fmt.Println(year)
	broken := "G# r#cks!"
	replacer := strings.NewReplacer("#", "o")
	fixed := replacer.Replace(broken)
	fmt.Println(fixed)
}

函数或方法多个返回值

Go中的函数或方法可以返回任意数量的返回值

  1. 使用_空白标识符作为占位符

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

    import (
            "bufio"
            "fmt"
            "os"
    )

    func main() {
            fmt.Print("Enter")
            reader := bufio.NewReader(os.Stdin)
            input, _ := reader.ReadString('\n')
            fmt.Println(input)
    }

  2. if语句进行错误处理
    if的条件语句不需要() 但是要{}

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

    import (
            "bufio"
            "fmt"
            "os"
            "log"
    )

    func main() {
            fmt.Print("Enter")
            reader := bufio.NewReader(os.Stdin)
            input, err := reader.ReadString('\n')
            if err != nil {
                    log.Fatal(err)
            }
            fmt.Println(input)
    }

    要避免变量名与类型名、内置函数名、包名重复,否则会导致被变量名覆盖

变量作用域

和C差不多

短变量声明要求必须有一个变量是新的，新变量被视为声明，其他旧变量视为赋值

包的导入路径

导入路径只是一个独特的字符串，用于标识包以及在导入语句中使 用的包。一旦导入了包，就可以通过其包名来引用它,但导入路径和包名称不必相同

Go语言不要求包名与其导入路径有任何关系。但按照惯例，导入路径的最后(或唯一)一段也用作包名

导入路径 包名
fmt fmt
math/rand rand

循环

for后面不用() 但是要{}

for 初始化语句;条件表达式(返回true false);标志语句 {

}

初始化和标志(post)语句是可选的

break, continue和C一样

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
// guess challenges players to guess a random number.
package main

import (
	"bufio"
	"fmt"
	"log"
	"math/rand"
	"os"
	"strconv"
	"strings"
	"time"
)

func main() {
	seconds := time.Now().Unix() //获取当前时间
	rand.Seed(seconds)//播种随机数生成器
	target := rand.Intn(100) + 1 //0 ~ 100的随机数
	fmt.Println("I've chosen a random number between 1 and 100.")
	fmt.Println("Can you guess it?")

	reader := bufio.NewReader(os.Stdin)
	success := false
	for guesses := 0; guesses < 10; guesses++ { //10次输入机会
		fmt.Println("You have", 10-guesses, "guesses left.")
		fmt.Print("Make a guess: ")
		input, err := reader.ReadString('\n')
		if err != nil {
			log.Fatal(err)
		}
		input = strings.TrimSpace(input) //删除换行
		guess, err := strconv.Atoi(input) //字符串转整数
		if err != nil {
			log.Fatal(err)
		}

		if guess < target {
			fmt.Println("Oops. Your guess was LOW.")
		} else if guess > target {
			fmt.Println("Oops. Your guess was HIGH.")
		} else {
			success = true
			fmt.Println("Good job! You guessed it!")
			break
		}
	}

	if !success {
		fmt.Println("Sorry, you didn't guess my number. It was:", target)
	}
}

其他

字符串转数字 strconv.ParseFloat
去除空白字符 strings.TrimSpace

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

二线城市码农，方向偏OS多一点，热爱技术但更热爱生活<br><br>喜欢撸铁，爱玩HIFI但囊中羞涩，梦想开一家属于自己的照相馆，虽然我现在还不会拍照(=_=)