1、基本数据类型

基本数据类型有：布尔型、数字型和字符型

1.1、布尔类型 bool

布尔型的值只可以是常量 true 或者 false。
两个类型相同的值可以使用相等 == 或者不等 != 运算符来进行比较并获得一个布尔型的值。
当相等运算符两边的值是完全相同的值的时候会返回 true，否则返回 false，并且只有在两个的值的类型相同的情况下才可以使用。

var aVar = 10
aVar == 5 -> false
aVar == 10 -> true
aVar != 5 -> true
aVar != 10 -> false
!T -> false
!F -> true
T && T -> true
T && F -> false
F && T -> false
F && F -> false
T || T -> true
T || F -> true
F || T -> true
F || F -> false

1.2、数字类型

1.2.1、整型

int 和 uint 在 32 位操作系统上，它们均使用 32 位（4 个字节），在 64 位操作系统上，它们均使用 64 位（8 个字节）。
uintptr 的长度被设定为足够存放一个指针即可。

整数：

int8（-128 -> 127）
int16（-32768 -> 32767）
int32（-2,147,483,648 -> 2,147,483,647）
int64（-9,223,372,036,854,775,808 -> 9,223,372,036,854,775,807）

无符号整数：

uint8（0 -> 255）
uint16（0 -> 65,535）
uint32（0 -> 4,294,967,295）
uint64（0 -> 18,446,744,073,709,551,615） ```go var a int var b int32 a = 15 b = a + a // 编译错误 b = b + 5 // 因为 5 是常量，所以可以通过编译

var n int16 = 34 var m int32 m = int32(n) fmt.Printf(“32 bit int is: %d\n”, m) fmt.Printf(“16 bit int is: %d\n”, n)

//安全地从 int 型转换为 int8 func Uint8FromInt(n int) (uint8, error) { if 0 <= n && n <= math.MaxUint8 { // conversion is safe return uint8(n), nil } return 0, fmt.Errorf(“%d is out of the uint8 range”, n) }

//安全地从 float64 转换为 int func IntFromFloat64(x float64) int { if math.MinInt32 <= x && x <= math.MaxInt32 { // x lies in the integer range whole, fraction := math.Modf(x) if fraction >= 0.5 { whole++ } return int(whole) } panic(fmt.Sprintf(“%g is out of the int32 range”, x)) }

<a name="oFhuj"></a>
### 1.2.2、浮点型
**浮点型（IEEE-754 标准）：**
   - float32（+- 1e-45 -> +- 3.4 * 1e38）
   - float64（+- 5 _1e-324 -> 107 _1e308）
<a name="oNFLQ"></a>
### 1.2.3、复数
complex64 (32 位实数和虚数)<br />complex128 (64 位实数和虚数)<br />复数使用 `re+imI` 来表示，其中 `re` 代表实数部分，`im` 代表虚数部分，`I` 代表根号负 1。
```go
var c1 complex64 = 5 + 10i
fmt.Printf("The value is: %v", c1)
// 输出： 5 + 10i
如果 re 和 im 的类型均为 float32，那么类型为 complex64 的复数 c 可以通过以下方式来获得：
c = complex(re, im)

1.3、字符类型

Go 语言严格来说，没有字符类型，所谓字符只是整数的特殊用例。byte 类型是 uint8 的别名，对于只占用 1 个字节的传统 ASCII 编码的字符来说，完全没有问题。例如：var ch byte = 'A'；字符使用单引号括起来。
在 ASCII 码表中，A 的值是 65，而使用 16 进制表示则为 41，所以下面的写法是等效的：

var ch byte = 65 或 var ch byte = '\x41'

2、字符串

字符串是 UTF-8 字符的一个序列（当字符为 ASCII 码时则占用 1 个字节，其它字符根据需要占用 2-4 个字节）。UTF-8 是被广泛使用的编码格式，是文本文件的标准编码，其它包括 XML 和 JSON 在内，也都使用该编码。
string 类型的零值是长度为零的字符串，即空字符串 “”。
一般的比较运算符（==、!=、<、<=、>=、>）通过在内存中按字节比较来实现字符串的对比。你可以通过函数 len() 来获取字符串所占的字节长度，例如：len(str)。
字符串的内容（纯字节）可以通过标准索引法来获取，在中括号 [] 内写入索引，索引从 0 开始计数：

字符串 str 的第 1 个字节：str[0]
第 i 个字节：str[i - 1]
最后 1 个字节：str[len(str)-1]

需要注意的是，这种转换方案只对纯 ASCII 码的字符串有效。

2.1、解释字符串

\n：换行符
\r：回车符
\t：tab 键
\u 或 \U：Unicode 字符
\\：反斜杠自身
2.2、非解释字符串
该类字符串使用反引号括起来，支持换行
```
str := `This is a raw string
       This is a raw string`
```
2.3、字符串拼接符
两个字符串 s1 和 s2 可以通过 s := s1 + s2 拼接在一起。
拼接的简写形式 += 也可以用于字符串：
```
s := "hel" + "lo,"
s += "world!"
fmt.Println(s) //输出 “hello, world!”
```
3、指针
程序在内存中存储变量的值，每个内存块（或字）有一个地址，通常用十六进制数表示，如：0x6b0820 或 0xf84001d7f0 。
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。 ```go // 声明一个普通int变量
a := 5 // 声明一个指针变量 var b int // 取出a变量的地址，赋值给b变量 b = &a // 通过指针改变变量的值，此时所有引用地址的变量的值都将改变 b = 10 fmt.Println(“a=”, a) fmt.Println(“&a=”, &a) fmt.Println(“b=”, b) fmt.Println(“b=”, b)

//输出结果 a= 10 &a= 0xc00008a890 b= 0xc00008a890 *b= 10

<a name="CmHCQ"></a>
# 4、时间和日期
```go
// 获取当前时间 CST
t := time.Now()
fmt.Println(t)
// 使用fmt格式化天.月.年
fmt.Printf("%02d.%02d.%4d\n", t.Day(), t.Month(), t.Year())
// 获取当前时间 UTC
t = time.Now().UTC()
fmt.Println(t)
// 一周后时间
var week time.Duration
week = 60 * 60 * 24 * 7 * 1e9
week_from_now := t.Add(week)
fmt.Println(week_from_now)
// 使用time包自带方法格式化年-月-日
s := t.Format("2006-01-02")
fmt.Println(t, "=>", s)
// 输出结果
2020-06-16 10:36:43.6904988 +0800 CST m=+0.028933501
16.06.2020
2020-06-16 02:36:43.6904988 +0000 UTC
2020-06-23 02:36:43.6904988 +0000 UTC
2020-06-16 02:36:43.6904988 +0000 UTC => 2020-06-16

数据类型