变量
var
语句定义了一个变量的列表;跟函数的参数列表一样,类型在后面。
就像在这个例子中看到的一样,`var` 语句可以定义在包或函数级别。
package main
import "fmt"
var c, python, java bool
func main() {
var i int
fmt.Println(i, c, python, java)
}
输出结果:
零值
变量在定义时没有明确的初始化时会赋值为 零值。
零值是:
- 数值类型为 `0`,
- 布尔类型为 `false`,
- 字符串为 `""`(空字符串)。
package main
import "fmt"
func main() {
var i int
var f float64
var b bool
var s string
fmt.Printf("%v %v %v %q\n", i, f, b, s)
}
输出结果:
%v the value in a default format(对应值的默认格式)
when printing structs, the plus flag (%+v) adds field names(打印结构体时,用%+v的方式会添加字段名)
初始化变量
变量定义可以包含初始值,每个变量对应一个。
如果初始化是使用表达式,则可以省略类型;变量从初始值中获得类型。
package main
import "fmt"
var i, j int = 1, 2
func main() {
var c, python, java = true, false, "no!"
fmt.Println(i, j, c, python, java)
}
短声明变量
在函数中,`:=` 简洁赋值语句在明确类型的地方,可以用于替代 var
定义。
函数外的每个语句都必须以关键字开始(`var`、`func`、等等),`:=` 结构不能使用在函数外。
package main
import "fmt"
func main() {
var i, j int = 1, 2
k := 3
c, python, java := true, false, "no!"
fmt.Println(i, j, k, c, python, java)
}
基本类型
Go 的基本类型有:
bool
string
uint8 无符号8位整数 (0 to 255)
uint16 无符号16位整数 (0 to 65535)
uint32 无符号32位整数 (0 to 4294967295)
uint64 无符号64位整数 (0 to 18446744073709551615)
int8 有符号8位整数 (-128 to 127)
int16 有符号16位整数 (-32768 to 32767)
int32 有符号32位整数 (-2147483648 to 2147483647)
int64 有符号64位整数 (-9223372036854775808 to 9223372036854775807)
//预先声明的数字类型,长度由操作系统的位数决定
uint 32位或64位
int 同uint
uintptr 一个无符号整数,其大小足以存储指针值的范围,32位下为4字节,64位下为8字节
byte uint8 的别名,用于表示二进制数据的 bytes
rune int32 的别名,代表一个Unicode码
float32 所有IEEE-754 32位浮点数的集合。math.MaxFloat32表示float32能表示的最大数值,大约是 3.4e38。
最小值近似为1.4e-45。
float64 所有IEEE-754 64位浮点数的集合。math.MaxFloat64常量大约是 1.8e308。最小值近似为4.9e-324。
complex64 包含float32实部和虚部的复数
complex128 包含float64实部和虚部的复数
为避免可移植性问题,所有数字类型都是特定的类型,除了byte是unit8的别名,rune是int32的别名外,每个类型都是不同的。因此,在表达式或赋值中混合使用不同的数字类型时,需要进行显示转换。例如,即使int32和int在特定体系结构上可能具有相同的大小,也依然是不同的类型。
下面的例子演示了将不同类型的变量的定义,像导入语句一样,“打包”在一个语法块中。
package main
import (
"fmt"
"math/cmplx"
)
var (
ToBe bool = false
MaxInt uint64 = 1<<64 - 1
z complex128 = cmplx.Sqrt(-5 + 12i)
)
func main() {
const f = "%T(%v)\n"
fmt.Printf(f, ToBe, ToBe)
fmt.Printf(f, MaxInt, MaxInt)
fmt.Printf(f, z, z)
}
输出结果:
cmplx包提供了复数的常用常数和常用函数。
%T a Go-syntax representation of the type of the value(对应值的Go语法表示形式的值类型)
类型转换
表达式 T(v)
将值 v
转换为类型 `T`。
一些关于数值的转换:
var i int = 42
var f float64 = float64(i)
var u uint = uint(f)
或者,更加简单的形式:
i := 42
f := float64(i)
u := uint(f)
与 C 不同的是 Go 在对不同类型之间的项赋值时,总是需要显式转换。
package main
import (
"fmt"
"math"
)
func main() {
var x, y int = 3, 4
var f float64 = math.Sqrt(float64(x*x + y*y))
var z int = int(f)
fmt.Println(x, y, z)
}
上面例子中,如果不进行显示转换的话是会出现编译错误的。
类型推导
在定义一个变量但不指定其类型时(使用没有类型的 var
或 :=
语句), 变量的类型由右值推导得出。
当右值定义了类型时,新变量的类型与其相同:
var i int
j := i // j 也是一个 int
但是当右边包含了未指名类型的数字常量时,新的变量就可能是 int 、 float64
或 `complex128`。 这取决于常量的精度:
i := 42 // int
f := 3.142 // float64
g := 0.867 + 0.5i // complex128
我发现Go的类型推导也不是万能的,例如,上文说到Go的int类型的大小在64位操作系统中的范围是(-9223372036854775808 , 9223372036854775807),看如下代码:
package main
import "fmt"
func main() {
var v = 1<<64 -1
fmt.Printf("%T(%v)\n", v,v)
}
运行后:
溢出了,类型推导认为 18446744073709551615 是一个int的类型,但是编译时又发现这个数超出了int类型的范围。然而,我却可以说这个数是一个uint64类型的数,因为咱刚才才用过(基本类型内容中)。
常量
常量的定义与变量类似,只不过使用 const
关键字。
常量可以是字符、字符串、布尔或数字类型的值。
常量不能使用 :=
语法定义。
package main
import "fmt"
const Pi = 3.14
func main() {
const World = "世界"
fmt.Println("Hello", World)
fmt.Println("Happy", Pi, "Day")
const Truth = true
fmt.Println("Go rules?", Truth)
}
输出结果:
数值常量
数值常量是高精度的 _值_。
一个未指定类型的常量由上下文来决定其类型。
package main
import "fmt"
const (
Big = 1 << 100
Small = Big >> 99
)
func needInt(x int) int { return x*10 + 1 }
func needFloat(x float64) float64 {
return x * 0.1
}
func main() {
//fmt.Println(Big)
fmt.Println(needInt(Small))
//fmt.Println(needInt(Big))
fmt.Println(needFloat(Small))
fmt.Println(needFloat(Big))
fmt.Println(float64(Big))
}
输出结果:
但是 ,数值常量也不能是随意大的值。
当移位运算 1<<512 时,会报错:
当这个数达到8.5e183左右,会出现内部编译器错误:
以上可能是我闲的。。。