概览

下载
开发: vi emacs idea eclipse vs sublime
Ide: GoLand,liteIDE
默认 gopath ~/go/src

基本语法

变量定义使用 var,函数外定义可以使用括号的方式

package main

import "fmt"

//函数外定义要使用var
var aa=3
var ss="kkk"
var bb =true

//可以使用括号的方式
var (
    cc int
    dd string
    ee bool
)

func variableZeroValue() {
    var a int
    var s string
    fmt.Println("%d %qn", a, s)
}

func variableInitialValue() {
    var a, b int = 3, 4
    var s string = "abc"
    fmt.Println(a, b, s)
}

func variableTypeDedtection() {
    var a, b, c, s = 2, 3, true, "def"
    //    类型推断
    fmt.Println(a, b, c, s)
}

//冒号定义
func variableShorter() {
    //第一次
    a, b, c, s := 2, 3, true, "def"
    //    类型推断
    fmt.Println(a, b, c, s)
}

func main()  {
    fmt.Println("hello world")
    variableZeroValue()
    variableInitialValue()
    variableTypeDedtection()
    variableShorter()

}

内建类型

• bool string
• (u)int (u)int8 (u)int16 (u)int32 (u)int64 uintptr(指针)
• byte,rune(字符 go 的 char 类型，32 位)
• float32,float64,complex64,complex128(complex 复数类型，实部虚部)

复数回顾

• i = $sqrt{-1}$
• 复数：3+4i
• $|x+y|$ 的模 = $sqrt{3^2+4^2}$ = 5
• $i^2$=-1,$i^3$=-i,$i^4$=1,...
• $e^{iphi}$ = cos$phi$+isin$phi$

e 是单位圆，$phi$是逆时针旋转的角度，如图 (泰勒极数展开)

• $e^{iphi}$ = $sqrt{cos^2phi+sin^2phi}$ = 1
• $e^{ipi}$ = -1, $e^{ifrac{3}{2}pi}$ = -i,$e^{i2pi}$=1
• 推导出欧拉公式 $e^{ipi}$+1=0

go 语法来验证

func euler(){
    c:= 3+4i //表示复数
    fmt.Println(cmplx.Abs(c))
    //欧拉公式
    fmt.Println(cmplx.Pow(math.E,1i*math.Pi)+1)
    fmt.Println(cmplx.Exp(1i*math.Pi)+1)
}

强制类型转换

go 只有强制类型转换

func triangle() {
    var a, b int = 3, 4
    var c int
    c = int(math.Sqrt(float64(a*a + b*b)))
    fmt.Println(c)
}

常量定义

func consts() {
    const filename = "abc.txt"
    const a, b = 3, 4
    var c int
    c = int(math.Sqrt(float64(a*a + b*b)))
    fmt.Println(filename, c)
}

枚举类型

• 普通枚举类型
• 自增值枚举类型

func enums() {
    const (
        cpp    = 0 //iota const是自增值
        java   = 1
        python = 2
        gloang = 3
    )
    //    b,kb,mb,gb,tb,pb
    const (
        b = 1 << (10 * iota)
        kb
        mb
        gb
        tb
        pb
    )
}

回顾

• 变量类型写在变量之后
• 编译器可推测变量类型
• 没有 char,只有 rune
• 原生支持复数类型

if

// 不需要括号的
package main

import (
    "fmt"
    "io/ioutil"
)

func main() {
    const filename = "abc.txt"
    contents,err:=ioutil.ReadFile(filename)
    if err!=nil {
        fmt.Println(err)
    } else {
        fmt.Printf("%sn",contents)
    }
}

// 或者条件之前先赋个值用分号分隔
func main() {
    const filename = "abc.txt"
    //contents,err:=ioutil.ReadFile(filename)
    if contents,err:=ioutil.ReadFile(filename); err!=nil {
        fmt.Println(err)
    } else {
        fmt.Printf("%sn",contents)
    }
}

switch

// switch 没有break;

func switchFunc(a, b int, op string) int {
    var result int
    switch op {
    case "+":
        result = a + b
    case "-":
        result = a - b
    case "*":
        result = a * b
    case "/":
        if b == 0 {
            fmt.Printf("%sn", errors.New("除数为零"))
            break
        }
        result = a / b
    default:
         fmt.Printf("not found operation")
    }
    return result
}
// 另外一种switch不写值，而在case中写条件判断

