【go语言入门教程】——2. 变量及类型

1. 变量

1.1 变量的声明方式

1.1.1 声明单个变量

1、只声明变量

语法格式：

var 变量名 变量类型

示例：

package main

import "fmt"

func main() {
	//声明变量
	var name string
	//赋值
	//name = "小明"
	fmt.Println("name：" + name)
}

2、声明变量并赋值进行初始化

语法格式：

var 变量名 变量类型 = 值

示例：

package main

import "fmt"

func main() {
	var name string = "小明"
	//var name = "小明"
	fmt.Println("name：" + name)
}

注意点：由于 Go 能够根据初始值自动推断变量类型，因此在有初始化的情况下，变量类型可以省略不写。

1.1.2 声明多个变量

1、声明同类型的多个变量

语法格式：

var 变量名1,变量名2 变量类型 = 值1,值2

示例：

package main

import "fmt"

func main() {
	var staff1, staff2 string = "小明", "小李"
	//var staff1, staff2 string
	//staff1 = "小明"
	//staff2 = "小李"
	fmt.Println("staff1：", staff1, "staff2：", staff2)
}

2、声明不同类型的多个变量

语法格式：

var(
	变量1 = 值1
	变量2 = 值2
)

示例

package main

import "fmt"

func main() {
	var (
		name   = "小明"
		age    = 23
		height = 175
	)
	//亲测效果同上  var name1,age,height = "小明", 23,175
	fmt.Println("name：", name, "age：", age, "height：", height)
}

1.1.3 简短声明

使用 := 操作符进行声明，使用要求是所有使用此方式声明的变量都要有初始值。

语法格式：

变量名 := 值

示例：

package main

import "fmt"

func main() {
	name, age, height := "小明", 23, 175
	fmt.Println("name：", name, "age：", age, "height：", height)
}

2. 基本类型

Go 语言支持的基本类型如下：

• 布尔类型：bool
• 数字类型：
  • int8, int16, int32, int64, int
  • uint8, uint16, uint32, uint64, uint
  • float32, float64
  • complex64, complex128
  • byte
  • rune
• 字符串类型：string

2.1 布尔类型

bool 类型的值为 true 或 false

示例：

package main

import "fmt"

func main() {
	a := true
	b := false
	fmt.Println("a：", a, "b:", b)
	c := a && b
	fmt.Println("c：", c)
	d := a || b
	fmt.Println("d：", d)
}

运行结果：

a： true b: false
c： false
d： true

2.2 数字类型

数字类型：

• int8, int16, int32, int64, int
• uint8, uint16, uint32, uint64, uint
• float32, float64
• complex64, complex128
• byte
• rune

数字类型比较多，又可以将它们分为有符号整型、无符号整型、浮点型、复数类型、其它数字类型

2.2.1 有符号整型

名称	含义	大小	范围
int8	表示8位有符号整型	8位	-128～127
int16	表示16位有符号整型	16位	-32768～32767
int32	表示32位有符号整型	32位	-2147483648～2147483647
int64	表示64位有符号整型	64位	-9223372036854775808～9223372036854775807
int	根据不同的底层平台（Underlying Platform），表示32或64位整型。除非对整型的大小有特定的需求，否则你通常应该使用 int 表示整型	在32位系统下是32位，而在64位系统下是64位	在32位系统下是 -2147483648～2147483647，而在64位系统是 -9223372036854775808～9223372036854775807

2.2.2 无符号整型

名称	含义	大小	范围
uint8	表示8位无符号整型	8位	0~255
uint16	表示16位无符号整型	16位	0~65535
uint32	表示32位无符号整型	32位	0~4294967295
uint64	表示64位无符号整型	64位	0~18446744073709551615
uint	根据不同的底层平台，表示 32 或 64 位无符号整型	在 32 位系统下是 32 位，而在 64 位系统下是 64 位	在 32 位系统下是 0～4294967295，而在 64 位系统是 0～18446744073709551615

2.2.3 浮点型

名称	含义
float32	32 位浮点数
float64	64 位浮点数

float64 是浮点数的默认类型，不做特别声明时，使用的是64位浮点数。

示例：

package main

import "fmt"

func main() {
	a, b := 3.95, 6.63
	fmt.Printf("type of a %T b %T\n", a, b)
	sum := a + b
	diff := a - b
	fmt.Println("sum", sum, "diff", diff)

	no1, no2 := 45, 33
	fmt.Println("sum", no1+no2, "diff", no1-no2)
}

运行结果：

type of a float64 b float64
sum 10.58 diff -2.6799999999999997
sum 78 diff 12

2.2.4 复数类型

名称	含义
complex64	实部和虚部都是 float32 类型的的复数
complex128	实部和虚部都是 float64 类型的的复数

内建函数 complex

内建函数 complex 用于创建一个包含实部和虚部的复数，它的定义如下：

func complex(r, i FloatType) ComplexType

参数分别代表实部和虚部，函数返回一个复数类型。实部和虚部要相同类型，也就是 float32 或 float64。如果实部和虚部都是 float32 类型，那么函数会返回一个 complex64 类型的复数。如果实部和虚部都是 float64 类型，那么函数会返回一个 complex128 类型的复数。

使用内建函数创建复数的示例：

package main

import "fmt"

func main() {
	c1 := complex(5, 7)
	fmt.Println("得到的复数:", c1)
}

输出结果：

得到的复数: (5+7i)

使用简短语法创建复数

语法如下：

c := 5 + 7i

使用示例：

package main

import "fmt"

func main() {
	c1 := complex(5, 7)
	c2 := 4 + 9i
	sum := c1 + c2
	fmt.Println("两个复数的和是:", sum)
	data := c1 * c2
	fmt.Println("两个复数的乘积是:", data)
}

运行结果：

两个复数的和是: (9+16i)
两个复数的乘积是: (-43+73i)

2.2.5 其它数字类型

名称	含义
byte	uint8 的别名
rune	int32 的别名

2.3 string类型

使用示例：

package main

import "fmt"

func main() {
	data := "学习"
	out := "go语言"
	result := data + out
	fmt.Println(result)
}

运行结果：

学习go语言

2.4 类型转换

示例：

package main

import "fmt"

func main() {
	i := 10
	//将int类型转换成浮点型
	var j float64 = float64(i)
	fmt.Println("j的值是：", j)
}

结果：

j的值是： 10