Golang通脉之数据类型详情

目录 1、标识符与关键字 1.1 标识符 1.2 关键字 2、变量 2.1 什么是变量 2.2 变量类型 2.3 变量声明 3、常量 3.1 iota 4、基本数据类型 0 Comments

目录
  • 1、标识符与关键字
    • 1.1 标识符
    • 1.2 关键字
  • 2、变量
    • 2.1 什么是变量
    • 2.2 变量类型
    • 2.3 变量声明
  • 3、常量
    • 3.1 iota
  • 4、基本数据类型
    • 4.1 整型
    • 4.2 浮点型
    • 4.3 复数
    • 4.4 布尔值
    • 4.5 字符串
    • 4.6 byte和rune类型
    • 4.7 类型转换
  • 5、运算符
    • 5.1 算数运算符
    • 5.2 关系运算符
    • 5.3 逻辑运算符
    • 5.4 位运算符
    • 5.5 赋值运算符
    • 5.6 运算符优先级

1、标识符与关键字

在了解数据类型之前，先了解一下go的标识符和关键字

1.1 标识符

在编程语言中标识符就是定义的具有某种意义的词，比如变量名、常量名、函数名等等。 Go语言中标识符允许由字母数字和_(下划线）组成，并且只能以字母和_开头：abc , _ , _123, a123。

1.2 关键字

关键字是指语言预先定义好的具有特殊含义的标识符。 关键字和保留字都不建议用作变量名。

Go语言有25个关键字：

?

1

2

3

4

5

break default func interface select

case defer go map struct

chan else goto package switch

const fallthrough if range type

continue for import return var

Go语言中有37个保留字

?

1

2

3

4

5

6

7

8

9

10

Constants: true false iota nil

Types: int int8 int16 int32 int64

uint uint8 uint16 uint32 uint64 uintptr

float32 float64 complex128 complex64

bool byte rune string error

Functions: make len cap new append copy close delete

complex real imag

panic recover

2、变量

2.1 什么是变量

程序运行过程中的数据都是保存在内存中，想要在代码中操作某个数据时就需要去内存上找到这个变量，但是如果直接在代码中通过内存地址去操作变量的话，代码的可读性会非常差而且还容易出错，所以就利用变量将这个数据的内存地址保存起来，以后直接通过这个变量就能找到内存上对应的数据了。

所以变量的本质就是一小块内存，用于存储数据，在程序运行过程中数值可以改变

变量是为存储特定类型的值而提供给内存位置的名称。在go中声明变量有多种语法。

2.2 变量类型

变量（Variable）的功能是存储数据。不同的变量保存的数据类型可能会不一样。常见变量的数据类型有：整型、浮点型、布尔型等。

Go语言中的每一个变量都有自己的类型，并且变量必须经过声明才能开始使用。

2.3 变量声明

Go语言中的变量需要声明后才能使用，同一作用域内不支持重复声明。 并且Go语言的变量声明后必须使用，否则无法通过编译。

标准声明：

Go语言的变量声明格式为：

变量声明以关键字var开头，变量类型放在变量的后面，行尾无需分号：

?

1

2

3

var name string

var age int

var isTrue bool

批量声明：

每声明一个变量就需要写var关键字会比较繁琐，go语言中还支持批量变量声明：

?

1

2

3

4

5

6

var (

a string

b int

c bool

d float32

)

变量的初始化：

Go语言在声明变量的时候，会自动对变量对应的内存区域进行初始化操作。每个变量会被初始化成其类型的默认值，即零值，例如： 整型和浮点型变量的默认值为0。 字符串变量的默认值为空字符串。 布尔型变量默认为false。 切片、函数、指针变量的默认为nil。

当然也可在声明变量的时候为其指定初始值。变量初始化的标准格式如下：

?

1

2

3

var 变量名 类型 = 表达式

var name string = "golang"

var age int = 18

或者一次初始化多个变量

?

1

var name, age = "golang", 20

类型推导：

有时候会将变量的类型省略，这个时候编译器会根据等号右边的值来推导变量的类型完成初始化。

?

1

2

var name = "golang"

var age = 18

短变量声明：

在函数内部，可以使用更简略的 := 方式声明并初始化变量。

?

1

2

3

4

5

6

7

8

// 全局变量m

var m = 100

func main() {

n := 10

m := 200 // 此处声明局部变量m

fmt.Println(m, n)

}

匿名变量：

在使用多重赋值时，如果想要忽略某个值，可以使用匿名变量（anonymous variable）。 匿名变量用一个下划线_表示，例如：

?

1

2

3

4

5

6

7

8

9

func foo() (int, string) {

return 10, "golang"

}

func main() {

x, _ := foo()

_, y := foo()

fmt.Println("x=", x)

fmt.Println("y=", y)

}

匿名变量不占用命名空间，不会分配内存，所以匿名变量之间不存在重复声明。

注意事项：

  • 函数外的每个语句都必须以关键字开始（var、const、func等）
  • :=不能使用在函数外，不能定义全局变量，并且左边的变量名至少有一个是新的。
  • _多用于占位，表示忽略值。
  • 变量必须先定义才能使用，定义了就一定要使用。
  • 变量的类型和赋值的类型必须一致。
  • 变量名在同一个作用于域内不能冲突。

3、常量

相对于变量，常量是恒定不变的值，多用于定义程序运行期间不会改变的那些值。 常量的声明和变量声明非常类似，只是把var换成了const，常量在定义的时候必须赋值。

?

1

2

const pi = 3.1415

const e = 2.7182

声明了pi和e这两个常量之后，在整个程序运行期间它们的值都不能再发生变化了。

多个常量也可以一起声明：

?

1

2

3

4

const (

pi = 3.1415

e = 2.7182

)

const同时声明多个常量时，如果省略了值则表示和上面一行的值相同。 例如：

?

1

2

3

4

5

const (

n1 = 100

n2

n3

)

上面示例中，常量n1、n2、n3的值都是100。

常量可以作为枚举，常量组

?

1

2

3

4

5

const (

Unknown = 0

Female = 1

Male = 2

)

常量组中如不指定类型和初始化值，则与上一行非空常量右值相同

?

1

2

3

4

5

6

7

8

9

10

func main() {

const (

x uint16 = 16

y

s = "abc"

z

)

fmt.Printf("%T,%v\n", y, y) //uint16,16

fmt.Printf("%T,%v\n", z, z) //string,abc

}

常量的注意事项：

  • 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型
  • 不曾使用的常量，在编译的时候，是不会报错的
  • 显示指定类型的时候，必须确保常量左右值类型一致，需要时可做显示类型转换。这与变量就不一样了，变量是可以是不同的类型值

3.1 iota

iota是go语言的常量计数器，是特殊的常量，只能在常量的表达式中使用。

iota在const关键字出现时将被重置为0。const中每新增一行常量声明将使iota计数一次(iota可理解为const语句块中的行索引)。 使用iota能简化定义，在定义枚举时很有用。

?

1

2

3

4

5

6

const (

n1 = iota //0

n2 //1

n3 //2

n4 //3

)

几个常见的iota示例:

使用_跳过某些值

?

1

2

3

4

5

6

const (

n1 = iota //0

n2 //1

_

n4 //3

)

iota声明中间插队

?

1

2

3

4

5

6

7

const (

n1 = iota //0

n2 = 100 //100

n3 = iota //2

n4 //3

)

const n5 = iota //0

定义数量级 （这里的<<表示左移操作，1<<10表示将1的二进制表示向左移10位，也就是由1变成了10000000000，也就是十进制的1024。同理2<<2表示将2的二进制表示向左移2位，也就是由10变成了1000，也就是十进制的8。）

?

1

2

3

4

5

6

7

8

const (

_ = iota

KB = 1 << (10 * iota)

MB = 1 << (10 * iota)

GB = 1 << (10 * iota)

TB = 1 << (10 * iota)

PB = 1 << (10 * iota)

)

多个iota定义在一行

?

1

2

3

4

5

const (

a, b = iota + 1, iota + 2 //iota = 0、a = 1, b = 2

c, d //iota = 1、c = 2, d = 3

e, f //iota = 2、e = 3, f = 4

)

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

4、基本数据类型

4.1 整型

整型分为以下两个大类： 按长度分为：int8、int16、int32、int64 对应的无符号整型：uint8、uint16、uint32、uint64

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

类型 描述
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）

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

v := 0b00101101， 代表二进制的 101101，相当于十进制的 45。 v := 0o377，代表八进制的 377，相当于十进制的 255。 v := 0x1p-2，代表十六进制的 1 除以 2²，也就是 0.25。

而且还允许用 _ 来分隔数字，比如说： v := 123_456 表示 v 的值等于 123456。

将一个整数以不同进制形式展示：

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

func main(){

// 十进制

var a int = 10

fmt.Printf("%d \n", a) // 10

fmt.Printf("%b \n", a) // 1010 占位符%b表示二进制

// 八进制 以0开头

var b int = 077

fmt.Printf("%o \n", b) // 77

// 十六进制 以0x开头

var c int = 0xff

fmt.Printf("%x \n", c) // ff

fmt.Printf("%X \n", c) // FF

}

4.2 浮点型

Go语言支持两种浮点型数：float32和float64。这两种浮点型数据格式遵循IEEE 754标准： float32 的浮点数的最大范围约为 3.4e38，可以使用常量定义：math.MaxFloat32。 float64 的浮点数的最大范围约为 1.8e308，可以使用一个常量定义：math.MaxFloat64。

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

?

1

2

3

4

func main() {

fmt.Printf("%f\n", math.Pi)

fmt.Printf("%.2f\n", math.Pi)

}

4.3 复数

complex64和complex128

?

1

2

3

4

5

6

var c1 complex64

c1 = 1 + 2i

var c2 complex128

c2 = 2 + 3i

fmt.Println(c1)

fmt.Println(c2)

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

4.4 布尔值

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

注意：

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

4.5 字符串

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

?

1

2

s1 := "hello"

s2 := "你好"

字符串转义符：

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

转义符 含义
\r 回车符（返回行首）
\n 换行符（直接跳到下一行的同列位置）
\t 制表符
\' 单引号
\" 双引号
\\ 反斜杠
打印一个Windows平台下的一个文件路径：

?

1

2

3

func main() {

fmt.Println("str := \"d:\\go\\go.exe\"")

}

多行字符串：

定义一个多行字符串时，就必须使用反引号字符：

?

1

2

3

4

5

s1 := `第一行

第二行

第三行

`

fmt.Println(s1)

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

字符串的常用操作：

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

4.6 byte和rune类型

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

?

1

2

var a := '中'

var b := 'x'

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。无论哪种转换，都会重新分配内存，并复制字节数组。

?

1

2

3

4

5

6

7

8

9

10

11

12

func changeString() {

s1 := "big"

// 强制类型转换

byteS1 := []byte(s1)

byteS1[0] = 'p'

fmt.Println(string(byteS1))

s2 := "白萝卜"

runeS2 := []rune(s2)

runeS2[0] = '红'

fmt.Println(string(runeS2))

}

4.7 类型转换

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

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

其中，T表示要转换的类型。表达式包括变量、复杂算子和函数返回值等.

?

1

2

3

4

5

6

7

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)

}

