当前位置:   article > 正文

golang学习-基本数据类型_golang基本数据类型

golang基本数据类型

Go语言类型

在Go编程语言中,数据类型用于声明函数和变量。

数据类型的出现是为了数据分成所内存大小不同的数据,编程的时候需要用大数据的时候才需要申请大内存,这样就可以充分利用内存。

Go语言按照类别分别由以下集中数据类型:
请添加图片描述

数字类型

整数型

简单来说,整数类型就是用来存放整数值的。

int
类型有无符号占用存储空间表数范围
int81字节-128~127
int162字节-215~215-1
int324字节-231~231-1
int648字节-263~263-1

案例

package main
	
import(
	"fmt"
)
	
func main(){

	// 测试取值范围
	var j int8 = -128
	fmt.Println(j)
	//j = -129 as int8 value in assignment (overflows)
	
	var a int8 = 127
	fmt.Println(a)
	//a = 128 as int8 value in assignment (overflows) 
    
    // int的其他数据类型取值范围同样严格要求表数范围
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
unit
类型有无符号占用存储空间表数范围
uint81字节0~255
uint162字节0~216-1
uint324字节0~232-1
uint648字节0~264-1

unitint相比取值范围更大,并且无负数,原因是因为:

int8而言,因为有一位要表示符号位,因此如果除符号位为负,则最小值为-27,如果符号位为正,则最大值为27-1。

unit8而言,不需要以为表示符号位,因此如果每一位都为0,则最小值为0,如果每一位都为1,则最大值为28-1。

package main
	
import(
	"fmt"
)
	
func main(){

	// 测试unit8取值范围
	var a uint8 = 255
	fmt.Println(a)
	//a = 256 as uint8 value in assignment (overflows)
	
	var b uint8 = 0
	fmt.Println(b)
	//b = -1 as uint8 value in assignment (overflows)
	fmt.Println(b)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

整形的使用细节:

1)Golang中各整数类型分为:有符号无符号,int uint的默认大小和系统有关。

2)Golang的整形默认声明为int型。

3)在程序中使用格式化输出可以查看某个变量的字节大小和数据类型。

​ fmt.Printf(“%T” , 变量名)

​ fmt.Printf(“%d” , unsafe.Sizeof(变量名)) 需要引入unsafe包

4)Golang程序中整形变量在使用时,遵守选小不选大的原则,即:在保证程序正常运行下,尽量使用占用空间小的数据类型。

浮点型

Golang的浮点型用来存放小数值。

浮点型的分类

类型占用存储空间表数范围
float324字节-3.403E38~3.4.3E38
float648字节-1.798E308~1.798E308

1)关于浮点数在机器中存放形式的简单说明,浮点数=符号位+指数位+尾数位

2)尾数部分可能丢失。造成精度损失。

3)float32和float64都是有符号的。

4)Golang的浮点型默认声明为float64类型。

案例

package main
	
import(
	"fmt"	
)
	
func main(){
	var price float32 = 89.12 
	fmt.Println(price)

	// float32 和 float64都是有符号的
	var num1 float32 = -0.00
	var num2 float64 = -0.00
	fmt.Println("num1= " , num1 , "num2= " , num2)

	// 尾数部分可能丢失,造成精度损失
	// float64 比 float32精度更大
	var num3 float32 = -123.0000901 // num3= -123.00009
	var num4 float64 = -123.0000901
	fmt.Println("num3=", num3 , "num4" , num4)
    
    num5 := 89.001
	fmt.Printf("%T", num5) //float64
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

字符串类型

Golang中没有专门的字符类型,如果要存储单个字符,一般用byte来保存。字符串就是一串固定长度的字符连接起来的字符序列,Golang的字符串是由单个字节连接起来的,也就是说对于传统的字符串是由字符组成的,而Go的字符串不同,它是由字节组成的。

package main
	
import(
	"fmt"
)

// 演示golang中字符类型使用
func main(){

	var c byte = '0'
	var d byte = 'b'

	// 输出字符对应的ascii码
	fmt.Println("c=" , c) //48
	fmt.Println("d=" , d) //98
	// 如果想要输出字符内容,需要采用格式化输出
	fmt.Printf("%c\n", c) //0
	fmt.Printf("%c\n", d) //b

	// byte的取值范围是0-255,'中'字符如果存在buye中会出现overflows溢出,因此我们需要使用其他类型
	var a int = '中'
	fmt.Printf("%c", a)

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24

1)如果保存的字符在ASCII表中,可以直接保存到byte中。

2)如果保存的字符对应码值大于255,这时可以考虑使用int类型。

3)如果想要输出字符内容,需要采用格式化输出。

go语言字符串字面量

在Go语言中,字符串字面量使用""或者'反引号来创建。双引号用来创建可解析的字符串,支持转义。但不能用来引用多行;反引号用来创建原生的字符串字面量,可能由多行组成,但不支持转义,并且可以包含除了反引号外其他所有字符。双引号创建可解析的字符串应用最广泛,反引号用来创建原生的字符串则多用于书写多行消息,HTML以及正则表达式。

package main
	
import(
	"fmt"
)

