go 基础语法(变量常量枚举)

变量定义

1. 使用 var 关键词
   1. var a, b, v bool
   2. var s1, s2 string = "hello", "world"
   3. 可放在函数内,或直接放在包内
   4. 使用 var() 可以定义多个变量
   5. 编译器可以自动区分变量类型
   6. 使用 := 定义变量 (只能在函数内使用)

        package main

        import (
            "fmt"
        )

        // 在函数外面定义变量不能使用 :=
        // 函数外定义的变量时包内变量,不会作用到全局
        // var aa = 3
        // var bb = "lalala"
        // var cc = true

        // 每个变量都要用var 比较麻烦,可以使用括号来简写
        var (
            aa = 2
            bb = "fun"
            cc = false
        )

        func variableZeroValue() {
            // 使用 var 定义 变量
            // 在 go 语言中 变量名写在前面 类型写在后面
            var a int
            var s string
            // go 语言变量定义完成后一定要有合理的初始值
            fmt.Printf("%d %q\n", a, s)
        }

        func varableInitialValue() {
            // 变量可以定义多个,通过逗号分割
            // go 语言非常严格,定义的变量一定要使用否则会报错
            var a, b int = 3, 4
            var s string = "avc"
            fmt.Println(a, b, s)
        }

        func varableTypeDeduction() {
            // go 语言 也可以省略类型 会自动推断类型
            // 不规定类型可以混写,规定类型不能混写
            var a, b, c, s = 3, 4, true, "fuc"
            fmt.Println(a, b, c, s)
        }

        func variableShorter() {
            // var 也可以简写 可以使用 := 来定义
            // 第一次使用该变量可以使用 := 后面修改该变量不能使用 :=
            a, b, c := 2, true, "fuc"
            fmt.Println(a, b, c)
        }

        // 函数入口
        func main() {
            fmt.Println("hello world!")
            variableZeroValue()
            varableInitialValue()
            varableTypeDeduction()
            variableShorter()
            fmt.Println(aa, bb, cc)
        }

内建变量

1. 内建变量类型

   1. bool,string

   2. (u)int, (u)int8, (u)int16, (u)int32, (u)int64, uintptr
      (u: 代表无符号整数 后面数字可以规定长度,不规定长度根据系统位数来, ptr 是指针的意思,长度根据操作系统来)

   3. byte, rune (rune 长度32位,类似char)

   4. float32, float64, complex64, complex128
      (complex 是复数的意思 64代表实部和虚部分别是32位 128则代表分别是64位)

      // 欧拉公式实现
      func euler() {
       // c := 3 + 4i  // 注: 4i 可以直接被识别为复数
       // fmt.Println(cmplx.Abs(c))
       // 方法1:
       fmt.Println(cmplx.Pow(math.E, 1i*math.Pi) + 1)
       // 方法2: 
       fmt.Println(cmplx.Exp(1i*math.Pi) + 1)
      
       fmt.Printf("%.3f\n", cmplx.Exp(1i*math.Pi)+1)
      }

2. 强制类型转换
   1. 类型转化是强制的

      func triangle() {
        var a, b int = 3, 4
        var c int
        // go 语言中不能 int 和 float 不会隐式转换,必须要去显示转换
        c = int(math.Sqrt(float64(a*a + b*b))) // Sqrt 请求的参数要求是float 返回也是float
        fmt.Println(c)
      }

      注意:浮点数运算可能不准,例如4.999强制类型转换结果是4需要这方面需要考虑到

   ---

常量与枚举

1. 常量的定义
   1. 使用 const 进行常量定义
   2. const 数值可作为各种类型使用

      // 常量也可以定义在方法外面,也可以通过 () 批量定义
      const filename = "abc.txt"
      func consts() {
       // 使用方法与 var 相似
       // 一般 go 中的常量是不大写的, 大小写在 go 中有特殊含义
       const a, b = 3, 4
       var c int
       c = int(math.Sqrt(a*a + b*b))
       fmt.Println(filename,c)
      }

2. 枚举类型

   1. 特殊的常量

   2. 通过 const() 来进行定义

      func enums() {
        // go 没有特殊的枚举关键字,我们一般使用一组const块来表示
        const (
            php = iota // iota 表示这组 const 是 自增值的
            html
            java
            _ // _ 是可以跳过当前这个自增值
            golang
        )
        fmt.Println(php, html, java, golang)
        // 0,1,2,4
      
        const (
            // iota 还可以做运算
            b = 1 << (10 * iota)
            kb
            mb
            gb
            tb
            pb
        )
        fmt.Println(b, kb, mb, gb, tb, pb)
        // 1 1024 1048576 1073741824 1099511627776 1125899906842624
      }

本作品采用《CC 协议》，转载必须注明作者和本文链接