Golang常量与变量-Go语法1

标识符

• 在编程语言中标识符就是程序员定义的具有特殊意义的词，就是为变量名、常量名、函数名等等取的一个见名知义的名称。 Go语言中标识符由字母数字和_(下划线）组成，并且只能以字母和_开头。 举几个例子：abc, _, _123, a123，标识符不能以数字开头，可以取中文标识符但不推荐。

关键字

• 关键字是指编程语言中系统预先定义好的具有特殊含义的标识符。 关键字和保留字都不可以用作变量名。系统已经占用了。

• Go语言中25个关键字

  /**
  var和const:变量和常量的声明
  package && import:导入
  func:用于定义函数和方法
  return:用于从函数返回
  defer:在函数退出之前执行
  go:用于并行
  select:用于选择不同类型的通讯
  interface:用于定义接口
  struct:用于定义抽象数据类型结构体
  break、case、continue、for、fallthrough、else、if、switch、goto、default 流程控制
  chan:用于channel通讯
  type:用于声明自定义类型
  map:用于声明map类型数据
  range:用于读取slice、map、channel数据
  */
  

• Go语言中37个保留字

  /**
  Constants: true  false  iota  nil
  Types: int  int8  int16  int32  int64  uint  uint8  uint16  uint32  uint64  uintptr float32  float64  complex128  complex64 bool  byte  rune  string  error
  Functions: make  len  cap  new  append  copy  close  delete complex  real  imag
  panic  recover
  */
  

关键字和保留字无需特意关注用熟悉后自然会记住

变量

• 变量来历

  • 程序运行过程中的数据都是保存在内存中，我们想要在代码中操作某个数据时就需要去内存上找到这个变量，但是如果我们直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以我们就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了。

• Go变量类型

  • 变量（Variable）的功能是存储数据。不同的变量保存的数据类型可能会不一样。经过半个多世纪的发展，编程语言已经基本形成了一套固定的类型。
  • Go语言的变量类型分为两类：基本数据类型和派生数据类型
    • 基本数据类型包括数字类型（整型和浮点型）、布尔类型（true和false）、字符串类型
      • 有符号整型：int8、int16、int32（rune是int32的别名）、int64
      • 无符号整型：uint8（byte 是 uint8的别名）、uint16、uint32、uint64
      • 浮点型：float32、float64、complex64、complex128
    • 派生数据类型包括指针类型、数组类型、切片类型、Map类型、结构化类型、接口类型、Channel类型、函数类型

• 变量声明

  • Go语言中的每一个变量都有自己的类型，并且变量必须经过声明才能开始使用。Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值，例如： 整型和浮点型变量的默认值为0。 字符串变量的默认值为空字符串。 布尔型变量默认为false。 切片、函数、指针变量的默认为nil。

  • 变量声明定义分为日常三种

    • //var 变量名 变量类型
      var name string
      var age int
      var isOk bool
      name = "BeiJing"
      age = 22
      //第一种先定义变量再赋值
      

    • var name = "北京"
      //第二种定义时直接赋值 变量名后无需跟变量类型自动推导
      

    • 该方式只能在函数内部声明不能在函数外使用

      name := "北京"
      //第三种自动推导直接赋值（）
      

  • 匿名变量

    在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示，匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

    func foo() (int, string) {
    	return 10, "xiaoxiao"
    }
    func main() {
    	x, _ := foo()
    	_, y := foo()
    	fmt.Println("x=", x)
    	fmt.Println("y=", y)
    }
    

  • 变量平行赋值

    i, j := 10, 20 //同时定义两个变量
    fmt.Println("变换前==》 i:", i, ", j:", j)
    i, j = j, i
    fmt.Println("变换后==》i:", i, ", j:", j
    

  • 注意：

    1. 函数外的每个语句都必须以关键字开始（var、const、func等）在方法外声明var name string 此时name为全局变量也就是包变量同包下无法重复声明，全局变量可在声明同时赋值也可以只声明在方法中赋值，但不可以在方法外先声明再赋值。

       package main
       var address string
       //address = "中国" //该语法是错误的
       func main() {
       	address="中国"
       	fmt.Printf(address)
       }
       

    2. :=不能使用在函数外。

    3. _多用于占位，表示忽略值。

  • 批量声明

    每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量声明：

    var (
        a string
        b int
        c bool
        d float32
    )
    

常量

• 常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值。

  const pi = 3.1415
  const wan = 10000
  

  声明了pi和`wan这两个常量之后，在整个程序运行期间它们的值都不能再发生变化了。

• 多个常量也可以一起声明

• 同时声明多个常量时，如果省略了值则表示和上面一行的值相同

  const (
      n1 = 100
      n2
      n3
  )
  //常量n1、n2、n3的值都是100
  

• iota是go语言的常量计数器，只能在常量的表达式中使用。

  iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。

  const (
  		n1 = iota //0
  		n2        //1
  		n3        //2
  		n4        //3
  	)
  const (
  		c1 = iota //0
  		c2        //1
  		_
  		c4        //3
  	)
  const (
  		a1 = iota //0
  		a2 = 100  //100
  		a3 = iota //2
  		a4        //3
  	)
  const a5 = iota //0
  const (
  		a, b = iota + 1, iota + 2 //1,2
  		c, d                      //2,3
  		e, f                      //3,4
  )
  const(
  	a1,a2=iota+1,iota+2//此时iota为0，输出1，2
  	a3,a4=iota+1,iota+2//此时iota为1，输出2，3
  	a5,a6=7,8//输出7，8
  	a7,a8=iota+3,iota+5//此时iota为3，输出6，8
  )
  

​