// 演示golang中字符串类型使用
func main(){
	str1 := "ljy"

	str2 :=`
	<html>
	 	<head>ljy</head>
	</html>`

	fmt.Println(str1)
	fmt.Println(str2)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

go语言字符串连接

使用+号

虽然Go中的字符串是不可变的,但是字符串支持+级联操作和+=追加操作,例如:

package main
	
import(
	"fmt"
)

// 演示golang中字符串类型使用
func main(){
	name := "ljy"
	age := "12"
	msg := name + " " + age

	fmt.Println(name)
	fmt.Println(age)
	fmt.Println(msg) //ljy 12

	msg += name
	fmt.Println(msg) //ljy 12ljy
	msg += age
	fmt.Println(msg) //ljy 12ljy12
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

golang里面的字符串都是不可变的,每次运算都会产生一个新的字符串,所以会产生很多临时的无用的字符串,不仅没有用,还会给gc带来额外的负担,所以性能比较差。


使用fmt.Sprintf()函数

package main
	
import(
	"fmt"
)

// 演示golang中字符串类型使用
func main(){
	name := "ljy"
	age := "12"

	// 使用fmt.Sprintf()函数拼接
	msg := fmt.Sprintf("%s,%s",name , age)
	fmt.Println(msg)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

内部使用[]byte实现,不像直接运算符这种会产生很多临时的字符串,但是内部的逻辑比较复杂,由很多额外的判断,还用到了interface,所以性能也不是很好。


strings.Join()

package main
	
import(
	"fmt"
	"strings"
)

// 演示golang中字符串类型使用
func main(){
	name := "ljy"
	age := "20"
	msg := strings.Join([]string{name,age},",")
	fmt.Println(msg)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

join会先根据字符串数组的内容,计算出一个拼接之后的长度,然后申请对应大小的内润,一个一个字符串填入,在已有一个数组的情况下,这种效率会很高,但是本来没有,去构造这个数据的代价也不小。


buffer.WriteString()

package main
	
import(
	"fmt"
	"bytes"
)

// 演示golang中字符串类型使用
func main(){
	var buffer bytes.Buffer
	buffer.WriteString("ljy")
	buffer.WriteString(",")
	buffer.WriteString("20")
	fmt.Println(buffer.String())
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

这个比较理想,如果当成可变字符使用,对内存的增长也有优化,如果能预估字符串的长度,还可以使用buffer.Grow()接口来设置capacity。

go语言字符串转义字符

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

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

go语言字符串切片操作

package main
	
import(
	"fmt"
)

// 演示golang中字符串类型使用
func main(){
	// 字符串切片操作
	str := "hello world"
	n := 3
	m := 5

	fmt.Println(str[n])		// 获取字符串索引位置为n的原始字节
	fmt.Println(str[n:m])	// 截取得字符串索引位置为n到m-1的字符串
	fmt.Println(str[n:])	// 截取得字符串索引位置为n到len(str) - 1的字符串
	fmt.Println(str[:m])	// 截取得字符串索引位置为0到m-1的字符串
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

go语言字符串常用操作

函数作用
len(str)求字符串长度
+或fmt.Sprintf()拼接字符串
strings.Split()分割字符串,以指定规则
strings.Contains()判断是否包含
strings.HasPrefix,strings.HasSuffix前缀/后缀判断
strings.Index(),strings.LastIndex()字串出现的位置
strings.koin(a[]sring,sep string)join操作
package main
	
import(
	"fmt"
	"strings"
)

// 演示golang中字符串类型使用
func main(){
	// 字符串常用操作
	str := "hello world"
	fmt.Println(len(str)) //获取字符串长度

	fmt.Println(strings.Split(str , " ")) //字符串分割

	fmt.Println(strings.Contains(str , "hello")) //判断是否包含字串

	fmt.Println(strings.HasPrefix(str , "hello")) //判断是否作为前缀

	fmt.Println(strings.HasSuffix(str , "world")) //判断是否作为后缀

	fmt.Println(strings.Index(str , "l")) //字串出现的位置

	fmt.Println(strings.LastIndex(str , "l")) //join拼接操作
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25

布尔类型

go语言中的布尔类型有两个常量值:truefalse。布尔类型经常用在条件判断语句,或者循环语句。也可以用在逻辑表达式中

案例

package main
	
import(
	"fmt"
)
	
func main(){
	var b1 bool = true
	var b2 bool = false
	var b3 = true
	var b4 = false
	b5 := true
	b6 := false

	fmt.Println(b1)
	fmt.Println(b2)
	fmt.Println(b3)
	fmt.Println(b4)
	fmt.Println(b5)
	fmt.Println(b6)
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

用在逻辑判断中

package main
	
import(
	"fmt"
)
	
func main(){
	num1 := 13
	ok := num1 >= 18

	if ok {
		fmt.Println("您已经成年!")
	} else {
		fmt.Println("您还未成年!")
	}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

用在循环中

package main
	
import(
	"fmt"
)
	
func main(){
	for i:= 0 ; i < 10 ; i++ {
		fmt.Printf("i=%v \t", i)
	}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

用在逻辑表达式中

package main
	
import(
	"fmt"
)
	
func main(){
    
	age := 18
	gender := "男"

	if age >= 18 && gender == "男" {
		fmt.Println("你是成年男子!")
	}
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

不能用0和非0数表示真假

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小丑西瓜9/article/detail/206324
推荐阅读
相关标签
  

闽ICP备14008679号