latte Studio

go基础语法之基本数据类型

go基础语法之基本数据类型
 开发/go  3113  7 分钟  

基础数据类型

go语言中数据类型：

  • 整型
  • 浮点型
  • 布尔型
  • 字符串
  • 数组
  • 切片
  • 结构体
  • 函数
  • map
  • 通道channel
  • ...

整型

整型分2大类：

  • 有符号整型:

    其中数字代表内存中一个该类型数据占几位，位越多，能表示的范围就越大；

    • int8
    • int16：对应c语言的short
    • int32
    • int64：对应c语言中的long型

  • 无符号位整型:

    无符号位的整型，因第一位不用充当符号位，即正数或负数，表示的访问为无符号数最大值砍半，然后均分在0的2侧；

    • uint8：即byte型，
    • uint16
    • uint32
    • uint64

图示：

image-20201228134631420

特殊整型

  • unit：没有指明位数，在32位系统就是uint32，在64位系统就是uint64
  • int，在32位系统就是int32，在64系统就是int64
  • uintptr，无符号整型，存放一个指针；

所以，考虑到不同平台的差异，最后明确指定位数的整型数据；

数字字面量语法

go1.13版本引入，方便以二进制、八进制、十六进制定义数字；

eg：

  • v := 0b00101101 表示二进制101101，相当于十进制45
  • v := 0o377表示二进制377，十进制的255
  • v :=0x1p-2表示十六进制的1除以2的平方，相当于十进制0.25
  • 使用_分隔数据
    • v := 123_456，v值就是123456

demo函数

 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
26
27
28
29
30
31
32
33
34
35
36
37

package main

import "fmt"

func main() {

	// 十进制
	var a int = 10         // 定义一个十进制数10
	fmt.Printf("%d \n", a) // 以十进制格式输出，还是10
	fmt.Printf("%b \n", a) // 将10以二进制格式输出，就是1010

	// 二进制 以0开头
	var b int = 077
	fmt.Printf("%o \n", b)
	fmt.Printf("%d \n", b)

	// 十六进制 以0x开头
	var c int = 0xff
	fmt.Printf("%x \n", c)
	fmt.Printf("%X \n", c)
	fmt.Printf("%d \n", c)

	// %d 表示十进制格式
	// %b 表示二进制格式
	// %o 八进制而是
	// %x 十六进制小写格式
	// %X 十六进制大写格式

}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe
10
1010
77
63
ff
FF
255

浮点型

go支持2种浮点型，float32和float64；

  • float32范围：3.4e38，使用常量定义：math.MaxFloat32
  • float64范围：1.8e308，使用常量定义：math.MaxFloat64

demo:

打印浮点数，%f是浮点数的格式占位符；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import (
	"fmt"
	"math"
)

