一. Go语言的结构

在我们开始学习 Go 编程语言的基础构建模块前，让我们先来了解 Go 语言最简单程序的结构。

Go 语言的基础组成有以下几个部分：

包声明 引入包 函数 变量 语句 & 表达式 注释

通过简单的代码看本质

  1. /**
  2. 1. Go语言结构 包声明 引入包 函数 变量 语句&表达式 注释
  3.  */

  5.  // 我是单行注释
  6.  /**
  7.  我是多行注释
  8.   */

  10. // 包声明  package main 定义了包名，表示可以独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包
  11. package 语言结构
  12. // 引入包 fmt 包实现了格式化 IO（输入/输出）的函数
  13. import "fmt"

  15. // 函数 开始执行的函数，这里要注意一点，如果有init()函数，它将会先于main函数执行
  16. func main() {
  17.     // 变量
  18.     var a string = "我是字符串";
  19.     // 语句 输入一串字符串到控制台，它会自动进行换行
  20.     fmt.Println(a)
  21. }

二. 基本数据类型

1.布尔类型

true false

2.数字类型

整型 int 浮点型 float32、float64，

3.字符串类型

string

4.派生类型

(a) 指针类型（Pointer） (b) 数组类型 (c) 结构化类型(struct) (d) Channel 类型 (e) 函数类型 (f) 切片类型 (g) 接口类型（interface） (h) Map 类型

三. 定义变量

Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。 声明变量的一般形式是使用 var 关键字 var identifier type 变量名在前 类型在后 这个有所不同

定义变量分为四种

  1. 指定变量类型

  2. 根据值自行判定变量类型

  3. 最简体

  4. 聚合声明

  1. /**
  2. Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
  3. 声明变量的一般形式是使用 var 关键字
  4. var identifier type 变量名在前 类型在后 这个有所不同

  6. 定义变量分为四种
  7. 1. 指定变量类型
  8. 2. 根据值自行判定变量类型
  9. 3. 最简体
  10. 4. 聚合声明
  11.  */
  12. package main

  14. import "fmt"

  16. // 定义具体变量 使用默认初值
  17. func variableDefaultValue() {
  18.     var a int    // 0
  19.     var b string // ""
  20.     var c bool   // false
  21.     fmt.Println(a, b, c)
  22. }

  24. // 定义变量，赋初值
  25. func variableInitialValue() {
  26.     var a, b int = 1, 2
  27.     var s string = "www.lhdyx.cn"
  28.     fmt.Println(a, b, s)
  29. }

  31. // 类型推断
  32. func variableTypeDeduction() {
  33.     var a, b, c, d = 1, 2, true, "www.lhdyx.cn"
  34.     fmt.Println(a, b, c, d)
  35. }

  37. // 最简定义变量方式
  38. func variableShorter() {
  39.     a, b, c, d := 3, 2, true, "hi"
  40.     fmt.Println(a, b, c, d)
  41. }

  43. // 聚合调用
  44. func variablePolymerization() {
  45.     var a, b, c string
  46.     a, b, c = "1","2","3"
  47.     fmt.Println(a, b, c)
  48. }
  49. // 依次调用
  50. func main() {
  51.     variableDefaultValue()
  52.     variableInitialValue()
  53.     variableTypeDeduction()
  54.     variableShorter()
  55.     variablePolymerization()
  56. }

四. 常量与枚举

常量是一个简单值的标识符，在程序运行时，不会被修改的量。 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。 常量的定义格式：const identifier [type] = value常量分为两种

  1. 指定类型定义： const b string = "abc"

  2. 推断类型定义： const b = "abc"

  1. /**
  2. 常量是一个简单值的标识符，在程序运行时，不会被修改的量。
  3. 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型。
  4. 常量的定义格式：const identifier [type] = value
  5. 常量分为两种
  6. 1. 指定类型定义： const b string = "abc"
  7. 2. 推断类型定义： const b = "abc"

  9.  */
  10. package main

  12. import "fmt"

  14. // 常量
  15. func consts() {
  16.     // 单个常量
  17.     const A string = "1"

  19.     // 多个常量
  20.     const B, C, D string = "2", "3", "4"
  21.     // 推断定义常量
  22.     const E = 1
  23.     fmt.Println(A, B, C, D, E)
  24. }

  26. // 枚举
  27. func enums()  {
  28.     // 使用常量枚举
  29.     const (
  30.         Unknown = 0
  31.         Female = 1
  32.         Male = 2
  33.     )
  34.     fmt.Println(Unknown, Female, Male) // 0 1 2

  36.     // 使用 iota 块来实现自增枚举
  37.     // iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前)，
  38.     // const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)
  39.     const (
  40.         a = iota
  41.         b
  42.         c
  43.     )
  44.     fmt.Println(a,b,c)
  45. }

  47. // 依次调用
  48. func main() {
  49.     consts()
  50.     enums()
  51. }

五. 运算符

