popo

go-doc-基础

Posted on Edited on

注意事项

  1. Go源文件以 go 为扩展名
  2. Go应用程序的执行入口是main()函数
  3. Go语言严格区分大小写
  4. Go方法由一条条语句构成，每条语句后不需要分好(Go语言会在每行后自动添加分号)，这也体现Golang的简洁性
  5. Go编译器是一行行进行编译的，因此我们一行就写一条语句，不能把多条语句写在同一个，否则报错
  6. Go语言定义的变量或者import的包如果没有使用到，代码不能编译通过。
  7. 大括号都是成对出现的，缺一不可
  8. 一行最大不超过80字符，超过使用换行展示，保持格式优雅

转义字符

字符 描述
\t 一个制表符，实现对齐功能
\n 换行符
\\ 一个\
\" 一个"
\r 一个回车，不是换行，回车后面的内容覆盖字符串前面的内容fmt.Println("1234567\rabc")结果为abc4567

注释

//行注释

/**/块注释

变量声明定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 逐个逐个地定义全局变量
var g1 = 100
var g2 = "tom"

// 一次性定义多个全局变量
var (
    g3 = 11
    g4 = "jim"
)

// 定义主函数
func main() {
    // 1. 声明不赋值，使用默认值
    var i int

    // 2. 根据值自信判断变量类型(类型推导)
    var num = 10.11

    // 3. 省略var，使用:=
    name := "tom"

    // 4. 一次性声明多个
    var n1, n2, n3 int

    // 5. 一次性赋值多个
    // n4 = 100
    // n5 = "tom"
    // n6 = 101
    var n4, n5, n6 = 100, "tom", 101
}

命名规范

  1. 保持包名和目录一致
  2. 变量名、函数名、常量名采用驼峰法
  3. 如果变量名、函数名、常量名首字母大写，则可以被其他包访问(类似别的语言的public)；如果首字母消息，则只能本包钟使用(类似别的语言的private)

保留关键字

关键字 描述
break
default
func 函数
interface
select
case
defer
go
map
struct
chan
else
goto
package
switch
const
fallthrough
if
range
type
continue
for
import
return
var

预定标识符

标识符 描述
append
bool
byte
cap
close
complex
complex64
complex128
uint16
copy
false
float32
float64
imag
int
int8
int16
int32
int64
uint
uint8
uint16
uint32
uint64
itoa
len
make
new
nil
panic
print
println
real
recover
string
true
uintptr

运算符

Go不支持三元运算符

算术运算符

运算符 描述 范例
+ 正号 +3
- 负号 -3
+ 加 3+3
- 减 3-3
* 乘 3*3
/ 除，整数之间做除法时，只保留整数部分舍弃小数部分 3/3
% 取模 3%3
++ 自增，只能写在变量后，只能独立使用而不可进行赋值 a++
-- 自减，只能写在变量后，只能独立使用而不可进行赋值 a--
+ 字符串相加 "hello" + "world"

关系运算符

运算符 描述 范例
== 相等于 4==3
!= 不等于 4!=3
< 小于 4<3
> 大于 4>4
<= 小于等于 4<=3
>= 大于等于 4>=3

逻辑运算符

用于连接多个条件，最终的结果是bool值

运算符 描述 范例
&& 逻辑与，如果两边的操作数都是true，则为true；否则为false A&&B
｜｜ 逻辑或，若果两边的操作数有一个是true，则为true；否则为false A｜｜B
! 逻辑非，如果条件为true，则为false；否则为true !(A&&B)

赋值运算符

赋值运算符就是将某个运算后的值，赋给指定的变量

运算符 描述 范例
= 简单的赋值运算符，将一个表达式的值赋给一个左值 C=A+B
+= 相加后再赋值 C+=A等于C=C+A
-= 相减后再赋值 C-=A等于C=C-A
*= 相乘后再赋值 C*=A等于C=C*A
/= 相除后再赋值 C/=A等于C=C/A
%= 求余后再赋值 C%=A等于C=C%A
<<= 左移后赋值 C<<=2等于C=C<<2
>>= 右移后赋值 C>>=2等于C=C>>2
&= 按位与后赋值 C&=2等于C=C&2
^= 按位异后赋值 C^=2等于C=C^2
｜= 按位或后赋值 C｜=2等于C=C｜2

位运算符

运算符 描述 范例
& 按位与，参与运算的两数各对应的二进制相与，同为1结果为1，否则0 A=A&C
｜ 按位或，参与运算的两数各对应的二进制相或，有一个为1结果为1，否则0 A=A｜C
^ 按位异或，参与运算的两数各对应的二进制相 异或，有二进为不同时，结果为1，否则0 A=A^C
<< 左移，左移n位就是乘以2的n次方 A=A<<2
>> 右移，右移n位就是除以2的n次方 A=A>>2

其他运算符

运算符 描述 范例
& 返回变量存储地址 &a
* 指针变量 *a

进制

进制 描述
二进制 0,1表示，满2进1
十进制 0-9，满10进1
八进制 0-7，满8进1，以数值0开始表示
十六进制 0-9及A-F，满16进1，以0x或0X开头表示

二进制

