GO 语言变量、常量、字面量


1. GO 语言变量

1.1 变量类型

  • 整型 包含的 go 的变量类型有:int int8 int16 int32 int64 uint uint8 uint16 uint32 uint64,fmt 输出为 %d
  • 浮点型 包含的 go 的变量类型有:float32 float64,fmt 输出为 %f %e %g
  • 复数型 包含的 go 的变量类型有:complex128 complex64,fmt 输出为 %v
  • 布尔型 包含的 go 的变量类型有:bool,fmt 输出为 %t
  • 指针型 包含的 go 的变量类型有:uintptr,fmt 输出为 %p
  • 引用型 包含的 go 的变量类型有:map slice channel,fmt 输出为 %v
  • 字节型 包含的 go 的变量类型有:byte,fmt 输出为 %c
  • 任意字符型 包含的 go 的变量类型有:rune,fmt 输出为 %c
  • 字符串型 包含的 go 的变量类型有:string,fmt 输出为 %d
  • 错误型 包含的 go 的变量类型有:error,fmt 输出为 %v

1.2 变量声明

第一种:如果声明后未显示初始化,数值型初始值为 0,字符型初始值为 空字符串,布尔型初始值为 false,引用类型、函数、指针、接口初始化为 nil

package main

import "fmt"

func main() {

    // 声明 a 是字符串型,但未赋值则为空
    var a string
    fmt.Printf("a = [%s]\n\r", a)

    // 没有初始化就为零值
    var b int
    fmt.Printf("b = [%d]\n\r", b)

    // bool 零值为 false
    var c bool
    fmt.Printf("c = [%t]\n\r", c)
}

以上实例执行结果为:

a = []
b = [0]
c = [false]

以下几种类型为 nil:

var a *int
var a []int
var a map[string] int
var a chan int
var a func(string) int
var a error // error 是接口

第二种:根据值自行判定变量类型。

package main

import "fmt"

func main() {
    //系统自动判定为 bool
    var d = true
    fmt.Printf("d = [%t]\n\r", d)
    //系统自动判定为 int
    var e = 3
    fmt.Printf("e = [%d]\n\r", e)
    //系统自动判定为 string
    var f = "hello"
    fmt.Printf("f = [%s]\n\r", f)
}

以上实例执行结果为:

d = [true]
e = [3]
f = [hello]

第三种,如果变量已经使用 var 声明过了,再使用 := 声明变量,就产生编译错误,例如:

var intVal int
intVal :=1 // 这时候会产生编译错误,因为 intVal 已经声明,不需要重新声明

直接使用下面的语句即可:

intVal := 1 // 此时不会产生编译错误,因为有声明新的变量,因为 := 是一个声明语句

intVal := 1 相等于:

var intVal int //先声明
intVal =1 //再赋值

可以将 var f string = "Runoob" 简写为 f := "Runoob":

package main
import "fmt"
func main() {
    f := "Runoob" // var f string = "Runoob"

    fmt.Println(f)
}

以上实例执行结果为:

Runoob

1.3 多变量声明

//类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3

var vname1, vname2, vname3 = v1, v2, v3 // 和 python 很像,不需要显示声明类型,自动推断

vname1, vname2, vname3 := v1, v2, v3 // 出现在 := 左侧的变量不应该是已经被声明过的,否则会导致编译错误

// 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)
package main

var x, y int
var (  // 这种因式分解关键字的写法一般用于声明全局变量
    a int
    b bool
)

var c, d int = 1, 2
var e, f = 123, "hello"

//这种不带声明格式的只能在函数体中出现
//g, h := 123, "hello"

func main(){
    g, h := 123, "hello"
    println(x, y, a, b, c, d, e, f, g, h)
}

以上实例执行结果为:

0 0 0 false 1 2 123 hello 123 hello

2. GO 语言常量

常量是一个简单值的标识符,在程序运行时,不会被修改的量。一般建议用大写来表示!
常量中的数据类型直可以是布尔型、数字型(整数型、浮点型和复数)和字符串型。
常量的定义格式:const identifier [type] = value

你可以胜率类型说明符 [type],因为比那一其可以根据变量的值来推断其类型。

  • 显式类型定义: const b string = "abc"
  • 隐式类型定义: const b = "abc"

多个相同的类型的声明可以简写为: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\n\r", area)
    println(a, b, c)
}

以上实例运行结果为:

面积为:50
1 false str
package main

import "fmt"

func main() {
    const (
        A = 0
        B = 1
        C = 2
        D //2 跟上一行的值相同
        E //2 跟上一行的值相同
        F //2 跟上一行的值相同
    )
    fmt.Println(A, B, C, D, E, F)
}

以上实例运行结果为:

0 1 2 2 2 2

iota
iota,特殊常量,可以认为是一个可以被编译器修改的常量。
iota 在 const 关键字出现时将被重置为 0(const 内部的第一行之前),const 中每新增一行常量声明将使 iota 计数一次(iota 可理解为 const 语句块中的行索引)。

iota 可以被用作枚举值:

const (
    a = iota
    b = iota
    c = iota
)

第一个 iota 等于0,每当 iota 在新的一行被使用时,它的值都会自动加 1;所以 a=0,b=1,c=2 可以简写为如下形式:

const (
    a = iota
    b
    c
)

iota 用法

import "fmt"

func main() {
    const (
        a = iota //0
        b        //1
        c        //2
        d = "ha" //独立值,iota += 1
        e        //"ha",iota += 1
        f = 100  //独立值,iota += 1
        g        //100,iota += 1
        h = iota //7.恢复计数
        i        //8
    )

    fmt.Println(a, b, c, d, e, f, g, h, i)
}

以上实例运行结果为:

0 1 2 ha ha 100 100 7 8

我们再做一个有趣的 iota 实验

package main

import (
    "fmt"
)

func main() {
    const (
        i = 1 << iota //i=1:左移 0 位,不变仍为  1
        j = 3 << iota //j=3:左移 1 位,变为二进制 110,即 6
        x             //x=3:左移 2 位,变为二进制 1100,即 12
        y             //y=3:左移 3 位,变为二进制11000.即 24
    )

    fmt.Println("i=", i)
    fmt.Println("j=", j)
    fmt.Println("x=", x)
    fmt.Println("y=", y)
}

*注:<<n==(2^n)**

3. GO 字面量

字面量即为没有出现变量名,直接出现的量。基础类型的字面量相当于是常量

fmt.Printf("%t\n", 04 == 4.00)      //用到了整型字面量和浮点型字面量
fmt.Printf("%v\n", .4i)             //虚数字面量 0.4i
fmt.Printf("%t\n", '\u4f17' == '众') //Unicode和rune字面量
fmt.Printf("Hello\nWorld\n!\n")     //字符串字面量

点赞

发表评论

电子邮件地址不会被公开。必填项已用 * 标注