[TOC]
# Go语言基础之基本数据类型
Go语言中有丰富的数据类型,除了基本的整型、浮点型、布尔型、字符串外,还有数组、切片、结构体、函数、map、通道(channel)等。
# 基本数据类型
## 类型自定义
~~~
type MyInt int //类型定义 新的类型,
type MySting = string //类型别名 相当于string的别名,可以把string类型的值附上去
~~~
## 整型(两个大类)
对应的无符号整型:uint8、uint16、uint32
按长度分为:int8、int16、int32、int64
| 类型 | 描述 |
| --- | --- |
| uint8 | 无符号 8位整型 (0 到 255) |
| uint16 | 无符号 16位整型 (0 到 65535) |
| uint32 | 无符号 32位整型 (0 到 4294967295) |
| uint64 | 无符号 64位整型 (0 到 18446744073709551615) |
| int8 | 有符号 8位整型 (-128 到 127) |
| int16 | 有符号 16位整型 (-32768 到 32767) |
| int32 | 有符号 32位整型 (-2147483648 到 2147483647) |
| int64 | 有符号 64位整型 (-9223372036854775808 到 9223372036854775807) |
### 特殊整型
| 类型 | 描述 |
| --- | --- |
| uint | 32位操作系统上就是`uint32`,64位操作系统上就是`uint64` |
| int | 32位操作系统上就是`int32`,64位操作系统上就是`int64` |
| uintptr | 无符号整型,用于存放一个指针 |
`注意`:在使用`int`和`uint`类型时,不能假定它是32位或64位的整型,而是考虑`int`和`uint`可能在不同平台上的差异。
`注意事项`:获取对象的长度的内建`len()`函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中,切片或 map 的元素数量等都可以用`int`来表示。在涉及到二进制传输、读写文件的结构描述时,为了保持文件的结构不会受到不同编译目标平台字节长度的影响,不要使用`int`和`uint`。
## 浮点型
| 类型 | 描述 |
| --- | --- |
| float32 | IEEE-754 32位浮点型数 |
| float64 | IEEE-754 64位浮点型数 |
`*注:IEEE-754是一种数据格式标准`
## 复数
| 类型 | 描述 |
| --- | --- |
| complex64| 32 位实数和虚数 |
| complex128 | 64 位实数和虚数 |
~~~
var c1 complex64
c1 = 1 + 2i
var c2 complex128
c2 = 2 + 3i
fmt.Println(c1) //(1+2i)
fmt.Println(c2) //(2+3i)
// 创建一个复数
complexNumber := 3 + 4i
// 获取复数的实部和虚部
realPart := real(complexNumber)
imaginaryPart := imag(complexNumber)
fmt.Printf("实部: %v\n", realPart)
fmt.Printf("虚部: %v\n", imaginaryPart)
~~~
## 布尔值
以`bool`类型进行声明布尔型数据,布尔型数据只有`true(真)`和`false(假)`两个值。
**注意:**
1. 布尔类型变量的默认值为`false`。
2. Go 语言中不允许将整型强制转换为布尔型.
3. 布尔型无法参与数值运算,也无法与其他类型进行转换。
## 字符串
字符串的值为`双引号(")`中的内容
Go 语言的字符串常见转义符包含回车、换行、单双引号、制表符等,如下表所示。
| 转义符 | 含义 |
| --- | --- |
| `\r` | 回车符(返回行首) |
| `\n` | 换行符(直接跳到下一行的同列位置) |
| `\t` | 制表符 |
| `\'` | 单引号 |
| `\"` | 双引号 |
| `\\` | 反斜杠 |
### 多行字符串
Go语言中要定义一个多行字符串时,就必须使用`反引号`字符:
~~~
s := `aaaa
bbb
ccc
ddd
\n
eeee
`
fmt.Println(s)
output:// aaaa
// bbb
// ccc
// ddd
// \n
// eeee
~~~
反引号间换行将被作为字符串中的换行,但是所有的转义字符均无效,文本将会原样输出。
### 字符串的常用操作
| 方法 | 介绍 |
| --- | --- |
| len(str) | 求长度 |
| +或fmt.Sprintf | 拼接字符串 |
| strings.Split | 分割 |
| strings.contains | 判断是否包含 |
| strings.HasPrefix,strings.HasSuffix | 前缀/后缀判断 |
| strings.Index(),strings.LastIndex() | 子串出现的位置 |
| strings.Join(a[]string, sep string) | join操作 |
## byte和rune类型
组成每个字符串的元素叫做“字符”,可以通过遍历或者单个获取字符串元素获得字符。 字符用单引号(’)包裹起来
~~~
var a = '小'
var b = 'x'
~~~
Go 语言的字符有以下两种:
1. `uint8`类型,或者叫 `byte` 型,代表了`ASCII码`的一个字符。
2. `rune`类型,代表一个`UTF-8字符`。
当需要处理中文、日文或者其他复合字符时,则需要用到`rune`类型。`rune`类型实际是一个`int32`
### byte和rune区别
* rune是用来区分字符值和整数值的
* rune 等同于int32,即4个字节长度,常用来处理unicode或utf-8字符。
* byte 等同于int8,即一个字节长度,常用来处理ascii字符
* 中文字符在unicode下占2个字节,在utf-8编码下占3个字节,而golang默认编码正好是utf-8。
* ASCII编码是1个字节,而UTF-8是可变长的编码
* 当要表示中文等非ASCll编码的字符时,需要使用UTF-8编码来保证不会乱码。
* UTF8编码下一个中文汉字由3~4个字节组成,而字符串是由byte字节组成,所以长度也是byte字符长度,这样遍历时遇到中文就乱码了
* 所谓对字符串的修改其实不是对字符串本身的修改,而是复制字符串,同时修改值,即重新分配来内存。
* 在go中修改字符串,需要先将字符串转化成数组,[]byte 或 []rune,然后再转换成 string型。
### 修改字符串
要修改字符串,需要先将其转换成`[]rune`或`[]byte`,完成后再转换为`string`。无论哪种转换,都会重新分配内存,并复制字节数组。
~~~go
func changeString() {
s1 := "小叮当"
// 强制类型转换
byteS1 := []byte(s1)
byteS1[0] = '老'
fmt.Println(string(byteS1))
//报错:constant 32769 overflows byte
s2 := "老叮当"
runeS2 := []rune(s2)
runeS2[0] = '小'
fmt.Println(string(runeS2))// 小叮当
}
~~~
## 类型转换
强制类型转换的基本语法如下:
~~~
T(表达式)
~~~
其中,T表示要转换的类型
~~~
var a int16 = 1
fmt.Printf("%T\n", a) //int16
fmt.Printf("%T\n", int32(a)) //int32
~~~
## 字符串
### 字符串拼接:
1、“+”
2、fmt.Sprintf 性能比较低
3、string 库的builder 追求性能
~~~
var builder strings.Builder
name := "叫我小叮当啊"
builder.WriteString("姓名:")
builder.WriteString(name)
re := builder.String()
fmt.Println(re) //姓名:叫我小叮当啊
~~~
### 字符串的常用函数
~~~
//包含
name := "go,haha"
fmt.Println(strings.Contains(name, "go")) //true
//出现次数
fmt.Println(strings.Count(name, "ha")) //2
//分割字符串
fmt.Println(strings.Split(name, ",")) //[go haha]
fmt.Printf("%T", strings.Split(name, ",")) //[]string
//包含前缀
fmt.Println(strings.HasPrefix(name, "go")) //true
//包含后缀
fmt.Println(strings.HasSuffix(name, "ha")) //true
//查询子串出现的位置
fmt.Println(strings.Index(name, "ha")) //3
//替换字符串 -1:全部替换,1替换一次
fmt.Println(strings.Replace(name, "go", "php", -1)) //php,haha
//大写
fmt.Println(strings.ToUpper("go")) //GO
//小写
fmt.Println(strings.ToLower("GO")) //go
//去掉左右两边的指定字符
fmt.Println(strings.Trim("?hhaha ha1 ", "?")) //hhaha ha1
//出现任意的字符
fmt.Println(strings.Trim("?#hhaha ha1 ", "#?")) //hhaha ha1
~~~
- Go准备工作
- 依赖管理
- Go基础
- 1、变量和常量
- 2、基本数据类型
- 3、运算符
- 4、流程控制
- 5、数组
- 数组声明和初始化
- 遍历
- 数组是值类型
- 6、切片
- 定义
- slice其他内容
- 7、map
- 8、函数
- 函数基础
- 函数进阶
- 9、指针
- 10、结构体
- 类型别名和自定义类型
- 结构体
- 11、接口
- 12、反射
- 13、并发
- 14、网络编程
- 15、单元测试
- Go常用库/包
- Context
- time
- strings/strconv
- file
- http
- Go常用第三方包
- Go优化
- Go问题排查
- Go框架
- 基础知识点的思考
- 面试题
- 八股文
- 操作系统
- 整理一份资料
- interface
- array
- slice
- map
- MUTEX
- RWMUTEX
- Channel
- waitGroup
- context
- reflect
- gc
- GMP和CSP
- Select
- Docker
- 基本命令
- dockerfile
- docker-compose
- rpc和grpc
- consul和etcd
- ETCD
- consul
- gin
- 一些小点
- 树
- K8s
- ES
- pprof
- mycat
- nginx
- 整理后的面试题
- 基础
- Map
- Chan
- GC
- GMP
- 并发
- 内存
- 算法
- docker