go数据类型一

go数据类型分为：基本数据类型 和 派生数据类型

一 基本数据类型

基本数据类型分为：布尔类型、数字类型、字符串类型

1 布尔类型

布尔型的值只可以是常量 true 或者 false

2 数字类型

(1) 整型

(2) 浮点类型

(3) 其他整型

byte 类似 uint8
rune 类似 int32
uint 类似 uint32 或 uint64
int 类似 int32 或 int64
uintptr 无符号整型，用于存放一个指针
备注uint 和 int 取决于操作系统是32位还是64位

3 字符串类型

字符串就是一串固定长度的字符连接起来的字符序列。Go 的字符串是由单个字节（byte）连接起来的。Go 语言的字符串的字节使用 UTF-8 编码标识 Unicode 文本。

二 派生数据类型

指针类型、数组类型、结构化类型、channel类型
函数类型、切片类型、接口类型、map类型

1 指针类型

(1)概念

<1> 一个指针变量指向一个值的内存地址
<2> Go 语言的取地址符是 &

(2)声明

var var_name *var-type
例如：
var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 *

(3) 使用

定义指针变量
为指针变量赋值
访问指针变量中指向地址的值

举例：

package main
import "fmt"
func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */
   ip = &a  /* 指针变量的存储地址 */
   fmt.Printf("a 变量的地址是: %x\n", &a  )
   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )
   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}

(4) Go 空指针

当一个指针被定义后没有分配到任何变量时，它的值为 nil

(5) go 指针数组

数组中存放指针。
定义： var ptr [MAX]*int

举例：

package main
import "fmt"
const MAX int = 3
func main() {
   a := []int{10,100,200}
   var i int
   var ptr [MAX]*int;
   for  i = 0; i < MAX; i++ {
      ptr[i] = &a[i] /* 整数地址赋值给指针数组 */
   }
   for  i = 0; i < MAX; i++ {
      fmt.Printf("a[%d] = %d\n", i,*ptr[i] )
   }
}

(6)go 语言指向指针的指针

举例：

package main
import "fmt"
func main() {
   var a int
   var ptr *int
   var pptr **int
   a = 3000
   /* 指针 ptr 地址 */
   ptr = &a
   /* 指向指针 ptr 地址 */
   pptr = &ptr
   /* 获取 pptr 的值 */
   fmt.Printf("变量 a = %d\n", a )
   fmt.Printf("指针变量 *ptr = %d\n", *ptr )
   fmt.Printf("指向指针的指针变量 **pptr = %d\n", **pptr)
}

2 数组类型

数组是具有相同唯一类型的一组已编号且长度固定的数据项序列，这种类型可以是任意的原始类型例如整形、字符串或者自定义类型。

(1) 数组声明

Go 语言数组声明需要指定元素类型及元素个数，语法格式如下：

var variable_name [SIZE] variable_type
// 举例：
var balance [10] float32

(2) 数组初始化

var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
初始化数组中 {} 中的元素个数不能大于 [] 中的数字。
如果忽略 [] 中的数字不设置数组大小，Go 语言会根据元素的个数来设置数组的大小：
var balance = […]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
举例：

package main
import "fmt"
func main() {
   var n [10]int /* n 是一个长度为 10 的数组 */
   var i,j int
   /* 为数组 n 初始化元素 */        
   for i = 0; i < 10; i++ {
      n[i] = i + 100 /* 设置元素为 i + 100 */
   }
   /* 输出每个数组元素的值 */
   for j = 0; j < 10; j++ {
      fmt.Printf("Element[%d] = %d\n", j, n[j] )
   }
}

(3) 二维数组的声明

var arrayName [ x ][ y ] variable_type

a = [3][4]int{  
 {0, 1, 2, 3} ,   /*  第一行索引为 0 */
 {4, 5, 6, 7} ,   /*  第二行索引为 1 */
 {8, 9, 10, 11},   /* 第三行索引为 2 */
}

3 切片类型

(1)概念

Go 语言切片是对数组的抽象。
Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go中提供了一种灵活，功能强悍的内置类型切片(“动态数组”),与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

(2) 定义

var slice1 []type = make([]type, len)
// 简写：
slice1 := make([]type, len)
// 也可以指定容量，其中capacity为可选参数
make([]type, length, capacity)

(3) 初始化

方式一 直接初始化

s: = []int{1,2,3}
// 直接初始化切片，[]表示是切片类型，{1,2,3}初始化值依次是1,2,3.其cap=len=3

方式二 用数组初始化

s := arr[:]
s := arr[startIndex:endIndex]
// 将arr中从下标startIndex到endIndex-1 下的元素创建为一个新的切片

方式三 通过切片初始化切片

s1 := s[startIndex:endIndex] 

方式四 通过make初始化切片

s :=make([]int,len,cap)

(4)len() 和 cap() 函数

s := make([]int, 2, 5)
len(s)
cap(s) 

len() 获取切片的长度
cap() 获取切片的容量

(5)空(nil)切片

一个切片在未初始化之前默认为 nil，长度为 0，实例如下：

package main
import "fmt"
func main() {
   var numbers []int
   if(numbers == nil){
      fmt.Printf("切片是空的")
   }
}

(6)切片截取

可以通过设置下限及上限来设置截取切片 [lower-bound:upper-bound]

例如：

package main
import "fmt"
func main() {
   /* 创建切片 */
   numbers := []int{0,1,2,3,4,5,6,7,8}  
   printSlice(numbers)
   /* 打印原始切片 */
   fmt.Println("numbers ==", numbers)
   /* 打印子切片从索引1(包含) 到索引4(不包含)*/
   fmt.Println("numbers[1:4] ==", numbers[1:4])
   /* 默认下限为 0*/
   fmt.Println("numbers[:3] ==", numbers[:3])
   /* 默认上限为 len(s)*/
   fmt.Println("numbers[4:] ==", numbers[4:])
   numbers1 := make([]int,0,5)
   printSlice(numbers1)
   /* 打印子切片从索引  0(包含) 到索引 2(不包含) */
   number2 := numbers[:2]
   printSlice(number2)
   /* 打印子切片从索引 2(包含) 到索引 5(不包含) */
   number3 := numbers[2:5]
   printSlice(number3)
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}

结果：

7 append() 和 copy() 函数

// copy
numbers := []int{0,1,2,3,4,5,6,7,8}  
numbers1 := make([]int, len(numbers), (cap(numbers))*2)
/* 拷贝 numbers 的内容到 numbers1 */
copy(numbers1,numbers)

// append
// append 的时， 当切片容量不足时，会自动增加容量
package main
import "fmt"
func main() {
   var numbers []int
   printSlice(numbers)
   /* 允许追加空切片 */
   numbers = append(numbers, 0)
   printSlice(numbers)
   /* 向切片添加一个元素 */
   numbers = append(numbers, 1)
   printSlice(numbers)
   /* 同时添加多个元素 */
   numbers = append(numbers, 2,3,4)
   printSlice(numbers)
}
func printSlice(x []int){
   fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x)
}