03-GO语言基础基本数据类型

整型

整型分类

特殊整型：

数字字面量语法

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

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

事例：

package main

import "fmt"

func f7() {
	var (
		i1 int8   = 0b1001  //二进制
		i2 uint64 = 0o644   //八进制
		i3        = 0x123   //十六进制  默认int
		i4 int32  = 123_456 //分隔让数字更直观
	)
	fmt.Println(i1, i2, i3, i4)
	//利用fmt.Printf 格式化打印
	i5 := 123
	fmt.Println("自带换行")
	fmt.Printf("十进制：%d \n", i5)
	fmt.Printf("八进制： %o\n", i5)
	fmt.Printf("二进制：%b\n", i5)
	fmt.Printf("十六进制：%x\n", i5)

}

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

浮点型

计算机中浮点数都是不精确的！

Go语言支持两种浮点型数：float32和float64。实际写业务遇到浮点数运算都是转成整型来计算的。打印浮点数时，可以使用fmt包配合动词%f,代码如下：

package main

import (
	"fmt"
	"math"
)

func f8() {
	fmt.Printf("%f\n", math.Pi)
	fmt.Printf("%2f\n", math.Pi)
}
1
2
3
4
5
6
7
8
9
10
11

布尔型

var b11 = true
var b12 bool // false
1
2

注意：

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

字符串

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

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

字符串转义符

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

//表示windows下的一个文件路径
	f := "C:\\go\\hello\\hello.exe"
	fmt.Println(f)
1
2
3

多行字符串

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

//多行字符串
	s2 := `王磊
	是个还总
	把
	`
	fmt.Println(s2)
1
2
3
4
5
6

字符串常用操作

package main

import (
	"fmt"
	"strings"
)

func f9() {
	//表示windows下的一个文件路径
	f := "C:\\go\\hello\\hello.exe"
	fmt.Println(f)
	s1 := "\"永远不要高估自己\""
	fmt.Println(s1)
	//多行字符串
	s2 := `王磊
	是个还总
	把
	`
	fmt.Println(s2)

	//字符串操作
	//1 字符串长度
	s3 := "hello小男孩"
	fmt.Println(len(s3)) //一个汉子是3个字符,所以总共14个字符

	//2 拼接字符串
	name := "wanglei"
	value := "过年好"
	fmt.Println(name + value)

	ret := fmt.Sprintf("大家好，%s祝大家%s", name, value)
	fmt.Println(ret)

	//3 分隔
	s4 := "你:好:呀"
	fmt.Println(strings.Split(s4, ":"))

	fmt.Println(strings.Contains(s4, "好"))  //true
	fmt.Println(strings.HasPrefix(s4, "你")) //true
	fmt.Println(strings.HasSuffix(s4, "a")) //false

	//字串出现的索引位置

	fmt.Println(strings.Index(s4, ":")) // 3

	//拼接

	slice := []string{"你", "我", "他"}
	fmt.Println(strings.Join(slice, "-"))
}
	

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
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

字符

byte和rune

byte：常见的a、b、c等字符

rune 是用来表示中文、日文等复合字符的

package main

import "fmt"

func f10() {
	s1 := "hello小男孩"
	//遍历字符串
	for i := 0; i < len(s1); i++ { //byte
		fmt.Printf("%v(%c)", s1[i], s1[i])
	}
	fmt.Println()
	for _, v := range s1 { //rune  会将汉子完整输出
		fmt.Printf("%v(%c)", v, v)
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

类型转换

package main

import "fmt"

// 类型转换

// T()

func f3() {
	var i11 int8 = 1

	i12 := int64(i11)             // int8 -> int64
	fmt.Printf("i12: %T \n", i12) // int64

	f11 := 12.34                  // float64
	f12 := int64(f11)             // float64 -> int64
	fmt.Printf("f12: %T \n", f12) // int64

	// bool(1) // int -> bool 🚫
}

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

练习

1. 编写代码统计出字符串"hello爱写代码的小男孩"中汉字的数量。

   package main
   
   import "fmt"
   
   func f11() {
   	s1 := "hello爱写代码的小男孩"
   	count := 0
   	for _, v := range s1 {
   		if v > 'z' {
   			count++
   		}
   	}
   	fmt.Println(count)
   }
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14