Golang之旅3-基本数据类型

基本数据类型

GO语言中的数据类型十分丰富，包含：整型、浮点型、布尔型，还有数组、切片、结构体、函数、map、通道chanel等

go基本数据类型

整型

1. 无符号整型

   • uint8：，0到255

   • uint16：,0到65535

   • uint32

   • uint64

2. 有符号整型

   • int8：-128到127

   • int16：-32768到32767

   • int32

   • int64

3. 其他数字类型

   • uint：32/64位系统上就是uint32/uint64

   • int：32/64位系统上就是int32/int64

   • uintptr：无符号整型，用于存放一个指针

   注意：

   • 在使用int和 uint类型时，不能假定它是32位或64位的整型，而是考虑int和uint可能在不同平台上的差异。

   • 获取对象的长度的内建len()函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或 map 的元素数量等都可以用int来表示。在涉及到二进制传输、读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int和 uint。

浮点型

两种浮点类型：float32和float64，需要导入包math。

• float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32

• float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64

package main
import (
    "fmt"
    "math"    // 导入math包
)
    //浮点数
    fmt.Printf("%f\n", math.Pi)
    fmt.Printf("%f\n", math.Phi)
    fmt.Printf("%.2f\n", math.Pi)

    // 查看系统默认最大的浮点数
    fmt.Println(math.MaxFloat32)
    fmt.Println(math.MaxFloat64)
}

复数

有complex64（实部和虚部都是32位）和complex128（实部和虚部都是64位）两种

var c1 complex64
c1 = 1 + 5i

var c2 complex64
c2 = 10 + 10i

布尔值

• 只有False和True，默认是Fasle

• Go语言中不允许将数值类型强制转成布尔型

• 布尔类型不参与运算，无法和其他类型进行转换

字符串

• Go语言中以原生数据类型出现

• 使用的的是utf-8编码，默认是支持中文的

• 字符串为双引号（""）里面的内容

• 可以在Go语言的源码中直接添加非ASCII码字符

s1 := "hello beijing" 
s2 := "你好，北京"
fmt.Println(s1, s2)转义字符

• 转义字符

//转义字符：打印路径
fmt.Println("c:\\code\\go.exe") //第一个反斜杠是转义字符，第二个表示原样输出反斜杠

多行字符串

通过反引号来实现，类似于Python中的r''，里面的内容是原样输出，不进行任何转义

//多行字符串输出：里面的内容是原样输出，不进行任何转义
s3 := `go语言是谷歌开发的\n
go语言有多种数据类型
多行字符串通过反引号来实现
`
fmt.Println(s3)

字符串操作

• 求长度

• 拼接

• 分割

• 是否包含

• 前后缀判断

• 子串出现的位置

• jion操作

image

package main

import (
    "fmt"
    "strings"
)

func main()  {
    s1 := "hello"   //一个英文字母占据一个字节
    s2 := "go语言"  //一个汉字占3个字节

    //求长度
    fmt.Println(len(s1), len(s2))

    //拼接
    fmt.Println(s1 + s2)
    s3 := fmt.Sprintf("%s - %s", s1, s2)  //通过Sprintf方法
    fmt.Println(s3)

    //分割
    s4 := "how do you do"
    fmt.Println(strings.Split(s4, " "))  //两个参数：待分割字符和指定分割的符号
    fmt.Printf("%T\n", strings.Split(s4, " "))  //判断字符串类型

    //包含与否
    fmt.Println(strings.Contains(s4, "do"))

    //判断前后缀
    fmt.Println(strings.HasPrefix(s4, "how"))
    fmt.Println(strings.HasSuffix(s4, "how"))

    //子字符串的位置，通过strings.Index
    fmt.Println(strings.Index(s4, "do"))
    fmt.Println(strings.LastIndex(s4, "do"))

    //join操作
    s5 := []string{"how", "do", "you", "do"}  //如何创建列表
    fmt.Println(s5)
    fmt.Println(strings.Join(s5, "+"))
}

//result
D:\go\src\code\str>go build
D:\go\src\code\str>str.exe
5 8
hellogo语言
hello - go语言
[how do you do]
[]string
true
true
false
4
11
[how do you do]
how+do+you+do

byte和rune类型

组成每个字符串的元素叫做“字符”，通过遍历的方式获取字符串中单个字符。字符用单引号括起来

var a := "zhong"
var b := "中"

Go语言的字符有两种：

• uint8类型，或者叫做byte类型，代表ASCII码的一个字符，处理默认字符串类型，不能处理中日韩等文字
• rune类型，代表的是utf-8字符，实际上是一个int32，用来处理Unicode类型

package main

import "fmt"

func main(){
    //byte处理ASCII码；rune处理Unicode编码
    var c1 byte = 'c'
    var c2 rune = 'c'
    fmt.Println(c1, c2)
    fmt.Printf("c1:%T  c2:%T\n", c1, c2)

    s := "hello中国"
    for i := 0; i < len(s); i++{   //遍历方式
        fmt.Printf("%c\n", s[i])
    }
    fmt.Println()  //打印空行分割作用
    for _, r := range s{   // range循环实现
        fmt.Printf("%c\n", r)
    }
    fmt.Println()
}

• byte类型不能处理中文，出现乱码
• rune处理中日韩等文字，根据字符来遍历

修改字符串

要修改字符串需要先将其转成[]rune或者[]byte类型，完成后再转成string。转换会重新分配内存，并且赋值字节数组。字符串--->[]rune/[]byte--->string

package main

import "fmt"

func main(){
    s1 := "big"
    //强制类型转换
    byteS1 := []byte(s1)
    byteS1[0] = 'p'
    fmt.Println(string(byteS1))

    s2 := "白萝卜"
    byteS2 := []rune(s2)
    byteS2[0] = '红'   //赋值语句
    fmt.Println(string(byteS2))
}

Go语言中只有强制类型转换，没有隐式类型转换

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