Go新手需注意的知识点(一)

学习Go的一些需要注意的知识点。

一、GO中的包

1、这个是GO中非常基础，包使用package定义，使用import导入，可以理解PHP中的类，使用自动加载，所以包名称和路径名称必需一致，且包名称必需小写

2、包中的常量、变量、函数的首字母，表示包外常量、包外变量、包外方法，可以理解为public，可以在另一个包中使用。如果首字母小写，表示包内，可以理解为private，仅可以在同一个包内部使用。

3、因为一个目录即表示一个包，所以同一个目录下的包名称必需一致

4、你可以通过使用包的别名来解决包名之间的名称冲突。

二、变量

1、使用关键字var声明，格式 var identifier type

2、type的类型有：

string：字符串，Go语言的字符串的字节使用UTF-8编码标识Unicode文本
bool：true / false
int系列：包括int、int8、int16、int32、int64、uint、uint8、uint16、uint32、uint64
int：32位或64位，和操作系统有关。
int8：2的7次方，-128到127
int16：2的15次方，-32768到32767
int32：2的31次方，-2147483648 到 2147483647
int64：2的63次方，-9223372036854775808 到 9223372036854775807
uint：32位或64位，和操作系统有关。
uint8：2的8次方，0 到 255
int16：2的16次方，0 到 65535
int32：2的32次方，0 到 4294967295
int64：2的64次方，0 到 18446744073709551615
浮点系列：float32、float64、complex64、complex128
float32：IEEE-754 32位浮点型数
float64：IEEE-754 64位浮点型数
complex64：32 位实数和虚数
complex128：64 位实数和虚数
其它类型：byte、rune、uintptr
byte：类似 uint8
rune：类似 int32
uintptr：无符号整型，用于存放一个指针
派生类型：指针类型（Pointer）、数组类型、结构化类型(struct)、Channel 类型、函数类型、切片类型
、接口类型（interface）、Map 类型

三、运算符

1、GO是强类型语言，不同类型的值进行二元运算，无法通过编译。

2、Go 对于值之间的比较有非常严格的限制，只有两个类型相同的值才可以进行比较，假如 a == b，此时a、b的类型也必需一致，否则，无法通过编译。

四、时间

1、特别注意：在go中的日期format格式，使用2006代表年，01代表月，02代表日，03代表小时、04代表分、05代表秒。

2、获取当前时间戳，time.Now().Unix()
获取指定时间的时间戳：
tm1, _ := time.Parse(“2006-01-02 03:04:05″, “2018-01-01 01:01:01″)
fmt.Println(tm1.Unix())
mt.Println(tm1.Format(“2006-01-02 03:04:05″))

五、控制结构

1、Go 完全省略了 if、switch 和 for 结构中条件语句两侧的括号，相比 Java、C++ 和 C# 中减少了很多视觉混乱的因素，同时也使你的代码更加简洁。

2、switch的集中格式：

switch var1 {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

switch {
    case condition1:
        ...
    case condition2:
        ...
    default:
        ...
}

switch initialization {
    case val1:
        ...
    case val2:
        ...
    default:
        ...
}

六、函数

1、函数中可以没有形参，但必需要有形参的类型，例如：func f1(int, string) (string){return “a” }

2、函数中如果有有多个分支，则每个分支都必需有return，例如：if else 则必需有2个return 关键字。

3、理解函数非命名返回值和命名返回值，尽量使用命名返回值：会使代码更清晰、更简短，同时更加容易读懂。

4、defer函数的用法

5、闭包函数的用法，看下面的例子

func Connect() {
    start := time.Now()  
    p2 := add()
    fmt.Println(p2(2))
    p3 := adder(20)
    fmt.Println(p3(30))
    fmt.Println(p3(60))
    fmt.Println(p3(10))
    elapsed := time.Since(start)
    fmt.Println(elapsed)
}
func add() (func(arg int) int) {
    return func(b int)(rst int) {
        rst = b + 1
        return
    }
}
func adder(arg int) (func(arg int) int) {
    return func (a int) (rst int) {
        arg += a
        return arg
    }
}

输出结果：

利用闭包函数(其实这里使用了工厂函数)高效实现斐波那契数列，相比递归实现性能高出何止千倍。

func Connect() {
    start := time.Now()  
    add(10) 
    elapsed := time.Since(start)
    fmt.Println(elapsed)
}
func add(a int) {
    f := adder();
    for i := 1; i <= a; i++ {
        fmt.Println(f(i))
    } 
}
func adder() (func(a int) int) {
    pre1, pre2 := 0,0
    return func(a int) (rst int) {
        if a <= 1 {
            pre1, rst = 1,1
        } else {
            rst = pre1 +  pre2 
            pre2 = pre1
            pre1 = rst 
        }
        return
    }
}

6、工厂函数：一个返回值为另一个函数的函数可以被称之为工厂函数，这在您需要创建一系列相似的函数的时候非常有用：书写一个工厂函数而不是针对每种情况都书写一个函数。下面的函数演示了如何动态返回追加后缀的函数。

举例说明：

func Connect() {
    start := time.Now()  
    addBmp := makeAddSuffix(".bmp")
    addPng := makeAddSuffix(".png")
    fmt.Println(addBmp("header"))
    fmt.Println(addPng("banner"))
    elapsed := time.Since(start)
    fmt.Println(elapsed)
}
func makeAddSuffix(suffix string) (func(file string) string) {
    return func(file string) string {
        return file + suffix 
    }
}

7、计算代码执行时间

start := time.Now()
.........
end := time.Now()
delta := end.Sub(start)

start := time.Now()
..........
elapsed := time.Since(start)
fmt.Println(elapsed)

《Go新手需注意的知识点(一)》上有2条评论