本文已参与「新人创作礼」活动，一起开启掘金创作之路。

前情提要，因为参加了字节的青训营，会使用到Go语言，但我没学过，所以现在尝试把Go语言的基础学到，然后在做项目的时候，不拖队友后腿。

Go语言的基础语法和语言变量

package main

func main() {
   /*
      var a string = "Runoob" //一次声明一个变量并初始化
      fmt.Println(a)

      //没有初始化
      var bb int
      fmt.Println(bb)

      var cc bool //bool 零值为false
      fmt.Println(cc)

      var b, c int = 1, 2 //一次声明多个变量
      fmt.Println(b, c)

      var i int
      var f float64
      var bbb bool
      var s string
      fmt.Printf("%v %v %v %q\n", i, f, bbb, s)

      //根据值自行判定变量类型
      var d = true
      fmt.Println(d)

      //如果变量已经用var声明过了，再使用 := 声明变量，就会编译错误
      //var intVal int
      intVal := 1 //等等于
      /*
         var intVal int
         intVal = 1
   */
   //fmt.Println(intVal)

   //多声明类型
   x, y := 123, "hello"
   println(a, b, c, d, e, f, g, h, x, y)
}

var a, b int
var ( //因式分解关键字的写法一般用于声明全局变量
   c int
   d bool
)

var e, f int = 1, 2
var g, h = 123, "hello"

Go的语言常量

package main

import "fmt"

import "unsafe"

//常量可以用len(), cap(), unsafe.Sizeof()函数计算表达式的值。
//函数必须是内置函数，否则编译过不了
const (
   x = "abc"
   y = len(x)
   z = unsafe.Sizeof(x)
)

/*
iota, 特殊常量，可以被认为是一个可以被编译器修改的常量
iota可以被用作枚举值
*/

func main() {
   /*
      显示类型定义：const b string = "abc"
      隐式类型定义：const b = "abc"
      在函数中定义的变量和常量一定要被使用，否则会报错
   */
   const length int = 10
   const width int = 5
   var area int
   const a, b, c = 1, false, "str" //多重赋值

   area = length * width
   fmt.Printf("面积为：%d", area)
   println() //换行
   println(a, b, c)

   //枚举
   println(x, y, z)

   //iota用法
   const (
      aa = iota //   0
      bb        //   1
      cc        //   2
      d  = "ha" //   独立值，iota += 1
      e         //   "ha"，iota += 1
      f  = 100  //   iota += 1
      g         //   100  iota += 1
      h  = iota //恢复计数：7
      i         //   8
   )
   fmt.Println(aa, bb, cc, d, e, f, g, h, i)
}

Go 语言运算符

运算符用于在程序运行时执行数学或逻辑运算。

Go 语言内置的运算符有：

• 算术运算符

package main

import "fmt"

func main() {
   var a int = 10
   var b int = 8
   var c int

   c = a + b
   fmt.Printf("a + c 的值为 %d\n", c)

   c = a - b
   fmt.Printf("a - c 的值为 %d\n", c)

   c = a * b
   fmt.Printf("a * c 的值为 %d\n", c)

   c = a / b
   fmt.Printf("a / c 的值为 %d\n", c)

   c = a % b
   fmt.Printf("c 的值为 %d\n", c)

   a++
   fmt.Printf("a 的值为：%d\n", a)

   b--
   fmt.Printf("b 的值为：%d\n", b)
}

• 关系运算符

package main

import "fmt"

func main() {
   var a int = 21
   var b int = 10

   if a == b {
      fmt.Printf("第一行 - a 等于 b\n")
   } else {
      fmt.Printf("第一行 - a 不等于 b\n")
   }
   if a < b {
      fmt.Printf("第二行 - a 小于 b\n")
   } else {
      fmt.Printf("第二行 - a 不小于 b\n")
   }

   if a > b {
      fmt.Printf("第三行 - a 大于 b\n")
   } else {
      fmt.Printf("第三行 - a 不大于 b\n")
   }

   // 改变a 和 b的值
   a = 5
   b = 20
   if a <= b {
      fmt.Printf("第四行 - a 小于等于 b\n")
   }
   if b >= a {
      fmt.Printf("第五行 - b 大于等于 a\n")
   }
}

• 逻辑运算符

package main

import "fmt"

func main() {
   var a bool = true
   var b bool = false
   if a && b {
      fmt.Printf("第一行 - 条件为 true\n")
   }
   if a || b {
      fmt.Printf("第二行 - 条件为 true\n")
   }
   /* 修改 a 和 b 的值 */
   a = false
   b = true
   if a && b {
      fmt.Printf("第三行 - 条件为 true\n")
   } else {
      fmt.Printf("第三行 - 条件为 false\n")
   }
   if !(a && b) {
      fmt.Printf("第四行 - 条件为 true\n")
   }
}

• 位运算符

package main

import "fmt"

func main() {

   var a uint = 60 /* 60 = 0011 1100 */
   var b uint = 13 /* 13 = 0000 1101 */
   var c uint = 0

   c = a & b /* 12 = 0000 1100 */
   fmt.Printf("第一行 - c 的值为 %d\n", c)

   c = a | b /* 61 = 0011 1101 */
   fmt.Printf("第二行 - c 的值为 %d\n", c)

   c = a ^ b /* 49 = 0011 0001 */
   fmt.Printf("第三行 - c 的值为 %d\n", c)

   c = a << 2 /* 240 = 1111 0000 */
   fmt.Printf("第四行 - c 的值为 %d\n", c)

   c = a >> 2 /* 15 = 0000 1111 */
   fmt.Printf("第五行 - c 的值为 %d\n", c)
}

• 赋值运算符

package main

import "fmt"

func main() {
   var a int = 21
   var c int

   c = a
   fmt.Printf("第 1 行 - =  运算符实例，c 值为 = %d\n", c)

   c += a
   fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c)

   c -= a
   fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c)

   c *= a
   fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c)

   c /= a
   fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c)

   c = 200

   c <<= 2
   fmt.Printf("第 6行  - <<= 运算符实例，c 值为 = %d\n", c)

   c >>= 2
   fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c)

   c &= 2
   fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c)

   c ^= 2
   fmt.Printf("第 9 行 - ^= 运算符实例，c 值为 = %d\n", c)

   c |= 2
   fmt.Printf("第 10 行 - |= 运算符实例，c 值为 = %d\n", c)

}

• 其他运算符

package main

import "fmt"

func main() {
   var a int = 4
   var b int32
   var c float32
   var ptr *int

   /* 运算符实例 */
   fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a)
   fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b)
   fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c)

   /*  & 和 * 运算符实例 */
   ptr = &a /* 'ptr' 包含了 'a' 变量的地址 */
   fmt.Printf("a 的值为  %d\n", a)
   fmt.Printf("*ptr 为 %d\n", *ptr)
}