原码、反码、补码

  1. 二进制的最高为是符号位。0表示整数，1表示负数
  2. 正数的源码，反码，补码一样
    • 1 的原码 0000 0001
    • 1 的反码 0000 0001
    • 1 的补码 0000 0001
  3. 负数的反码等于它源码符号位不变，其他位取反
  4. 负数的补码等于它的反码+1
    • -1 的原码 1000 0001
    • -1 的反码 1111 0001
    • -1 的补码 1111 1111
  5. 0的反码补码都是0
  6. 在计算机运算的时候，都是以补码的方式来运算的
    • -2^2 => 补码(1111 1110)^(0000 0010)
    • => 补码(1111 1100)
    • => 反码(1111 1011)
    • => 原码(1000 0100)
    • => -4

程序流程控制

Go 没有while和do while

if-else

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
package main 

import (
    "fmt"
)

func main() {

    var num int = 1

    if num == 1 {
        // if条件直接定义变量
        if age := 10; age > 18 {
            fmt.Println("大年龄")
        } else {
            fmt.Println("小年龄")
        }
    } else if num == 2{
        fmt.Println("条件2")
    } else {
        fmt.Println("其他条件")
    }
}

switch

基本介绍

  1. switch语句用于基于不同条件执行不同动作，每个case分支都是唯一的，从上到下直到匹配为止
  2. 匹配项后面不需要加break
  3. switch后可以不带表达式，类似if-else分支使用
  4. switch语句可以被用于type-switch来判断某个interface变量中实际指向的变量类型
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
package main 

import (
    "fmt"
)

func main() {

    var num int = 1

    switch num {
    case 1, 2, 3:
        fmt.Println("条件1")
    case 4:
        fmt.Println("条件2")
    default:
        fmt.Println("其他条件")
    }

    // 当if-else使用
    switch {
    case num == 1 || num == 2 || num == 3:
        fmt.Println("条件1")
    case num == 4:
        fmt.Println("条件2")
    default:
        fmt.Println("其他条件")
    }

    // 用于interface类型判断
    var x interface {}
    switch t := x.(type) {
    case nil:
        fmt.Println("条件 nil", t)
    case int:
        fmt.Println("条件 int")
    default:
        fmt.Println("条件 其他类型")
    }
}

for

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
package main 

import (
    "fmt"
)

func main() {


    for i := 1; i <= 20; i++ {
        fmt.Println("i = ", i)

        if i == 15 {
            break
        }
    }

    fmt.Println("=============")

    // 带中文字符串变量
    var str2 string = "hello world 中国"
    str3 := []rune(str2)
    for i := 0; i < len(str3); i++ {
        fmt.Printf("index=%d, val=%c\n", i, str3[i])
    }

    fmt.Println("=============")

    // for-range
    var str string = "hello world 中国"
    for i, val := range str {
        fmt.Printf("index=%d, val=%c\n", i, val)
    }
}

break

break要点

  1. break默认会跳出最近的for循环
  2. break后面可以指定标签，跳出标签对应的for循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main 

import (
    "fmt"
)

func main() {

    label1:
    for i := 1; i <= 20; i++ {
        fmt.Println("i = ", i)

        for j := 1; j < 100; j++ {
            if j == 15 {
                // 跳出最近的for循环
                break
            }

            if i == 4 && j == 14 {
                // 跳出指定的for循环
                break label1
            }

            fmt.Printf("i=%d j=%d\n", i, j)
        }
    }
}

continue

continue要点

  1. continue默认用于结束本次循环，继续执行下一次循环
  2. continue后面可以指定标签，指明要跳过的是哪一层循环，与break不同continue不会跳出循环
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
package main 

import (
    "fmt"
)

func main() {

    label1:
    for i := 1; i <= 20; i++ {
        fmt.Println("i = ", i)

        for j := 1; j < 100; j++ {
            if j == 15 {
                // 跳过出本次循环
                continue
            }

            if i == 4 && j == 14 {
                // 跳到指定循环
                continue label1
            }

            fmt.Printf("i=%d j=%d\n", i, j)
        }
    }
}

goto

goto要点

  1. goto语句可以无条件地转移到程序中指定的行
  2. 一般不建议使用，以免造成程序流程的混乱
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main 

import (
    "fmt"
)

func main() {
    fmt.Println("1")
    fmt.Println("2")
    fmt.Println("3")
    goto label1
    fmt.Println("4")
    fmt.Println("5")
    label1:
    fmt.Println("6")
    fmt.Println("7")
}

常量

  • 基本语法
1
const 常量名 [类型] = 值

常量要点

  1. 常量使用const修饰
  2. 常量在定义的时候，必须初始化
  3. 常量不能修改
  4. 常量只能是bool、数值类型、string类型
  5. go中没有常量名必须字母全大小的要求 例如 NAME
  6. 常量依然通过首字母大小写控制访问范围
  7. 数值类型自增的时候可以使用 itoa 表示值
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
package main

import (
    "fmt"
)

const (
    Nanosecond           = 1
    Microsecond          = 1000 * Nanosecond
    Millisecond          = 1000 * Microsecond
    Second               = 1000 * Millisecond
    Minute               = 60 * Second
    Hour                 = 60 * Minute
)

// 自增
const (
    A = iota
    B 
    C
)

func main() {
    fmt.Println(Nanosecond)
    fmt.Println(A, B, C)
}