@[toc]

分享一下学习go的网站：
国外的网站：https://golang.org
go编程网站：https://golang.google.cn/ （go的包，函数等均可以在这里查看）
菜鸟教程-Go ：菜鸟
易百教程-Go：易百教程
W3c-Go：w3c
极客-Go：极客
Go高级编程
GO语言中文库：https://studygolang.com/pkgdoc(常用)

1.GO语言的注释
  1. //单行注释
  3. /*
  5. 多行注释
  7. */

2.GO语言的转义字符
  1. \t ：对齐功能
  2. \n：换行符
  3. \“：一个”字符
  4. \r：回车

代码：

  1. package main
  3. import "fmt"
  5. func main() {
  6.     fmt.Println("hello\tdadaw")
  7.     fmt.Println("hello\ndadaw")
  8.     fmt.Println("hello\rdadaw")
  9.     fmt.Println("hello\"dadaw")
  10. }

效果：
Go基础知识二 - 图1

3.GO语言的基本类型

3.1数字类型

数据类型工作中就是把数据分成内存大小不同的数据，充分利用

  • uint8 位整型 (0 到 255)
  • uint16 16位整型 (0 到 65535)
  • uint32 32位整型 (0 到 4294967295)
  • uint64 64位整型 (0 到 18446744073709551615)
  • int8 8位整型 (-128 到 127)
  • int16 16位整型 (-32768 到 32767)
  • int32 32位整型 (-2147483648 到 2147483647)
  • int64 64 位整型 (-9223372036854775808 到 9223372036854775807)
  • uintptr 无符号整型，用于存放一个指针

3.2浮点型

float32 32位浮点型数
float64 64位浮点型数
complex64 32位实数和虚数
complex128 64位实数和虚数

3.3布尔型

（a）true （b）false

3.3字符串型

预先声明是string

3.4派生类型

(a)指针类型
(b)数组类型
(c)结构类型
(d)联合类型
(e)函数类型
(f)切片类型
(g)函数类型
(h)接口类型
(i) 类型

4.GO语言变量

go是静态类型语言，因此声明的变量必须是明确类型的，一般用var关键字
变量=变量名+变量值+类型
变量规范：变量由字母，数字，下划线组成，不能以数字开头

-标准声明变量的格式:

  1. var 变量名 变量类型
  2. var 变量名,变量名 *变量类型

代码：

  1. var num int
  2. var num,num2 *int

-批量声明格式：

  1. var (
  2.     a int
  3.     b string
  4.     c []float32
  5.     d func() bool
  6.     e struct {
  7.         x int
  8.     }
  9. )
  • 简短格式：(声明了数据类型的变量是不能使用简短格式输出的)
  • 不能提供数据类型
  • 只能在函数内部使用
  • 定义的变量，显示初始化
  1.  名字:= 表达式

代码：

  1. func main() {
  2.     a:=100
  3.     c,d:=50,"huawei"
  4. }

常用声明赋值总结

  1. package main
  3. import "fmt"
  5. //全局声明的变量类型
  6. var (
  7.     name   string      //字符串
  8.     age    int         //整数型
  9.     salary float32     //浮点型
  10. )
  12. func main() {
  13.     //以下均是局部变量
  15.     // 简短式表达式
  16.     a, b, c := 100, 100.12345, "你好"
  17.     fmt.Println(a)
  18.     fmt.Println(b)
  19.     fmt.Println(c)
  21.     //声明多个变量类型表达式()
  22.     var d, e, f = 18.5, "小王", 4500
  23.     fmt.Println(d, e, f)
  25.     //这里使用全局变量声明的类型，拿来使用输出
  26.     name = "huawei"
  27.     age = 18
  28.     salary = 1000
  29.     fmt.Println(name)
  30.     fmt.Println(age)
  31.     fmt.Println(salary)
  32. }
  33. 输出：
  34. 100
  35. 100.12345
  36. 你好
  37. 18.5 小王 4500
  38. huawei
  39. 18
  40. 1000

5.GO语言常量

常量（const）一般被定义后，在程序运行时，是不会被修改的量，iota除外

  • 常量定义的格式：(变量类型可以省略，在定义值时，编译器可以自动推断类型)

const defintion [type] = values

  • 多个相同类型的常量定义：

const defintion_1,defintion_2 = value01,value02

