（二）go的基础数据结构类型

1.go的常量

package main

import "fmt"

/*
常量是指程序运行时不可改变的值，常量必须初始化值。定义常量既可以指定类型,编译器也可以在常量初始化时做类型判断。
并且在函数代码块中定义常量，不被使用也不会出现编译错误。
在常量组中，如果不指定类型和常量值，那么常量的类型和值回和上一个常量的类型和值相同
 */

const a = 1 //用const关键字表明a是一个常量
const b = "satori"

//也可以一次性初始化多个常量
const c,d,e = "4", 5, "6"

//也可以以常量组的形式初始化
const (
	f = "python"
	g //此时g什么都不写，那么和它的上一个常量f的值与类型是一样的，等价于g = "python"
)

//iota,默认为零，并且自增1
const (
	h = iota //iota初始化为零，等价于h = 0
	i //不写的话，等价于i = iota,但是iota会增加，因此等价于i = 1
)

const (
	x = 2 << iota //iota初始化为零，等价于x = 2 << 0
	y //iota默认加一，等价于 y = 2 << 1
	z = 666 //z我指定了值，那么z就等于我指定的666。但此时的iota依旧在增加，此时iota = 2
	w //由于z的出现，w不指定的话不会等于2 << 3,而是和z一样也等于666，和上一个常量一致。但是别忘记此时iota = 3
	k = 3 << iota //此时的k = 3 << iota就等价于k = 3 << 4
	s //s不写的话等价于s = 3 << iota,但此时iota=5，因此相当于s = 3 << 5

)
func main(){
	// 这里的%v表示万能打印，可以打印所有类型的值
	fmt.Printf("a = %v\n", a)
	fmt.Printf("b = %v\n", b)
	fmt.Printf("c = %v\n", c)
	fmt.Printf("d = %v\n", d)
	fmt.Printf("e = %v\n", e)
	fmt.Printf("f = %v\n", f)
	fmt.Printf("g = %v\n", g)
	fmt.Printf("h = %v\n", h)
	fmt.Printf("i = %v\n", i)
	fmt.Printf("x = %v\n", x)
	fmt.Printf("y = %v\n", y)
	fmt.Printf("z = %v\n", z)
	fmt.Printf("w = %v\n", w)
	fmt.Printf("k = %v\n", k)
	fmt.Printf("s = %v\n", s)
}
//输出结果
/*
a = 1
b = satori
c = 4
d = 5
e = 6
f = python
g = python
h = 0
i = 1
x = 2
y = 4
z = 666
w = 666
k = 48
s = 96
 */

　　

2.go的变量

package main

import "fmt"

/*
变量就是可以改变的量,并且在go语言中，变量一旦声明必须使用，否则报错
 */
func main() {
	var a= 1 // 初始化一个变量a = 1

	//也可以先声明一个变量然后再初始化
	var b string //声明了一个变量b，这个变量的值的类型为string
	// 给b赋值
	b = "satori"

	//我们之前说的常量一旦声明必须赋值，但是变量不需要
	//在go中，如果变量不初始化，go语言会默认初始化一个0值
	//举个例子
	var c int
	var d string
	var e [3]int
	var f bool
	fmt.Printf("a = %v\n", a)
	fmt.Printf("b = %v\n", b)
	fmt.Printf("c = %v\n", c)
	fmt.Printf("d = %q\n", d)  //这里使用%q，可以打印出双引号
	fmt.Printf("e = %v\n", e)
	fmt.Printf("f = %v\n", f)
}
//输出结果
/*
a = 1
b = satori
c = 0
d = ""
e = [0 0 0]
f = false
 */

　　

3.go的字符串

package main

import "fmt"

