GoLang 小计

1. 每个package 都有 一个 init 函数可以默认进行调用。 不能自己手动调用。

2. 取模余数正负号和被除数一致。

3. new 出来的对象不一定是创建在堆上。 两个 空 struct 被new出来可能有相同的地址。

4. %v 内置格式输出 %b 二进制输出。

5. x & y 都是1 得到1 ，否则为0                                      交集

    x | y 有1 得1                                                                并集

    x^y 相同得0 否则得1                                                    对称差

   x&^y y对应1位 清理x对应位，否则不动                         差集

x =       00100010

y =       00000110

x&y =   00000010

x|y =    00100110

x^y =   00100100

x&^y = 00100000

6. 代码中数字  0666（八进制）  0xffffeeee（十六进制）

7.fmt.Printf(“%d %[1]o, %#[1]x“, thedata )  通常 %d有多少个，就需要有多少个参数， 但是[1][2] 等通知使用第[1][2]个参数。 %# 加对应前缀，比如0x ， 0X， 0 等等。

十六进制区分大消息 %#x 或者 %#X

%q  双引号围绕着的字符串

%v 默认内置类型输出

7. 简单utf8

for i, r := range "hellow 世界"{
   fmt.Printf("%d\t%q\t%d\n", i, r, r )
}

utf8str := "HI GAOYANG 高扬"
chcounts := utf8.RuneCountInString( utf8str)
fmt.Printf( "%d\n", chcounts )

8. string ( []bytes 一样 )

var data string = "abcgaoyan ggao"
    fmt.Printf("Contains : %v\n", strings.Contains( data, "gao"))
    fmt.Printf("Count : %v\n", strings.Count( data, "gao"))
    fmt.Printf("Fields : %v len : %v \n", strings.Fields( data), len(strings.Fields( data)))
    fmt.Printf("Index : %v\n", strings.Index( data, "n g") )
    var dataslice = []string{ "abc", "def","efg" }
    fmt.Printf("Join : %v\n", strings.Join( dataslice, "^_^") )

 9. slice 会改变“形参”的值

func main(){
    var myintslice = []int{ 1, 2, 3 }
    test( myintslice )
    fmt.Println( myintslice )
}

func test( intslice []int ){
    intslice[0] = 9999
}

上面代码运行结果 [9999 2 3]   注意，当参数是数组的时候，并不会改变形参的值。

func main(){
    var array1 = [10]int{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }
    debugarray( array1 )
    var array2 = array1
    array2[0] = 9999
    debugarray( array2 )

    //var slice1 = []int{ 1, 2, 3, 4, 5 }
    var slice1 = make([]int, 5, 10)
    var slice2 = append(slice1,999)
    var slice3 = append( slice2, 6, 7, 8, 9, 10, 11 )
    debugslice(slice1)
    debugslice(slice2)
    debugslice(slice3)

    slice2[0] = 9999
    debugslice(slice1)
    debugslice(slice2)
    debugslice(slice3)
}

func debugslice( theslice []int ){
    //fmt.Println( theslice )
    var thecap = cap(theslice)
    thecap++
    fmt.Printf("%v LEN : %d CAP : %d\n", theslice, len(theslice), cap(theslice))
}
func debugarray( thearray [10]int){
    fmt.Println( thearray )
}
[1 2 3 4 5 6 7 8 9 10]
[9999 2 3 4 5 6 7 8 9 10]
[0 0 0 0 0] LEN : 5 CAP : 10
[0 0 0 0 0 999] LEN : 6 CAP : 10
[0 0 0 0 0 999 6 7 8 9 10 11] LEN : 12 CAP : 20
[9999 0 0 0 0] LEN : 5 CAP : 10
[9999 0 0 0 0 999] LEN : 6 CAP : 10
[0 0 0 0 0 999 6 7 8 9 10 11] LEN : 12 CAP : 20

这里有疑问， 当数据为slice的时候，老数据是否真的被变更取决于新数据的cap是否发生变化。感觉用法很奇怪。

这样当 slice1 = slice2 发生后， 经过一系列slice2发生改变，slice1可能改变，也可能不改变。

func main(){
    var arr1 = []int{1,2,3,4,5}
    //var arr2 = arr1[:2]
    var arr2 = arr1[:2:2]
    _ = append( arr2, 0 )
    fmt.Println(arr1)
}

类似这个方法，可以指定arr2 的cap 就是2，这样当arr2 被append 后，会重新分配内存，不会影响到arr1

10. strconv 各种转换

数字转换16进制显示 formatint 返回的是字符串。 fmt.Println( strconv.FormatInt(123, 16 ))