golang学习笔记

注释

单行 //   

多行 /*  这是注释的内容 */

 

打印 信息 

import "fmt"

fmt.Println("message to be printed");

 

数值类型

int8 ， int16 int32 int64

float32 float64

complex

 

布尔类型

bool

 

字符串

string

 

字符串与其他类型转换  import "strconv" 

 字符串转换到其他类型

package main

import (
    "fmt"
    "strconv"
)

func main() {
    a := "123"
    x, err := strconv.Atoi(a)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(x)

    b, _ := strconv.ParseBool("true")
    c, _ := strconv.ParseFloat("3.1415", 64)
    if b {
        fmt.Println("b is true")
    } else {
        fmt.Println("b is false")
    }

    fmt.Println(c)
}

其他类型转换到字符串

package main

import (
    "fmt"
    "strconv"
)

func main() {
    a := 123
    x := strconv.Itoa(a)
    fmt.Println(x)

    x = strconv.FormatBool(true)
    fmt.Println(x)
    x = strconv.FormatFloat(3.1415, 'E', -1, 64)
    fmt.Println(x)
    x = strconv.FormatInt(-42, 10)
    fmt.Println(x)
    x = strconv.FormatUint(42, 16)
    fmt.Println(x)
}

字符串 截取， 判断包含  import "strings" 

package main

import (
    "fmt"
    "strings"
)

func main() {
    fmt.Println(strings.HasPrefix("Gopher", "Go"))                 //前者是否以后者开头
    fmt.Println(strings.HasSuffix("Amigo", "go"))                  //前者是否以后者结束
    fmt.Println(strings.Contains("seafood", "foo"))                // 前者是否包含后者
    fmt.Println(strings.Index("chicken", "ken"))                   // 后者在前者的位置，以0开始， 不在则得到 -1
    fmt.Printf("%q
", strings.Split("a,b,c", ","))                // 以后者分割前者
    fmt.Println(strings.TrimSpace(" 	
 a lone gopher 
	
")) // 掐头去尾中的空白符
}

以上输出

true
true
true
4
["a" "b" "c"]
a lone gopher

 

指针

http://www.runoob.com/go/go-pointers.html  

 

格式化输出

%d 十进制数字  %o 八进制数字 %b 二进制数字 %x十六进制数字 %s 字符串 %v 任意变量按默认格式输出

更多详情 参考 https://golang.org/pkg/fmt/ 

 

常量使用驼峰命名法， 第一个字符大小写由可见性决定是否小大写

 

值拷贝类型

整型 浮点型 布尔型 string array struct

引用传递类型

slice map 

数组

声明格式 var name [num]type, 如果初始化能确定的给出元素，可以省略人工数个数，让编译器自动推导， 但是要用 三个点代替。。 因为如果是空就是切片而不是数组了

 

切片 Slice

切片的声明和数组非常像 只要不给定长度就是切片letters := []string{"a", "b", "c", "d"}

如果一开始不能定下元素， 后面动态设置元素的话， 可以用 make 内置函数 创建一个空切片

 func make([]T, len, cap) []T

参考 http://hustcat.github.io/array_and_slice/  http://www.jianshu.com/p/839b7fb04ae1 

https://blog.golang.org/go-slices-usage-and-internals  

 

字典/映射 Map

创建一个空 Map  

mymap := make(map[key-type]val-type).

例如 

m := make(map[string]int)  // 创建
m["k1"] = 7  // 存
m["k2"] = 13 // 存
fmt.Println("map:", m)
v1 := m["k1"]  // 取
fmt.Println("v1: ", v1)
fmt.Println("len:", len(m))
delete(m, "k2")  // 删
fmt.Println("map:", m)

// 第一个返回值是value， 第二个返回值是bool， 如果key不存在或者 value是零值 则返回false， 有效的情况下返回true
//如果value 是int 放入0 返回 true， 如果value是string 型 放入 "" 返回false
_, prs := m["k2"]  
            
fmt.Println("prs:", prs)
n := map[string]int{"foo": 1, "bar": 2} // 创建的同时填值
fmt.Println("map:", n)

range  https://gobyexample.com/range

range 数组， 得到 索引和值

for index ，value：= range arr { }

 

range 切片  得到索引和值 

for index， value ：= range slice {}

 

range 字典 得到 key 和 value

for key， value ：=  range map { }

获取变量类型

http://stackoverflow.com/questions/20170275/how-to-find-a-type-of-a-object-in-golang

时间日期  import "time" 

 时间格式化， 与其他语言相比非常别扭， 如下获取系统时间并用习惯的格式显示出来

package main

import (
    "fmt"
    "time"
)

func main() {
    t := time.Now()
    fmt.Println(t.Format("2006-01-02 15:04:05")) // go中必须这样写, 改成别的数字就不对了， 在 java 中是 yyyy-MM-dd HH:mm:ss
    fmt.Println(t.Format("01/02/2006 15:04:05")) // 分隔符换掉， 年份放后面
}

以上输出如下， 具体看你运行代码的时间决定而不同

2017-03-16 20:26:18
03/16/2017 20:26:18

定时器timer

package main

import (
    "fmt"
    "time"
)

func main() {
    timer1 := time.NewTimer(3 * time.Second)
    <-timer1.C
    fmt.Println("boom !!!")
}

计时器

计算函数执行时间

start := time.Now()
longCalculation()
end := time.Now()
delta := end.Sub(start)
fmt.Printf("longCalculation took this amount of time: %s
", delta)

并发：

用 所有的核计算 runtime.GOMAXPROCS(runtime.NumCPU())

 

goroutine

启动方式 go funcNameBeInvoked（argetment1，...）   对比java 的 new Thread（Runnable）.start()

 

channel

不要通过共享内存来通信，而要通过通信来共享内存

Do not communicate by sharing memory; instead, share memory by communicating.