func main(){
	//声明并初始化一个字符串
	var s = "satori"
	fmt.Println(s) //satori

	//获取字符串的第一个字符,但是这样打印的是一个bytes，需要转成字符输出
	fmt.Println(string(s[0])) //s

	//获取最后一个字符，在go中没有-1这个说法，可以使用string[长度-1]
	//那么字符串的长度如何获取呢？这个和python是一样的，可以使用len获取
	fmt.Println(string(s[len(s)-1])) //i

	//也可以使用range遍历
	/*
	关于range，如果指定一个值那么获取的就是索引
	如果指定两个值，那么分别获取索引和值
	 */
	var name = "satori"
	for k:=range name{
		fmt.Println(k)
		/*
		0
		1
		2
		3
		4
		5
		 */
	}
	for k,v:=range name{
		fmt.Println(k,string(v))
		/*
		0 s
		1 a
		2 t
		3 o
		4 r
		5 i
		 */
	}
	//但是如果我想只想要值，又不想要索引呢？因为在go中如果声明了，必须使用，这是怎么办呢？可以使用_
	for _, v:=range name{ // _表明这个值我要它没用
		fmt.Println(string(v))
		/*
		s
		a
		t
		o
		r
		i
		 */
	}

	//这种遍历方式还有一个问题，这个问题在python中是不存在的。那就是中文
	var username = "古明地觉"
	//由于go的索引，比如说username[0]，表示获取username字符串的第1个字节
	//英文一个字符占一个字节，所以没问题，但是中文一个占三个字节，所以会出问题
	fmt.Println(string(username[0])) // å, 打印的结果是这么个玩意

	//但是使用range遍历获取值是没有问题的，但是如果想通过索引正常获取的话，怎么办呢？
	//可以使用[]rune(),[]rune(username)便是按照字符来获取
	fmt.Println(string([]rune(username)[0])) //古

	//在比方说，我们获取长度，按照字节肯定是12个，因为go采用utf-8编码，按照字符那么占4个。在python中使用len占4个
	fmt.Printf("len(username)=%d, len([]rune(username)=%d\n", len(username), len([]rune(username))) //len(username)=12, len([]rune(username)=4
}

那么go的字符串都有哪些操作呢？

package main
 
import (
    "fmt"
    "regexp"
    "strconv"
    "strings"
)
 
func main(){
    //1.查看字符串中是否包含某个子串，类似于Python中的__contains__，或者 in
    fmt.Println(strings.Contains("古明地觉", "古明"))//true
    fmt.Println(strings.Contains("古明地觉", "古明地觉"))//true
    fmt.Println(strings.Contains("古明地觉", "古明地盆"))//false
 
    //2.将多个字符串按照一定规则组合在一块，类似于Python中的join
    s := []string{"古明地盆","东方地灵殿"}
    fmt.Println(strings.Join(s, "来自"))//古明地盆来自东方地灵殿
 
    //3.查找字符串中某个子串的位索引，查不到为-1，类似于Python中的find
    fmt.Println(strings.Index("satori","ri"))//4
    fmt.Println(strings.Index("satori","shi"))//-1
 
    //4.将一个字符串重复n次，类似Python中的*
    fmt.Println(strings.Repeat("satori", 3)) //satorisatorisatori
 
    //5.将一个字符串按照指定字符进行切割，类似于Python中的split
    s1:="satori|koishi|古明地盆|古明地恋"
    fmt.Println(strings.Split(s1, "|"))//[satori koishi 古明地盆 古明地恋]
 
    //6.去掉字符串两头，类似于Python中的strip
    fmt.Println(strings.Trim("aababbb古明地盆古明地恋bababaa", "ab"))//古明地盆古明地恋
 
    //7.去掉所有的空格，将元素放在一个切片中
    fmt.Println(strings.Fields("    are      古明地盆    ok"))//[are 古明地盆 ok]
 
    //8.计算指定字符出现的次数
    fmt.Println(strings.Count("古明地盆古明地恋", "古"))//2
 
    //9.判断字符串是否以指定字符开头
    fmt.Println(strings.HasPrefix("satori", "sa"))//true
 
    //10.判断字符串是否以指定字符结尾
    fmt.Println(strings.HasSuffix("satori","ri"))//true
 
    //----------------------------
 
    //1.转化为字符串后追加到字节数组
    slice := make([]byte, 0, 1024)
    slice = strconv.AppendBool(slice, true)
    //第三个参数表示以多少进制追加
    slice = strconv.AppendInt(slice, 1024, 10)
    slice = strconv.AppendQuote(slice, "satori")
    slice = strconv.AppendQuote(slice, "古明地盆")
    //转化为字符串打印
    fmt.Println(string(slice)) //true1024"satori""古明地盆"
 
    //2.字符串转整型
    //具有两个返回值，另一个是错误信息
    fmt.Println(strconv.Atoi("6666")) //6666 <nil>
 
    //3.整型转字符串
    fmt.Println(strconv.Itoa(2333)) //2333
    fmt.Printf("%q\n", strconv.Itoa(2333))//"2333"
 
 
    //正则表达式，熟悉Python的话，这个自不必说，只介绍不同的地方
    //Python表示原生字符串需要在""前面加上r，go中使用``表示即可
    //步骤分为两步
    //1.使用MustCompile解析并返回一个正则表达式
    reg := regexp.MustCompile(`\d{4}`)
    //2.调用需要的函数查找
    result1 := reg.FindAllString("123-1234-12345",-1)
    result2 := reg.FindAllStringSubmatch("123-1234-12345",-1)
    fmt.Println(result1)//[1234 1234]
    fmt.Println(result2)//[[1234] [1234]]
}