Go 语言常量

优质

小牛编辑

149浏览

2023-12-01

和 C 语言一样Go语言中的常量也分为整型常量、实型常量、字符常量、字符串常量、自定义常量

自定义常量

C 语言自定义常量：const 数据类型常量名称 = 值;

  #include <stdio.h>
  int main(int argc, const char * argv[])
  {
      const float PI = 998;
      PI = 110; // 报错
      printf("PI = %d\n", PI );
      return 0;
  }

Go 语言自定义常量：const 常量名称数据类型 = 值 or const 常量名称 = 值

package main
import "fmt"
func main() {
  //const PI float32 = 3.14
  //PI = 110 // 报错
  //fmt.Println("PI = ", PI )

  const PI = 3.14
  PI = 110 // 报错
  fmt.Println("PI = ", PI )
}

除此之外 Go 语言还支持 一次性定义多个常量

package main
import "fmt"
func main() {
  // 多重赋值方式
  const num1, num2 int  = 100, 200
  fmt.Println("num1 = ", num1)
  fmt.Println("num2 = ", num2)

  // 常量组方式
  const (
  	num3 = 100
  	num4 = 200
  )
  fmt.Println("num3 = ", num3)
  fmt.Println("num4 = ", num4)

  // 常量组+多重赋值
  const (
  	num5, num6 = 100, 200
  	num7 = 300
  )
  fmt.Println("num5 = ", num5)
  fmt.Println("num6 = ", num6)
  fmt.Println("num7 = ", num7)
}

Go 语言自定义常量注意点

定义的局部变量或者导入的包没有被使用，那么编译器会报错，无法编译运行
但是定义的常量没有被使用，编译器不会报错，可以编译运行

package main
import "fmt"
func main() {
  // 可以编译运行
  const PI float32 = 3.14
}

在常量组中，如果上一行常量有初始值，但是下一行没有初始值，那么下一行的值就是上一行的值

package main
import "fmt"
func main() {
  const (
  	num1 = 998
  	num2 // 和上一行的值一样
  	num3 = 666
  	num4 // 和上一行的值一样
  	num5 // 和上一行的值一样
  )
  fmt.Println("num1 = ", num1) // 998
  fmt.Println("num2 = ", num2) // 998
  fmt.Println("num3 = ", num3) // 666
  fmt.Println("num4 = ", num4) // 666
  fmt.Println("num5 = ", num5) // 666

  const (
  	num1, num2 = 100, 200
  	num3, num4  // 和上一行的值一样, 注意变量个数必须也和上一行一样
  )
  fmt.Println("num1 = ", num1)
  fmt.Println("num2 = ", num2)
  fmt.Println("num3 = ", num3)
  fmt.Println("num4 = ", num4)
}

枚举常量

C 语言中枚举类型的本质就是整型常量
Go 语言中没有 C 语言中明确意义上的 enum 定义，但是可以借助 iota 标识符来实现枚举类型

C 语言枚举格式：

 enum　枚举名　{
    枚举元素1,
    枚举元素2,
 };

C 语言枚举中，如果没有指定初始值，那么从0开始递增

#include <stdio.h>
int main(int argc, const char * argv[])
{
    enum Gender{
        male,
        female,
        yao,
    };
//    enum Gender g = male;
//    printf("%d\n", g); // 0
//    enum Gender g = female;
//    printf("%d\n", g); // 1
    enum Gender g = yao;
    printf("%d\n", g); // 2
    return 0;
}

C 语言枚举中，如果指定了初始值，那么从指定的数开始递增

#include <stdio.h>
int main(int argc, const char * argv[])
{
    enum Gender{
        male = 5,
        female,
        yao,
    };
//    enum Gender g = male;
//    printf("%d\n", g); // 5
//    enum Gender g = female;
//    printf("%d\n", g); // 6
    enum Gender g = yao;
    printf("%d\n", g); // 7
    return 0;
}

Go 语言实现枚举格式

const(
  枚举元素1 = iota
  枚举元素2 = iota
  ... ...
)

利用 iota 标识符标识符实现从 0 开始递增的枚举

package main
import "fmt"
func main() {
	const (
		male = iota
		female = iota
		yao = iota
	)
	fmt.Println("male = ", male) // 0
	fmt.Println("male = ", female) // 1
	fmt.Println("male = ", yao) // 2
}

iota 注意点：

在同一个常量组中，iota 从 0 开始递增，每一行递增1
在同一个常量组中，只要上一行出现了 iota，那么后续行就会自动递增

package main
import "fmt"
func main() {
  const (
  	male = iota // 这里出现了iota
  	female // 这里会自动递增
  	yao
  )
  fmt.Println("male = ", male) // 0
  fmt.Println("male = ", female) // 1
  fmt.Println("male = ", yao) // 2
}

在同一个常量组中，如果 iota 被中断，那么必须显示恢复

package main
import "fmt"
func main() {
  const (
  	male = iota 
  	female = 666 // 这里被中断, 如果没有显示恢复, 那么下面没有赋值的常量都和上一行一样
  	yao
  )
  fmt.Println("male = ", male) // 0
  fmt.Println("male = ", female) // 666
  fmt.Println("male = ", yao) // 666
}

package main
import "fmt"
func main() {
  const (
  	male = iota 
  	female = 666 // 这里被中断
  	yao = iota // 这里显示恢复, 会从当前常量组第一次出现iota的地方开始,每一行递增1, 当前是第3行,所以值就是2
  )
  fmt.Println("male = ", male) // 0
  fmt.Println("male = ", female) // 666
  fmt.Println("male = ", yao) // 2
}

iota 也支持常量组+多重赋值，在同一行的 iota 值相同

package main
import "fmt"
func main() {
  const (
    a, b = iota, iota
    c, d = iota, iota
  )
  fmt.Println("a = ", a) // 0
  fmt.Println("b = ", b) // 0
  fmt.Println("c = ", c) // 1
  fmt.Println("d = ", d) // 1
}

iota 自增默认数据类型为 int 类型，也可以显示指定类型

package main
import "fmt"
func main() {
const (
    male float32 = iota // 显示指定类型,后续自增都会按照指定类型自增
    female
    yao
)
fmt.Printf("%f\n", male) // 0.0
fmt.Printf("%f\n", female) // 1.0
fmt.Printf("%f\n", yao) // 2.0
fmt.Println("male = ", reflect.TypeOf(female)) // float32
}

Go 语言 fmt 包实现了类似 C 语言 printf 和 scanf 的格式化 I/O，格式化动作源自 C 语言但更简单