GO基础

go语言不需要写分号

1. 基本程序结构

package 包名
import ""
func main(){
    //code
}

2. 导包方式

2.1单独导入

import ""

2.2多包导入方式

import(
    ""
    ""
)

3. 变量类型

3.1 普通变量类型

bool
string
int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr
byte // alias for uint8
rune // alias for int32
// represents a Unicode code point
float32 float64
complex64 complex128

3.2 衍生数据类型

Array types 数组
Structure types 结构体
Union types 联合
Slice types 切片，引用类型
Interface types 接口
Map types 字典，引用类型
Channel Types 通道，引用类型
Slice， Map， Channel 这三种是引用数据类型， 使用需要make

3.3 golang支持自定义数据类型–类似于别名

type flag byte

4. 变量定义以及赋值

var 变量1, 变量2 变量类型\

例如

var x, y int
var x, y int = 2, 3
var (
    x,y int
    a,s = 100, "abc"
)

缺省赋值只能用在函数内部 \

x, y := 2, 3 // 会自动类型推断

5. 常量定义以及赋值

常量可以只定义不使用
常量不能读地址 const 常量名 数据类型 = 值

const variable type = value
const name, size = "carrot", 100
const(
    var1 type = value
    var2 type = value
    var3 = value // 也可以自动类型推断
)

//这种情况下， BBB和CCC的值也是120
const(
    AAA = 120
    BBB
    CCC
)

// Golang中没有枚举类型，但是可以使用iota来更优雅的定义一个枚举
// iota从0开始递增，步长1

const(
    Low = 5 * iota //Low = 0
    Medium         //Medium = 5
    High           //High = 10
)
//iota可以被中断
const(
    a = iota  //a = 0,默认值
    b         //1
    c         //2
    d = 100   //100
    e         //100
    f = iota  //5
)

6. 变量 类型转换—必须使用显式类型转换

a := 1
b := byte(a)
// go中不能将非布尔类型的类型转换成布尔类型， 也不能作为布尔类型来使用

7. 流程控制 – GO语言推荐不适用圆括号

关键字展示

  1. if
  2. if else
  3. if (){}else if(){} else{}
  4. switch
  5. for
  6. goto break contunue
  7. 没有while!没有while!没有while! 重要的事情说三遍

7.1 if

if a > 1 {
    //code
}

7.2 if else

if a > 1 {//左花括号不能换行
    //code
} else { //else关键字不能换行，左花括号不能换行
    //code
}

7.3 if (){}else if(){} else

if a > 1 {
    //code
} else if a > 2 {
    //code
} else {
    //code
}

7.4 switch

//可以不用写break,go语言执行完一个case后默认break
//default也可以不写在最后, 但是建议还是写最后
//如果不想执行完一个case后就被break可以使用fallthrough
func main() {
    a, b, c, x := 1, 2, 3, 2
    switch x{
    case a, b:
        fmt.Println("a|b")
        fallthrough // 这样就不会被退出了
    case c:
        fmt.Println("c")
    default:
        fmt.Println("default")
    }
}

7.5 for

//普通的for
for i := 0; i<max; i++ {

}

//迭代列表和切片
date := [4]string{"a","b",“c”}
for i， str := range date {
    fmt.Println(i, str)
}

//迭代mqp
for k, v := range map {
    fmt.Println(k,v)
}

// 死循环
for {
    //code
}

7.6 函数

// 1. 不支持内部定义函数,但是可以定义匿名函数
func main() {
    func swap(x, y string) (string, string) {
    return y, x
    }
    a, b := swap("hello", "world")
    fmt.Println(a, b)
}
// 错误：syntax error: unexpected swap, expecting (

// 2. 匿名函数, 用法有点像js
func main() {
    func (s string) {
        fmt.Println(s)
    } ("hello, go!")
}
// 3. 函数可以返回多个值, 参数也可以是可变参数
func fun_name (str string, a ...int) int {}
func fun_name (str string, a ...int) (x, y int) {}
// 4. 函数参数没有默认值即使是 下划线开头 func fun_name (str string, a int, _boo bool)

// 5. 闭包的写法, 返回一个函数的函数就是闭包闭包内的局部变量是自我维护的
func intSeq() func() int {
    i := 0
    return func() int {
        i += 1
        return i
    }
}
func main(){
    nextInt := intSeq()
    nextInt()
    nextInt()
    nextInt()
}