变量的案例：

  1. package main
  3. import "fmt"
  5. //定义的变量一般在全局范围
  6. const language string = "GO"
  7. const scholar = "caicai"
  9. func main() {
  10.     //局部变量内使用变量
  11.     fmt.Println("this is const")
  12.     fmt.Println("语言:", language, "学者:", scholar)
  13. }
  15. 运行输出：
  16. this is const
  17. 语言: GO 学者: caicai

特殊常量iota
iota 简单记:i/o它, 是一个可以改变的常量，每遇到一个const关键字时会被重置为0，在const内的数字会被自动增加1，直接比喻为常量计数器

iota的案例：

  1. package main
  3. import "fmt"
  5. func main() {
  6.     fmt.Println("this is iota")
  8.     const (
  9.         a = iota //a=iota开始计数，a=0
  10.         b        //1
  11.         c        //2
  12.         d        //3
  13.         e        //4
  14.     )
  15.     fmt.Println(a, b, c, d, e)
  17.     const (
  18.         aa = iota     //aa=iota开始计数，aa=0
  19.         bb = "linux"  //bb赋予单独值，iota此时计数为1（不显示计数数字，只显示赋予的值）
  20.         cc = "java"   //cc赋予独值，iota此时计数为2（不显示计数数字，只显示赋予的值）
  21.         dd = "python" //dd赋予独值，iota此时计数为3（不显示计数数字，只显示赋予的值）
  22.         ee = iota     //ee没有单独赋予值，恢复计数为4（显示计数数字）
  23.     )
  24.     fmt.Println(aa, bb, cc, dd, ee)
  26.     const (
  27.         aaa = iota
  28.         bbb = "三国演义"
  29.         ccc = 500
  30.         ddd = 600      //ddd赋予单独值，iota此时计数为3（不显示计数数字，只显示赋予的值）
  31.         eee               //eee继承ddd的赋予值，iota此时计数为4（不显示计数数字，只显示赋予的值）
  32.         fff               //fff继承eee的赋予值，iota此时计数为5（不显示计数数字，只显示赋予的值）
  33.         ggg = iota        //恢复计数，ggg=6                                                                                                                                       
  34.     )
  35.     fmt.Println(aaa, bbb, ccc, ddd, eee, fff, ggg)
  36. }
  38. 运行输出：
  39. this is iota
  40. 0 1 2 3 4
  41. 0 linux java python 4
  42. 0 三国演义 500 600 600 600 6

kubernetes中对于iota的使用

  1. 针对于pod组件的Success、Error、Unscheduleable、UnschedulableAndUnresolvable、Wait、Skip这六种状态字段
  2. 表达的效果为Success=0、Error=1等
  1. package main
  3. import "fmt"
  5. func main() {
  6.     type Code int   //定义一个Code的整数型
  8.     const (
  9.         // Success means that plugin ran correctly and found pod schedulable.
  10.         // NOTE: A nil status is also considered as "Success".
  11. Success Code=iota  //开始计数，Success=0
  12.         // Error is used for internal plugin errors, unexpected input, etc.
  13. Error  //iota自增加1，Error=1
  14.         // Unschedulable is used when a plugin finds a pod unschedulable. The scheduler might attempt to
  15.         // preempt other pods to get this pod scheduled. Use UnschedulableAndUnresolvable to make the
  16.         // scheduler skip preemption.
  17.         // The accompanying status message should explain why the pod is unschedulable.
  18. Unschedulable //iota自增加1，Unschedulable=2
  19.         // UnschedulableAndUnresolvable is used when a PreFilter plugin finds a pod unschedulable and
  20.         // preemption would not change anything. Plugins should return Unschedulable if it is possible
  21.         // that the pod can get scheduled with preemption.
  22.         // The accompanying status message should explain why the pod is unschedulable.
  23. UnschedulableAndUnresolvable   //iota自增加1，UnschedulableAndUnresolvable=3
  24.         // Wait is used when a Permit plugin finds a pod scheduling should wait.
  25. Wait   //iota自增加1，Wait=4
  26.         // Skip is used when a Bind plugin chooses to skip binding.
  27. Skip  //iota自增加1，Wait=5
  28.     )
  29.     fmt.Println(Success, Error, Unschedulable, UnschedulableAndUnresolvable, Wait, Skip)
  30. }
  32. 输出显示：
  33. [Running] go run "/root/workspace/goproject/src/go_code/project01/main/kubernet-iota.go"
  34. 0 1 2 3 4 5

