Go语言数据类型之变量与常量

• 变量声明,初始化与赋值

  • 单个变量声明和赋值

    package main
    import "fmt"
    var a int          // var <变量名称> [变量类型]
    func main()  {       
      fmt.Print(a)     //打印结果 0  (int类型未赋值则是默认值)
    }

  • 变量的赋值格式

    package main
    import "fmt"
    var a int  
    func main()  { 
       a = 123       // <变量名称> = <值, 表达式, 函数等>   打印结果 123
       fmt.Print(a)
    }
     

  • 声明和赋值同时进行

    package main
    import "fmt"
    var a int = 123  // var <变量名称> [变量类型] = <值, 表达式, 函数等>
    func main()  {
       fmt.Print(a)  //打印结果 123
    }   

  • 分组声明格式

    package main
    import "fmt"
    var (
           i int
         j float32 = 1.01
         name string = "一起学Go吧"
    )
    func main()  {       
       fmt.Print(i)             // 0
       fmt.Print("\n")     
       fmt.Print(j)             // 1.01
       fmt.Print("\n")  
       fmt.Print(name)          // 一起学Go吧
       fmt.Print("\n")
    
       var d int = 1
       fmt.Print(d)             //当然也可以在函数体内申明变量   1
       var (
            e int
            f float32 = 1.01
            k string = "一起学Go吧"
       )
       fmt.Print(e)             // 0
       fmt.Print("\n") 
       fmt.Print(f)             // 1.01
       fmt.Print("\n")
       fmt.Print(k)             // 一起学Go吧
       fmt.Print("\n")          
    }

• 附加说明

  • 同一行声明多个变量和赋值: var a, b, c int =1,2,3 或者 a,b : = 1,2

    package main
    import (
       "fmt"
       "reflect"
    )
    func main()  {
       var a, b, c int = 1,2,3
       fmt.Print(a)                    // 1
       fmt.Print("\n")
       fmt.Print(b)                    // 2
       fmt.Print("\n")
       fmt.Print(c)                    // 3
       fmt.Print("\n")
       //可以省略类型,当省略类型,Go语言会自动推断值的类型并赋值给对应变量
       var d, e ,f = 4,5.11,"ss"
       fmt.Print(d)                    // 4
       fmt.Print("\n")
       fmt.Print(reflect.TypeOf(d))    //打印变量d类型 int
       fmt.Print("\n")                 
       fmt.Print(e)                    // 5.11 
       fmt.Print("\n")
       fmt.Print(reflect.TypeOf(e))    //打印变量e类型  float64
       fmt.Print("\n")
       fmt.Print(f)                    // ss
       fmt.Print("\n")
       fmt.Print(reflect.TypeOf(f))    //打印变量f类型  string
       fmt.Print("\n")
    }

  • 全局变量(在函数体外)的声明必须使用var关键词,局部变量(在函数体内)则可以省略 例如a,b : = 1,2

    错误代码

    package main
    import "fmt"
    q, w, r := 1, 2.22, "ss"           // 全局变量的声明必须使用var关键词,因此错误
    func main()  {
        fmt.Print(q)
        fmt.Print("\n")
        fmt.Print(w)
        fmt.Print("\n")
        fmt.Print(r)
        fmt.Print("\n")
    }

    正确代码

    package main
    import "fmt"
    func main()  {
       q, w, r := 1, 2.22, "ss"         // 局部变量的声明则可以省略var关键词,因此正确
       fmt.Print(q)                    // 1
       fmt.Print("\n")
       fmt.Print(w)                    // 2.22
       fmt.Print("\n")
       fmt.Print(r)                    // ss
       fmt.Print("\n")
    }

  • 特殊变量下划线"_"相当于忽略这个变量,丢弃这个变量

    package main
    import "fmt"
    //var a,_,_,c = 11, 21, 2, 31      
    func main()  {
       //var a,_,_,c = 11, 21, 2, 31
       a,_,_,c := 11, 21, 2, 31        //简写方式,上面有详细说过的
       fmt.Print(a)
       fmt.Print("\n")
       fmt.Print(c)
    }

• 变量的类型转换

  • Go中不存在隐式转换,类型转换必须是显式的
  • 类型转换只能发生在两种兼容类型之间

  • 类型转换格式: <变量名称> [:]= <目标类型>( <需要转换的变量> )

    package main
    import (
        "fmt"
        "reflect"
     )
    func main()  {
       var  a int = 1
       b := float32(a)                //把a变量int类型转化为float32类型      
       fmt.Print(a)                   // 打印值为 1
       fmt.Print("\n")    
       fmt.Print(reflect.TypeOf(a))   // int  
       fmt.Print("\n")      
       fmt.Print(b)                   // 打印值为 1
       fmt.Print("\n")
       fmt.Print(reflect.TypeOf(b))   // float32   
       fmt.Print("\n")
       // float 类型转化为int类型会丢失精度
        c:= 1.01
        e := int(c)
        fmt.Print(c)                   // 打印值为 1.01
        fmt.Print("\n")    
        fmt.Print(reflect.TypeOf(c))   // float32  
        fmt.Print("\n")      
        fmt.Print(e)                   // 打印值为 1
        fmt.Print("\n")
        fmt.Print(reflect.TypeOf(e))   // int   
        fmt.Print("\n")
        //以上为两种兼容类型可以转化,下面为不兼容类型的转化(错误)
        var h bool = true
            k := int(h)                 //错误转化
            l := float64(h)             //错误转化
    }

• 变量可见性规则

  • 大写字母开头的变量是可导出的,也就是其它包可以读取的,是公用变量

  • 小写字母开头的就是不可导出的,是私有变量。
    目录结构：

     test
        ├── b1
        │   └── b.go
        └── main.go

    b.go文件

    package b1
    
    var a = "我对外不可见变量"
    var B = "我对外可变量"
    
    func c() string {
        return "我是对外不可见方法"
    }
    
    func D() string {
        return "我是对外可见方法"
    }

    main.go文件

    package main
    
    import (
      "./b1"
      "fmt"
    )
    //不能调用a变量和c方法
    func main() {
      b1.D()
      fmt.Print(b1.B)
    }