【Go语言】2.2基础语法

直接贴代码了~ 不解释，语法很好理解，大赞~  喜欢go

/**
Go语言基础：
关键字	break default func interface select case defer go map struct
chan else goto package switch const fallthrough if range type
continue for import return var
**/
package main

//导入多个包
import (
	"errors"
	"fmt"
)

//定义多个常量
const (
	SITE    = "qq.com"
	NAME    = "QQ"
	SITEAGE = 23
)

//批量定义全局变量
var (
	pname  string
	page   int8 = 25
	pisdel      = false
)

//定义变量
var name string
var a1, a2, a3 string
var age uint8 = 24
var b1, b2, b3 uint8 = 1, 2, 3
var c1, c2, c3 = 22, "test", false //编译器会根据值的类型初始化
//常量
const SiteUrl = "www.baidu.com"
const Pi float32 = 3.1415926
const tablePrefix = "wish_"

// func main() {
// 	//testStart()

// 	// testString()

// 	//testErrors()

// 	//testConst()

// 	// testArr()

// 	testMap()
// }

func testStart() {
	//函数内定义并赋值变量，_丢弃对应的值
	v1, v2, _ := 21, "chris", true
	fmt.Println(v1, v2)
	//go语言支持int和uint，其中uint是无符号
	//int8 int16 int32(rune) int64和 uint8(byte) uint16 uint32 uint64
	//数值类型的不同长度变量之间不允许相互赋值或操作,会报错
	// var a int8 = 23
	// var b int32 = 345
	// var c int32
	// c := a + b

	//浮点型
	var f1 float32 = 23.234
	var f2 float64 = 128.02123
	fmt.Println(f1, f2)
	//复数 默认 complex128（64位实数，64位虚数）
	//复数形式RE+IMi RE实数部分，IM虚数部分 i虚数单位
	var c complex64 = 5 + 5i
	fmt.Printf("c complex is:%v", c) //c complex is:(5+5i)
}

/**
测试字符串类型
**/
var msg string           //声明字符串一般方法
var emptyMsg string = "" //声明一个空字符串

func testString() {
	s1, s2, s3 := "no", "yes", "maybe" //简短声明多个字符串变量
	sayhello := "hello chris"
	msg = "你好世界"
	//修改英文字符串
	message := []byte(sayhello)
	message[0] = 'H'
	msgValue := string(message)
	fmt.Println("\n", s1, s2, s3, sayhello, msg, msgValue)
	//连接字符串
	fmt.Println(s3 + sayhello)

	/**
	利用切片替换字符串
	**/
	//修改字符串可以利用字符串切片做
	fmt.Println(sayhello[:5] + "贸")
	//中文修改
	cnStr := "北京欢迎你!"
	r := []rune(cnStr)
	fmt.Println(string(r[:4]) + "您" + string(r[5:]))

	//声明多行字符串
	more := `开头：
中间
		结尾`
	fmt.Println(more)
}

func testErrors() {
	err := errors.New("\nemail:你的邮箱错误！")
	if err != nil {
		fmt.Println(err)
	}
}

/**
1byte 比特 8bit
1个int = int32 = float32 = 4byte
str := [5]byte{'h','e','l','l','o'}  即 5byte
nums := [3]int{1,2,3} 即 12byte
*/

/**
iota 只能在常量中使用
以下静态变量输出：false 1 2 3 111 5 6 0 0
iota用来声明枚举变量时使用
默认值是0，每次调用一次 iota就自动加1，被定义的常量也会被计算在枚举内。理论上A0是0，所以A1才是1
只有枚举常量在一个 ()中才会累加。不在其中的则被重新计数为0
**/
const (
	A0 = false
	A1 = iota // A1=0
	A2        //A2 =1
	A3        //A3 = 2
	A4 = 111
	A5 = iota
	A6
)

const A7 = iota
const A8 = iota

func testConst() {
	fmt.Println(A0, A1, A2, A3, A4, A5, A6, A7, A8)
}

///////////////////////常量枚举结束

///////////////////////数组
var arr [6]int8

func testArr() {
	array := [...]int8{1, 2, 3, 4, 5, 6, 7, 8, 9, 0} //根据元素个数计算长度，进行初始化
	doubleArr := [2][3]int8{{1, 2, 3}, {3, 4, 5}}    //声明多维数组
	arr[0] = 22
	arr[1] = 33

	//slice引用类型实现“动态数组”，当数据源被修改，则引用该数据源的slice也会被修改。即引用的是内存指针
	//slice默认开始位置为0
	var slice1, slice2 []int8
	slice1 = array[2:4] //从key=2开始，到第4个元素结束
	slice2 = array[3:6]
	fmt.Println(arr[1], arr[5], doubleArr) //最后一个元素无赋值，默认为0
	fmt.Println(array, slice1, slice2)
	// array[3] = 100
	fmt.Println(array, slice1, slice2)
	//slice内置函数 len获取长度  cap 最大容量 append追加并返回一个新slice copy函数
	fmt.Println(len(slice2), cap(slice2), append(slice2, 20))

	fmt.Println(slice1, append(slice1, 22)) //[3 4] [3 4 22]
	array[3] = 99
	fmt.Println(slice1, append(slice1, 22)) //[3 99] [3 99 22]
}

//////////////////Map
/**
格式：  map[keyType]valueType
**/
var members map[string]int8 //声明一个key为字符串，值为int8的字典；此方式声明后使用前用make初始化
func main() {
	testMap()
}
func testMap() {
	members := make(map[string]int8) //必须先make初始化
	members["one"] = 1
	members["ten"] = 10
	members["age"] = 24
	members["one"] = 22
	fmt.Println(members, members["age"])
	fmt.Println(members, len(members))
	/**
	1、map是无序的，每次打印出来map都不一样。必须用key获取值
	2、map长度是不固定的，和slice一样是一种引用类型
	3、len同样适用于map，返回map的元素个数
	4、方便修改
	**/

	//另一种map初始化
	maps := map[string]float32{"A": 2.2, "B": 2.3, "C": 10}
	//判断map中某个key是否存在，并返回值
	value, res := maps["C"]
	if res {
		fmt.Println("key : C++ ; value : ", value)
	} else {
		fmt.Println("key C++ not find! res:", res)
	}
	maps1 := maps
	fmt.Println(maps, maps1) //map[A:2.2 B:2.3 C:10] map[A:2.2 B:2.3 C:10]
	delete(maps, "C")        //删除A为key的数据
	fmt.Println(maps, maps1) //map[A:2.2 B:2.3] map[A:2.2 B:2.3]
	//注：因为map是引用类型，当map源修改时，一个改变另一个也随之改变
}

///////make new
/**
make用于内建类型（slice， map 、channel）的内存分配。
new用于各种类型的内存分配。返回的是指针，指向新分配类型的零值

make和new的区别：make只能创建slice、map、channel类型，并且返回的是一个有初始值（非零）的类型，不是指针。

例如：slice是一个包含指向数据（内部array）的指针、长度和容量的三项描述符。在slice初始化之前slice是nil。
对于slice、map和channel来说，make初始化了内部的数据结构，填充了适当的值。所以make返回初始化后的（非零）值



零值：
并非是空值，而是变量未填充之前的默认值。通常为0。例如：

类型	零值
int		0
int8	0
int32	0
int64	0
uint	0x0
rune	0//是int32
byte	0x0//实际类型是uint8
float32	0//长度4byte
float64	0//长度8byte
bool	false
string 	""
**/