Go语言学习函数+结构体+方法+接口

1
2
3
4
5
func typedTwoValues() (int, int) {
    return 1, 2
}
a, b := typedTwoValues()
fmt.Println(a, b)

1
2
3
4
5
func named Ret Values() (a, b int) {
       a = 1
       b = 2
       return
}

1
2
3
4
5
6
7
8
func fire() {
	fmt.Println("fire")
}
func main() {
	var f func()  //将变量f声明为func()类型，此时f就被俗称为“回调函数”。此时f的值为nil。
	f = fire
	f()
}

1
2
3
func(data int) {
     fmt.Println("hello", data)
}(100)

1
2
3
4
5
6
// 将匿名函数体保存到f()中
f := func(data int) {
       fmt.Println("hello", data)
}
// 使用f()调用
f(100)

1
2
3
4
5
6
7
8
9
10
11
12
13
// 遍历切片的每个元素，通过给定函数进行元素访问
   func visit(list []int, f func(int)) {
        for _, v := range list {
              f(v)
        }
   }
   func main() {

       // 使用匿名函数打印切片内容
        visit([]int{1, 2, 3, 4}, func(v int) {
              fmt.Println(v)
        })
   }

1
2
3
func Println(a ...interface{}) (n int, err error) {
    return Fprintln(os.Stdout, a...)
}

1
fmt.Println(5, "hello", &struct{ a int }{1}, true)

1
2
3
4
5
6
func Printf(format string, a ...interface{}) (n int, err error) {
	return Fprintf(os.Stdout, format, a...)
}
------------------------------------------------------
fmt.Printf("pure stringn")
fmt.Printf("value: %v %fn", true, math.Pi)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
func main() {
	var f = add()
	fmt.Printf("f(10): %vn", f(10))
	fmt.Printf("f(20): %vn", f(20))
	// f(10): 10
	// f(20): 30
}
func add() func(int) int {
	var x int
	return func(y int) int {
		x += y
		return x
	}
}

1
2
3
type error interface {
    Error() string    // 返回错误的具体描述.
}

1
var err = errors.New("this is an error")

1
2
3
4
package main
func main() {
panic("crash")
}

1
2
3
4
5
6
7
type Point struct {
	X int
	Y int
}
var p Point
p.X = 10
p.Y = 20

1
2
3
4
5
6
7
type Player struct {
	name string
	age int
}
p = new(Player)
p.name = "james"
p.age = 40

1
2
3
4
5
6
7
8
9
10
11
//使用结构体定义一个命令行指令（Command），指令中包含名称、变量关联和注释等
type Command struct {
	name string
	Var *int
	comment string
}
var version int = 1
cmd := &Command{}
cmd.name = "version"
cmd.Var = &version
cmd.comment = "show version"

1
2
3
4
5
6
7
8
9
10
11
12
13
type People struct {
	name string
	child *People
}
relation := &People{
	name: "爷爷"
	child: &People{
		name: "爸爸"
		child: &People{
			name: "我"
		}，
	}
}

1
2
3
4
5
6
7
8
9
10
type Bag struct {
	items[] int
}
func (b *Bag) insert(itemid int) {
	b.items = append(b.items, itemid)
} 
func main() {
	b := new(Bag)
	b.insert(1001)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// 定义属性结构
type Property struct {
	value int
}
// 设置属性值方法
func (p *Property) setVal(val int) {
	p.value = val
}
// 获取属性值方法
func (p *Property) getVal() int {
	return p.value
}
func main() {
	p := new(Property)
	p.value = 123
	fmt.Println(p.getVal())
	p.setVal(666)
	fmt.Println(p.getVal())
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
type Point struct {
	x, y int
}
func (p Point) add(other Point) Point {
	return Point{p.x + other.x, p.y + other.y}
}
func main() {
	// 初始化点
	p1 := Point{1, 1}
	p2 := Point{2, 2}
	res := p1.add(p2)
	fmt.Println(res)

	p3 := Point{3, 3}
	p4 := p1.add(p2).add(p3)
	fmt.Println(p4)
}

1
2
3
4
type 接口类型名 interface {
	方法1(参数列表) 返回值
	...
}

1
2
3
type Writer interface {
	Write(p []type) (n int, err error)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
// 定义一个数据写入器接口
type DataWriter interface {
	WriteData(data interface{}) error
}
// 定义文件结构，用于实现DataWriter
type file struct {
}
// 实现DataWriter接口的方法
func (d *file) WriteData(data interface{}) error {
	// 模拟写入数据
	fmt.Println("Write Data:", data)
	return nil
}
func main() {
	// 实例化file
	f := new(file)
	// 声明一个DataWriter接口
	var writer DataWriter
	// 将接口赋值，也就是*file
	writer = f
	writer.WriteData("one line data")
}