GO语言学习–基本数据类型

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

整型

基本整型

类型	描述
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	无符号整型，用于存放一个指针

数字字面量语法（Number literals syntax）

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

 package main

     import "fmt"

     //整型

     func main() {
         var i1 = 101
         //十进制
         fmt.Printf("%d\n", i1)
         fmt.Printf("%o\n", i1) //把十进制数转换成八进制
         fmt.Printf("%x\n", i1) //把十进制数转换成十六进制
         fmt.Printf("%b\n", i1) //把十进制数转换成二进制
         // 八进制
         i2 := 077
         fmt.Printf("%d\n", i2)
         //十六进制
         i3 := 0x1234567
         fmt.Printf("%d\n", i3)
         //查看变量的类型
         fmt.Printf("%T\n", i3)

         //声明int8类型的变量
         i4 := int8(9)
         fmt.Printf("%T\n", i4)
     }

浮点型

打印浮点数时，可以使用fmt包配合动词%f，代码如下：

 package main

     import "fmt"

     //浮点型

     func mian() {
         // math.MaxFloat32 // float32
         f1 := 1.23456
         fmt.Printf("%T\n", f1) //默认go语言中的小数都是float64类型
         f2 := float32(1.23456)
         fmt.Printf("%T\n", f2) //显示声明float32类型
         //  f1 = f2  //floot32类型的值不能直接赋值给float64类型的变量
     }

复数

complex64和complex128

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

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

布尔值

Go语言中以bool类型进行声明布尔型数据，布尔型数据只有true（真）和false（假）两个值。

注意：

布尔类型变量的默认值为false。

Go 语言中不允许将整型强制转换为布尔型.

布尔型无法参与数值运算，也无法与其他类型进行转换。

 package main

     import "fmt"

     //布尔值
     func mian() {
         b1 := true
         var b2 bool
         fmt.Printf("%T/n", b1)
         fmt.Printf("%T value:%v\n", b2, b2)
     }

字符串

Go语言中的字符串以原生数据类型出现，使用字符串就像使用其他原生数据类型（int、bool、float32、float64 等）一样。 Go 语言里的字符串的内部实现使用UTF-8编码。字符串的值为双引号(“)中的内容，可以在Go语言的源码中直接添加非ASCII码字符，例如：

 //字符串
     s := "Hello 你好"
     //单独的字母、汉字、符号表示一个字符
     c1 := 'h'
     c2 := '1'
     c3 := '你'
     //字节： 1字节=8Bit（8个二进制位）

注意：go语言中的字符串是用双引号包裹的！！！

Go语言中单引号包裹的是字符！！

字符串转义符

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

转义符	含义
\r	回车符（返回行首）
\n	换行符（直接跳到下一行的同列位置）
\t	制表符
\’	单引号
\”	双引号
\\	反斜杠

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

 package main

     import "fmt"

     func main() {
         // \ 本来是具有特殊的含义的，我应该告诉程序我写的就是一个单纯的\
         path1 := "\"D:\\GO\\src\\adminxe.com\\MoCoCN\\day01\""
         fmt.Println(path1)
         path2 := "'D:\\GO\\src\\adminxe.com\\MoCoCN\\day01'"
         fmt.Println(path2)

     }

多行字符串

