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

龙泷VK · · 816 次点击 · · 开始浏览    
这是一个创建于 的文章,其中的信息可能已经有所发展或是发生改变。

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 <变量名称> [:]= <目标类型>(<需要转换的变量>);

有疑问加站长微信联系(非本文作者)

本文来自:简书

感谢作者:龙泷VK

查看原文:【Golang 基础】Go 语言的变量与常量

入群交流(和以上内容无关):加入Go大咖交流群,或添加微信:liuxiaoyan-s 备注:入群;或加QQ群:692541889

816 次点击  
加入收藏 微博
暂无回复
添加一条新回复 (您需要 登录 后才能回复 没有账号 ?)
  • 请尽量让自己的回复能够对别人有帮助
  • 支持 Markdown 格式, **粗体**、~~删除线~~、`单行代码`
  • 支持 @ 本站用户;支持表情(输入 : 提示),见 Emoji cheat sheet
  • 图片支持拖拽、截图粘贴等方式上传