Go语言基本数据类型

Go语言中数据类型，除了基本的整形，浮点型，布尔型，字符串外，还有数组，切片，结构体，函数，map,通道(channel)等。

基本数据类型

整形

整形分为两大类有符号与无符号

按长度划分：

有符号: int8 int16 int32 int64
无符号: uint8 uint16 uint32 uint64

其中: uint8 是byte类型 int16对应C语言中的short型 int64对应C语言中的long型。

特殊整形

uint 32位操作系统上就是uint32 64位操作系统上就是uint64
int 32位操作系统上就是int32 64位操作系统上就是int64
uintptr 无符号整形，用于存放一个指针

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

注意事项: 获取对象的长度的内建 len() 函数返回的长度可以根据不同平台的字节长度进行变化。实际使用中，切片或map的元素数量等

都可以用 int 来表示。在涉及到二进制传输，读写文件的结构描述时，为了保持文件的结构不会受到不同编译目标平台字节长度的影响，不要使用int 和 uint。

数字字面量语法

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

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

package main

import "fmt"

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

浮点型

Go支持两种浮点数: float32 和 float64

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

package main

import (
     "fmt"
     "math"
)

func main(){
        fmt.Printf("%f\n",math.Pi)
        fmt.Printf("%.2f\n",math.Pi)
}

布尔值

Go中以bool类型进行声明布尔数据类型

注意:

布尔类型变量的默认值为false
Go中不允许将整形强转为布尔型
布尔型无法参与数值运算，也无法与其他类型进行转换。

字符串

Go语言里的字符串的内部实现使用 UTF-8编码。字符串的值为双引号(") 中的内容。可以在Go的源码中直接添加非

ASCII码字符，例如:

s1 := "hello"
s2 := "你好"

字符串转义符

Go的字符串常见转义符包含回车，换行，单双引号，制表符等

\r 回车符
\n 换行符
\t 制表符
\' 单引号
\" 双引号
\\ 反斜杠

例子：打印一个windows平台的文件路径:

package main
import (
    "fmt"
)
func main() {
    fmt.Println("str := \"c:\\Code\\lesson1\\go.exe\"")
}

多行字符串

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

s1 := `  my name is zzp
      my age is 18
      hello world   
      `
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操作

示例:

1. strings.Split

package main

import (
    "fmt"
    "strings"
)

func main() {
    name := "周1泽1平"
    a := strings.Split(name, "1")
    fmt.Println(a)
}

//结果:  [周 泽 平]            类型:[]string

2.len(str)

package main

import (
    "fmt"
)

func main() {
    name := "周1泽1平"
    a := len(name)
    fmt.Println(a)
}

// 结果: 11 
//注意: 中文字符  3个字节   数字英文字母  1个字节

3. + 或 fmt.Sprintf

package main

import (
    "fmt"
)

func main() {
    name := "zhou"
    l_name := "s686"
    username := name + l_name
    fmt.Println(username)
}
//结果: zhous686

package main

import (
    "fmt"
)

func main() {
    name := "zhou"
    l_name := "s686"
    username := fmt.Sprintf("%v%v", name, l_name)
    fmt.Println(username)
}
//结果: zhous686

4.strings.Contains

package main

import (
    "fmt"
    "strings"
)

func main() {
    name := "zhous686"
    is_con := strings.Contains(name, "zhou")
    fmt.Println(is_con)

    is_con1 := strings.Contains(name, "wj")
    fmt.Println(is_con1)
}
//结果:  is_con  true    
//         is_con1  false

5. strings.HasPrefix, strings.HasSuffix

package main

import (
    "fmt"
    "strings"
)

func main() {
    name := "zhous686"
    is_con := strings.HasPrefix(name, "zhou")
    fmt.Println(is_con)

    is_con1 := strings.HasSuffix(name, "86")
    fmt.Println(is_con1)
}

//结果:  is_con  true    
//         is_con1  false

6. strings.Index()，strings.LastIndex() （这两个是一个意思）

package main

import (
    "fmt"
    "strings"
)

func main() {
    name := "zhous686"
    f_idx := strings.Index(name, "zhou")
    fmt.Println(f_idx)

    l_idx := strings.LastIndex(name, "zhou")
    fmt.Println(l_idx)
}
//结果: f_idx =0             l_idx =0

7.strings.Join(a[]string,sep string)

Todo:..............

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 traversalString() {
    s := "hello沙河"
    for i := 0; i < len(s); i++ {
        fmt.Printf("%v(%c)", s[i], s[i])
    }
    fmt.Println()

    for _, r := range s {
        fmt.Printf("%v(%c)", r, r)
    }
    fmt.Println()

}

func main() {
    traversalString()
}

//结果:
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数组，所以可以和 []byte 类型相互转换。字符串是不能修改的字符串是由byte字节组成,所以字符串的长度是byte字节的长度。rune类型

用来表示 utf8 字符，一个rune字符由一个或多个byte组成。

修改字符串

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

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

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

类型转换

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

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

T (表达式)

其中，T表示要转换的类型。

例子：

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)
}

posted @ 2020-04-23 17:04 s686编程传阅读(159) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

s686

Go语言 基本数据类型