Go语言基础之基本数据类型

Go语言中有丰富的数据类型，除了基本的整型、浮点型、布尔型、字符串外，还有数组、切片、结构体、函数、map、通道（channel）等。Go 语言的基本类型和其他语言大同小异。

基本数据类型 整型

整型分为以下两个大类： 按长度分为：int8、int16、int32、int64 对应的无符号整型：uint8、uint16、uint32、uint64

uint8byteint16shortint64long
类型 描述
uint8 无符号 8位整型 (0 到 255) 对应byte类型
uint16 无符号 16位整型 (0 到 65535)
uint32 无符号 32位整型 (0 到 4294967295)
uint64 无符号 64位整型 (0 到 18446744073709551615)
int8 有符号 8位整型 (-128 到 127)
int16 有符号 16位整型 (-32768 到 32767)
int32 有符号 32位整型 (-2147483648 到 2147483647) 对应rune类型
int64 有符号 64位整型 (-9223372036854775808 到 9223372036854775807)
特殊整型 
uint32uint64int32int64
intuintintuint
len()intintuint
数字字面量语法（Number literals syntax）

Go1.13版本之后引入了数字字面量语法，这样便于开发者以二进制、八进制或十六进制浮点数的格式定义数字，例如：

v := 0b00101101， 代表二进制的 101101，相当于十进制的 45。 v := 0o377，代表八进制的 377，相当于十进制的 255。 v := 0x1p-2，代表十六进制的 1 除以 2²，也就是 0.25。 而且还允许我们用 _ 来分隔数字，比如说：

v := 123_456 等于 123456。

我们可以借助fmt函数来将一个整数以不同进制形式展示。

package main
 
import "fmt"
 
func main(){
    // 十进制
    var a int = 10
    fmt.Printf("%d \n", a)  // 10
    fmt.Printf("%b \n", a)  // 1010  占位符%b表示二进制
 
    // 八进制  以0开头
    var b int = 077
    fmt.Printf("%o \n", b)  // 77
 
    // 十六进制  以0x开头
    var c int = 0xff
    fmt.Printf("%x \n", c)  // ff
    fmt.Printf("%X \n", c)  // FF
}

对于两个不同类型的整数型不能直接比较，但各种类型的整型变量都可以直接与字面常量进行比较，如下

var i int32
var j int64

i, j = 1, 2

if i == j {　　//编译错误
   fmt.Println("i and j are equal.")       
}

if i == 1 || j == 2 {　　//编译通过
   fmt.Println("i and j are equal.")    
}
浮点型 
float32float64IEEE 754float323.4e38math.MaxFloat32float641.8e308math.MaxFloat64
fmt%f
package main
import (
        "fmt"
        "math"
)
func main() {
        fmt.Printf("%f\n", math.Pi)
        fmt.Printf("%.2f\n", math.Pi) // 保留2位小数（四舍五入），不够在左侧填充空格
}

浮点数比较 因为浮点数不是一种精确的表达方式，所以像整型那样直接用==来判断两个浮点数是否相等 是不可行的，这可能会导致不稳定的结果，例如

package main

import (
    "fmt"
)
func main() {
    x := 0.1
    y := 0.2

    res := x + y
    fmt.Println(res)        // 0.30000000000000004
    fmt.Println(res == 0.3) // false

}

浮点数里有个叫非数的东西

fmt.Println(math.NaN()) // NaN

var z float32
fmt.Println(z) // 0
fmt.Println(z/z) // NaN

x:=z/z
fmt.Println(x < x) // false
fmt.Println(x > x) // false 
fmt.Println(x == x) // false
fmt.Println(x != x) // true
复数

complex64和complex128

var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1)
fmt.Println(c2)

复数有实部和虚部，complex64的实部和虚部为32位，complex128的实部和虚部为64位。

布尔值 
booltrue（真）false（假）

注意：