运算符用于在程序运行时执行数学或逻辑运算。

5、运算符

Go 语言内置的运算符有：

  • 算术运算符
  • 关系运算符
  • 逻辑运算符
  • 位运算符
  • 赋值运算符

5.1 算数运算符

运算符 描述
+ 相加
- 相减
* 相乘
/ 相除
% 求余

注意： ++ （自增）和--（自减）在Go语言中是单独的语句，并不是运算符。

5.2 关系运算符

运算符 描述
== 检查两个值是否相等，如果相等返回 True 否则返回 False。
!= 检查两个值是否不相等，如果不相等返回 True 否则返回 False。
> 检查左边值是否大于右边值，如果是返回 True 否则返回 False。
>= 检查左边值是否大于等于右边值，如果是返回 True 否则返回 False。
< 检查左边值是否小于右边值，如果是返回 True 否则返回 False。
<= 检查左边值是否小于等于右边值，如果是返回 True 否则返回 False。

5.3 逻辑运算符

运算符 描述
&& 逻辑 AND 运算符。 如果两边的操作数都是 True，则为 True，否则为 False。
|| 逻辑 OR 运算符。 如果两边的操作数有一个 True，则为 True，否则为 False。
! 逻辑 NOT 运算符。 如果条件为 True，则为 False，否则为 True。

