Golang语法快速上手3

golang入门进阶组1

调用命令行

所有的命令行参数都会被解析为字符串类型的

os.Args 接收所有我们传入的参数；

假设该文件编译为了一个 exe，我们执行该 exe 是使用代码： main.exe asd 123
则上面三个元素都会变成参数传递给 os.Args

import (
	"fmt"
	"os"
)

func main() {
	// 获取传入参数个数
	num := len(os.Args)
	// 输出所有参数
	for i := 0; i < num; i++ {
		fmt.Printf(os.Args[i])
	}
}

flag 包可以自定义传参名称

则运行 exe 是可以使用命令：main.exe -name=tom

// 写法一
func main() {
	// flag对应的三个参数
	// 参数名、参数默认值、参数简介
	name := flag.String("name", "jack", "使用者名称")
	// 命令行参数解析到注册函数
	flag.Parse()
	// flag返回的均为指针类型，所以需要解指针
	fmt.Println("名字是：", *name)
}

// 写法二
func main() {
	var (
		name string
		age  int
	)
	flag.StringVar(&name, "name", "jack", "姓名")
	flag.IntVar(&age, "age", 13, "你的年龄")
	flag.Parse()
}

函数进阶

go 中甚至可以为返回值指定名称，即系统会自动返回该名称变量

// 注意这里不使用:=
func say() (res string) {
	res = "shit"
	return
}

匿名函数

func main() {
	// 匿名函数声明方式一
	a := func() {
		fmt.Printf("shit")
	}
	a()

	// 匿名函数声明方式二
	func(name string) {
		fmt.Println(name)
	}("fuck")
}

匿名函数作为参数传入

func main() {
	work(func() {
		fmt.Println("fuck")
	})
}

func work(f func())  {
	fmt.Println("shit")
	f()
}

闭包

经典闭包，只要匿名函数使用外部函数任意一个变量，那么该变量就会一直存在（和 js 闭包概念一致）

func add() func() int {
	x := 100
	return func() int {
		x++
		return x
	}
}

延迟执行 defer

加了 defer 修饰的语句会在当前函数正常语句执行完毕后才执行；
加 defer 的语句按照 LIFO 原则

func main() {
	// 序号表示执行顺序
	defer fmt.Println("第一个入栈") // 3
	fmt.Println("正常输出")        // 1
	defer fmt.Println("第二个入栈") // 2
}

方法

说白了，就是为一个结构体添加额外的方法

但是一个方法不可以直接调用，比如下方代码直接 hello() 是报错的（即可以认定该方法是绑定于结构体上的一部分）

import "fmt"

type Person struct {
	name string
}

// 这是一个方法
// 为结构体扩展一个新的方法
func (p Person) hello() {
	fmt.Println(p.name)
}

func main() {
	p := Person{name: "shit"}
	// 使用刚刚扩展的新方法
	p.hello()
}

接口

和 java 的接口如出一辙

// Dog 定义结构体
type Dog struct {
	name string
}
// 定义接口，需要后续实现
type Animal interface {
	walk()
}

// 实现接口，这里被扩展的结构体为Dog
func (d Dog) walk() {
	fmt.Println("开始走路")
}

// 实例化dog，然后调用对应接口即可
func main() {
	dog := Dog{name: "shit"}
	dog.walk()
}