Golang行情

Golang的优势

  • 极简部署方式

    • 可直接编译成机器码
    • 不依赖其他库
    • 直接运行即可部署

  • 静态类型语言

    • 编译的时候检查出来隐藏的大多数问题

  • 语言层面的并发

    • 不通过外层包装，原生支持并发

    • 充分利用多核

  • 强大的标准库

    • runtime系统调度机制(垃圾回收，资源平均分配)
    • 高效GC垃圾回收
    • 丰富的标准库

  • 简单易学

    • 25个关键字
    • 内嵌C语法支持
    • 面向对象(继承、多态、封装)

Golang的不足

  • 大部分包管理在github上
  • 无泛化
  • 所有的Exception都用Error来处理
  • 对C的降级，并非无缝。没有降级到asm那么完美

Golang第一个程序:letsgo

package main //含有main函数的包，包名不需要与项目名和文件名相同

import(
    "fmt"
    "time"
)

//import "fmt"
// import "time"

func main(){//左花括号不换行 
    //golang表达式，';'可加可不加，建议不加
    fmt.Println("letsgo") 
}
go run letsgo.go
go build letsgo.goletsgo

Golang四种变量声明方式与多变声明方式

func main(){
	//方法一：声明一个变量，默认值是0
    var v1 int
	fmt.Println("v1 = ", v1)
	fmt.Printf("type of v1 is %T\n", v1)

    //方法二：声明一个变量，初始化一个值
	var v2 int = 10
	fmt.Println("v2 = ", v2)
	fmt.Printf("type of v2 is %T\n", v2)

	//方法三：在初始化的时候，省去数据类型，通过值自动匹配当前变量的数据类型
	var v3 = "str"
	fmt.Println("v3 = ",v3)
	fmt.Printf("type of v3 = %T\n",v3)

    //方式四：省去var关键字，直接自动匹配
    //:=只能放在函数体内声明，不支持全局变量
	v4:="str"
	fmt.Println("v4 = ",v4)
	fmt.Printf("type of v4 = %T\n",v4)
    
    //声明多个变量
    
    //多行的多变量声明
}

const与iota

iotaconst()
const con int = 10
const(
    a, b = iota+1, iota+2
    c, d
    e, f
    
    g, h = iota*10, iota*20
    l, m
)

Golang函数多返回值三种写法

func test1(a string, b int)(string, int){
	return a,b+1
}

func test2(a string, b int)(c string, d int){
	c=a
	d=b+1
	return //或return c, d
}

func test3(a int, b int)(e, f int){
	e=a
	f=b
	return
}

func main() {
	fmt.Println(test1("san6", 6))
	fmt.Println(test2("san6", 6))
	fmt.Println(test3(5, 6))
}

import导包

  • 函数和变量首字母大写时，表示是对外开放的

  • init()早于main()

  • Golang导入的包必须使用，否则会报错

init导包路径与init方法调用流程

// demo1/lib1/lib1.go go从ROOT和PATH下找包
package lib1

import "fmt"

func init(){
	fmt.Println("lib1 init()...")
}
func Lib1func() {
	fmt.Println("lib1func()...")
}
// demo1/letsgo.go 
package main

import (
	"fmt"
	"demo1/lib1"
	"demo1/lib2"
)

func main() {
	fmt.Println("main()...")
	lib1.Lib1func()
	lib2.Lib2func()
}

import匿名及别名导包方式

import(
	_"lib1" //匿名导包。无法使用包内方法，但是会调用包的init()方法
    l1 "lib2" //给包起一个别名，l1.show()来直接调用
    ."lib3" //把包内方法全部导入本包中，包括非公开方法
)

Golang指针

package main

import "fmt"

func swap(a *int, b *int) {
	*a = *a + *b
	*b = *a - *b
	*a = *a - *b
}

func main() {
	var a, b = 3, 4
	swap(&a, &b)
	fmt.Println("a = ", a, " b = ", b)
}

defer语句调用顺序

  • 方法执行周期结束时，执行defer语句
  • 多个defer语句存在，以压栈形式执行
  • return属于方法执行周期，先于defer执行
package main

import "fmt"

func deferfunc1() {
	fmt.Println("deferfunc1() called")
}
func deferfunc2() {
	fmt.Println("deferfunc2() called")
}
func returnfunc()int {
	fmt.Println("returnfunc() called")
	return 0
}
func defertest()int {
	defer deferfunc1()
	defer deferfunc2()
	return returnfunc()
}
func main() {
	defertest()
}