• golang学习笔记系列之变量和常量


    变量

    变量是计算机语言中能存储计算结果或能表示值的抽象概念,不同的的变量保存的数据类型可能不一样。

    声明变量

    go语言中的变量需要声明后才能使用,同一作用域内不支持重复声明。并且go语言的变量声明后必须使用,否者会报错。

    默认语法
    var indertifer type
    
    //例:
    var age int    //int类型的变量不赋值,默认值是0
    var price float64 //默认值是0
    var flag bool  //默认值是false 
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    类型推断

    不需要为变量指定类型,根据变量的值来自动推断变量的类型。

    var name = “TOm”
    var num = 10
    
    • 1
    • 2
    同时声明多个变量
    var name,age,gender = "Tom",18,true
    
    • 1
    短变量声明

    短变量只能在函数内部进行声明,使用**:=**运算符对变量进行声明和初始化。

    identifer := ""
    
    //例:注意,一定是在函数内部声明,否则会报错!
    
    func fun(){
        age:=18
    	name:=tom
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    匿名变量

    如果我们接收到多个变量,有一些变量使用不到,可以使用下划线,便是变量名,这种变量叫做匿名变量。

    func Fun() (string, int) {
    	return "Tom", 18
    }
    //匿名变量 匿名变量不使用也不会报错
    tom_name, _ := Fun()
    fmt.Printf("tom_name: %v\n", tom_name)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    常量

    常量,就是在程序编译阶段就确定下来的值,二程序在运行时则无法改变该值。在go语言中,常量可以是数值类型,布尔类型,字符串类型等等。

    常量声明

    定义一个常量使用const关键字,语法格式如下:

    const constantName [type] = value
    
    • 1
    • const:定义常量的关键字
    • constantName:常量名
    • type:常量的类型,可选
    • value:常量的值
    package main
    
    import "fmt"
    
    func main() {
    
    	//常规语法
    	const PI float32 = 3.14
    	const H = 100
    
    	//定义多个
    	const (
    		NAME = "Tom"
    		AGE  = 18
    	)
    
    	//注意:声明多个变量时,如果省略了赋值,则表示和上面的一行值相同
    	const (
    		a = 1
    		b //b=a=1
    		c = 100
    		d //d=c=100
    	)
    
    	fmt.Printf("a: %v\n", a)
    	fmt.Printf("b: %v\n", b)
    	fmt.Printf("c: %v\n", c)
    	fmt.Printf("d: %v\n", d)
    
    	//同时定义
    	const X, Y, Z = 2, 3, 4
    	fmt.Printf("X: %v\n", X)
    	fmt.Printf("Y: %v\n", Y)
    
    }
    
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    iota

    iota比较特殊,可以被认为是一个可被编译器修改的常量,它的默认值是0,每调用一次值就加一,遇到const关键字时被重置为0。

    //iota
    	const (
    		A = iota //0 
    		B = iota //1
    		C = iota //2
    
    	)
    	fmt.Printf("A: %v\n", A)
    	fmt.Printf("B: %v\n", B)
    	fmt.Printf("C: %v\n", C)
    
    	//iota中间截断
    	const (
    		aa = iota //0
    		_         //1
    		cc = iota //2
    	)
    
    	fmt.Printf("aa: %v\n", aa)
    	fmt.Printf("cc: %v\n", cc)
    
    
    	const(
    		aaa=iota  //0
    		bbb=1000  //1000 [1]
    		ccc=iota  //2
    	)
    
    	fmt.Printf("aaa: %v\n", aaa)
    	fmt.Printf("ccc: %v\n", ccc)
    
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30

    同步更新于个人博客系统:golang学习笔记系列之变量和常量

  • 相关阅读:
    SpringBoot属性注入
    英语单词(五)
    一篇文章讲清楚 Mendix 与 SAP 集成开发流程
    浅谈Java语法中的字符串:String
    函数式编程
    Asp-Net-Core开发笔记:给SwaggerUI加上登录保护功能
    【全方位带你配置yolo开发环境】快速上手yolov5
    1-31 正则表达式 String Buffer String Builder
    工作小计 zookpeer3.8 C api环境搭建
    基于云边协同架构的五大应用场景革新
  • 原文地址:https://blog.csdn.net/max_LLL/article/details/126798173