5.4 位运算符

位运算符对整数在内存中的二进制位进行操作。

运算符 描述
& 参与运算的两数各对应的二进位相与。 （两位均为1才为1）
| 参与运算的两数各对应的二进位相或。 （两位有一个为1就为1）
^ 参与运算的两数各对应的二进位相异或，当两对应的二进位相异时，结果为1。 （两位不一样则为1）
&^ 二进制位清空&^
<< 左移n位就是乘以2的n次方。 “a<<b”是把a的各二进位全部左移b位，高位丢弃，低位补0。
>> 右移n位就是除以2的n次方。 “a>>b”是把a的各二进位全部右移b位。

A B A&B A|B A^B
0 0 0 0 0
0 1 0 1 1
1 1 1 1 0
1 0 0 1 1

5.5 赋值运算符

运算符 描述 示例
= 简单的赋值操作符，分配值从右边的操作数左侧的操作数 C = A + B 将分配A + B的值到C
+= 相加并赋值运算符，它增加了右操作数左操作数和分配结果左操作数 C += A 相当于 C = C + A
-= 减和赋值运算符，它减去右操作数从左侧的操作数和分配结果左操作数 C -= A 相当于 C = C - A
*= 乘法和赋值运算符，它乘以右边的操作数与左操作数和分配结果左操作数 C *= A 相当于 C = C * A
/= 除法赋值运算符，它把左操作数与右操作数和分配结果左操作数 C /= A 相当于 C = C / A
%= 模量和赋值运算符，它需要使用两个操作数的模量和分配结果左操作数 C %= A 相当于 C = C % A
<<= 左移位并赋值运算符 C <<= 2 相同于 C = C << 2
>>= 向右移位并赋值运算符 C >>= 2 相同于 C = C >> 2
&= 按位与赋值运算符 C &= 2 相同于 C = C & 2
^= 按位异或并赋值运算符 C ^= 2 相同于 C = C ^ 2
|= 按位或并赋值运算符 C |= 2 相同于 C = C | 2

5.6 运算符优先级

有些运算符拥有较高的优先级，二元运算符的运算方向均是从左至右。由上至下代表优先级由高到低：

优先级 运算符
7 ~ ! ++ --
6 * / % << >> & &^
5 + - ^
4 == != < <= >= >
3 <-
2 &&
1 ||

当然，可以通过使用括号来临时提升某个表达式的整体运算优先级。

到此这篇关于Golang通脉之数据类型详情的文章就介绍到这了,更多相关Golang 数据类型内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://www.cnblogs.com/drunkery/p/15402180.html

本文链接：https://my.lmcjl.com/post/14952.html

展开阅读全文

相关文章

4 评论

留下您的评论.