6.GO语言运算符

6.1GO运算的分类

算术运算符
关系运算符
逻辑运算符
位运算符
赋值运算符
其他运算符

6.2算术运算
  1. 运算符    描述     表达式
  2. +        相加    A + B
  3. -        相减    A - B 
  4. *        相乘    A * B 
  5. /        相除    A/ B 
  6. %        求余    A % B 
  7. ++        自增    A++ 
  8. --        自减    A--

实例

  1. package main
  3. import "fmt"
  5. func main() {
  6.     a := 20
  7.     b := 10
  8.     var c int
  9.     c = a + b
  10.     fmt.Println(c)
  11.     c = a * b
  12.     fmt.Println(c)
  13.     c = a / b
  14.     fmt.Println(c)
  15.     c = a % b
  16.     fmt.Println(c)
  17.     a++
  18.     fmt.Println(a)
  19.     b++
  20.     fmt.Println(b)
  21. }
  24. 运行输出：
  25. [Running] go run "/root/workspace/goproject/src/go_code/project01/main/arich.go"
  26. 30
  27. 200
  28. 2
  29. 0
  30. 21
  31. 11

6.3关系运算
  1. ==    检查两个值是否相等，如果相等返回 True 否则返回 False。    (A == B) 为 False
  2. !=    检查两个值是否不相等，如果不相等返回 True 否则返回 False。    (A != B) 为 True
  3. >    检查左边值是否大于右边值，如果是返回 True 否则返回 False。    (A > B) 为 False
  4. <    检查左边值是否小于右边值，如果是返回 True 否则返回 False。    (A < B) 为 True
  5. >=    检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。    (A >= B) 为 False
  6. <=    检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。    (A <= B) 为 True

6.4逻辑运算
  1. &&    逻辑 AND 运算符    如果两边的操作数都是 True，则条件 True，否则为 False
  2. ||    逻辑 OR 运算符    如果两边的操作数有一个 True，则条件 True，否则为 False
  3. !    逻辑 NOT 运算符    如果条件为 True，则逻辑 NOT 条件 False，否则为 True

6.5赋值运算
  1. =    表达式赋值，给予左边
  2. +=   相加再赋值
  3. -=   相减再赋值
  4. *=     相乘后再赋值
  5. /=     相除后再赋值
  6. %=   求余后再赋值
  7. <<=     左移后赋值
  8. >>=     右移后赋值
  9. &=     按位与后赋值
  10. ^=     按位异或后赋值
  11. |=     按位或后赋值

6.6位运算
  1. a    b     a&b    a|b      a^b
  2. 0     0      0       0        0
  3. 0     1        0       1        1
  4. 1     1        1       1           0
  5. 1     0        0       1        1

6.7其它运算
  1. &   返回变量存储地址
  2. *   指针变量

7go条件语句

if 语句
if else语句
if else else if嵌套语句
switch语句

7.1if语句

  1. if 布尔表达式 {
  2.    /* 当布尔表达式为 true 时执行 */
  3. }

7.2if else语句

  1.     d := 400
  2.     e := 500
  3.     if d >= e {
  4.         fmt.Println("d>=e")
  5.     } else {
  6.         fmt.Println("d<e")
  7.     }
  9. 运行输出：
  10. d<e

7.3if嵌套语句

  1. if 布尔表达式noe {
  2.    /* 在布尔表达式 one 为 true 时执行 */
  3.    if 布尔表达式 two {
  4.       /* 在布尔表达式two 为 true 时执行 */
  5.    }
  6. }

7.4switch语句

switch 语句用于基于不同条件执行不同动作，每一个 case 分支都是唯一的，从上至下逐一测试，直到匹配为止。
switch 语句执行的过程从上至下，直到找到匹配项，匹配项后面也不需要再加 break。
switch 默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough

  1. package main
  3. import "fmt"
  5. func main() {
  6.     var grade string = "A"
  7.     var marks int = 90
  9.     switch marks {
  10.     case 90:
  11.         grade = "A"
  12.     case 80:
  13.         grade = "B"
  14.     case 70:
  15.         grade = "C"
  16.     case 60:
  17.         grade = "D"
  18.     default:
  19.         grade = "E"
  20.     }
  21.     switch {
  22.     case grade == "A":
  23.         fmt.Println("优秀\n")
  24.     case grade == "B":
  25.         fmt.Println("良\n")
  26.     case grade == "C", grade == "D":
  27.         fmt.Println("一般\n")
  28.     case grade == "E":
  29.         fmt.Println("很差\n")
  31.     }
  33. }
  34. 运行输出：
  35. 优秀