Go 语言内置的运算符有：算术运算符 关系运算符 逻辑运算符 位运算符 赋值运算符 其他运算符

  1. /**
  2. Go 语言内置的运算符有：
  3.     算术运算符
  4.     关系运算符
  5.     逻辑运算符
  6.     位运算符
  7.     赋值运算符
  8.     其他运算符
  9.  */
  10. package main

  12. import "fmt"

  14. // 算术运算符
  15. func arithmeticOperator() {
  16.     var a int = 20;
  17.     var b int = 10;
  18.     var c int

  20.     // 相加
  21.     c = a + b
  22.     fmt.Println(c)
  23.     // 相减
  24.     c = a - b
  25.     fmt.Println(c)
  26.     // 相乘
  27.     c = a * b
  28.     fmt.Println(c)
  29.     // 相除
  30.     c = a / b
  31.     fmt.Println(c)
  32.     // 求余
  33.     c = a % b
  34.     fmt.Println(c)
  35.     // 自增
  36.     a++
  37.     fmt.Println(a)
  38.     // 自减
  39.     b--
  40.     fmt.Println(b)
  41. }

  43. // 关系运算符
  44. func relationalOperator() {
  45.     var a int = 20;
  46.     var b int = 10;
  47.     // 检查两个值是否相等，如果相等返回 True 否则返回 False
  48.     fmt.Println(a == b)
  49.     // 检查两个值是否不相等，如果不相等返回 True 否则返回 False
  50.     fmt.Println(a != b)
  51.     // 检查左边值是否大于右边值，如果是返回 True 否则返回 False
  52.     fmt.Println(a > b)
  53.     // 检查左边值是否小于右边值，如果是返回 True 否则返回 False
  54.     fmt.Println(a < b)
  55.     // 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False
  56.     fmt.Println(a >= b)
  57.     // 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False
  58.     fmt.Println(a <= b)
  59. }

  61. // 逻辑运算符
  62. func logicalOperators() {
  63.     var a bool = true
  64.     var b bool = false
  65.     // 逻辑 AND 运算符。 如果两边的操作数都是 True，则条件 True，否则为 False
  66.     fmt.Println(a && b)
  67.     // 逻辑 OR 运算符。 如果两边的操作数有一个 True，则条件 True，否则为 False
  68.     fmt.Println(a || b)
  69.     // 逻辑 NOT 运算符。 如果条件为 True，则逻辑 NOT 条件 False，否则为 True
  70.     fmt.Println(!(a && b))

  72. }

  74. // 位运算符
  75. // 位运算符对整数在内存中的二进制位进行操作
  76. func bitOperator() {
  77.     // 假定 A = 60; B = 13; 其二进制数转换为
  78.     var a uint = 60 /* 60 = 0011 1100 */
  79.     var b uint = 13 /* 13 = 0000 1101 */
  80.     var c uint = 0
  81.     // 按位与运算符"&"是双目运算符。 其功能是参与运算的两数各对应的二进位相与
  82.     c = a & b /* 12 = 0000 1100 */
  83.     fmt.Println(c)

  85.     // 按位或运算符"|"是双目运算符。 其功能是参与运算的两数各对应的二进位相或
  86.     c = a | b /* 61 = 0011 1101 */
  87.     fmt.Println(c)

  89.     // 按位异或运算符"^"是双目运算符。 其功能是参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。
  90.     c = a ^ b /* 49 = 0011 0001 */
  91.     fmt.Println(c)

  93.     // 左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。
  94.     c = a << 2 /* 240 = 1111 0000 */
  95.     fmt.Println(c)

  97.     // 右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。
  98.     c = a >> 2 /* 15 = 0000 1111 */
  99.     fmt.Println(c)

  101. }

  103. // 赋值运算符
  104. func assignmentOperator() {
  105.     var a int = 21
  106.     var c int

  108.     // 简单的赋值运算符，将一个表达式的值赋给一个左值
  109.     c = a
  110.     fmt.Println(c)

  112.     // 相加后再赋值 c += a 等于 c = c + a
  113.     c += a
  114.     fmt.Println(c)

  116.     // 相减后再赋值 c -= a 等于 c = c - a
  117.     c -= a
  118.     fmt.Println(c)

  120.     // 相乘后再赋值 c *= a 等于 c = c * a
  121.     c *= a
  122.     fmt.Println(c)

  124.     // 相除后再赋值 c /= a 等于 c = c / a
  125.     c /= a
  126.     fmt.Println(c)

  128.     c = 200;

  130.     // 左移后赋值 c <<= a 等于 c = c << a
  131.     c <<= 2
  132.     fmt.Println(c)

  134.     // 右移后赋值 c >>= a 等于 c = c >> a
  135.     c >>= 2
  136.     fmt.Println(c)

  138.     // 按位与后赋值 c &= a 等于 c = c & a
  139.     c &= 2
  140.     fmt.Println(c)

  142.     // 按位异或后赋值 c ^= a 等于 c = c ^ a
  143.     c ^= 2
  144.     fmt.Println(c)

  146.     // 按位或后赋值 c |= a 等于 c = c | a
  147.     c |= 2
  148.     fmt.Println(c)
  149. }

  151. // 其他运算符
  152. func otherOperators() {
  153.     var a int = 4
  154.     var b int32
  155.     var c float32
  156.     var ptr *int

  158.     /* 运算符实例 */
  159.     fmt.Println(a)
  160.     fmt.Println(b)
  161.     fmt.Println(c)

  163.     /*  & 和 * 运算符实例 */
  164.     // &返回变量存储地址
  165.     ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */
  166.     fmt.Println(a)
  167.     // *是一个指针变量
  168.     fmt.Println(*ptr)
  169. }
  170. // 依次调用
  171. func main() {
  172.     arithmeticOperator()
  173.     relationalOperator()
  174.     logicalOperators()
  175.     bitOperator()
  176.     assignmentOperator()
  177.     otherOperators()
  178. }


源码下载: https://github.com/LiHaodong888/GoLearn