读书笔记：Go 关键字

go 关键字

• var && const

// 使用var关键字是Go最基本的定义变量方式，也可以用 := 来定义变量
// 定义变量
var name string
// 定义变量并初始化值
var name string = "abc"
// 同时初始化多个同类型变量
var name1, name2, name3 string = "abc1", "abc2", "abc3"
// 同时初始化多个不同类型的变量
var (
name string = "abc1"
count int = 1
)
// 省略变量类型
var name1, name2, name3 = "abc1", "abc2", "abc3"
// 可使用:=取代var和type，这种方式被称为简短声明，不过它有一个限制，那就是它只能用在函数内部；在函数外部使用则会无法编译通过，所以定义全局变量时候要用var。
// const 用来声明一个常量，const 语句可以出现在任何 var 语句可以出现的地方，声明常量方式与 var 相同，需要注意的是，const 声明的是常量，一旦创建，不可赋值修改。

• package && import

// package 是函数和数据的集合。用package关键字来定义一个包，用import关键字引入一个包，文件名不需要和包名一致，包名约定使用小写字符。Go 包可以由多个文件组成，但是使用相同的 package 这一行。
// 当函数或者变量等首字母为大写时，会被导出，可在外部直接调用
import "runtime/internal/atomic"
// 多个包的导入
import (
        "runtime/internal/atomic"
        "runtime/internal/math"
        "runtime/internal/sys"
        "unsafe"
)

• map

// map是 Go 内置关联数据类型
// 创建一个map
m := make(map[string]int)
// 设置键值对对map赋值
m["k"] = 7
// 当对一个 map 调用内建的 len 时，返回的是键值对数目
fmt.Println("len:", len(m))
// 可以使用内建的delete从一个map 中移除键值对
delete(m, "k")
// 当从一个 map 中取值时，可选的第二返回值指示这个键是在这个 map 中。这可以用来消除键不存在和键有零值，像 0 或者 "" 而产生的歧义。
val, ok := m["k"]
fmt.Println("val:", val)

• func

// 使用关键字func定义函数
func test(a, b int) int {
  return a + b
}
// 其中，有返回值的函数，必须有明确的终止语句，否则会引发编译错误。
// 函数是可变参的，变参的本质上是slice，只能有一个，且必须是最后一个，如
func test(s string, n ...int) string {
  var x int
  for _, i := range n {
    x += i
  }
  return fmt.Sprintf(s, x)
}
// Golang 函数支持多返回值。这个特性在 Go 语言中经常被用到，例如用来同时返回一个函数的结果和错误信息
func vals() (int, int) {
  return 3, 7
}

• return && defer

// defer用于资源的释放，会在函数返回之前进行调用
func test() {
	f, err := os.Open("/Users/haohaiwei/1.xt")
	if err != nil {
		panic(err)
	}
	defer f.Close()
}
func main(){
	test()
}
// 如果有多个defer表达式，调用顺序类似于栈，越后面的defer表达式越先被调用，即后入先出的规则。
func test() {
	defer fmt.Println(1)
	defer fmt.Println(2)

}
func main(){
	test()
}
// 返回结果
2
1

• type

// type是go语法里的重要而且常用的关键字，其主要作用就是用来定义类型
// 定义结构体
type Person struct {
  name string
}
// 类型等价定义，相当于类型重命名
type name string
func main() {
  var myname name = "golang" //其实就是字符串类型
  fmt.Println(myname)
}
// 定义接口
type Person interface {
  Run()
}

• struct

// Go 的结构体 是各个字段字段的类型的集合。是值类型，赋值和传参会赋值全部内容
// 基本用法
type Person struct {
	Name string
	Age  int
}

func main() {
	p := Person{
		Name: "ck",
		Age:  20,
	}
	p.Age = 25
	fmt.Println(p)
}

• if else

// golang 中 if 要注意的点是
// 可省略条件表达式的括号。
// 支持初始化语句，可定义代码块局部变量。
// 代码块左大括号必须在条件表达式尾部。
// 不支持三元操作符 "a > b ? a : b"
if num := 9; num < 0 {
  fmt.Println(num, "is negative")
} else if num < 10 {
  fmt.Println(num, "has 1 digit")
} else {
  fmt.Println(num, "has multiple digits")
}

• chan

// channel[通道]是golang的一种重要特性，正是因为channel的存在才使得golang不同于其它语言。channel使得并发编程变得简单容易有趣。 一个channel可以理解为一个先进先出的消息队列
// 可以通过如下几行创建channel
var ch chan string; // nil channel
ch1 := make(chan string); // zero channel
ch2 := make(chan string, 10); // buffered channel
// channel里面的value buffer的容量也就是channel的容量。channel的容量为零表示这是一个阻塞型通道，非零表示缓冲型通道[非阻塞型通道]。
// 阻塞型通道 从无缓存的 channel 中读取消息会阻塞，直到有 goroutine 向该 channel 中发送消息；同理，向无缓存的 channel 中发送消息也会阻塞，直到有 goroutine 从 channel 中读取消息。
// 非阻塞型通道 有缓存的 channel 的声明方式为指定 make 函数的第二个参数，该参数为 channel 缓存的容量,有缓存的 channel 类似一个阻塞队列(采用环形数组实现)。当缓存未满时，向 channel 中发送消息时不会阻塞，当缓存满时，发送操作将被阻塞，直到有其他 goroutine 从中读取消息

• go

// 轻松开启高并发，一直都是golang语言引以为豪的功能点。golang通过goroutine实现高并发，而开启goroutine的钥匙正是go关键字。开启并发执行的语法格式是
go funcName()