换个语言学一下 Golang （4）——变量与常量

一、变量定义

名称类型数据存储位置

//看一个例子

package main

import (

    "fmt"

)

func main() {

    var x string = "hello world"

    fmt.Println(x)

}

变量的定义首先使用var关键字，然后指定变量的名称x，再指定变量的类型string，在本例中，还对变量x进行了赋值，然后在命令行输出该变量。Go这种变量定义的方式和其他的语言有些不同，但是在使用的过程中，你会逐渐喜欢的。当然上面的变量定义方式还可以如下，即先定义变量，再赋值。

    var x string

    x = "hello world"

或者是直接赋值，让Go语言推断变量的类型。如下：

var x = "hello world"

快捷方式Go来推断语言的类型var

x := "hello world"

:=只能用在函数内部

package main

import (

    "fmt"

)

x:="hello world"

func main() {

    y :=

    fmt.Println(x)

    fmt.Println(y)

}

对于上面的变量定义x是无效的。会导致编译错误：

./test_var_quick.go:: non-declaration statement outside function body

不过我们对上面的例子做下修改，比如这样是可以的。也就是使用var关键字定义的时候，如果给出初始值，就不需要显式指定变量类型。

package main

import (

    "fmt"

)

var x = "hello world"

func main() {

    y :=

    fmt.Println(x)

    fmt.Println(y)

}

变量它们的值在程序运行过程中可以发生变化它们的变量类型是无法改变的Go语言是静态语言不支持变量类型发生变化强制类型转换只支持同类的变量类型

下面我们看几个例子：

package main

import (

    "fmt"

)

func main() {

    var x string = "hello world"

    fmt.Println(x)

    x = "i love go language"

    fmt.Println(x)

}

本例子演示变量的值在程序运行过程中发生变化，结果输出为

hello world

i love go language

我们尝试不同类型的变量之间转换

package main

import (

    "fmt"

)

func main() {

    var x string = "hello world"

    fmt.Println(x)

    x =

    fmt.Println(x)

}

在本例子中，如果试图将一个数值赋予字符串变量x，那么会发生错误：

./test_var.go:: cannot use  (type int) as type string in assignment

上面的意思就是无法将整型数值11当作字符串赋予给字符串变量。

但是同类的变量之间是可以强制转换的，如浮点型和整型之间的转换。

package main

import (

    "fmt"

)

func main() {

    var x float64 = 32.35

    fmt.Println(x)

    fmt.Println(int(x))

}

输出的结果为

32.35

二、变量命名

Go的变量名称必须以字母或下划线(_)开头，后面可以跟字母，数字，或者下划线(_)

三、变量作用域

全局变量局部变量

package main

import (

    "fmt"

)

var x string = "hello world"

func main() {

    fmt.Println(x)

}

这里变量x定义在main函数之外，但是main函数仍然可以访问x。全局变量的作用域是该包中所有的函数。

package main

import (

    "fmt"

)

var x string = "hello world"

func change() {

    x = "i love go"

}

func main() {

    fmt.Println(x)

    change()

    fmt.Println(x)

}

在上面的例子用，我们用了change函数改变了x的值。输出结果如下：

hello world

i love go

我们再看一下局部变量的例子。

package main

import (

    "fmt"

)

func change() {

    x := "i love go"

}

func main() {

    fmt.Println(x)

}

该例子中main函数试图访问change函数中定义的局部变量x，结果发生了下面的错误(未定义的变量x)：

./test_var.go:: undefined: x

三、常量

常量就是在程序运行过程中保持值不变的变量定义const必须有初始值

package main

import (

    "fmt"

)

func main() {

    const x string = "hello world"

    const y = "hello world"

    fmt.Println(x)

    fmt.Println(y)

}

:=

常量的值在运行过程中是无法改变的，强制改变常量的值是无效的。

我们看一个Go包math里面定义的常量Pi，用它来求圆的面积。

package main

import (

    "fmt"

    "math"

)

func main() {

    var radius float64 =

    var area = math.Pow(radius, ) * math.Pi

    fmt.Println(area)

}

四、多变量或常量定义

同时定义多个变量或者常量

package main

import (

    "fmt"

)

func main() {

    var (

        a int     =

        b float64 = 32.45

        c bool    = true

    )

    const (

        Pi   float64 = 3.14

        True bool    = true

    )

    fmt.Println(a, b, c)

    fmt.Println(Pi, True)

}

在定义常量组时，如果不提供初始值，则表示将使用上行的表达式。

package main

import "fmt"

const (

    a =

    b

    c

    d

)

func main() {

    fmt.Println(a)

    // b、c、d没有初始化，使用上一行(即a)的值

    fmt.Println(b)   // 输出1

    fmt.Println(c)   // 输出1

    fmt.Println(d)   // 输出1

}

五、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 用法

实例

package main

import "fmt"

func main() {

    const (

            a = iota   //

            b          //

            c          //

            d = "ha"   //独立值，iota += 1

            e          //"ha"   iota += 1

            f =     //iota +=1

            g          //100  iota +=1

            h = iota   //7,恢复计数

            i          //

    )

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

}

   ha ha    

package main

import "fmt"

const (

    i=<<iota

    j=<<iota

    k

    l

)

func main() {

    fmt.Println("i=",i)

    fmt.Println("j=",j)

    fmt.Println("k=",k)

    fmt.Println("l=",l)

}

i=

j=

k=

l=