Go语言中的基础数据类型如何使用寻技术

这篇文章主要介绍了Go语言中的基础数据类型如何使用的相关知识，内容详细易懂，操作简单快捷，具有一定借鉴价值，相信大家阅读完这篇Go语言中的基础数据类型如何使用文章都会有所收获，下面我们一起来看看吧。

基础数据类型

整型

在

Go

中整型数据类型主要分为

有符号整型
无符号整型
特殊整型

有符号整型

```
int8
```
: 8位（-128 ~ 127）
```
int16
```
: 16位（-32768 ~ 32767）
```
int32
```
: 32位（-2147483648 ~ 214748347）
```
int64
```
: 64位（-9223372036854775808 ~ 9223372036854775807）

var a int8
var b int16
var c int32
var d int64

无符号整型

```
uint8
```
: 8位（0 ~ 255）
```
uint16
```
: 16位（0 ~ 65535）
```
uint32
```
: 32位（0 ~ 4294967295）
```
uint64
```
: 64位（0 ~ 18446744073709551615）

var a uint8
var b uint16
var c uint32
var d uint64

特殊整型

```
uint
```
: 在32位操作系统上就是
```
unit32
```
，64位操作系统上就是
```
uint64
```
```
int
```
: 在32位操作系统上就是
```
int32
```
，64位操作系统上就是
```
int64
```
```
unitptr
```
: 无符号整型，用于存放一个指针

var a unit
var b int
var c unitptr

在

Go

中也可以使用数字字面量语法

```
0b
```
开头的代表二进制
```
0o
```
开头的代表八进制
```
0x
```
开头的代表十六进制

浮点型

在

Go

中支持的浮点型有两种

```
float32
```
```
float64
```

var a float32 = 3.14
var b float64 = 3.1415

复数

在

Go

中支持的复数有两种

```
complex64
```
```
complex128
```

var a complex64
a = 1 + 2i
var b complex128
b = 2 + 3i

复数拥有实部和虚部，

complex64

的实部和虚部为32位，而

complex128

的实部和虚部为64位

布尔值

在

Go

中布尔值通过

bool

进行类型声明，布尔值的数据只能时

true

和

false

，并且布尔类型变量的默认值为

false

，

Go

中不允许将整型强制转换为布尔型，而且布尔型无法参加数值运算，也无法与其他类型进行转换

var a bool = true
var b bool = false

字符串

在

Go

中字符串是以双引号包裹的内容

var a string = "water"
var b string = "你好"

字符串的转义符

：回车符
：换行符
```
	
```
：制表符
```
'
```
：单引号
```
"
```
：双引号
：反斜杠

多行字符串

在

Go

中要定义一个多行字符串时，需要使用反引号包裹

var a string = `这是
什么
`

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

常用的操作字符串的手段

name := "water"
zhName := "中国"
join := []string{"water", "iio"}

```
len(string)
```
获取字符长度

// len
fmt.Println(len(name)) => 5
fmt.Println(len(zhName)) => 6 // 一个汉字占用3个字符所以是字符的长度

```
utf8.RuneCountInString
```
获取字符串长度

// utf8.RuneCountInString
fmt.Println(utf8.RuneCountInString(name)) => 5
fmt.Println(utf8.RuneCountInString(zhName)) => 2

```
+/fmt.Sprintf
```
连接字符串

// +/fmt.Sprintf
fmt.Println(zhName + name) => "中国water"
fmt.Println(fmt.Sprintf("我是%s的%s", zhName, name)) => "我是中国的water"

```
strings.Split
```
分割字符串

fmt.Println(strings.Split(name, "")) => [w a t e r]

```
strings.Contains
```
判断是否包含子字符串

fmt.Println(strings.Contains(name, "w")) => true

```
strings.HasPrefix
```
判断是否以子字符串开头

fmt.Println(strings.HasPrefix(name, "w")) => true

```
strings.HasSuffix
```
判断是否以子字符串结尾

fmt.Println(strings.HasSuffix(name, "r")) => true

```
strings.Index()
```
判断子字符串或字符在父字符串中出现的位置（索引）

fmt.Println(strings.Index(name, "r")) => 4

```
strings.LastIndex()
```
返回子字符串在字符串中最后出现位置的索引（子字符串的第一个字符的索引）

fmt.Println(strings.LastIndex("waterte", "te")) => 5

```
strings.Join(a[]string,sep string)
```
把切片连接成字符串

fmt.Println(strings.Join(join, ",")) => "water,iio"

byte和rune类型

在

Go

中组成字符串的叫做字符，每个字符串都有字符组成，一般可以通过遍历或者单个获取字符串元素获得字符。字符用单引号包裹

var a = '我'
var b = 't'

在

Go

中字符有两种

```
uint8
```
类型也叫
```
byte
```
型，代表一个
```
ASCII
```
码字符
```
rune
```
类型，代表一个
```
UTF-8
```
字符

当需要处理中文、日文或者其他复合字符时，则需要用到

rune

类型。

rune

类型实际是一个

int32

Go

使用了特殊的

rune

类型来处理

Unicode

，让基于

Unicode

的文本处理更为方便，也可以使用

byte

型进行默认字符串处理，性能和扩展性都有照顾。

因为

UTF8

编码下一个中文汉字由

3~4

个字节组成，所以我们不能简单的按照字节去遍历一个包含中文的字符串，否则就会出现上面输出中第一行的结果。

字符串底层是一个

byte

数组，所以可以和

[]byte

类型相互转换。字符串是不能修改的字符串是由

byte

字节组成，所以字符串的长度是

byte

字节的长度。

rune

类型用来表示

utf8

字符，一个

rune

字符由一个或多个

byte

组成。

修改字符串

要修改字符串，需要先将其转换成

[]rune

或

[]byte

，完成后再转换为

string

。无论哪种转换，都会重新分配内存，并复制字节数组。

func setString() {
   name := "water"
   // 强制类型转换
   byteName := []byte(name)
   byteName[0] = 'm'
   fmt.Println(string(byteName))
   zhName := "大熊猫"
   runeZhName := []rune(zhName)
   runeZhName[0] = '小'
   fmt.Println(string(runeZhName))
}
=&gt;  mater
   小熊猫

类型转换

Go

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

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

T(表达式)
 fmt.Println(string(runeZhName))

本文地址：https://www.xunjs.com/golang/view_15086.html

Tags：言中基础语言数据类型

相关推荐