2 基本数据类型

整型、浮点型、布尔型、字符串

数组、切片、结构体、函数、map、通道等

2.1 整型

分为两个大类：

长度：int8, int16, int32, int64
- int16: short类型
- int64: long 类型
无符号：uint8，uint16, uint32, uint64
- uint8: byte型

2.1.1 特殊整型

特殊整型
- uint : 32为操作系统上是uint32
- int : 32位操作系统上是int32
- uintptr : 无符号整型，用于存放一个指针
注意：使用int和uint需要考虑不同平台的差异
注意：获取对象的长度的内建len()函数，返回的长度可以根据不同的平台的字节长度变化
- 实际使用中，切片或map元素数量可以用int表示
- 涉及二进制传输、读写文件的结构描述时，不要使用int和uint

2.1.2 数字字面量语法(Number literals syntax)

便于开发者以二进制、八进制、十六进制浮点数的格式 定义数字

v := 0b001: 二进制的001
v := 0o77: 八进制的77
v := 0xff: 十六进制的ff

允许使用_分隔数字：v := 12_3

允许开发者使用相应的占位符以二进制%b、八进制%o、十进制%d、十六进制%x输出：

由以上两个性质，我们可以将任意进制数字以任意进制形式输出

示例:

package main

import "fmt"

func main() {
    //定义
    var x int = 10
    var b int = 077
    var c int = 0xff
    
    //输出
    var a int = 15
	fmt.Printf("%d\n", a) //以十进制形式输出
	fmt.Printf("%b\n", a) //以二进制形式输出
	fmt.Printf("%o\n", a) //以八进制形式输出
	fmt.Printf("%x\n", a) //以十六进制形式输出
}

浮点型

两种浮点型：都遵循IEEE 754标准

float32 : 最大范围3.4e38, 可使用常量定义：math.MaxFloat32
float64：最大范围1.8e308 ,math.MaxFloat64

打印浮点数，使用占位符%f

package main
import (
    "fmt"
    "math"
)
func main(){
    fmt.Printf("%f\n",math.Pi)
    fmt.Printf("%.2f\n",math.Pi)
}

复数

两种：都由实部与虚部组成各占一半

complex64 : 实部未 32 位，虚部为 32 位
complex128

示例：

package main
import "fmt"
func main(){
    var c complex64 = 1 + 2i
    fmt.Println(c)
}

布尔型

bool 型两个值：true 、 false

==注意：==

默认值：false
不允许将整型强制转换为bool
bool 无法参与数值运算，无法与其他类型转换

字符串

Go 中的字符串以原生数据类型出现

注意：Go 语言的字符串内部实现使用UTF-8编码
字符串的值为双引号中的内容
可以在Go的源码中直接添加非ASCII码字符
- s1 := "hello"
- s2 := "你好"

字符串转义符

转义符	含义
\r	回车符（返回行首
\n	换行符（直接跳到下一行的同列位置
\t	制表符
`\'`	单引号
`\"`	双引号
`\\`	反斜杠，例如文件路径

多行字符串

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

s := `line1
lin2
`
fmt.Println(s)

字符串常用操作

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

byte 和 rune 类型

字符串的每个元素是字符，字符用单引号包裹

可以通过遍历或 单个获取字符串元素 获得字符

Go 的字符有两种：

uint8, 或叫byte型，代表ASCII码的一个字符
int32, 或叫rune类型，代表一个UTF-8码的一个字符
处理中文、日文或者其他符合字符：用到rune类型，实际上是一个int32

Go 使用特殊的 rune 类型处理 Unicode，让基于Unicode的文本处理更方便，也可以使用byte型进行默认字符串处理，性能和扩展性都有照顾：

示例：

```Go
package main

import “fmt”

func main() {

s := "hello, 世界"

//byte
for i := 0; i < len(s); i++ {
    fmt.Printf("%v %c\n", s[i], s[i])
}

//rune
for _, r := range s {
    fmt.Printf("%v %c\n", r, r)
}

}

1
2
3


* 输出：

104 h
101 e
108 l
108 l
111 o
44 ,
32
228 ä
184 ¸
150
231 ç
149
140
104 h
101 e
108 l
108 l
111 o
44 ,
32
19990 世
30028 界


* ==注意：==

  * `UTF-8` 编码下 一个汉字，由三至四个字节组成，所以不能简单按照字节去遍历 一个包含汉子的字符串
    * rune 用来表示`UTF-8`字符，一个rune 字符由一个或多个byte组成
  * ==字符串底层==：一个`byte`数组，所以可以和`[]byte`类型相互转换
  * 字符串是==不能 直接修改== 的
  * ==字符串长度==：`byte`数组的长度

* `for _,r := range s`

  * 



#### 修改字符串

* 需要将字符串转换成`[]rune`或`[]byte`

  * 在转换成`string`

* 转换，都会重新分配内存，并复制字节数组

* 示例

  * ```go
    package main
    
    import "fmt"
    
    func main() {
    	s := "hello world"
    
    	//强制类型转换
    	bytes := []byte(s)
    	bytes[0] = 'p'
    	fmt.Println(string(bytes))
    
    	s2 := "你好，世界"
    	runes2 := []rune(s2)
    	runes2[0] = '我'
    	fmt.Println(string(runes2))
    }

类型转换

Go 中只有强制类型转换，无隐式类型转换

只在两个类型之间支持相互转换的时候使用

语法：T(expression)
- T: 要转换的的类型
- 表达式：包括变量、复杂算子、函数返回值等
Sqrt 所接受的参数是float64类型

示例：

```go
package mainimport (

"fmt"
"math"

)func main() {

var a, b = 3, 4
var c int
c = int(math.Sqrt(float64(a*a + b*b)))
fmt.Println(c)

}


    

### 练习题

#### 练习一

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

* ```Go
  package main
  
  import "fmt"
  
  func main() {
  	s := "hello"
  	i := 10
  	f := 3.14
  	var b bool = true
  	fmt.Printf("%s %T\n", s, s)
  	fmt.Printf("%d %T\n", i, i)
  	fmt.Printf("%f %T\n", f, f)	
  	fmt.Printf("%t %T\n", b, b)	\\bool 的占位符：`%t`
  }

练习二

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

package main

import "fmt"

func main() {
    s := "hello沙河小王子"
    count := 0

    for _, i := range s {            //range
        if len(string(i)) > 1 {        //
            count++
        }
    }
    fmt.Println(count)
}