go数据类型

基础数据类型

byte和rune

字符串

常用方法

len(str) //求长度
strings.Split //分割
strings.Contains //判断是否包含
strings.HasPrefix , strings.HasSuffix //前缀 后缀判断
strings.Index() , strings.LastIndex() //子串出现的位置

数组

定义

//一维数组定义
arr := [5]int{} //定义一个长度为5，每个元素都为整形的数组
var arr [5]int = [5]int{1,2,3,4,5}
...
//定义二维数组
arr := [5][5]int //定义了一个5行5列的数组

数组的长度是固定的，数组中的每个元素的类型都相同

数组遍历

s := [5]int{1, 2, 3, 4}
for index, value := range s {
	fmt.Println(index, value)
}

切片

切片底层基于数组实现，本生为指针，切片长度len不等于capacity，预留了空间等待填入值

定义

var s []int // len=cap=0
s := []int{} // len=cap=0
s = make([]int,3) // len=cap=3
s = make([]int,3,5) // len=3, cap=5
s = int[]int{1,2,3,4,5} // len=cap=5
s2d := [][]int{
  {1},{2,3} // 二维数组各行的列数相等，但二维切片各行的len可以不等
}

切片方法

1 append //用于向预留空间添加值，达到上限时扩容
s := make([]int, 3, 5) //len为3，cap为5
s = append(s, 9)

切片的遍历

s := []int{1, 2, 3, 4}
for index, value := range s {
	fmt.Println(index, value)
	}

map

指针类型

map的初始化

var m map[string]int //声明map，指定key和value的数据类型
m = make(map[string]int) //初始化，容量为0
m = make(map[string]int,200) //初始化，容量为200
m := map[string]int{"语文":0,"数学":39} //初始化时直接赋值

删除和添加key

m["英语"] = 59 //往map里添加key-value对
m["英语"] = 70 //会覆盖之前的值
delete(m,"") //从map里删除key-value对
len(m) //获取map的长度
go不支持对map执行cap函数

map的遍历

m := map[string]int{"语文": 2, "数学": 22}
for k, v := range m {
	fmt.Println(k, v)
}

管道

指针类型，环状队列，不可扩容

管道的声明和初始化

var ch chan int //声明
ch = make(chan int,8) //初始化，环形队列可容纳8个元素

send和revc

ch := make(chan int, 8)
	ch <- -1  // 添加
	ch <- -2
	v1 := <-ch //取出
	v2 := <-ch
	fmt.Println(v1)
	fmt.Println(v2)

关闭管道

close(ch) //关闭管道之后就不允许往管道里写入了

管道的遍历

ch := make(chan int, 8)
ch <- -1
ch <- -2
close(ch) //遍历之前需要先关闭管道
for v := range ch {
	fmt.Println(v)
}

结构体

类似于其他语言中的对象，也就是 数据+方法

结构体定义

type user struct {
	id         int
	score      float32
	enrollment time.Time
	name, addr string
}

初始化一个实例

var u user //声明，会用相应类型的默认值初始化struct里的每一个字段
u := user{}  
u = user{id:3,name:"zcy"} //赋值初始化
u = user{4,100,time.Now(),"zcy","beijing"} //赋值初始化，可以不写字段名，但需要跟结构体定义里的字段顺序一致

成员函数（方法）

//可以把user理解为hello函数的参数，即hello(u user,man string)
func (u user) hello(man string){
  fmt.Println("hi" + man + ",my name is" + u.name)
}

//函数里不需要访问user的成员，可以传匿名，甚至也_不传
func (_ user) think(man string){
  fmt.Println("hi" + man + ",do you know my name?")
}

为任意类型添加方法

type UserMap map[int]User //自定义类型

//可以给自定义类型添加任意方法
func (um UserMap) GetUser(id int) {
  return nu[id]
}

匿名结构体

如果一个结构体只想创建一个实例，那么就可以使用匿名结构体

var stu struct { //声明stu是一个结构体，但这个结构体是匿名的
  Name string
  Addr string
}
stu.Name = "zcy"
stu.Addr = "bj"
// 匿名结构体通常用于只使用一次的情况

结构体中含有匿名成员

type Student struct {
  Id int
  string //匿名字段
  float32 //直接使用数据类型作为字段名，所以匿名字段中不能出现重复的数据类型
}
var stu = Student{Id:1,string:"zcy",float:93.3}
fmt.printf("annonymous_menber string menber = %s float member = %f\n",stu.string,stu.float32)

创建结构体指针

var u User
user := &u //通过取址符&得到指针

user := &User{ //直接创建结构体指针
  Id : 3
  Name : "zcy"
  addr : "beijing"
}

user := new(User) //通过new()函数实例化一个结构体，并返回其指针

构造函数

go没有关于构造函数的定义，但是可以借鉴其他语言

//构造函数。返回指针是为了避免值拷贝
func NewUser(id int, name string) *User{
  return &User{
    Id:id,
    Name:name,
    addr:"china",
    Score:59,
  }
}

go中值传递的三种情况

1 =号赋值
a := 11
b := a

2 函数入参
func ChangeArr(arr [5]int) {
  fmt.Println(arr) //函数内部的arr和外部的arr的内存地址并不相同
}

func main() {
  arr := [5]int{1, 2, 3, 4, 5}
  ChangeArr(arr) //将arr拷贝的新的内存地址中，在函数内部使用新的arr
}


3 函数出参
func CreateArr() [5]int {
	arr := [5]int{1, 2, 3, 4, 5}
	return arr //函数中创建的arr数组
}
func main() {
  arr := CreateArr() //拷贝返回的函数赋值arr
}

引用类型

slice、map和channel是go于语言里的3中引用类型，都是通过make函数来进行初始化（申请内存分配）

因为他们都包含一个指向底层数据结构的指针，所以称他们为引用类型

引用类型未初始化时都是nil，可以对他们执行len()函数返回0

强制类型转换

低精度向高精度转换没问题，高精度向低精度转换会丢失位数

无符号向有符号转换，最高位是符号位

byte和int可以互相转换

float和int可以互相转换，小数位会丢失

bool和int不能相互转换

不同长度的int或float之间可以相互转换

不能对常量执行强制类型转换

string和int互转

var err error
var i int = 8
var i64 int64 = int64(i)
var s string = strconv.Itoa(i) //int转string，内部调用formatInt

s = strconv.FormatInt(i64,10) //int64转string
i, err = strconv.Atoi(s) //string转int
i64，err = strconv.ParseInt(s,10,64) //string转int64

string和float互转

//float转string
var f floaty4 = 8.23
s := strconv.FormatFloat(f,'f',2,64)

//string转float
f, err = strcon.ParseFloat(s,64)

可见性

go语言关于可见的统一规则：大写字母开头跨package也可
以访问；否则只能本package内部访问

结构体名称以大写开头时，package外部可见，在此前提下，
结构体中以大写开头在成员变量或成员函数在package外部也
可见