Go 编程基础 类型与变量 03

Go基本类型

布尔型:bool

  • 长度:1字节
  • 取值范围: true,false
  • 注意事项: 不可以用数字代替true或false

整型: int/uint(uint代表无符号)

  • 根据运行平台可能是32或64位

8位整型: int8/uint8

  • 长度:1字节
  • 取值范围: -128~127/0~255

字节型: byte(uint8别名)

16位整型:int16/uint16

  • 长度:2字节
  • 取值范围: -32768 ~ 32767/0~65535

32位整型:int32(rune)/uint32

  • 长度:8字节
  • 取值范围: -2^32/2 ~ 2^32/2-1 / 0~2^32-1

64位整型:int64/uint64

  • 长度:8字节
  • 取值范围: -2^64/2 ~ 2^64/2-1 / 0~2^64-1

浮点型: float32/float64

  • 长度: 4/8 字节
  • 小数位: 精确到 7/15 小数位

复数: complex64/complex128

  • 长度 8/16 字节

足够保存指针的32位或者64位整数型: uintptr

uintptr是一个无符号的整数,和整数型一样,不过uintptr还要多一部分指针的部分,同样会根据平台来判断是32位还是64位

其他值类型

  • array struct string

引用类型

  • slice map chan

接口类型: interface

函数类型: func

在go语言中函数是可以赋值给变量的,所以函数也算是一种类型

类型零值

零值并不等于空值,而是当变量呗声明为某种类型后的默认值,通常情况下值类型的默认值是

  • 整型 => 0
  • bool => false
  • string => 空字符串
var (
    myInt int
    myBool bool
    myString string
)
func main() {
    fmt.Println(myInt)
    fmt.Println(myBool)
    fmt.Println(myString)
}
0
false

因为这里是空字符串,所以显示不出来

//这里不指定数组的容量
var a []bool
//指定数组容量,指定为bool型
var b [1]bool
//指定数组容量,指定为int32型
var c [1]int32
//指定数组容量,指定为byte型,byte其实就是uint8的别名
var d [1]byte
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
[]
[false]
[0]
[0]

判断整型是否超出范围

用math包的Max/Min打头的函数可以打印出最大/最小值

import (
    "fmt"
    "math"
)

fmt.Println(math.MaxInt64)

类型别名

type (
    ByteSize int64
    中文 string
)

var name 中文
name = "我是中文啊!!!"
var MyBite ByteSize
MyBite = 12312
fmt.Println(name)
fmt.Println(MyBite)

这里我们看到用ByteSize来命名int64,因为在go中没有一个类型表示计算机容量(其实也是int64),但是你这样使用别名,代码可读性会很高,另外,还可以用中文作为别名(支持utf8的特性),但是不建议使用

我是中文啊!!!
12312

单个变量的声明与赋值

  • 变量的声明格式: var <变量名称> <变量类型>
  • 变量的赋值格式: <变量名称> = <表达式>
  • 变量的同时赋值: var <变量名称> [变量类型] = <表达式>

类型推断

如果你赋值的时候不声明变量类型,那么go会自动给你判断并声明

// 类型推断,这里我赋值1,那么go会声明我的变量c是int型
var c = 1
// 那么我再这里重新赋值为浮点型,那么就是错误的
c = 1.1
fmt.Println(c)
# command-line-arguments
./main.go:53:6: constant 1.1 truncated to integer

省略var关键字赋值(变量声明与赋值的最简写法)

c := 1

这样变量的类型就只能靠go自己去推断了,这样的写法是不能声明变量类型的

多种变量赋值声明方式的使用场景

声明和赋值两步走

var a int
a = 123

当你这个变量还没有要用,但是在后面,比如一些分支结构当中,可能会用到它,那么你就不能再结构中声明,可能在结构退出以后,你还要进行一些其他的运算,那么这个时候,你就需要提前声明变量,然后才可以在后面的整个过程中使用,那么,这样你就可以以后再一些分支结构中进行一些赋值

变量声明的同时赋值

var b int = 123

一般用于全局变量,因为全局是不能使用 := 这种形式的

声明变量是否指定类型的区别

最简写法

c := 1

如果你想让系统自动推断类型,同时又不想写var 关键字,就可以用这种

多个变量的声明与赋值

  • 全局变量的声明可使用var()的方式进行简写
  • 全局变量的声明不可以省略var,但可以使用并行方式
  • 所有变量都可以使用类型推断
  • 局部变量不可以使用var()的方式简写,只能使用并行方式

声明多个全局变量

var (
    //使用常规方式
    aaa = "hello"
    //使用并行方式,及类型推断
    bbb,ccc = 1,2
    //这种 := 是不行的,因为这种形式就是省略的var关键字,这样相当于你写了两个var关键字
    //ddd := 3
)

方法体内声明赋值多个变量

//多个变量的声明
var a,b,c,d int
//多个变量的赋值
a,b,c,d = 1,2,3,4

//多个变量声明的同时赋值
var e,f,g,h int = 1,2,3,4

//省略变量类型,由系统推断
var e,f,g,h = 1,2,3,4

//多个变量声明赋值的最简写法
e,f,g,h := 1,2,3,4

赋值的空白符号

//赋值的空白符号,_符号相当于忽略了2的赋值
a,_,c,d := 1,2,3,4

fmt.Println(a)
fmt.Println(c)
fmt.Println(d)
1
3
4

但是这个用法真正的是使用在函数返回值的时候,并不用在赋值,这里只是作为一个举例

变量的类型转换

  • Go中不存在隐式转换,所有类型转换必须显式声明
  • 转换只能发生在两种相互兼容的类型之间
  • 类型转换格式: <ValueA> [:] = <TypeOfValueA>(<ValueB>)

<ValueA>

新的值,如果在转换之前,已经对 ValueA 声明了,就不需要 : 既 <ValueA> = <TypeOfValueA>(<ValueB>)

[:]

如果赋值的变量声明了,就不需要写 : ,否则要写 :

<TypeOfValueA>(<ValueB>)

  • TypeOfValueA 赋值的变量类型
  • ValueB 被转换的变量

兼容的转换

//在相互兼容的两种类型之间转换,最多就是精度丢失了
var a float32 = 1.1
b := int32(a)
fmt.Println(a)
fmt.Println(b)
1.1
1

不兼容的转换

//以下表达式无法通过编译,bool型就无法和int型转换了
var c bool = true
d := int(c)
fmt.Println(c)
fmt.Println(d)
# command-line-arguments
./main.go:43:10: cannot convert c (type bool) to type int

作业

看看会输出什么,为什么?

var a int = 65
b := string(a)
fmt.Println(b)

我们会直观的以为是一个字符串的"65",但是却是A

string()表示将数据转换成文本格式,因为计算机中存储的任何东西本质上都是数字,因此此函数自然地认为我们需要的是用数字65(十进制的65) 表示文本Aascii

那我们想转换为一个字符串的65呢

import (
    "fmt"
    "strconv"
)

var a int = 65
//Itoa 表示整型转为字符串
b := strconv.Itoa(a)
fmt.Println(b)
// 字符串换行为整型
c,_ := strconv.Atoi(b)
fmt.Println(c)