func grade(score int) string {
    g := ""
    switch {
    case score<0 || score>100
        panic(fmt.Sprintf("Wrong score: %d", score)) //中断程序执行
    case score < 60:
        g = "F"
    case score < 80:
        g = "C"
    case score < 90:
        g = "B"
    case score <= 100:
        g = "A"
    }
    return g
}

switch 会自动 break,除非使用 fallthrough

for

直观的是没有括号

package main

import (
    "fmt"
    "strconv"
)

func convertToBin(n int) string {
    result := ""
    for ; n > 0; n /= 2 {
        lsb := n % 2
        result = strconv.Itoa(lsb) + result
    }
    return result
}

func main() {
    fmt.Println(
        convertToBin(5),  //101
        convertToBin(13), //1011--> 1101
    )
    // 调用时，返回值不有可以用_来点位
}

递增条件也可以省略

func printFile(filename string) {
    file, err := os.Open(filename)
    if err != nil {
        panic(err)
    }
    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
       //相当于while
       fmt.Println(scanner.Text())
    }
}
//什么都不加就是死循环，因为并发编程时要用到gorutine

函数

函数名在前 返回值在后。返回值可以是多个值，可以给返回值取名字;通常情况下返回一个值，一个 error，函数的参数也可以是个函数，它没有默认参数，有一个可变参数列表...

package main

import (
    "fmt"
    "math"
    "reflect"
    "runtime"
)

func main() {
    //div(13, 3)
    fmt.Println(apply(pow, 2, 3))
    fmt.Println(apply(func(i int, i2 int) int {
        return int(math.Pow(float64(i), float64(i2)))
    }, 3, 4))
    fmt.Println("多参数和：", sum(1, 2, 3))
}
func divid(a,b int) (int,int){
    var q,r int
    q = a/b
    r = a%b
    return q,r
}
// 多个返回值，并指定名字
func div(a, b int) (q, r int) {
    q = a / b
    r = a % b
    return
}

func pow(a, b int) int {
    return int(math.Pow(float64(a), float64(b)))
}
// 参数传函数
func apply(op func(int, int) int, a, b int) int {
    p := reflect.ValueOf(op).Pointer()
    opName := runtime.FuncForPC(p).Name()
    fmt.Printf("Calling function %s with args"+
        "(%d,%d)n", opName, a, b)
    return op(a, b) //也可以使用匿名函数
}
// 可变参数
func sum(number ...int) int {
    sum := 0
    for _, v := range number {
        sum += v
        //fmt.Println(v)
    }
    return sum
}

特点

• 返回值类型写在最后面
• 可返回多个值
• 函数可作为参数
• 没有默认参数，可变参数列表

指针

var a int=2
var pa *int = &a
*pa = 3
// 有指针，但指针不能运算

go 传值，引用传递? go 语言只有值传递一种方式

// 没效果
func main(){
    c, d := 2, 3
    fmt.Printf("c=%v,d=%vn", c, d)
    swap(c, d)
    fmt.Printf("nswaped c=%v,d=%vn", c, d)
}
// 值传递的，还是地址传递的说明
func swap(a, b int) {
    a, b = b, a
}
// 解决一 swap参数为地址，调用时要传地址
func main(){
    c, d := 2, 3
    fmt.Printf("c=%v,d=%vn", c, d)
    swap(&c, &d)
    fmt.Printf("nswaped c=%v,d=%vn", c, d)
}
// 值传递的，还是地址传递的说明
func swap(a, b *int) {
    *a, *b = *b, *a //地址交换
}
// 解决二，返回新的数据
func swapv1(a,b int) (int,int){
    return b,a
}

数组

func main() {
    var arr1 [5]int
    arr2:=[3]int{1,3,5}
    arr3:=[...]int{2,4,6,8,10} //不写...就是切片了
    fmt.Println(arr1,arr2,arr3)
    // 遍历数据
    for i := 0; i < len(arr3); i++ {
        fmt.Println(arr3[i])
    }
    //    一般使用range来遍历 i是下标，v是值
    for i, v := range arr3 {
        fmt.Println(i, v)
    }
    // 最大值
    maxi, maxv := MaxNumber(&arr3)
    fmt.Printf("nMax index %v value %vn",maxi, maxv)

    arr4:=[]int{1,3,5,7,9,11}
    maxi, maxv := MaxNumberv1(&arr4)
    fmt.Printf("nMax index %v value %vn",maxi, maxv)
}


