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为全局变量也就是包变量同包下无法重复声明,如果是大写字母开头为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
    )
    
作用域
var Aa = 3 //全局变量,大写字母开头,所有地方都可以访问,跨包需要带上包名
var aa = 4 //全局变量,小写字母开头,仅限包内访问
func main() {
	bb := 5 //局部变量,仅限本函数访问
	{
		cc := 6 //局部变量,仅限{}内访问访问
		fmt.Println(cc)
	}
	fmt.Println(bb)
	fmt.Printf(cc) //报错无法访问
}
posted @   白黑黑  阅读(60)  评论(0编辑  收藏  举报
(评论功能已被禁用)
相关博文:
阅读排行:
· 阿里最新开源QwQ-32B,效果媲美deepseek-r1满血版,部署成本又又又降低了!
· 单线程的Redis速度为什么快?
· SQL Server 2025 AI相关能力初探
· AI编程工具终极对决:字节Trae VS Cursor,谁才是开发者新宠?
· 展开说说关于C#中ORM框架的用法!
点击右上角即可分享
微信分享提示