精华内容
下载资源
问答
  • Go语言 常量

    2020-04-05 21:21:19
    说说 Go语言 常量~

    导言

    • 原文链接: Part 5: Constants
    • If translation is not allowed, please leave me in the comment area and I will delete it as soon as possible.

    常量

    定义

    Go 中,我们把一些固定的值叫做常量,例如 5-89"I love Go"67.89

    看看下面的代码先:

    var a int = 50  
    var b string = "I love Go"  
    

    在上面的代码中,我们把常量 50"I love Go" 分别分配给 ab

    我们可以使用 关键字const 定义常量。虽然在上面的代码中,我并没有显式地使用 const,但实际在 Go 中,50"I love Go" 就是常量。

    再来看个程序:

    package main
    
    func main() {  
        const a = 55 //allowed
        a = 89 //reassignment not allowed
    }
    

    我们无法给常量重新赋值,因此上面的程序会出现编译错误:

    cannot assign to a.
    

    函数与常量

    在编译时,常量的数值必须是确定的。因此函数的返回值不能分配给常量,因为函数调用发生在运行时期。

    package main
    
    import (  
        "fmt"
        "math"
    )
    
    func main() {  
        fmt.Println("Hello, playground")
        var a = math.Sqrt(4)//allowed
        const b = math.Sqrt(4)//not allowed
    }
    

    在上面的程序中,a 是一个变量,因此我们可以把 math.Sqrt(4) 的返回值分配给它。

    b 是一个常量,它的值必须在编译时期确定。因为在运行时,math.Sqrt(4) 的值才被算出,所以执行 const b = math.Sqrt(4) 时,会抛出一个错误:

    main.go:11: const initializer math.Sqrt(4) is not a constant.
    

    字符串常量

    Go 中,被双引号括起的值 就是 字符串常量。举个例子,“Hello World""Sam" 都是字符串常量。

    字符串常量的类型是什么?答案是 无类型 (untyped)

    字符串常量没有类型!

    const hello = "Hello World"  
    

    在上面的代码中,我们将 "Hello World" 分配给字符串常量 hello。此时 hello 是没有类型的。

    Go 是强类型语言。所有的变量都有一个显性的类型。那么,在下面的程序中,如果我们把 无类型的常量"Sam" 分配给 变量name,这会发生什么?

    package main
    
    import (  
        "fmt"
    )
    
    func main() {  
        var name = "Sam"
        fmt.Printf("type %T value %v", name, name)
    }
    

    答案就是:常量都有一个与之相关联的默认类型,当有一行代码用到该常量时,该常量才表现出默认类型。

    在上面的 var name = "Sam"语句 中,name 是需要类型的,而这个类型来自 常量"Sam" 的默认类型 — string

    我们能创建有类型的常量吗?答案是肯定的,代码如下:

    const typedhello string = "Hello World"  
    

    在上面的代码中,typehello 就是一个类型为 string 的常量。

    Go 是一门强类型语言,因此它不允许混合类型分配。通过代码看看这是什么意思:

    package main
    
    func main() {  
            var defaultName = "Sam" //allowed
            type myString string
            var customName myString = "Sam" //allowed
            customName = defaultName //not allowed
    }
    

    在上面的代码中,我们首先创建了一个 变量defaultName,并给它分配了一个 常量"Sam"。常量"Sam" 的默认类型是 string,所以分配后,defaultName 的类型是 string

    在下一行,我们定义了一个新的类型 myString,它来自 string类型。

    之后,我们创建了一个 变量customName,并将 常量"Sam" 也分配给它。因为 常量"Sam" 是无类型的,所以它能分配给任何 string类型 的变量。因此,这个分配也是允许的,分配后,customName 的类型为 myString

    现在,我们拥有了 string类型 的 defaultName,以及 myString类型 的 customName。但是,即使 myString 是以 string 为基础创建的,Go语言 的类型政策还是不允许将 string类型 变量,分配给 myString类型 变量。

    因此,customName = defaultName 并不能执行,编译器会抛出一个错误:

    main.go:7:20: cannot use defaultName (type string) as type myString in assignment
    

    布尔常量

    布尔常量和字符串常量差别不大,只不过布尔常量只有两个取值:truefalse。由于适用于字符串常量的规则,同样适用于布尔常量,这里我就不赘述了。

    下面是一个关于布尔常量的简单例子:

    package main
    
    func main() {  
        const trueConst = true
        type myBool bool
        var defaultBool = trueConst //allowed
        var customBool myBool = trueConst //allowed
        defaultBool = customBool //not allowed
    }
    

    代码不言自明。


    数字常量

    数字常量包括整型常量、浮点型常量以及复数常量。数字常量有点 小不同

    通过代码来说说 小不同

    package main
    
    import (  
        "fmt"
    )
    
    func main() {  
        const a = 5
        var intVar int = a
        var int32Var int32 = a
        var float64Var float64 = a
        var complex64Var complex64 = a
        fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
    }
    

    在上面的程序中,常量a 是没类型的,它的值为 5。你可能想知道:

    • a 的默认类型是什么呢?
    • a 分配给不同类型的变量时,会发生什么呢?

    这依赖于 a 的句式。通过代码你会更明白:

    package main
    
    import (  
        "fmt"
    )
    
    func main() {  
        var i = 5
        var f = 5.6
        var c = 5 + 6i
        fmt.Printf("i's type %T, f's type %T, c's type %T", i, f, c)
    }
    

    在上面的程序中,数字常量的句式,决定了每个变量的类型。在句式上,5 是整数,5.6 是浮点数,而 5 + 6i 是复数。所以运行上面的程序,输出会是:

    i's type int, f's type float64, c's type complex128
    

    现在,下面程序的工作原理将会清晰起来:

    package main
    
    import (  
        "fmt"
    )
    
    func main() {  
        const a = 5
        var intVar int = a
        var int32Var int32 = a
        var float64Var float64 = a
        var complex64Var complex64 = a
        fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
    }
    

    在上面的程序中,a 的值为 5,而它的句式是通用的 (它可以代表 浮点数、整数、甚至是没有虚部的复数),所以它能被分配给任何兼容的类型 — 这一类常量的默认类型,可以认为是根据上下文动态生成的

    var intVar int = a 要求 aint类型,所以 a 变为了 int类型 常量。
    var complex64Var complex64 = a 要求 acomplex64类型,所以 a 变为了 complex64类型 常量。


    数字表达式

    数字常量的任意混合搭配 构成了 数字表达式,数字表达式也可看作数字常量。

    package main
    
    import (  
        "fmt"
    )
    
    func main() {  
        var a = 5.9/8
        fmt.Printf("a's type %T value %v",a, a)
    }
    

    在上面的程序中,在句式上,5.9 是一个浮点数,8 是一个整数 (也可以是浮点数、复数)。

    因为5.98 都是数字常量,所以表达式 5.9/8 能通过编译。这个表达式的结果是 0.7375,它是一个浮点数常量,因此 变量a 也为浮点数。

    运行上面的程序,输出如下:

    a's type float64 value 0.7375.
    

    这就是常量了~

    祝你吃好睡好身体棒~


    原作者留言

    优质内容来之不易,您可以通过该 链接 为我捐赠。


    最后

    感谢原作者的优质内容。

    欢迎指出文中的任何错误。

    展开全文
  • Go语言常量

    2020-01-23 12:47:22
    Go语言常量 GO语言学习教程 www.lsdcloud.com 相对于变量,常量是恒定不变的值,多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似,只是把var换成了const,常量在定义的时候必须赋值。 声明...

    Go语言常量

    GO语言学习教程
    www.lsdcloud.com
    相对于变量,常量是恒定不变的值,多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似,只是把var换成了const,常量在定义的时候必须赋值。

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

    const pi = 3.1415
    const e = 2.7182
    

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

    const (
        pi = 3.1415
        e = 2.7182
    )
    

    iota

    iota是go语言的常量计数器,只能在常量的表达式中使用。
    iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义,在定义枚举时很有用。
    const (
    		n1 = iota //0
    		n2        //1
    		n3        //2
    		n4        //3
    	)
    

    几个常见的iota示例:

    使用_跳过某些值

    const (
    		n1 = iota //0
    		n2        //1
    		_
    		n4        //3
    	)
    

    iota声明中间插队

    const (
    		n1 = iota //0
    		n2 = 100  //100
    		n3 = iota //2
    		n4        //3
    	)
    	const n5 = iota //0
    

    定义数量级 (这里的<<表示左移操作,1<<10表示将1的二进制表示向左移10位,也就是由1变成了10000000000,也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位,也就是由10变成了1000,也就是十进制的8。)

    const (
    		_  = iota
    		KB = 1 << (10 * iota)
    		MB = 1 << (10 * iota)
    		GB = 1 << (10 * iota)
    		TB = 1 << (10 * iota)
    		PB = 1 << (10 * iota)
    	)
    

    多个iota定义在一行

    const (
    		a, b = iota + 1, iota + 2 //1,2
    		c, d                      //2,3
    		e, f                      //3,4
    	)
    

    GO语言学习教程
    www.lsdcloud.com

    展开全文
  • Golang 常量

    2020-04-08 13:16:08
    Golang常量常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型 const indentifier [type] = value 多个相同类型常量的声明: const c_name1, c_name2 = value1, value2 package ...

    Golang常量:

    常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型

    const indentifier [type] = value

     

    多个相同类型常量的声明:

    const c_name1, c_name2 = value1, value2

    package main
    
    import "fmt"
    
    func main()  {
    	const LENGTH int = 10
    	const WIDTH int = 5
    	var area int
    	const a, b, c = 1, false, "str"
    
    	area = LENGTH * WIDTH
    	fmt.Printf("面积为:%d", area)
    	println()
    	println(a, b, c)
    }
    //面积为:50
    //1 false str

     

    iota

    特殊常量,一个可以被编译器修改的常量,iota 在 const关键字出现时将被重置为 0(const 内部的第一行之前),

    const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

    package main
    import "fmt"
    
    func main()  {
    	const (
    		a = iota
    		b
    		c
    		d = "ha"
    		e
    		f = 100
    		g
    		h = iota
    		i
    	)
    	fmt.Println(a,b,c,d,e,f,g,h,i)
    }
    //0 1 2 ha ha 100 100 7 8

     

    展开全文
  • golang 常量

    2019-09-18 11:25:39
    go支持定义字符常量 字符串常量 布尔常量 数值常量 const 关键字来定义常量 */ package main import ( "fmt" "math" ) const s string = "constant" func main() { //常量必须有初始值 const n = 5000 ...

    /*
      go 常量
      go支持定义字符常量 字符串常量 布尔常量 数值常量
      const 关键字来定义常量
    */

    package main

    import (
        "fmt"
        "math"
    )

    const s string = "constant"

    func main() {
        //常量必须有初始值
        const n = 5000
        const d = 22 / n

        //知识点 显示类型转换
        int64(d)
        math.Sin(n)
    }
     

    展开全文
  • golang常量

    2017-09-07 09:59:22
    GO语言常量constconst b string = "abc" const a = "abc"const LENGTH int = 10 const WIDTH int = 5 const a,b,c = 1,false,"str"// 常量还可以用作枚举 const( Unknown = 0 Female = 1 Male = 2 )//常量表达式...
  • Go 语言常量

    2018-12-06 18:05:00
    Go语言常量 常量是一个简单值的标识符,在程序运行时,不会被修改的量。 常量中的数据类型只可以是布尔型、数字型(整数型、浮点型和复数)和字符串型。 常量的定义格式: package main import "fmt...
  • GO语言常量

    2018-09-16 09:11:20
     在Go语言中,常量是指编译期间就已知且不可改变的值。常量可以是数值类型(包括整型、浮点型和复数类型)、布尔类型、字符串类型等。 常量的定义  常量声明可以使用iota常量生成器初始化,它用于生成一组以...
  • go语言 常量

    2020-01-01 13:01:24
    常量定义 package main import "fmt" func main() { //变量:运行期间,可以改变的量,var //常量:运行期间,不可以改变的量,const const a int = 1 fmt.Println(a) //自动推导类型常量(没有用:=) const b = 2 ...
  • golang常量和变量常量的定义变量的定义1.先声明后初始化2.声明后立即初始化3.省略数据类型4.golang简短声明格式多个变量声明 常量的定义 基本语法: const name int = 4 变量的定义 1.先声明后初始化 单个变量: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,371
精华内容 16,548
关键字:

go常量