// 求最大值
func MaxNumber(numbers *[5]int)(int,int){
    maxi:=-1
    maxValue:=-1
    for i,v:=range numbers {
        if v>maxValue {
            maxi,maxValue = i,v
        }
    }
}

// 求最大值
func MaxNumberv1(numbers *[]int) (int, int) {
    maxi := -1
    maxValue := -1
    for i, v := range *numbers {
        if v > maxValue {
            maxi, maxValue = i, v
        }
    }
    return maxi, maxValue
}

数组是值类型 而且必须规定长度

func printArray(arr [5]int) {
    // 注意这个参数 [5]int 和 []int不是一回事儿
    // 也可以*[5]int也可以传地址
    for i,v:=range arr {
        fmt.Println(i,v)
    }
}

// main中调用时
printArray(arr3) //对的
printArray(arr4) //会报类型错误
printArray(arr1) //对的
printArray(arr2) //错的 因为长度对不上，认为是两种类型

切片 Slice

理解为它是数组的一个视图

package main

import "fmt"

func main() {
    arr := [...]int{1, 2, 3, 4, 5, 6, 7}
    s := arr[2:6]
    fmt.Println("arr=", arr)
    fmt.Println("arr[2:6]=", s)
    fmt.Println("arr[2:]=", arr[2:])
    fmt.Println("arr[:6]=", arr[:6])
    fmt.Println("arr[:]=", arr[:])
    s1 := arr[2:]
    s2 := arr[:]
    fmt.Println("s1=", s1)
    fmt.Println("s2=", s2)
    fmt.Println("After updateSlice(s1)")
    UpdateSlices(s1)
    fmt.Println(s1)
    fmt.Println(arr)

    fmt.Println("After updateSlice(s2)")
    UpdateSlices(s2)
    fmt.Println(s2)
    fmt.Println(arr)
}

func UpdateSlices(s []int) {
    s[0] = 100
}


/*
arr= [1 2 3 4 5 6 7]
arr[2:6]= [3 4 5 6]
arr[2:]= [3 4 5 6 7]
arr[:6]= [1 2 3 4 5 6]
arr[:]= [1 2 3 4 5 6 7]
s1= [3 4 5 6 7]
s2= [1 2 3 4 5 6 7]
After updateSlice(s1)
[100 4 5 6 7]
[1 2 100 4 5 6 7]
After updateSlice(s2)
[100 2 100 4 5 6 7]
[100 2 100 4 5 6 7]
*/

证明 slice 是数组的一个视图，

reslice

    fmt.Println("Reslice:")
    s2=s2[:5]
    s2=s2[2:]
    fmt.Println("Reslice s2[:5] s2[2:]",s2)
    s2[0] = 200
    fmt.Println("arr", arr)
    /*
    Reslice:
    Reslice s2[:5] s2[2:] [100 4 5]
    arr [100 2 200 4 5 6 7]
    它们都是不同的view array
    */
    arr[0], arr[2] = 1, 2
    s1 = arr[2:6]
    s2 = s1[3:5]
    fmt.Println("s1=", s1)
    fmt.Println("s2=", s2)
/*
rr [100 2 200 4 5 6 7]
s1= [2 4 5 6]
s2= [6 7]
*/

为什么能取出这样的值呢看下图，slice 下标更新示意图

只要你不超过 capicity

slice 可以向后扩展，不可以向前扩展，s[i]不可以超越len(s)，向后扩展不可以超越底层数组cap(s)

    arr[0], arr[2] = 1, 2
    s1 = arr[2:6]
    s2 = s1[3:5]
    fmt.Printf("s1=%d,len(s1)=%d,cap(s1)=%vn", s1, len(s1), cap(s1))
    fmt.Printf("s2=%d,len(s2)=%d,cap(s2)=%vn", s2, len(s2), cap(s2))

向 slice 中不断的添加值

    s3 := append(s2, 10)
    s4 := append(s3, 11)
    s5 := append(s4, 12)
    fmt.Println("arr", arr)
    fmt.Println("s3,s4,s5", s3, s4, s5)