8.go循环语句

8.1for循环语句格式：

  1. for 变量初始条件; 循环条件; 变量迭代{}
  3. for 循环条件{}
  5. for {}

输出5遍：2月的天，3月的地

  1. package main
  3. import "fmt"
  5. func main() {
  7.     for init := 1; init <= 5; init++ {
  8.         fmt.Println("2月的天，3月的地")
  9.     }
  10. }
  12. 运行输出：
  13. [Running] go run "/root/workspace/goproject/src/go_code/project01/main/for.go"
  14. 2月的天，3月的地
  15. 2月的天，3月的地
  16. 2月的天，3月的地
  17. 2月的天，3月的地
  18. 2月的天，3月的地

输出30-60数字

  1. package main
  3. import "fmt"
  5. func main() {
  6.     for i := 30; i <= 60; i++ {
  7.         fmt.Println(i)
  8.     }
  9. }
  10. 运行输出：
  11. [Running] go run "/root/workspace/goproject/src/go_code/project01/main/for.go"
  12. 30
  13. 31
  14. 32
  15. 33
  16. 34
  17. 35
  18. 36
  19. 37
  20. 38
  21. 39
  22. 40
  23. 41
  24. 42
  25. 43
  26. 44
  27. 45
  28. 46
  29. 47
  30. 48
  31. 49
  32. 50
  33. 51
  34. 52
  35. 53
  36. 54
  37. 55
  38. 56
  39. 57
  40. 58
  41. 59
  42. 60

8.2循环控制语句

  1. break：中断for循环，跳出switch语句
  2. continue：跳出当前循环，继续下一轮循环
  3. goto：可以无条件地转移到过程中指定的行

break有条件的中止循环体的输出
输出30-60数字，但是不要50-60

  1. package main
  3. import "fmt"
  5. func main() {
  6.     for i := 30; i <= 60; i++ {
  7.         fmt.Println(i)
  8.         if i > 50 {
  9.             break //循环到i=50时，直接跳出循环
  10.         }
  11.     }
  12. }
  13. 运行循环：
  14. [Running] go run "/root/workspace/goproject/src/go_code/project01/main/for.go"
  15. 30
  16. 31
  17. 32
  18. 33
  19. 34
  20. 35
  21. 36
  22. 37
  23. 38
  24. 39
  25. 40
  26. 41
  27. 42
  28. 43
  29. 44
  30. 45
  31. 46
  32. 47
  33. 48
  34. 49
  35. 50

打印九九乘法表

%d:输出宽度也是输出十进制整数 printf：格式输出函数

  1. package main
  3. import "fmt"
  5. func main() {
  6.     //处理九行
  7.     for y := 1; y <= 9; y++ {
  8.         // 针对于y的行处理列
  9.         for x := 1; x <= y; x++ {
  10.             fmt.Printf("%d*%d=%d ", x, y, x*y)
  11.         }
  12.         // 手动生成回车
  13.         fmt.Println()
  14.     }
  15. }
  17. 运行输出：
  18. 1*1=1 
  19. 1*2=2 2*2=4 
  20. 1*3=3 2*3=6 3*3=9 
  21. 1*4=4 2*4=8 3*4=12 4*4=16 
  22. 1*5=5 2*5=10 3*5=15 4*5=20 5*5=25 
  23. 1*6=6 2*6=12 3*6=18 4*6=24 5*6=30 6*6=36 
  24. 1*7=7 2*7=14 3*7=21 4*7=28 5*7=35 6*7=42 7*7=49 
  25. 1*8=8 2*8=16 3*8=24 4*8=32 5*8=40 6*8=48 7*8=56 8*8=64 
  26. 1*9=9 2*9=18 3*9=27 4*9=36 5*9=45 6*9=54 7*9=63 8*9=72 9*9=81