GOLANG

May I Suggest ?

#leanote #leanote blog #code #hello world

Mutepig's Blog

GOLANG

无 195 0 0

mut3p1g

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

# 0x01 run
```
Go is a tool for managing Go source code.

Usage:

go command [arguments]

The commands are:

build       compile packages and dependencies
	clean       remove object files
	doc         show documentation for package or symbol
	env         print Go environment information
	fix         run go tool fix on packages
	fmt         run gofmt on package sources
	generate    generate Go files by processing source
	get         download and install packages and dependencies
	install     compile and install packages and dependencies
	list        list packages
	run         compile and run Go program
	test        test packages
	tool        run specified go tool
	version     print Go version
	vet         run go tool vet on packages

Use "go help [command]" for more information about a command.

Additional help topics:

c           calling between Go and C
	buildmode   description of build modes
	filetype    file types
	gopath      GOPATH environment variable
	environment environment variables
	importpath  import path syntax
	packages    description of package lists
	testflag    description of testing flags
	testfunc    description of testing functions
```
一般运行程序：
```
go run test.go
```

# 0x02 语法

## 1. 基础语法
### 1) demo
test.go
```
package main // 定义包名。你必须在源文件中非注释的第一行指明这个文件属于哪个包，如：package main。package main表示一个可独立执行的程序，每个 Go 应用程序都包含一个名为 main 的包。

import "fmt" // 告诉 Go 编译器这个程序需要使用 fmt 包（的函数，或其他元素），fmt 包实现了格式化 IO（输入/输出）的函数

func main() { // func main() 是程序开始执行的函数。main 函数是每一个可执行程序所必须包含的，一般来说都是在启动后第一个执行的函数（如果有 init() 函数则会先执行该函数）。 
// 需要注意的是, `{`必须跟在func定义的当前行后面，不能新起一行使用
   /* 这是我的第一个简单的程序 */
   fmt.Println("Hello, World!")
}
```

### 2) 一般结构
```
// 当前程序的包名
package main

// 导入其他包
import . "fmt"

// 常量定义
const PI = 3.14

// 全局变量的声明和赋值
var name = "gopher"

// 一般类型声明
type newType int

// 结构的声明
type gopher struct{}

// 接口的声明
type golang interface{}

// 由main函数作为程序入口点启动
func main() {
    Println("Hello World!")
}
```

### 3) 包的导入及调用

* 多个导入：
```
import (
    "fmt"
    "math"
)
```
* 包别名
```
import fmt2 "fmt" // 别名为fmt2
```
* 省略导入
```
import . "fmt"
这样就能直接调用Println而不需要使用fmt.Println了
```
* 调用
```
函数名首字母小写即为 private :
func getId() {}
函数名首字母大写即为 public :
func Printf() {}

所以在包外调用方法名首字母必须为大写
```

## 3. 变量声明
基本形式：
```
1. 指定变量类型
var v_name v_type = value
2. 根据值自行判定变量类型
var v_name = value
3. 省略var, 注意 :=左侧的变量不应该是已经声明过的，否则会导致编译错误
v_name := value
```
多变量声明：
```
1. 类型相同多个变量, 非全局变量
var vname1, vname2, vname3 type
vname1, vname2, vname3 = v1, v2, v3
2. 和python很像,不需要显示声明类型，自动推断
var vname1, vname2, vname3 = v1, v2, v3 
3. 出现在:=左侧的变量不应该是已经被声明过的，否则会导致编译错误
vname1, vname2, vname3 := v1, v2, v3 
4. 这种因式分解关键字的写法一般用于声明全局变量
var (
    vname1 v_type1
    vname2 v_type2
)

```
局部变量声明后不使用是会报错的，但全局变量不会。

## 4. 常量
eg. 
```
const b string = "abc"
const b = "abc"
```
枚举：
```
const (
    Unknown = 0
    Female = 1
    Male = 2
)
```
特殊用法：`iota`
```
const (
    a = iota   //0
    b          //1 如果不进行定义，表示使用上一行的值，即iota
    c          //2
    d = "ha"   //独立值，iota += 1
    e          //"ha"   iota += 1
    f = 100    //iota +=1
    g          //100  iota +=1
    h = iota   //7,恢复计数
    i          //8
)
```
## 5. 指针
&|返回变量存储地址|&a; 将给出变量的实际地址。
-|-
*|	指针变量|	*a; 是一个指针变量

eg.
```
var a int = 4
var ptr *int = & a
a == *ptr
```

## 6. 条件语句
```
1. if
if 布尔表达式 {
    ...
} else {
    ...
}
2. switch
switch中的每个case后面不用加break，会自动强制退出循环；如果需要执行下面的语句，则需要加上fallthrough
switch var1 {
    case val1:
        ...
    case val2:
        ...
        fallthrough
    default:
        ...
}
3. select
大概意思是用于channel通信，类似于switch，但多个条件都满足时，会随机选择一个满足的条件运行
```

## 7. 循环
eg. 
```
for init; condition; post { }
for condition { }
for i,x:= range 数组、字符串等 {}
```

## 8. 函数声明
eg. 
```
func max(num1, num2 int) int 
func swap(x string, y string) (string, string)

最后的类型表示返回值的类型，可以有多个返回值，也可以没有返回值
```

## 9. 数组、切片和集合
* 数组
数组的长度是固定的，无法改变
eg. 
```
var array [10] float32
var array = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
var array = [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0} // go根据元素个数确定数组大小
```
* 切片
切片和数组相似，但是长度可以改变，与数组定义的区别也就在于`[]`中是没有内容的
eg.
```
s :=[] int {1,2,3 } 
slice1 := make([]int, 3, 5) // 3表示切片的长度，5表示切片的容量;两者分别可以通过len()和cap()获得
//容量表示底层数组的大小，长度是你可以使用的大小
//容量的用处在哪？在与当你用append扩展长度时，如果新的长度小于容量，不会更换底层数组，否则，go会新申请一个底层数组，拷贝这边的值过去，把原来的数组丢掉。也就是说，容量的用途是：在数据拷贝和内存申请的消耗与内存占用之间提供一个权衡。
//而长度，则是为了帮助你限制切片可用成员的数量，提供边界查询的。所以用make申请好空间后，需要注意不要越界
s = append(s, 2,3,4,)
copy(s1, s) // 将s的内容拷贝到s1，但是copy不会帮助s1变大以将s全部拷贝过来，所以必须保证s1大小大于s才能将s的内容全部拷贝
```
* 集合
eg. 
```
初始化：
countryCapitalMap := map[string]string{}
var countryCapitalMap map[string]string = make(map[string]string)

设置键：
countryCapitalMap["France"] = "Paris"
删除键：
delete(countryCapitalMap, "France")
```
## 10. 结构体
eg. 
```
声明：
type Books struct {
   title string
   author string
   subject string
   book_id int
}
使用：
var Book1 Books
Book1.title = "123"
```

## 11. 接口
接口是`golang`实现的一种全新类型，类似于原本类的继承。
eg. 
```
package main

import (
    "fmt"
)

type Phone interface { // 定义接口
    call()
}

type NokiaPhone struct { // 定义结构体1
}

func (nokiaPhone NokiaPhone) call() { //定义结构体1的方法call
    fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct { // 定义结构体2
}

func (iPhone IPhone) call() { //定义结构体2的方法call
    fmt.Println("I am iPhone, I can call you!")
}

func main() {
    var phone Phone

phone = new(NokiaPhone) // 调用结构体1的接口
    phone.call()

phone = new(IPhone) // 调用结构体2的接口
    phone.call()

}

```
## 12. 并发
### 1) go
使用`go`语句即可触发并发，每条`go`语句相当于开启一个新线程来执行代码。
eg. 
```
func say(s string) {
        for i := 0; i < 5; i++ {
                time.Sleep(100 * time.Millisecond)
                fmt.Println(s)
        }
}

func main() {
        go say("world")
        say("hello")
}
```
### 2) channel
`channel`是用来传递数据的一个数据结构。
```
声明通道：
ch := make(chan int)
设置缓冲区：
ch := make(chan int, 100)
如果通道不带缓冲，发送方会阻塞直到接收方从通道中接收了值。如果通道带缓冲，发送方则会阻塞直到发送的值被拷贝到缓冲区内；如果缓冲区已满，则意味着需要等待直到某个接收方获取到一个值。接收方在有值可以接收之前会一直阻塞。

数据传输：
ch <- v    // 把 v 发送到通道 ch
v := <-ch  // 从 ch 接收数据,并把值赋给 v

关闭通道
cloase(ch)
```

# 0x03 编译选项
```
usage: compile [options] file.go...
  -%	debug non-static initializers
  -+	compiling runtime
  -A	for bootstrapping, allow 'any' type
  -B	disable bounds checking
  -D path
    	set relative path for local imports
  -E	debug symbol export
  -I directory
    	add directory to import search path
  -K	debug missing line numbers
  -L	use full (long) path in error messages
  -M	debug move generation
  -N	disable optimizations
  -P	debug peephole optimizer
  -R	debug register optimizer
  -S	print assembly listing
  -V	print compiler version
  -W	debug parse tree after type checking
  -asmhdr file
    	write assembly header to file
  -buildid id
    	record id as the build id in the export metadata
  -complete
    	compiling complete package (no C or assembly)
  -cpuprofile file
    	write cpu profile to file
  -d list
    	print debug information about items in list
  -dynlink
    	support references to Go symbols defined in other shared libraries
  -e	no limit on number of errors reported
  -f	debug stack frames
  -g	debug code generation
  -h	halt on error
  -i	debug line number stack
  -importmap definition
    	add definition of the form source=actual to import map
  -installsuffix suffix
    	set pkg directory suffix
  -j	debug runtime-initialized variables
  -l	disable inlining
  -largemodel
    	generate code that assumes a large memory model
  -live
    	debug liveness analysis
  -m	print optimization decisions
  -memprofile file
    	write memory profile to file
  -memprofilerate rate
    	set runtime.MemProfileRate to rate
  -msan
    	build code compatible with C/C++ memory sanitizer
  -newexport
    	use new export format
  -nolocalimports
    	reject local (relative) imports
  -o file
    	write output to file
  -p path
    	set expected package import path
  -pack
    	write package file instead of object file
  -r	debug generated wrappers
  -race
    	enable race detector
  -s	warn about composite literals that can be simplified
  -shared
    	generate code that can be linked into a shared library
  -trimpath prefix
    	remove prefix from recorded source file paths
  -u	reject unsafe code
  -v	increase debug verbosity
  -w	debug type checking
  -wb
    	enable write barrier (default 1)
  -x	debug lexer
  -y	debug declarations in canned imports (with -d)
```

觉得不错，点个赞？

文章目录