Go语言中要定义一个多行字符串时，就必须使用反引号”`”字符

  // 多行的字符串
         s2 := `
         你说林深见鹿
         亦可自度
         後来清晨见雾
         你未留住
         `
         fmt.Println(s2)
     
         s3 := `D:\GO\\src\adminxe.com\MoCoCN\day01`
         fmt.Println(s3)

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

字符串的常用操作

方法	介绍
len(str)	求长度
+或fmt.Sprintf	拼接字符串
strings.Split	分割
strings.contains	判断是否包含
strings.HasPrefix,strings.HasSuffix	前缀/后缀判断
strings.Index(),strings.LastIndex()	子串出现的位置
strings.Join(a[]string, sep string)	join操作

求长度

     //求长度
         fmt.Println(len(s3))

拼接字符串

     //字符串拼接
         name := "MoCo"
         world := "yyds"
         ss := name + world
         fmt.Println(ss)
         ss1 := fmt.Sprintf("%s%s", name, world)
         fmt.Println(ss1)

         fmt.Printf("%s%s", name, world)

分割

      //分割
         ret := strings.Split(s3, "\\")
         fmt.Println(ret)

判断是否包含

      //包含
         fmt.Println(strings.Contains(ss, "mocc"))
         fmt.Println(strings.Contains(ss, "MoCo"))

前缀/后缀判断

      //前缀
         fmt.Println(strings.HasPrefix(ss, "MoCo"))
         //后缀
         fmt.Println(strings.HasSuffix(ss, "MoCo"))

子串出现的位置

     //字串出现的位置
         s4 := "abcdeb"
         fmt.Println(strings.Index(s4, "c"))     //C在这个字符串里出现的位置
         fmt.Println(strings.LastIndex(s4, "b")) //b在这个字符串里最后出现的位置

join操作

 //join拼接
        fmt.Println(strings.Join(ret, "+"))

代码运行截图

byte和rune类型

组成每个字符串的元素叫做“字符”，可以通过遍历或者单个获取字符串元素获得字符。字符用单引号（’）包裹起来，如：

 var a = '中'
     var b ='x'

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

uint8类型，或者叫 byte 型，代表了ASCII码的一个字符。
rune类型，代表一个 UTF-8字符。

当需要处理中文、日文或者其他复合字符时，则需要用到rune类型。rune类型实际是一个int32。

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

 package main

     import "fmt"

     // 遍历字符串

     func main() {
         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.Println()
     }

修改字符串

要修改字符串，需要先将其转换成[]rune或[]byte，完成后再转换为string。无论哪种转换，都会重新分配内存，并复制字节数组。

 s5 := "白萝卜"
      s6 := []rune(s5) // 把字符串强制转换成了一个rune切片
      s6[0] = '红'
      fmt.Println(string(s6)) //  把rune切片强制转换成字符串

      c1 := "红"
      c2 := '红' // rune(int32)
      fmt.Printf("c1:%T c2:%T\n", c1, c2)
      c3 := "H"       //string
      c4 := 'H'       //int32
      c5 := byte('H') // byte(uint8)
      fmt.Printf("c3:%T c4:%T\n", c3, c4)
      fmt.Printf("%d\n", c4)
      fmt.Printf("c5:%T\n", c5)

字符串练习笔记代码（除byte和rune类型）

package main

import (
    "fmt"
    "strings"
)

func main() {
    // \ 本来是具有特殊的含义的，我应该告诉程序我写的就是一个单纯的\
    path1 := "\"D:\\GO\\src\\adminxe.com\\MoCoCN\\day01\""
    fmt.Println(path1)
    path2 := "'D:\\GO\\src\\adminxe.com\\MoCoCN\\day01'"
    fmt.Println(path2)

    // 多行的字符串
    s2 := `
    你说林深见鹿
    亦可自度
    後来清晨见雾
    你未留住
    `
    fmt.Println(s2)

    s3 := `D:\GO\\src\adminxe.com\MoCoCN\day01`
    fmt.Println(s3)

    //字符串相关操作

    //求长度
    fmt.Println(len(s3))

    //字符串拼接
    name := "MoCo"
    world := "yyds"
    ss := name + world
    fmt.Println(ss)
    ss1 := fmt.Sprintf("%s%s", name, world)
    fmt.Println(ss1)

    fmt.Printf("%s%s", name, world)

    //分割
    ret := strings.Split(s3, "\\")
    fmt.Println(ret)

    //包含
    fmt.Println(strings.Contains(ss, "mocc"))
    fmt.Println(strings.Contains(ss, "MoCo"))
    //前缀
    fmt.Println(strings.HasPrefix(ss, "MoCo"))
    //后缀
    fmt.Println(strings.HasSuffix(ss, "MoCo"))
    //字串出现的位置
    s4 := "abcdeb"
    fmt.Println(strings.Index(s4, "c"))     //C在这个字符串里出现的位置
    fmt.Println(strings.LastIndex(s4, "b")) //b在这个字符串里最后出现的位置

    //join拼接
    fmt.Println(strings.Join(ret, "+"))

    //字符串修改
    s5 := "白萝卜"
    s6 := []rune(s5) // 把字符串强制转换成了一个rune切片
    s6[0] = '红'
    fmt.Println(string(s6)) //  把rune切片强制转换成字符串

    c1 := "红"
    c2 := '红' // rune(int32)
    fmt.Printf("c1:%T c2:%T\n", c1, c2)
    c3 := "H"       //string
    c4 := 'H'       //int32
    c5 := byte('H') // byte(uint8)
    fmt.Printf("c3:%T c4:%T\n", c3, c4)
    fmt.Printf("%d\n", c4)
    fmt.Printf("c5:%T\n", c5)

    //类型转换
    //只有整型和浮点型可以相互转换，字符串和切片能互相转换
    n1 := 10 //int
    var f float64
    f = float64(n1)
    fmt.Println(f)
    fmt.Printf("%T\n", f)
}

byte和rune类型练习笔记代码

package main

import "fmt"

// 遍历字符串

func main() {
    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.Println()
}

类型转换

Go语言中只有强制类型转换，没有隐式类型转换。该语法只能在两个类型之间

     //类型转换
         //只有整型和浮点型可以相互转换，字符串和切片能互相转换
         n1 := 10 //int
         var f float64
         f = float64(n1)
         fmt.Println(f)
         fmt.Printf("%T\n", f)

参考链接

https://www.liwenzhou.com/posts/Go/02_datatype/

转载请注明：Adminxe's Blog » GO语言学习–基本数据类型

Adminxe's Blog 专注于信息安全和安全开发