1. 指针
// 创建了一块内存 让它指向了真正存储数据的地址
// 声明
var a *int
var b := new(int)
new关键字
// 创建内存 并进行内部数据初始化 返回一个指针类型
2. nil
// nil指向golang中的空值
3. 整型
3.1 有符号整数
// eg:
var a = int8(33)
fmt.Printf("%T\n", a) // 打印类型
3.2 无符号整数
3.3 特殊整型
int // 32位操作系统是int32 64位操作系统是int64
uint // 32位操作系统是uint32 64位操作系统是uint64
uintptr // 无符整型 存放指针
3.4 八进制和十六进制
// golang无法直接定义二进制
// 定义十进制
var a = 10
// 定义八进制(文件权限)
var b = 010
// 定义十六进制(内存地址)
var c = 0x100
// 进制输出
fmt.Printf("%d\n", a) // 十进制输出
fmt.Printf("%o\n", b) // 八进制输出
fmt.Printf("%x\n", c) // 十六进制输出
3.5 超大整型
// 超大整型(超过int64范围)
方法一
// 1.创建对象
var a big.Int
// 2.初始化
a.SetInt64(1234) // 只能写入int64范围内的数值
a.SetString("1234", 10) // 可以写入任意大数值(推荐使用)
方法二(不能使用)
var a *big.Int // a为一个nil指针
fmt.Println(a)
a.SetInt64(13415) // 赋值数字会报错
fmt.Println(a)
方法三(推荐使用 节省内存)
var a = new(big.Int)
a.SetInt64(4123345678883264786216432) // 报错
a.SetString("4123345678883264786216432", 10)
// 简单运算
a := new(big.Int)
b := new(big.Int)
c := new(big.Int)
d := new(big.Int)
a.SetInt64(324)
b.SetInt64(689)
c.Add(a, b) // 加
d.Mul(a, b) // 乘
fmt.Println(a, b, c, d)
// ps: Sub(v1, v2) Div(v1, v2)只得到商 DivMod(v1, v2, minder)得到商和余数
// 简写
a := new(big.Int)
a.SetInt64(64)
// 相当与
a := big.NewInt(64)
// func NewInt(x int64) *Int {
// return new(Int).SetInt64(x)
// }
// ps: result.Int64() result.String() 结果转化为Int64和字符串
//
// var result big.Int
// result.Add()
// 需要的参数必须是是指针类型
// 存储结果的可以是指针类型 也可以是Int类型 但是内部都会转化为指针类型
3.6 整型转化为字符串
ret := strconv.FormatInt(int64(25), 2) // 将25转化为二进制 再转化为字符串
fmt.Println(ret) // 11001
// ps: strconv.FormatUint()
// strconv.ParseUint()
// strconv.ParseInt()
// 可实现进制转化
4. 浮点型
// golang中小数类型推导为默认float64
// float64和float32是两种不同的类型
const (
MaxFloat32 = 3.40282346638528859811704183484516925440e+38
SmallestNonzeroFloat32 = 1.401298464324817070923729583289916131280e-45
MaxFloat64 = 1.797693134862315708145274237317043567981e+308
SmallestNonzeroFloat64 = 4.940656458412465441765687928682213723651e-324
)
4.1 常见数据运算
4.2 浮点型内部存储原理
// 处理时 非精确
var a float32 = 12.21
// 第一步：转化为二进制(整数部分和小数部分)
// 第二步：拼接 整数部分二进制.小数部分二进制 1100.0011011
// 第三步：科学计数法表示 1.1000011011 × 2^3
1.1000011011 × 2^3
// 第四步：存储
// 以float32为例
// 阶码部分(exponent): 共256中可能，含正负值(-127~128)。例如5存储到阶码部分，需要让3+127=130，再将130转化为二进制存储
// 尾数部分(fraction): 存储小数点后所有数据 超出则丢弃
// decimal精确的浮点数操作
// golang中没有内置decimal 需要下载第三方包
go get github.com/shopspring/decimal // 下载
// eg:
var a = decimal.NewFromFloat(0.1)
b := decimal.NewFromFloat(0.2)
var c = a.Add(b)
var d = a.Sub(b)
var e = a.Mul(b)
var f = a.Div(b)
fmt.Println(c, d, e, f)
var price = decimal.NewFromFloat(99.99)
var p1 = price.Round(1) // 保留小数点后1位(四舍五入)
var p2 = price.Truncate(1) // 保留小数点后1位
fmt.Println(p1, p2)
4.4 浮点型转化为字符串
// strconv.FormatFloat()
// strconv.ParseFloat()
5. 复数
复数转化为字符串
strconv.FormatComplex()
strconv.ParseComplex()
6. bool类型
true
false
var a bool
// 1.声明时为false
// 2.整型不可以强制转化为bool型
// 3.bool无法参与数值运算 也无法与其他类型进行转换
bool值转化为字符串
// 字符串转化为bool
result, err := strconv.ParseBool("true")
fmt.Println(result, err)
// func ParseBool(str string) (bool, error) {
// switch str {
// case "1", "t", "T", "true", "TRUE", "True":
// return true, nil
// case "0", "f", "F", "false", "FALSE", "False":
// return false, nil
// }
// return false, syntaxError("ParseBool", str)
// }
// bool转化为字符串
result := strconv.FormatBool(true)
fmt.Println(result)
// func FormatBool(b bool) string {
// if b {
// return "true"
// }
// return "false"
// }
7. 字符型
7.1 知识点
// golang中的字符串是utf-8编码的字符序列
// unicode字符集: 文字 -> 码点(usc4 4个字节表示)
// utf-8: 对码点再进行编码
// golang中字符串必须使用双引号
// 使用单引号的是字符(int32 rune)
// 使用反引号的是原生字符串
7.2 实例
// eg:
var a = 'a'
var b = "abc"
var c = `
情商
智商
逆商
`
7.3 字符串的常用操作
// 字节长度 len(str) 字节长度
// 字符长度 v, size := utf8.RuneCountInString(str) size表示最少表示的字节
// 拼接 +(效率低); fmt.Sprintf("%s%s", str1, str2)返回; fmt.Printf("%s%s", str1, str2)打印
// strings.Join(slice, "连接符")
// 分割 strings.Split(s, sep)
// 包含 strings.Contains(s, substr)
// 前缀 strings.HasPrefix(s, prefix)
// 后缀 strings.HasSuffix(s, suffix)
// 子串索引 strings.Index(s, substr); strings.LastIndex(s, substr)
// 拼接 strings.Join([]string, sep)
// 变大写 strings.ToUpper(str) 返回大写形式 但是本身不变
// 变小写 strings.ToLower(str)
// 去两边 strings.Trim(str, "") strings.TrimRight() strings.TrimLeft()
// 替换 strings.Replace(str, "被替换str", "替换str", "去除的个数") // 去除的个数为-1表示全部替换
7.4 字符串修改
// golang中字符串不可修改 需要先转化为rune切片
// golang中字符串索引获取到的是字节
s1 := "白萝卜"
s2 := []rune(s1) // 将s1转化为rune切片 将字符串转化为unicode字符集码点的集合
fmt.Println(s2) // ['白' '萝' '卜']
s2[0] = '红' // 修改切片
fmt.Println(s2) // ['红' '萝' '卜']
s3 := string(s2) // 将rune切片转化为字符串
fmt.Println(s3) // "红萝卜"
7.5 类型转换
// 类型转化
// 1.不借助其他模块
T(表达式)
整形和浮点型相互转化
字符串和切片相互转化
// 2.strconv模块
strconv.Itoa(666) // int转化为string
strconv.Atoi("666") // string转化为int
// 3.其他(数字转字符)
string(int32(65)) // A
// 应用场景: 随机验证码
7.6 字符串格式化
// fmt.Sprintf()
// eg:
var name = "turbo"
var age = 20
ret := fmt.Sprintf("My name is %s, and my age is %d", name, age)
fmt.Println(ret)
7.7 字符串索引、切片和遍历
s := "Turbo工作室"
// 1.索引: 获取字节
s[0] // T
// 2.切片: 获取一段字节
s[5:8] // 工
// 3.遍历: (了解)
// a.遍历字节
for i:=0; i<len(s); i++{
fmt.Println(i, s[i])
}
// b.遍历字符
for index, item := range s{
fmt.Println(index, item, string(item))
}
// 内部原理:
for index, item := range []rune(s){
fmt.Println(index, item, string(item))
}
8. 其他类型
