常量变量

常量 const

  1. package main
  2. import "unsafe"
  3. // 常量可以用len(), cap(), unsafe.Sizeof()常量计算表达式的值。
  4. // 常量表达式中，函数必须是内置函数，否则编译不过：
  5. const (
  6.   a = "abc"
  7.   b = len(a)
  8.   c = unsafe.Sizeof(a)
  9. )
  11. func main(){
  12.   const (
  13.     PI     = 3.14
  14.     const1 = "1"
  15.   )
  16.   const LENGTH int = 10
  17.   const e, f, g = 1, false, "str" //多重赋值
  18.   println(a, b, c,PI, LENGTH)
  19. }

上面例子const.go

iota 特殊常量，可以认为是一个可以被编译器修改的常量。iota.go

  1. package main
  2. import "fmt"
  3. func main() {
  4.   const (
  5.     // 第一个 iota 等于 0，每当 iota 在新的一行被使用时，它的值都会自动加 1；
  6.     // 所以 a=0, b=1, c=2 可以简写为如下形式：
  7.     a = iota   //0
  8.     b          //1
  9.     c          //2
  10.     d = "ha"   //独立值，iota += 1
  11.     e          //"ha"   iota += 1
  12.     f = 100    //iota +=1
  13.     g          //100  iota +=1
  14.     h = iota   //7,恢复计数
  15.     i          //8
  16.   )
  17.   fmt.Println(a,b,c,d,e,f,g,h,i)
  18. }

变量 var

  1. var (
  2.   name  = "gopher"
  3.   name1 = "1"
  4. )
  5. // 变量声明
  6. var a int
  7. a = 11 /* 赋值 */
  9. // 变量声明 并赋值
  10. var b int = 12
  12. // 应用在函数体内的方式
  13. var a, b, c, d int = 1, 2, 3, 4
  14. // a =1 
  15. // b =2 
  16. // c =3 
  17. // d =4 
  20. var a, _, c, d int = 1, 2, 3, 4
  21. // 忽略 _ 返回值忽略
  • 全局变量名 以大写开头
  • 全局变量不可以省略 var ，可以使用并行的方式
  • 所有变量都可以使用类型推断
  • 局部变量不可以使用var()简写的形式

变量的类型转换

  1. // 只能类型显式转换
  2. var a float32 = 1.1
  3. // 省略var, 简短形式，使用 := 赋值操作符
  4. b := int(a)
  5. // 不兼容的类型不能转换类型

多变量声明

  1. var x, y int
  2. // 这种因式分解关键字的写法一般用于声明全局变量
  3. var (
  4.   a int
  5.   b bool
  6. )
  8. var c, d int = 1, 2
  9. var e, f = 123, "hello"
  11. //这种不带声明格式的只能在函数体中出现
  12. //g, h := 123, "hello"