Go的语法记录

Go中的打印

package main

import "fmt"

func main() { 
    fmt.Printf("Hello, world\n") 
}

- Go的打印来自于fmt包，package main 这一行告诉我们当前文件属于哪个包，而包名 main 则告诉我们它是一个可独立运行的包，它在编译后会产生可执行文件。
- 为了打印 Hello, world...，我们调用了一个函数 Printf，这个函数来自于 fmt 包，所以我们在第三行中导入了系统级别的 fmt 包：import "fmt"。值得一提的是，如果直接写出fmt.Printf("Hello, world\n")IDE会自动导入fmt 包。
定义变量
- 使用 var 关键字是 Go 最基本的定义变量方式，与 C 语言不同的是 Go 把变量类型放在变量名后面。

var variableName type
如：var a int

- 内置类型布尔值的类型为 bool，值是 true 或 false，默认为 false。

var available bool

- 错误类型 Go 内置有一个 error 类型，专门用来处理错误信息，Go 的 package 里面还专门有一个包 errors 来处理错误：

err := errors.New("emit macho dwarf: elf header corrupted") 
if err != nil { 
    fmt.Print(err) 
}

- 分组定义变量 Go 语言中，同时声明多个常量、变量，或者导入多个包时，可采用分组的方式进行声明

import "fmt"

const i = 100
const pi = 3.1415
const s = "go"

var i int
var pi float32
var s string

可以写成如下形式：

import(
    "fmt"
)

const(
    i = 100
    pi = 3.1415
    s = "go"
)

var(
    i int
    pi float32
    s string
)

- 数组 array 就是数组

定义方式：var arr [n]type，呃~好像不常用

eg.var arr [10]int

- 常用slice 初始定义数组时，不知道需要多大的数组，因此我们就需要动态数组:slice，slice 并不是真正意义上的动态数组，而是一个引用类型。slice 总是指向一个底层 array，slice 的声明也可以像 array 一样，只是不需要长度。

和数组定义不同，后面少了长度var fslice []int

eg.

slice1 := []byte {'a', 'b', 'c', 'd'}

- map

map 也就是 Python 中字典的概念，它的格式为 map[keyType]valueType，通过 key 来操作获取value值。

var numbers map[string]int key为字符串，值为int的字典。

eg.numbers["seven"] = 7

控制语句
- if Go 里面 if 条件判断语句中不需要括号：

if x > 7 { 
    fmt.Println("go") 
} else { 
    fmt.Println("walk") 
}

- for Go 中只有一个循环语句 for。

package main

import "fmt"

func main(){
    sum := 0;
    for i:=0; i < 100 ; index++ {
        sum += i
    }
    fmt.Println("sum is ", sum)
}

Go 支持多个返回值。

for k, _ := range map{ 
    fmt.Println("key is:", k) 
}

- switch 当需要写很多的 if-else 时，可以用switch代替：

i := 10
switch i {
case 1:
    fmt.Println("i is equal to 1")
case 2, 3, 4:
    fmt.Println("i is equal to 2, 3 or 4")
case 10:
    fmt.Println("i is equal to 10")
default:
    fmt.Println("All I know is that i is an integer")
}

函数函数是 Go 里面的核心设计，它通过关键字 func 来声明，它的格式如下：

func funcName(input1 type1, input2 type2) (output1 type1, output2 type2) {
    // 这里是处理逻辑代码
    // 返回多个值
    return value1, value2
}

- 多个返回值：

package main

import "fmt"

// 返回 A+B 和 A*B
func SumAndProduct(A, B int) (int, int) {
    return A+B, A*B
}

func main() {
    x := 3
    y := 4

    xPLUSy, xTIMESy := SumAndProduct(x, y)

    fmt.Printf("%d + %d = %d\n", x, y, xPLUSy)
    fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
}

Go中的地址传递(好像C才这么说)！

package main

import "fmt"

// 参数+1的操作
func add1(a *int) int {
    *a = *a+1 // 修改了a的值
    return *a // 返回新值
}

func main() {
    x := 3

    fmt.Println("x = ", x)  // 应该输出 "x = 3"

    x1 := add1(&x)  // 调用 add1(&x) 传x的地址  和C一样耶

    fmt.Println("x+1 = ", x1) // 应该输出 "x+1 = 4"
    fmt.Println("x = ", x)    // 应该输出 "x = 4"
}

defer defer 后指定的函数会在函数退出前调用。减少代码量！

func ReadWrite() bool {
    file.Open("file")
    defer file.Close()
    if failure1 {
        return false
    }
    if failure2 {
        return false
    }
    return true
}

struct Go 语言中，也和 C 或者其他语言一样，我们可以声明新的类型，作为其它类型的属性或字段的容器。例如，我们可以创建一个自定义类型 person 代表一个人的实体。这个实体拥有属性：姓名、年龄、性别。

type person struct { 
    name string
    age int 
    sex string
}

- 使用struct

var P person  // P 现在就是 person 类型的变量了
P.name = "Jerry"  // 赋值 "Jerry" 给 P 的 name 属性.
P.sex = "Male" // 赋值 "Male" 给变量 P 的 sex 属性
P.age = 25  // 赋值 "25" 给变量 P 的 age 属性
fmt.Printf("The person's sex is %s", P.sex)  // 访问 P 的 sex 属性.

- 匿名字段！

type Student struct { 
    person // 匿名字段，那么默认 Student 就包含了 person 的所有字段 
    class string 
}

学习参考：learnku.com/docs/build-…

与Go的第一次相遇｜ 青训营笔记

Go的语法记录

与Go的第一次相遇｜青训营笔记