func main() {
	fmt.Printf("%f\n", math.Pi) // 默认是取小数点后6位
	fmt.Printf("%.2f\n", math.Pi)// .2表示取小数点后2位
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe
3.141593
3.14

复数

complex64和complex128,复数分为实部和虚部，complex64的实部和虚部都是64位，complex32则都是32位；

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main

import (
	"fmt"
)

// 复数demo
func main() {
	var c1 complex64
	c1 = 1 + 2i
	var c2 complex128
	c2 = 2 + 3i

	fmt.Println(c1)
	fmt.Println(c2)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe
(1+2i)
(2+3i)

布尔值

布尔型bool，只有ture和fasle2个值，

  • 默认是false
  • go不允许将整型，强制类型转换为，布尔型
  • 布尔型无法参于数据运算，无法和其他类型进行转换
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import (
	"fmt"
)

// bool demo

func main() {
	var isOk bool
	fmt.Println(isOk)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe
false

字符串

字符串是go语言中原生数据类型，go中字符串实现采用utf-8编码，所以go的字符串变量中可以填入“万国字符”——中文、英文、日文都中，其格式为外部有双引号。

1
2

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

字符串转义符

go中常用转义符：

  • \r 回车符，跳到下一行的行首
  • \n 换行符，跳到下一行的同列位置
  • \t 制表符
  • '单引号
  • "" 双引号
  • \ 反斜杠

demo：打印windows下的文件路径：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import (
	"fmt"
)

// 字符串demo，并转义
func main() {
	fmt.Println("str := \"c:\\Code\\lesson01\\go.exe\"")
}
// 打印时，像" 和 \ 这种特殊字符，需要前面加一个\进行转义

D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe
str := "c:\Code\lesson01\go.exe"

多行字符串

 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() {
	s1 := `
		line1
		line2 
		line3
	`
	fmt.Println(s1)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe

                line1
                line2
                line3

字符串的常用操作

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

byte和rune类型

组成字符串的每个元素：都叫做字符，如一个汉字、一个英文字母，一个日文、都是一个字符，注:不同字符所占据的字节是不同的;

通过遍历字符串，可获得其中的字符元素、字符用单引号包裹；

var a := "中"
var b := "Y"

go的字符有以下2种：

  • uint8类型，或叫byte型，代表ascill码表的一个字符，
  • rune类型，代表一个utf-8字符，**中文、日文、韩文、这种需要用到rune类型，rune本质是一个int32类型）

go使用rune类型处理unicode编码，更方便处理基于unicode的文件，若一个文件都是ascill字符，则可以使用byte类型做文本处理，更节省空间

demo：

 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
26
27
28

package main

import (
	"fmt"
)

// 遍历字符串demo
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()
}
// s这个字符串，由字母和中文组成，中文在utf-i编码中有3到4个字节组成，而第一个遍历方式，全部以一个byte看做一个字符遍历，显然会把一个汉字的从字节切开，然后导致乱码
// 第二种遍历方式，以rune类型遍历，自然就是每次遍历一个字符，即便多种字符混合也可正常遍历，支持万国码

D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe
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(河)

修改字符串

字符串本质是一个byte数组，一个字符占据一个数组的下标，修改字符串步骤：

  1. 先将其转换为[]rune适合utf-8编码的字符串，或[]byte，适合纯ascill字符组成的字符串！
  2. 对字符串数据，中的字符元素，进行修改，利用数组下标
  3. 完成后再转为string
  4. 转换中，会重新分配内存，并复制字节数组

demo：

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

package main

import (
	"fmt"
)

// 字符串修改demo
func main() {
	s1 := "big"

	bytes1 := []byte(s1) // 先转为字符串数组bytes1
	bytes1[0] = 'p' // 对bytes1的0号元素，替换为p
    				// 注意赋值用等号= , 单个字符用''单引号
	fmt.Println(string(bytes1)) // 再转回string类型

	s2 := "白萝卜"
	runes2 := []rune(s2) // 包含汉字，用[]rune做类型转换
	runes2[0] = '红'
	fmt.Println(string(runes2))
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe
pig
红萝卜

类型转换

go中，只有强制类型转换，没有隐式类型转换，只有2个类型数据，支持相互转换时，才可做类型转换；

语法：

​ T(表达式)：T是要转换的类型，表达式可是：变量、复杂算子、函数返回值等

demo：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package main

import (
	"fmt"
	"math"
)

// 类型转换demo
func main() {

	var a, b = 3, 4
	var c int

	c = int(math.Sqrt(float64(a*a + b*b)))
    // math.Sqrt 函数接收的参数类型是float64类型，
    // 所以，需要对内部计算表达式的结果做float64类型的转换
	fmt.Println(c)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe
5

练习

  1. 编写代码分别定义一个整型、浮点型、布尔型、字符串型变量，使用fmt.Printf()搭配%T分别打印出上述变量的值和类型。

     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
26
27
28

    package main
   
import (
 "fmt"
)
   
// test1
func main() {
 var num int = 10
 var f1 float32 = 6.66
 var isOk bool = true
 var str string = "good good study"
   
 fmt.Printf("%d, %T \n", num, num)
 fmt.Printf("%.1f, %T \n", f1, f1)
 fmt.Println(isOk)
 fmt.Printf("%T \n", isOk)
 fmt.Println(str)
 fmt.Printf("%T \n", str)
}
   
D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe
10, int
6.7, float32
true
bool
good good study
string

  2. 编写代码统计出字符串"hello沙河小王子"中汉字的数量

     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

    package main
   
import (
 "fmt"
)
   
// test2
// 先转换为rune数组，然后遍历数组的字符元素，
// 遍历时，字符元素再转换为string类型，并利用len函数求其长度，
// 若长度大于或等于3，则是汉字，计数值加1
func main()  {
 s1 := "hello沙河小王子溜溜溜"
 numOfHanzi := 0
 runes1 := []rune(s1)
   
 for i := 0; i < len(runes1); i++ {
     if len(string(runes1[i])) >= 3 {
         numOfHanzi++
     }
 }
   
 fmt.Printf("the num of hanzi is : %d", numOfHanzi)
}
D:\workstation\mycode\gocode\src\learngo\basic_grammar\03_data_type>03_data_type.exe
the num of hanzi is : 8
updatedupdated2020-12-282020-12-28

相关文章：

加载评论