变量命名

命名方法

var name type是定义单一变量的语法

package main

import "fmt"

func main(){
    var age int //variable declaration
    fmt.Println("My age is",age)
}

该语句中var age int声明了一个名为age的int类型变量. 但是并没有进行赋值, 这种情况下该类行变量被赋予0为他的初始值.

输出:

my age is 0

一个变量可以被分配任意该类型的值. 该程序中的age变量可以被赋予一个任意的integer value

package main

import "fmt"

func main(){
    var age int //variable declaration
    fmt.Println("my age is",age)
    age = 18 //assignment
    fmt.Println("my age is ",age)
    age = 19 // assignment
    fmt.Println("next year I will be", age, "years old boy")
}

output:

my age is 0
my age is 18
next year I will be 19 years old boy

声明变量并赋初值

声明变量同时可以赋予初始值

var name type = initial_value

package main

import "fmt"

func main(){
    var age int = 18 //variable declaration with initial value;(my age is 18)
    fmt.Println("my age is", age)
}

in the above program, age被声明并赋予初值18,如果你运行above program,你会得到following output:

my age is 18

类型推断 (type inference)

如果variable具有一个initial value, 那么go会自动根据initial value to infer the type of that variable.

所以, 如果你的变量具有initial value, 则可以省略便来嗯声明中的type.

使用var name = initial_value声明变量时,go会根据initial value自动推断变量类型.

in the following example, 我们声明变量age时把type省略掉, 但是赋予了age一个初始值, go会根据这个initial value推断得到变量的类型是int

package main

import "fmt"

func main(){
    var age = 100
    fmt.Println("my age is", age)
}

定义多个变量 in a single statement

多个变量可以一起声明

var name1, name2 type = initialvalue1, initialvalue2 单次声明多个变量

package main

import "fmt"

func main(){
    var width, height int = 1920, 1080 //declaring multiple variables
    fmt.Println(width, "x", height)
}

这里声明变量中的type也可以省略, 使用go语言的特性推断出变量类型

package main

import "fmt"

func main(){
    var width, height = 1920, 1080 //type is dropped
    fmt.Println(width, "x", height)
}

out put

1920 x 1080

当然我们也可以不赋初值, 只是定义两个默认初值的变量

package main

import "fmt"

func main(){
    var width, heiht int
    fmt.Println(width, height)
    width = 1920
    height = 1080
    fmt.Println(width, height)
}

the above program will print.

output:

0 0

1920 1080

某些情况下,我们在单个语句中声明属于不同类型的变量, 语法应该是:

var(
    name1 = initial value1
    name2 = initial value2
)

下述程序使用该语法声明不同类型的变量

package main

import "fmt"

func main(){
    var(
        name = "Gee"
        age = 18
        height int
    )
    fmt.Println("My name is", name, "age is",age, "and height is", height)
}

输出My name is Gee age is 18 and height is 0

简单的声明

Go 还提供了一种简洁的变量声明方式: name := initialvalue,使用:=代替var

package main

import "fmt"

func main(){
    name, age := "Gee", 18
    fmt.Println("my name is", name, "age is", age)
}

输出:my name is Gee age is 18

这样的声明需要把左侧所有的变量都进行赋值.否则会报错cannot assign n values to m variables.

package main

import "fmt"

func main(){
    name, age := "Gee" //error
    name, age := "Gee", 18 //correctness
    fmt.Println(name, age)
}

使用该声明方法时,左侧必须有至少一个变量是新声明的,参考以下程序:

package main

import "fmt"

func main(){
    a, b := 1, 2 //declare variables a ,b
    fmt.Println(a, b)
    b, c := 3, 4//b is already declared but c is new
    fmt.Println(b, c)
    b, c = 5, 6//assign new values to already declared variables b and c
    fmt.Println(b, c)
}

在上面的程序中, 第八行中的b已经被声明过了, 但是c是新声明的; 10 行中b, c都已经存在了, 所以不能再使用:=声明, 只能使用=进行赋值. 如果line No.10 使用:= 进行声明, 则会报错no new variables on left side of :=

输出:

1 2

3 4

5 6

赋值的时候也可以为变量分配运行计算的值. for example:

package main

import "fmt","math"

func main(){
    a, b := 199.9999, 200.0000
    c := math.Min(a,b)
    fmt.Println('minimum value is',c)
}

output:`minimum value is 199.9999

最后:

Go是强类型语言, 如果我们声明了一个变量,然后再赋值给他一个其他类型的值, 那么go会抛出异常:cannot use "naveen" (type string) as type int in assignment

如图所示:

strongly type

参考

[GOLANGBOT] https://golangbot.com/variables/