false
字符串 
UTF-8双引号(")
s1 := "hello"
s2 := "你好"

s1:='汪' // 字符类型
fmt.Println(s1)
fmt.Printf("%T",s1) // int32,即rune类型
字符串转义符

Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等，如下表所示。

\r\n\t\'\"\\

举个例子，我们要打印一个Windows平台下的一个文件路径：

package main
import (
    "fmt"
)
func main() {
    fmt.Println("str := \"c:\\Code\\lesson1\\go.exe\"")
}
多行字符串 
反引号
s1 := `
第一行
第二行
第三行
`
fmt.Println(s1)

反引号间换行将被作为字符串中的换行，但是所有的转义字符均无效，文本将会原样输出。

字符串的常用操作
方法 介绍
len(str) 求长度
+或fmt.Sprintf 拼接字符串
strings.Split 分割
strings.contains 判断是否包含
strings.HasPrefix,strings.HasSuffix 前缀/后缀判断
strings.Index(),strings.LastIndex() 子串出现的位置
strings.Join(a[]string, sep string) join操作 
len(str) 求长度（字节个数，文本字符采用的是utf-8编码）
例如：len("a你") 结果为4

// 字符串拼接
+或fmt.Sprintf拼接字符串
例如：d := fmt.Sprintf("%v - %v - %v", "2020", "05", 20) 结果为：2020 - 05 - 20


// strings
strings.HasPrefix(s string,preffix string) bool:
判断字符串s是否以prefix开头

stirngs.HasSuffix(s string,suffix string) bool:
判断字符串s是否以suffix结尾

strings.Index(s string,str string) int:
判断str在s中首次出现的位置，如果没有出现，则返回-1


strings.LastIndex(s string,str string) int:
判断str在s中最后出现的位置，如果没有出现，则返回-1

strings.Replace(str string,old string,new string,n int):
字符串替换

strings.Count(str string,count int)string:
字符串计数

strings.Repeat(str string,count int) string:
重复count次str

strings.ToLower(str string)
转换为小写

strings.ToUpper(str string)string:
转换为大写


strings.TrimSpace(str string):
去掉字符串首位空白字符

strings.Trim(str string,cut string):
去掉字符串首尾cut字符

strings.TrimLeft(str string,cut string):
去掉字符串首部cut字符

strings.TrimRight(str string,cunt string):
去掉字符串尾部cut字符

strings.Field(str string):
返回str空格分隔的所有子串的slice

string.Split(str string,split string):
返回str split分割的所有子串的slice
例如：strings.Split("randy:18:male",":")结果为切片：[randy 18 male]

strings.Join(s1 []string,sep string):
用sep把s1中的所有元素连接起来
例如：strings.Join([]string{"randy","18","male"},":")结果为randy:18:male

strings.contains
判断是否包含
例如：strings.Contains("abcdef","abc")结果为true

// strconv
scronv.Itoa(i int):把一个整数转换成字符串

scronv.Atio(str string)(int,errror):
把一个字符串转换成整数
byte和rune类型 
字符
var a := '中'
var b := 'x'

Go 语言的字符有以下两种：

uint8ASCII码runeUTF-8字符
runeruneint32

Go 使用了特殊的 rune 类型来处理 Unicode，让基于 Unicode 的文本处理更为方便，也可以使用 byte 型进行默认字符串处理，性能和扩展性都有照顾。

// 遍历字符串
func traversalString() {
    s := "hello沙河"
    for i := 0; i < len(s); i++ { //byte
        fmt.Printf("%v(%c) ", s[i], s[i])
    }
    fmt.Println()
    for _, r := range s { //rune
        fmt.Printf("%v(%c) ", r, r)
        fmt.Printf("%c",  r) // 字符使用`%c`参数打印，或者是用`%q`参数打印带单引号的字符：
    }
    fmt.Println()
}

输出：

104(h) 101(e) 108(l) 108(l) 111(o) 230(æ) 178(²) 153() 230(æ) 178(²) 179(³) 
104(h) 101(e) 108(l) 108(l) 111(o) 27801(沙) 27827(河)

因为UTF8编码下一个中文汉字由3~4个字节组成，所以我们不能简单的按照字节去遍历一个包含中文的字符串，否则就会出现上面输出中第一行的结果。

[]byte
动 词 功 能
%v 按值的本来值输出
%+v 在 %v 基础上，对结构体字段名和值进行展开
%#v 输出 Go 语言语法格式的值
%T 输出 Go 语言语法格式的类型和值
%% 输出 % 本体
%b 整型以二进制方式显示
%o 整型以八进制方式显示
%d 整型以十进制方式显示
%x 整型以十六进制方式显示
%X 整型以十六进制、字母大写方式显示
%U Unicode 字符
%f 浮点数
%p 指针，十六进制方式显示
修改字符串 
[]rune[]bytestring
func changeString() {
    s1 := "big"
    // 强制类型转换
    byteS1 := []byte(s1)
    byteS1[0] = 'p'
    fmt.Println(string(byteS1))

    s2 := "白萝卜"
    runeS2 := []rune(s2)
    runeS2[0] = '红'
    fmt.Println(string(runeS2))
}

pig
红萝卜

类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间支持相互转换的时候使用。

强制类型转换的基本语法如下：

T(表达式)

其中，T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等.

比如计算直角三角形的斜边长时使用math包的Sqrt()函数，该函数接收的是float64类型的参数，而变量a和b都是int类型的，这个时候就需要将a和b强制类型转换为float64类型。

func sqrtDemo() {
    var a, b = 3, 4
    var c int
    // math.Sqrt()接收的参数是float64类型，需要强制转换
    c = int(math.Sqrt(float64(a*a + b*b)))
    fmt.Println(c)
}

总结

  1. 整型 int 默认值为0
  2. 浮点型 float
  3. 字符类型:字节 byte：-uint8的别名，rune-int32的别名,通过类型转换修改字符串
  4. 复数complex64
  5. 字符串 string 默认值为空字符串
  6. 布尔类型bool默认值为false
  7. 类型转换T(表达式)