【Golang 基础】Go 语言的变量与常量

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/hvkCoder/article/details/82907695

Go 语言的变量与常量

变量声明，初始化与赋值 （示例代码）

• 变量的声明格式：var <变量名称> [变量类型]；
• 变量的赋值格式：<变量名称> = <值，表达式，函数等>；
• 声明和赋值同时进行：var <变量名称> [变量类型] = <值，表达式，函数等>；
• 分组声明的格式

package basic

import "fmt"

func DeclaratGroupVariable(){
	// 分组声明变量
	var (
		name string
		age int = 18
	)

	name = "hvkcoder"

	fmt.Printf("Hello！My name'is %d. I'm %d years old", name, age)
}

• 简写声明格式：<变量名称> := <值，表达式，函数等>，只能在局部变量声明时使用，并且必须赋值；
• 声明多个变量，需要以 ,隔开；

package basic

import "fmt"

func DeclaratMultiVariable(){
	// 声明多个变量
	var a , b, c int
	// 为多个变量赋值
	a, b, c = 1 ,2, 3
	fmt.Printf("a = %d , b = %d , c = %d", a, b, c)

	// 声明多个变量并赋值
	var e, f, g int = 4, 5, 6
	fmt.Printf("e = %d , f = %d , g = %d", e, f, g)

	// 简写声明
	h, i, j := 7, 8, 9
	fmt.Printf("h = %d , i = %d , j = %d", h, i, j)
}

声明全局变量时，不能使用简写声明，且必须使用 var关键字。变量名是 下划线（_) 表示忽略。

常量定义的形式，类型范围（示例代码）

• 常量定义从形式上可以分为 显式 和 隐式；

  • 显式：const <常量名称> [type] = value；
  • 隐式：const <常量名称> = value；

• 一般情况下常量名称需大写，若该常量为私有常量，只需在常量名前加 下滑线（_)，如：const _PI = 3.14；

• 常量可以使用内置表达式，如：len()，unsafe.SizeOf()等；

package basic

import "unsafe"


func DeclaratExpression(){
	const (
		_NAME string = "hvkcoder"
		_NAME_LENGTH int = len(_NAME)
		_NAME_SIZE  = unsafe.Sizeof(_NAME)
	)
}

• 多组常量声明时，常量默认取上一个常量的值；

package basic

import "fmt"

func DeclaratGroupConstant(){
	const (
		_NAME string = "hvkcoder"
		_FIRST_NAME
	)

	fmt.Println(_NAME)
	fmt.Println(_FIRST_NAME)
}

常量类型范围目前只支持 布尔型、数字型和字符串类型。

特殊常量 iota

• iota只能在常量的表达式中使用，在 const关键字出现时， iota将被重置为 0；

• const中每新增一行常量声明，将使 iota计数一次；

• iota常见用法：

  • 跳值使用法

  package basic
  
  import "fmt"
  
  func JumpValueByIota(){
      const (
          a = 3.14
          b
          c = iota  // 2
          d         // 3
      )
      fmt.Println(a,b,c,d)
  }
  

  • 插值使用法

  package basic
      
  import "fmt"    
  
  func InsertValueByIota(){
  	const (
  		a = iota   // 0
  		b = 3.14
  		c = iota   // 2
  		d          // 3
  	)
  	fmt.Println(a,b,c,d)
  }
  

  • 表达式隐式使用法

  package basic
  
  import "fmt"
  
  func ExpressionByIota(){
  	const (
  		B = 1 << (10 * iota)  // 1
  		KB                    // 1024
  		MB                    // 1048576
  		GB                    // 1073741824
  		TB                    // 1099511627776
  		PB                    // 1125899906842624
  	)
  
  	fmt.Println(B,KB,MB,GB,TB,PB)
  }
  

  • 单行使用法

  package basic
  
  import "fmt"
  
  func SingleLineByIota(){
  	const (
  		a , b = iota + 1, iota + 2
  		c, d = iota + 3, iota + 4
  
  		// a => 0 + 1
  		// b => 0 + 2
  		// c => 1 + 3
  		// d => 1 + 4
  	)
  	fmt.Println(a,b,c,d)
  }
  

变量的类型转换

• Go 语言中不存在隐式转换，类型转换必须是显式的；
• 类型转换只能发生在两种兼容类型之间；
• 类型转换的格式：var <变量名称> [:]= <目标类型>(<需要转换的变量>);