go基本语法

一、总结

1、Go没有对象，没有继承多台，没有泛型，没有try/catch
2、Go有接口，函数式编程，csp并发模型（goroutine+channel）
3、无全局变量，有包内变量。
4、只有强制类型转换
5、可通过_省略变量

二、定义

1、变量定义（有初始值）

//1
var a int 
var s string

fmt.printf("%d%q\n",a,s)
//2
var a = 3

//3 := 第一次可用：定义，只能在函数里用
a,b,c,d := 2,4,true,"def"

//4
var(    a = 33
          b = "kk"
)

//强制类型转换
var c int = int(math.sqrt(float64(a*a+b*b)))

2、常量定义

Const a,b = 3,4

//枚举
Const(
            cpp = 0
            java = 1
            python = 2
)
//iota 自增值
Const(
            b = 1 << (10*iota)
            kb
            mb
            gb
)

3、条件
4、循环
5、函数
6、指针

三、内建容器
1、数组
* range 意义明确，美观，可同时获取i和v
* 数组是值类型（只是对值进行拷贝，不会改变数组的值）
* [10]int和[20]int 是不同的类型
* 调用func f(arr [10]int)会拷贝数组

func printArray(arr [5]int){
   for i,v := range arr{
      fmt.Println(i,v)
   }
    arr[0] = 100 //并不会真正改变数组的值
}
func main() {
   var arr1 [5]int
   arr2 :=[...]int{1,1,3,4,6}

   printArray(arr1)
   printArray(arr2)
}

* 用指针可以修改数组的值
* go一般不直接使用数组

func printArray(arr *[5]int){ 
  arr[0] = 100
   for i,v := range arr{ 
     fmt.Println(i,v)   
}}
func main() {
   var arr1 [5]
int   arr2 := [...]int{1,1,3,4,6} 
  printArray(&arr1)
   printArray(&arr2) 
  fmt.Println(arr1)
}

2、切片slice（是数组的view视图）
* slice可向后扩展，不可向前扩展。
* slice最开始有指针ptr，切片的长度len(s)，cap（s）从ptr开始到数组最后。
* s[i]不可超过数组len(s)，向后扩展不可超越地城数组cap(s)

arr2 := [...]int{0,1,2,3,4,5,6,7}
s := arr2[2:6]    //从2到6，半开半闭，切片。
fmt.Println("arr[2:6] = ",s)

输出：arr[2:6] =  [2 3 4 5]  //左2右5

//作为函数参数，可改变函数值

func updateSlice(s []int){
   s[0] = 100
}
func main() {
   arr := [...]int{0,1,2,3,4,5,6,7}
   s := arr[2:6]
   fmt.Println("arr[2:6] = ",s)
   updateSlice(s)
   fmt.Println("updateS = ",s)
   fmt.Println("arr = ",arr)
}
输出：
arr[2:6] =  [2 3 4 5]
updateS =  [100 3 4 5]
arr =  [0 1 100 3 4 5 6 7]

* reslice 多次slice

扩展

s1 := arr[2:6]
s2 := s1[3:5]

fmt.Println("s1 = ",s1)
fmt.Println("s2 = ",s2)
输出：
s1 =  [2 3 4 5]
s2 =  [5 6]

//s3 no longer view arr
s3 := append(s2,9,10,199)
输出：s3 =  [5 6 9 10 199]

向slice添加元素
* 添加元素是如果超越cap，会重新分配新的底层数组
* 由于值传递的关系，必须接受append的返回值
* s = append (s,val)

其他操作
1.创建

//1.for循环创建slice
var s []int //zero value for slice in nil   s == nil
for i := 0; i < 100; i++{
   s = append(s, 2*i + 1)
}
fmt.Println(s)

//2.make
s1 := make([]int,16)
s2 := make([]int,16,32)
printSlice(s1)
printSlice(s2)

func updateSlice(s []int){
   s[0] = 100
}
输出：
%v,len=%d,cap=%d
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 16 16
%v,len=%d,cap=%d
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0] 16 32

2.copy(s2,s1) 从s1复制到s2
3.删除
s = append(s[:3],s[4:]...) //删除第三个元素
4.取头取尾元素

front := s[0]
tail := s[len(s) - 1]

5.s去头去尾

s = s[1:]
s = s[:len(s) - 1]

3、Map（存放是无序的）
1.定义

m := map[string]string {   "name":"AAA",   "course":"BBB",}m1 := make(map[string]int)// m1 == empty mapvar m2 map[string]int// m2 == nilfmt.Println(m,m1,m2)输出：map[course:BBB name:AAA] map[] map[]

2.遍历

for k,v := range m{
   fmt.Println(k,v)
}

3.取值

causeName := m["cause"]
causeName,ok := m["cause"]
输出：BBB true  //若不存在，输出空串和false

4.其他
* map的key
除了slice，map，function的内建类型都可以作为key。Struct类型不包含上述字段，也可作为key

4、字符串 rune
rune相当于够的char
* 使用range遍历pos，rune对（英文1，中文3）
* 使用utf8.RuneCountInString获得字符数量
* 使用len获得字节长度
* 使用[]byte获得字节
寻找最长不重复的字符串

func lengthOfNonRepeatingSubStr(s string) int {
   lastOccurred := make(map[rune]int)
   start := 0
   maxLength := 0
   for i,ch := range []rune(s){
      if lastI,ok := lastOccurred[ch];ok && lastI >= start {
         start = lastI + 1
      }
      if i-start+1 > maxLength {
         maxLength = i - start + 1
      }
      lastOccurred[ch] = i
      strings.
   }
   return maxLength
}
func main() {
   fmt.Println(lengthOfNonRepeatingSubStr("我是你爸爸"))
   fmt.Println(lengthOfNonRepeatingSubStr("assbdce我"))
}
输出：
4
6
Fields分割
Split ,Join,Contains,Index,ToLower,Trim,TrimRight,

5、接口
* 面向对象，go语言仅支持封装，不支持继承和多态
* 面向接口编程，
* go语言没有class，只有struct
1.定义

type treeNOde struct {
   value int
   left,right *treeNOde
}
//1创建空树
var root treeNOde  
//2
var root := treeNOde{3}
root.left = &treeNOde{}
root.right = &treeNOde{5,nil,nil}
root.right.left = new(treeNOde)
//3
var root treeNOde
root = treeNOde{value: 3}
root.left = &treeNOde{}
root.right = &treeNOde{5,nil,nil}
root.right.left = new(treeNOde)

nodes := []treeNOde{
   {value:3},
   {},
   {6,nil,&root},
}
fmt.Println(root)
fmt.Println(nodes)

使用自定义工厂函数

func createNode(value int) *treeNOde {
   return &treeNOde{value:value}//返回局部变量给函数用
}
调用：
root.left.right = createNode(2)

                         3
            0                    5
                    2        0

方法接受者
* 值接受者是go语言特有
*

//接受者函数    
func (node treeNOde)print()  {
   fmt.Print(node.value)
}
//指针接受者，可改变源内容  值接受者，不可改变
func (node *treeNOde)setValue(value int)  {
   node.value = value
}
root.left.right.setValue(100)
root.left.right.print()
输出：100   //把值改为100

* nil指针也可以调用方法

if node == nil {
   fmt.print("节点不存在")
}

2.封装
名字一般用CamelCase
首字母大写代表：public （针对于包来说）
首字母小写代表：private
* 包
每个目录一个包，main包包含可执行入口，
为结构定义的方法必须放在同一个包内，可以使不同文件。
调用不同包的函数，用包名.函数名（包名首字母大写）
* 如何扩充系统类型或者别人的类型

1.定义别名   2.使用组合