当前位置: 首页 > 编程语言 > 其它 > 正文

Go语言学习笔记

时间:2017-03-27

注释

单行 //

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

打印 信息

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\n", strings.Split("a,b,c", ","))                // 以后者分割前者
    fmt.Println(strings.TrimSpace(" \t\n a lone gopher \n\t\r\n")) // 掐头去尾中的空白符
}

以上输出

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).

例如

 1 m := make(map[string]int)  // 创建
 2 m["k1"] = 7  // 存
 3 m["k2"] = 13 // 存
 4 fmt.Println("map:", m)
 5 v1 := m["k1"]  // 取
 6 fmt.Println("v1: ", v1)
 7 fmt.Println("len:", len(m))
 8 delete(m, "k2")  // 删
 9 fmt.Println("map:", m)
10 
11 // 第一个返回值是value, 第二个返回值是bool, 如果key不存在或者 value是零值 则返回false, 有效的情况下返回true
12 //如果value 是int 放入0 返回 true, 如果value是string 型 放入 "" 返回false
13 _, prs := m["k2"]  
14             
15 fmt.Println("prs:", prs)
16 n := map[string]int{"foo": 1, "bar": 2} // 创建的同时填值
17 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\n", 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. 

来源:http://www.cnblogs.com/lonkiss/p/6537979.html