• 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)
      }  

关注友儿不迷路

Last modification:September 18th, 2020 at 04:55 pm
如果觉得我的文章对你有用,请随意赞赏