【GoLang】GO语言系列--002.GO语言基础

002.GO语言基础

1 参考资料

1.1 http://www.cnblogs.com/vimsk/archive/2012/11/03/2736179.html

1.2 https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/02.2.md

1.3 官网: https://golang.org/ref/spec#Constants

2 helloworld

2.1 Go使用package（和Python的模块类似）来组织代码

2.2 main.main()函数(这个函数位于主包）是每一个独立的可运行程序的入口点

2.3 Go使用UTF-8字符串和标识符(因为UTF-8的发明者也就是Go的发明者之一)，所以它天生支持多语言

3 go基础

3.1 定义变量

3.1.1 var vname1, vname2, vname3 type= v1, v2, v3 # 变量定义标准形式 var vname1, vname2, vname3 = v1, v2, v3 # 省略变量类型,编译器自动推导 vname1, vname2, vname3 := v1, v2, v3 # 函数内部使用 var a, b, c int64 = 1, 2, 3

3.1.2 _（下划线）是个特殊的变量名，任何赋予它的值都会被丢弃

3.1.3 Go对于已声明但未使用的变量会在编译阶段报错

3.1.4 默认值

3.1.4.1 int int32 int64 -> 0 bool -> false float32 float64 ->0.0 pointer(指针) map array slice ... -> nil

3.1.5 变量类型

3.1.5.1 http://www.cnblogs.com/vimsk/archive/2013/01/05/2843311.html

3.2 定义常量

3.2.1 程序编译阶段就确定下来的值，而程序在运行时无法改变该值

3.2.2 在Go程序中，常量可定义为数值、布尔值或字符串等类型

3.2.3 const constantName = value //如果需要，也可以明确指定常量的类型： const Pi float32 = 3.1415926

3.3 内置基础类型

3.3.1 bool

3.3.1.1 布尔值的类型为bool，值是true或false，默认为false

3.3.2 数值

3.3.2.1 rune, int8, int16, int32, int64和byte, uint8, uint16, uint32, uint64

3.3.2.2 rune是int32的别称，byte是uint8的别称

3.3.2.3 这些类型的变量之间不允许互相赋值或操作，不然会在编译时引起编译器报错 尽管int的长度是32 bit,但int与 int32并不可以互用

3.3.2.4 浮点数的类型有float32和float64两种（没有float类型），默认是float64

3.3.2.5 Go还支持复数。它的默认类型是complex128（64位实数+64位虚数）

3.3.2.6 如果需要小一些的，也有complex64(32位实数+32位虚数)

3.3.3 字符串

3.3.3.1 Go中的字符串都是采用UTF-8字符集编码。字符串是用一对双引号（""）或反引号（` `）括起来定义，它的类型是string

3.3.3.2 //示例代码 var frenchHello string // 声明变量为字符串的一般方法 var emptyString string = "" // 声明了一个字符串变量，初始化为空字符串

3.3.3.3 在Go中字符串是不可变的, 下面的代码编译时会报错： var s string = "hello" s[0] = 'c'

3.3.3.4 如果需要修改可以使用 []byte, 或者使用切片操作

3.3.3.5 可以使用+操作符来连接两个字符串

3.3.3.6 字符串虽不能更改，但可进行切片操作

3.3.3.7 可以通过反引号来声明多行字符串

3.3.4 error

3.3.4.1 Go内置有一个error类型，专门用来处理错误信息 Go的package里面还专门有一个包errors来处理错误

3.3.5 其他

3.3.5.1 uintptr , array, struct, string

3.3.5.1.1 var arr [n]type 数组必须指定长度

3.3.5.1.1.1 值类型, 不可变, 如果需要改变可以通过slice进行

3.3.5.2 map, channel , slice

3.3.5.2.1 动态数组slice var slice []byte = []byte{'a', 'b', 'c', 'd'}

3.3.5.2.1.1 注意slice和数组在声明时的区别：声明数组时， 方括号内写明了数组的长度或使用...自动计算长度， 而声明slice时，方括号内没有任何字符

3.3.5.2.1.2 slice是对数组的引用, 改变slice的值会改变数组的值

3.3.5.2.1.3 slice的默认开始位置是0，ar[:n]等价于ar[0:n]

3.3.5.2.1.4 slice的第二个序列默认是数组的长度，ar[n:]等价于ar[n:len(ar)]

3.3.5.2.1.5 如果从一个数组里面直接获取slice，可以这样ar[:]

3.3.5.2.1.6 slice的本质是数组的指针/引用

3.3.5.2.1.6.1 一个指针，指向数组中slice指定的开始位置

3.3.5.2.1.6.2 长度，即slice的长度

3.3.5.2.1.6.3 最大长度，也就是slice开始位置到数组的最后位置的长度

3.3.5.2.1.6.4 从Go1.2开始slice支持了三个参数的slice可以指定这个容量

3.3.5.2.2 map,key不仅为int的数组

3.3.5.2.2.1 map也就是Python中字典的概念，它的格式为map[keyType]valueType

3.3.5.2.2.2 map是无序的，每次打印出来的map都会不一样，它不能通过index获取，而必须通过key获取

3.3.5.2.2.3 map的长度是不固定的，也就是和slice一样，也是一种引用类型

3.3.5.2.2.4 内置的len函数同样适用于map，返回map拥有的key的数量

3.3.5.2.2.5 map的值可以很方便的修改，通过numbers["one"]=11可以很容易的把key为one的字典值改为11

3.3.5.2.2.6 map和其他基本型别不同，它不是thread-safe，在多个go-routine存取时，必须使用mutex lock机制

3.3.5.2.2.7 通过delete删除map的元素, delete(rating, "C") // 删除key为C的元素

3.3.5.2.2.8 map也是一种引用类型，如果两个map同时指向一个底层，那么一个改变，另一个也相应的改变

3.3.5.2.3 make与new的区别

3.3.5.2.3.1 make用于内建类型（map、slice 和channel）的内存分配。new用于各种类型的内存分配

3.3.5.2.3.2 new返回指针, 且值为 nil; new(T)分配了零值填充的T类型的内存空间，并且返回其地址

3.3.5.2.3.3 make返回对象, 且值不为nil; make返回初始化后的（非零）值

3.3.5.2.4 零值

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

3.3.5.3 interface

3.3.5.4 function

3.3.6 数据存储模型

3.3.6.1 http://research.swtch.com/godata

3.4 技巧

3.4.1 分组声明

3.4.1.1 import("fmt" "os") const( i = 100 pi = 3.1415 prefix = "Go_") var(i int pi float32 prefix string)

3.4.2 枚举

3.4.2.1 Go里面有一个关键字iota，这个关键字用来声明enum的时候采用， 它默认开始值是0，const中每增加一行加1

3.4.2.2 详细示例

3.4.2.2.1 https://github.com/astaxie/build-web-application-with-golang/blob/master/zh/02.2.md

3.4.3 fmt占位符详解

3.4.3.1 http://studygolang.com/articles/2644

3.4.4 规则

3.4.4.1 大写字母开头的变量是可导出的，也就是其它包可以读取的，是公有变量； 小写字母开头的就是不可导出的，是私有变量

3.4.4.2 大写字母开头的函数也是一样，相当于class中的带public关键词的公有函数； 小写字母开头的就是有private关键词的私有函数

 

package main

import (
    "fmt"
    //"mymath"
    "errors"
    "myhello"
    "strings"
)

func main() {
    //    fmt.Printf("Hello, world. Sqrt(2) = %v\n", mymath.Sqrt(2))

    //    //    var a, b, c int64 = 1, 2, 3
    //    //    fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
    //    //    var d int64
    //    //    fmt.Printf("d = %d\n", d)

    //    var a int
    //    var b float32
    //    var c bool
    //    var d string
    //    var e []int
    //    var f map[string]int
    //    var g *int
    //    if "" == d {
    //        fmt.Print("d is \"\" \n")
    //    }
    //    if nil == e {
    //        fmt.Print("e is nil \n")
    //    }
    //    if nil == f {
    //        fmt.Print("f is nil \n")
    //    }
    //    if nil == g {
    //        fmt.Print("g is nil \n")
    //    }
    //    fmt.Println(a, b, c, d, e, f, g)

    a, b := , false
    fmt.Println(a, b)

    const PI float64 = 3.1415926
    const MaxThread int8 =
    fmt.Println(PI, MaxThread)

    //    var aa int = 12
    //    var bb int32 = 24
    //    cc := aa + bb

    var c1 complex128 =  + 1i
    var c2 complex128 =  + 2i
    var c3 complex128 = c1 * c2
    fmt.Println(c3)

    var str1 string = `"How Are You?"`
    fmt.Println(str1)
    //str1[0] = 'X'
    str2 := strings.Replace(str1, "o", "OOO", -)
    fmt.Println(str2)
    fmt.Println(str1 + str2)
    fmt.Println(str2[:])

    //    err := errors.New("emit macho dwarf: elf header corrupted")
    var err error = errors.New("emit macho dwarf: elf header corrupted")
    if err != nil {
        fmt.Println(err)
    }

    hello.SayHello("JunneYang")

    var list1 []int64 = [...]int64{, , , , }
    list2 := [...]int64{, , , , }
    fmt.Println(list1)
    fmt.Println(list2)

    doubleArray := [][]int{[]int{, , , }, []int{, , , }}
    easyArray := [][]int{{, , , }, {, , , }}
    fmt.Println(doubleArray)
    fmt.Println(easyArray)

    var slice []byte = []byte{'a', 'b', 'c', 'd'}
    fmt.Println(slice)

    slice1 := list1[:]
    slice2 := list1[:]
    fmt.Println(slice1)
    fmt.Println(slice2)
    slice1[] =
    fmt.Println(slice1)
    fmt.Println(slice2)
    fmt.Println(list1)

    slice3 := list1[::]
    fmt.Println(slice3)
    fmt.Println(len(slice3))
    fmt.Println(cap(slice3))
    slice3 = append(slice3, )
    fmt.Println(slice3)

    fmt.Println(list1)

    var map1 map[string]string = make(map[string]string)
    fmt.Println(map1)
    fmt.Println(map1 == nil)

    var map2 *map[string]string = new(map[string]string)
    fmt.Println(map2)
    fmt.Println(map2 == nil)
    fmt.Println(*map2)
    fmt.Println(*map2 == nil)
    //    var map1 map[string]string
    map1["aaa"] = "AAA"
    map1["bbb"] = "BBB"
    map1["ccc"] = "CCC"
    fmt.Println(map1)
    fmt.Println(len(map1))

    var slicemake []int64 = make([]int64, , )
    fmt.Println(slicemake)
    fmt.Println(slicemake == nil)
    fmt.Println(len(slicemake))
    fmt.Println(cap(slicemake))

    //    slicemake = append(slicemake, 456)
    //    fmt.Println(slicemake)
    //    fmt.Println(len(slicemake))
    //    fmt.Println(cap(slicemake))

    slicemake1 := append(slicemake, )
    slicemake2 := append(slicemake1, )

    fmt.Println(slicemake)
    fmt.Println(len(slicemake))
    fmt.Println(cap(slicemake))

    fmt.Println(slicemake1)
    fmt.Println(len(slicemake1))
    fmt.Println(cap(slicemake1))

    fmt.Println(slicemake2)
    fmt.Println(len(slicemake2))
    fmt.Println(cap(slicemake2))

    var uint1 uint
    fmt.Println(uint1)
}