s4,s5 就不是原来的 arr,系统将会分配更新长的的数组。

添加元素时如果超越 cap,系统会重新分配更大的底层数组，原来数组有人用就保留，没有人用就回收

package main

import "fmt"

func main() {
    var s []int //zero value for slice is nil

    for i := 0; i < 100; i++ {
        printSlice(s)
        s = append(s, 2*i+1)
    }
    fmt.Println(s)
    s1:=[]int{2,4,6,8}
    // 长度是16
    s2:=make([]int,16)
    s3:=make([]int,10,32)
}

func printSlice(s []int) {
    fmt.Printf("len=%d,cap=%dn", len(s), cap(s))
}
// 它每次都是乘以2

声明 slice

s1:=[]int{2,4,6,8}
    // 长度是16
    s2:=make([]int,16)
    s3:=make([]int,10,32)
    fmt.Printf("s1=%v",s1)
    fmt.Printf("s2=%v",s2)
    fmt.Printf("s3=%v",s3)

copy(s2,s1)

    copy(s2, s1)
    fmt.Printf("copy(s2,s1)s2=%vn", s2)
    printSlice(s2)

删除 slice delete

    fmt.Println("Deleting elements from slice")
    s2 = append(s2[:3], s2[4:]...)
    fmt.Printf("copy(s2,s1)=>s2=%vn", s2)
    printSlice(s2)

从头或尾删除

    // pop tail
    fmt.Println("Popping from front")
    front := s2[0]
    s2 = s2[1:]
    fmt.Println("front=", front)
    printSlice(s2)

    fmt.Println("Popping from back")
    tail := s2[len(s2)-1]
    s2 = s2[:len(s2)-1]
    fmt.Println(tail)
    printSlice(s2)

Map

定义 map[k]v map[k1]map[k2]v 后面可以跟大括号初始化值

    m := map[string]string{
        "name":    "ccmouse",
        "course":  "golang",
        "site":    "imooc",
        "quality": "notabd",
    }
    fmt.Println(m)
    m2 := make(map[string]int) // m2== empty map
    var m3 map[string]int      // m3==nil
    fmt.Println(m, m2, m3)

    //    遍历
    for k, v := range m {
        fmt.Println(k, v) //这是无序的
    }
    // 获取名字
    fmt.Println("Getting values")
    courseName := m["course"]
    fmt.Println(courseName)
    //    如果不存在它会取zero value 本例中就是空串
    if courseName, ok := m["cs"]; ok {
        fmt.Println(courseName)
    } else {
        fmt.Println("key does not exist")
    }
    //删除元素
    fmt.Println("Deleteing values")
    name, ok := m["name"]
    fmt.Printf("Getting key='name' value=%v is %vn", name, ok)
    fmt.Println("Deleting...")
    delete(m, "name")
    name, ok = m["name"]
    fmt.Printf("Getting key='name' value=%v is %vn", name, ok)

• 创建make(map[string]int)
• 获取m[key]
• key 不存在获取的 value 类型的初始值(0 值)
• 用value,ok:=m[key]来判断是否存在 key
• delete()删除
• range 遍历，它是无序的，要排序要把 key 放在 slice 中排序再输出
• map 使用哈希表，必须可以比较相等
• 除了 slice,map,function 的内建类型都可以作为 key
• Struct 类型不包含上述字段，可以作为 key

实例

寻找最长不含有重复字符的子字符串 abcabcbb-->abc
bbbbb->b
pwwkew->wke

对于每一个字母 X

• lastOccurred[x]不存在，或者< start 无需操作
• lastOccurred[x]>=start更新 start 将 start 更新到 x+1 的位置
• 更新lastOccurred[x]，更新 maxLength

package main

import "fmt"

func nonRep(s string) int {
    lastOccurred := make(map[byte]int) //将byte=>rune(支持中文)
    start := 0
    maxLength := 0
    for i, ch := range []byte(s) { //将byte=>rune (支持中文)
        if lastI, ok := lastOccurred[ch]; ok && lastI >= start {
            start = lastOccurred[ch] + 1
        }
        if i-start+1 > maxLength {
            maxLength = i - start + 1
        }
        lastOccurred[ch] = i
    }
    return maxLength
}

func main()  {
    fmt.Println(nonRep("abcabcbb"))
}

上例支持中文 将byte=>rune(支持中文)