Golang笔记之基本数据类型

1、布尔类型

布尔类型用于表示真假，类型名为bool，只有两个值true和false，占用一个字节宽度，零值为false

    var flag bool = true
    flag1 := false
    fmt.Println(flag,flag1)

常用操作

逻辑运算： 与(&&) 只有左、右表达式结果都为true，运算结果为true

fmt.Println(flag&&true,flag1&&true) 
PS D:\goProject\day01> go run bool.go
true false

逻辑运算： 或(||) 只要左、右表达式有一个为true，运算结果为true

fmt.Println(flag||true,flag1||true,flag1||false)
PS D:\goProject\day01> go run bool.go
true true false

 逻辑运算： 非(!) 右表达式为true，运算结果为false；右表达式为false，运算结果为true

fmt.Println(!flag,!flag1) 
PS D:\goProject\day01> go run bool.go
false true

关系运算 等于(==) 和不等于(!=)

fmt.Println(flag == true, flag1 == true)
PS D:\goProject\day01> go run bool.go
true false

fmt.Println(flag != true, flag1 != true)
PS D:\goProject\day01> go run bool.go
false true

使用fmt.Printf进行格式化参数输出，占位符:%t

fmt.Printf("%t %t",flag,flag1) 
PS D:\goProject\day01> go run bool.go 
true false

2、数值类型

Go语言提供了5种有符号、5种无符号、1种指针、1种单字节、1种单个unicode 字符（unicode码点），共13种整数类型,零值均为0.

字面量

十进制表示法：以10为基数，采用0-9十个数字，逢10进位，例如：10

八进制表示法：以8为基数，采用0-7八个数字，逢8进位，使用0开头表示为八 进制表示，例如：010

十六进制表示法：以16为基数，采用0-9十个数字和A-F六个字母，逢16进位， 使用0X开头表示为十六进制 ，例如：0X10

    var (
        i1 int = 10   //十进制
        i2 int = 010  //八进制
        i3 int = 0x10  //16进制
        i4 int = 0b00010001 //二进制
        b1  byte = 65
                r1  rune = ';'
    )
    fmt.Println(i1,i2,i3,i4,b1,r1)
PS D:\goProject\day01> go run int.go
10 8 16 17 65 59

字面量-常用操作

算术运算符：+、-、 * 、/、%、++、--    //左右两边的操作数类型必须一致

    fmt.Println(i1+i2,i1-i2,i2*i2,i1/i3,i1%i2)
    i1++
    i2--
    fmt.Println(i1,i2)
PS D:\goProject\day01> go run int.go
18 2 64 0 2
11 7

注意：针对/除数不能为0，且结果依然为整数

关系运算符：>、>= 、<、<= 、 == 、!=  //结果为bool类型

fmt.Println(i1>i2,i1>=i2,i1<i2,i1<=i2,i1==i2,i1!=i2)
PS D:\goProject\day01> go run int.go
true true false false false true

位运算符：&、|、 ^ 、<<、>>、&^ 对于负整数在计算机中使用补码进行表示，对应正整数二进制表示取反+1，针对左、右移的右操作数必须为无符号整型

&：两个操作数位1，结果位1

|：只要1个操作数位1，结果位1

^(单目)：位1转换为0，位0转换为1  // 0b1111000 ==> 0b0000111

^(双目)：两个操作数相同为0，不同为1 //  0b1111000 ^ 0b1110000 ==> 0b0001000

>>：右移n位，补符号位 //0b1111000 右移3位0b0001111

<<：左移n位，补0  //0b1110000  左移3位 0b0000000

&>：位清除，右操作数为1变为0，右操作数位0保持不变  //0b1111000 &^ 0b1110000 ==> 0b1000

    var (
        i1 int8 = -0b1111000
        i2 int8 = -0b1110000
        u1 uint8 = 0b1111000
        u2 uint8 = 0b1110000
    )
    fmt.Printf("%b\n %b\n %b\n %b\n %b\n %b\n %b\n ",i1 & i2,i1 | i2, ^u1, u1 ^ u2, u1 >> 3, u2 << 3,u1 &^ u2)
PS D:\goProject\day01> go run int.go
 -10000000
 -1101000
 10000111
 1000
 1111
 10000000
 1000

赋值运算符：= 、+= 、-= 、 *= 、/= 、%= 、&= 、|= 、 ^= 、<<= 、>>=

    var n1 int
    n1 = 1
    fmt.Printf("n1: %d\n",n1)
    n1 += 10  //n1 = n1+10
    fmt.Printf("n1+=10 : %d\n",n1)
    n1 -=2    //n1 = n1-2
    fmt.Printf("n1-=2 : %d\n",n1)
PS D:\goProject\day01> go run int.go
n1: 1
n1+=10 : 11
n1-=2 : 9

类型转换： Go不会自动对数据类型转换，因此左、右操作数类型必须一致或某个字面量，可通过类型名(数据)的语法将数据转换为对应类型。需要注意值截断和值溢出问题

小范围转大范围是没问题的，大范围转小范围可能会被截断

    var i1 int8 = 125
    var i2 int64 = 200
    fmt.Println(int8(i2) + i1) //被截断。int8取值范围-128到127
    fmt.Println(int64(i1) + i2) //无问题
PS D:\goProject\day01> go run int.go
69
325

格式化输出

使用fmt.Printf进行格式化参数输出，占位符:

%b：二进制

%c：字符

%d：十进制

%+d表示对正整数带+符号

%nd表示最小占位n个宽度且右对齐

%-nd表示最小占位n个宽度且左对齐

%0nd表示最小占位n个宽度且右对齐，空字符使用0填充

%o：八进制，%#o带0的前缀

%x、%X：十六进制,%#x(%#X)带0x(0X)的前缀

%U: Unicode码点，%#U带字符的Unicode码点

%q：带单引号的字符

    fmt.Printf("%b, %c, %d, %o, %x, %#X, %U, %q\n",10,'a',10,10,10,10,'我','a')
    fmt.Printf("%+d, %+d\n",10,-10)
    fmt.Printf("%10d\n%-10d\n%010d\n",10,10,10)
PS D:\goProject\day01> go run int.go
1010, a, 10, 12, a, 0XA, U+6211, 'a'
+10, -10
        10
10
0000000010

3、浮点型

浮点数用于表示带小数的数字，Go提供float32和float64两种浮点类型

字面量

• 十进制表示法：3.1415926

• 科学记数法：1e5   //1000 => 1e3

    var f1 float64 = 3.2
    var f2 float64 = 1e-6

常用操作

算术运算符：+、-、 * 、/、++、-- 注意：针对/除数不能为0

关系运算符：>、>= 、<、<= 浮点型不能进行==或!=比较，可选择使用两个浮点数的差在一定区间内则认为相等

赋值运算符：= 、+= 、-= 、 *= 、/=

类型转换： Go不会对自动对数据类型转换，因此左、右操作数类型必须一致或某个字面量，可通过类型名(数据)的语法将数据转换为对应类型。需要注意值截断和值溢出问题

格式化输出

使用fmt.Printf进行格式化参数输出，占位符:

%f、%F：十进制表示法

 %n.mf表示最小占n个宽度并且保留m位小数

%e、%E：科学记数法表示

%g、%G：自动选择最紧凑的表示方法%e(%E)或%f(%F)

    fmt.Printf("%T,%f\n",f1,f1)
    fmt.Printf("%T,%e\n",f2,f2)
    fmt.Printf("%g,%g\n",f1,f2)
    fmt.Printf("%1.4f\n",f1)
PS D:\goProject\day01> go run float.go
float64,3.200000
float64,1.000000e-06
3.2,1e-06
3.2000

4、复数型

Go提供 complex64和 complex128两种复数类型，针对 complex64复数的实部和虚部均使用float32，针对 complex128复数的实部和虚部均使用 float64

字面量

十进制表示法：1 + 2i，, i*i = -1, 1为实部，2为虚部

常用函数

complex: 工厂函数，通过两个参数创建一个复数

real：用于获取复数的实部

imag: 用于获取复数的虚部

    var c1 complex128 = 1 + 2i
    fmt.Println(real(c1),imag(c1))
    var c2 complex64 = complex(3,4)
    fmt.Println(c2)
PS D:\goProject\day01> go run complex.go
1 2
(3+4i)

5、字符串类型

字面量

可解析字符串：通过双引号(")来创建，不能包含多行，支持特殊字符转义序列 

原生字符串：通过反引号(`)来创建，可包含多行，不支持特殊字符转义序列

    var s1 string = "11\t22"
    var s2 string = `11\t22`
    fmt.Println(s1,"\n",s2)
PS D:\goProject\day01> go run string.go
11      22
 11\t22

特殊字符

\\：反斜线

\'：单引号

\"：双引号

\a：响铃

\b：退格

\f：换页

\n：换行

\r：回车

\t：制表符

\v：垂直制表符

\ooo：3个8位数字给定的八进制码点的Unicode字符（不能超过\377）

\uhhhh：4个16位数字给定的十六进制码点的Unicode字符

\Uhhhhhhhh：8个32位数字给定的十六进制码点的Unicode字符

\xhh：2个8位数字给定的十六进制码点的Unicode字符

常用操作

字符串连接：+

    var s1 string = "11"
    var s2 string = `22`
    s3 := s1 + s2
    fmt.Println(s3)
PS D:\goProject\day01> go run string.go
1122

关系运算符：>、>= 、<、<= 、 == 、!=

赋值运算符：=、+=

索引：s[index]，针对只包含ascii字符的字符串，索引从0开始

切片：s[start:end] ，针对只包含ascii字符的字符串

 常用函数

len：获取字符串长度（针对只包含 ascii字符的字符串）

string: 将 byte或 rune数组转换为字符串

    var b1 byte = 'c'
    fmt.Printf("%T,%s,%d\n", string(b1),string(b1),len(string(b1)))
PS D:\goProject\day01> go run string.go
string,c,1

使用 fmt.Printf进行格式化参数输出，占位符:

%s

fmt.Printf("%s\n",s3)
PS D:\goProject\day01> go run string.go 
1122

5、枚举类型

常使用iota生成器用于初始化一系列相同规则的常量，批量声明常量的第一个常量使 用iota进行赋值，此时iota被重置为0，其他常量省略类型和赋值，在每初始化一个常 量则加1。

const (
    c1 int = iota
    c2
    c3
)
func main() {
    fmt.Println(c1,c2,c3)
}
PS D:\goProject\day01> go run enum.go  
0 1 2

来自于吴科老师《手撕go语言》 马哥go运维自动化四期

有疑问加站长微信联系（非本文作者）