目录

  • 1、什么是变量
  • 2、变量的声明
    • 2.1 声明单个变量
    • 2.2 声明变量并初始化
    • 2.3 类型推断
    • 2.4 声明多个变量并初始化
    • 2.5 简短声明
  • 3、数据类型
    • 3.1 bool
    • 3.2 数字类型
      • 3.2.1 有符号整形
      • 3.2.2 无符号整形
      • 3.2.3 浮点型
      • 3.2.4 复数类型
      • 3.2.5 byte和rune
    • 3.3 string
    • 3.4 类型转换
    • 3.5 格式说明符
  • 4、常量
    • 4.1 常量的值
    • 4.2 常量的类型
1、什么是变量

变量指定了某存储单元的名称，该存储单元会存储特定类型的值。在go中，有多种语法用于声明变量

2、变量的声明

2.1 声明单个变量

var name type
package main
import "fmt"
func main(){
var age int // 变量声明
fmt.Println("my age is",age)
}
// my age is 0
ageint
Goage
变量名 = 值

Go是强类型语言，因此不允许某一类型的变量赋值为其他类型，否则会报错

2.2 声明变量并初始化

声明变量的同时可以给定初始值

var age int = 18
var age int age = 18

2.3 类型推断

如果变量有初始化，那么Go能够自动推断具有初始值的变量的类型。因此初始化时，可以省略语法中的数据类型

var age = 18

2.4 声明多个变量并初始化

1、声明相同类型变量：

通过一条语句声明多个变量

var name1,name2 type = value1,value2

同样可以省略类型

var name1,name2 = value1,value2

同样，不初始化，那么必须声明类型，并且赋值该类型的零值

2、声明不同类型变量

语法：

var {
name1 = "tank"
age = 18
height int
}

2.5 简短声明

:=
name :=value

如：

package main
import "fmt"
func main(){
name,age := "tank",19
fmt.Print("my name is ",name," and my age is ",age)
}
// my name is tank and my age is 19

注意：

:=

2、变量也可以是在运行时进行赋值的，即变量的值，可以是一个表达式的执行结果

3、数据类型

3.1 bool

truefalse

3.2 数字类型

3.2.1 有符号整形

3.2.2 无符号整形

3.2.3 浮点型

float32：32位浮点数

float64：64位浮点数（默认类型）

3.2.4 复数类型

complex64：实部和虚部都是float32类型的复数

complex128：实部和虚部都是64位的复数类型

内建complex用于创建一个包含实部和虚部的复数

complex的定义：

func complex(r,i)

1、两个参数分别是实部和虚部，返回值是一个复数类型

2、实部和虚部，应该是相同类型

c := 6 + 7i

3.2.5 byte和rune

byte是uint8的别名

rune是int32的别名

3.3 string

字符串类型

在go中，字符串是字节的集合

可以简单理解为：很多字符组成的字符串

""
+

3.4 类型转换

Go中不允许不同类型之间的操作

float64int
type(value)
package main
import "fmt"
func main() {
a := 18
b := 180.5
c := a + int(b)
d := float64(a) +b
fmt.Print("c:",c)
fmt.Print(" d:",d)
}
//c:198 d:198.5

3.5 格式说明符

%T // 打印类型
%d // 打印字节大小 需要导入unsafe包，其中的Sizeof函数接收变量并返回它的字节大小
package main
import (
"fmt"
"unsafe"
)
func main() {
a := 18
b := "sb"
fmt.Println("value of a is ",a," and b is ", b)
fmt.Printf("type of a is %T,size of a is %d",a,unsafe.Sizeof(a))
fmt.Printf("\ntype of b is %T,size of b is %d",b,unsafe.Sizeof(b))
}
/*
value of a is 18 and b is sb
type of a is int,size of a is 8
type of b is string,size of b is 16
*/
4、常量

4.1 常量的值

5-89I love Go
// 变量被赋值为常量
var a int = 18
var name string = 'tank'
const
package main
func main(){
const a int = 18
a = 81 // 此时将会报错，因为a被定义为了常量，值是固定的，不能修改
}

3、Go是编译型语言，常量的值会在编译的时候确定，所以不能将函数的返回值赋值给常量

package main
import (
"fmt"
"math"
)
func main(){
fmt.Println("Hello,boys")
var a = math.Sqrt(4)
const b = math.Sqrt(4) // 将会报错
}

4.2 常量的类型

1、定义常量的两种方式：

const a = 9 //不声明数据类型，那么它可以关联的默认数据类型是所有的数字类型，在赋值时，才会确定
const b float32 = 10 //声明数据类型，那么这个常量就只能是该类型的常量
package main
import (
"fmt"
)
func main(){
const a = 9
const b float32 = 10
var c complex64 = a
//var d complex128 = b //报错，常量b类型是float32,不能赋值给类型为complex128的变量d
var e complex128 = c //报错，变量c的类型是complex64,不能赋值给类型为complex128的变量
fmt.Printf("a 的类型：%T",a)
fmt.Printf("\nb 的类型：%T",b)
fmt.Printf("\nc 的类型：%T",c)
//fmt.Printf("\nd 的类型：%T",d)
fmt.Printf("\ne 的类型：%T",e)
}

2、按数据类型分析常量

数字常量

1、不声明常量类型时，可以关联到所有的数字数据而类型

2、无类型常量的默认关联类型在语法中才能确定，但是不超过大类型，如数字不能关联到字符串

3、数字常量可以在表达式中进行自由混合和搭配，只有当他们被分配给变量或者需要类型的代码中才会需要类型

package main
import (
"fmt"
)
func main(){
const a = 18
var b int16 = a
var c float32 = a
var d complex64 = complex(a,6.5) // 数字常量6.5 在此语法中关联默认类型float32
var e complex128 = complex(float64(c),6) // 数字常量6 在此语法中关联默认类型float64
fmt.Println(a,b,c,d,e)
fmt.Printf("%T,%T,%T,%T,%T,%T",a,b,c,d,e,6.0) // 浮点数常量默认关联类型float64
}
/*
18 18 18 (18+6.5i) (18+6i)
int,int16,float32,complex64,complex128,float64
*/

字符串常量

1、双引号中的任何值都是Go中的字符串常量

stringMySring
stringMyString

布尔常量

truefalse

2、特点与字符串一样