Go语言特性

1.入口，go有且只有一个入口函数，就是main函数

　　liteide (IDE)的 一个工程（文件夹）只能有且只有一个main函数

package main
 
import "fmt"
 
// 入口函数
func main () {
    fmt.Println("hello world")
}

package main
 
import "fmt"
 
// 入口函数
// { 左括号必须和函数同行，不然异常
func main ()
{
    fmt.Println("hello world")
}

2. 调用函数

// go语言以包作为管理单位
// 每个文件必须先声明包
// 程序必须要有一个main包
package main
 
import "fmt"
 
// 入口函数
func main () { // 左括号必须和函数名同行
    // 打印
    // "hello go"打印到屏幕， Println()会直到换行
    // 调用函数，大部分都需要导入包
    /*
        块注释
    */
    fmt.Println("hello world") // go 语句结尾没有分号;
}

go build xxx.go
 
// 编译后生成xxx.exe，不运行
 
go run xxx.go
 
// 编译后直接运行，不生成xxx.exe

gofmt xxx.go        代码格式化
 
gofmt -w xxx.go  格式化后写入文件

golang语言特性

1. 垃圾回收

a. 内存自动回收，再也不需要开发人员管理内存

b. 开发人员专注业务实现，降低了心智负担

c. 只需要new分配内存，不需要释放

2. 天然并发

a. 从语言层面支持并发，非常简单

b. goroute，轻量级线程，创建成千上万个goroute成为可能

c. 基于CSP（Communicating Sequential Process）模型实现

func main() {
    go fmt.Println(“hello")
}

3.channel

a. 管道，类似unix/linux中的pipe

b. 多个goroute之间通过channel进行通信

c. 支持任何类型

func main() {
  pipe := make(chan int,3)
  pipe <- 1
  pipe <- 2
}

实现线程间管道通信

全局变量pipe

package main
 
import "fmt"
 
// pipe是个全局变量 ，会有问题 多线程共用值会被改变，要加锁处理
var pipe chan int  // 声明一个管道int类型
 
func add(a int, b int) {
    var sum int
    sum = a  + b
 
    pipe <- sum // 把sum放进管道
}
 
func main() {
    pipe = make(chan int, 1) // 初始化创建一个管道
    go add(2,5)　　　// goroute 调用add
    sum :=<- pipe   // 这段代码会阻塞到pipe里有值取出
    fmt.Println("sum=", sum)
}

传参的方式 pipe

package main
 
import "fmt"
 
// c作为pipe形参
func add(a int,b int, c chan int) {
    sum := a+b  // 等价 var sum int 后赋值
 
    c <- sum  // 把sum放进管道
}
 
func main(){
    pipe :=make(chan int, 1) // 初始化创建一个管道
 
    go add(2, 5, pipe) // 将pipe作为参数传入
 
    sum :=<-pipe // 这段代码会阻塞到pipe里有值取出
    fmt.Println("sum=" , sum)
}

4. 多返回值

a. 一个函数返回多个值

func calc(a int, b int)(int,int) {
    sum := a + b
    avg := (a+b)/2
    return sum, avg
}

package main
 
import "fmt"
 
func calc(a int, b int) (int, int) {
    c := a + b
    d := (a + b) / 2
    return c, d
}
 
func main() {
    sum, _ := calc(100, 200) // _ 不想要的值
    fmt.Println("sum=", sum)
}

包的概念

go编码 utf-8

1. 和python一样，把相同功能的代码放到一个目录，称之为包

2. 包可以被其他包引用

3. main包是用来生成可执行文件，每个程序只有一个main包

4. 包的主要用途是提高代码的可复用性

项目路径  project/src/go_dev/day1/example1/hello.go
 
编译
 
D:/project> go build go_dev/day1/example1    // go bulid 默认找src下的路径 不要带src
 
生成
 
D:/project> examp1.exe 在 project/下直接可以运行

包的导入

项目路径   D:\project\src\go_dev\day1\package_example下

包 calc

D:\project\src\go_dev\day1\package_example\calc 下有

add.go

package calc
 
// 要被其他包导入要首字母大写
func Add(a int, b int) int {
    return a + b
}

sub.go

package calc
 
// 要被其他包导入要首字母大写
func Sub(a int, b int) int {
    return a - b
}

包 main

D:\project\src\go_dev\day1\package_example\main
 
下有 main.go

package main
 
import (
    "fmt"
    "go_dev/day1/package_example/calc"
)
 
func main() {
    sum := calc.Add(100,200)
    sub := calc.Sub(100,300)
 
    fmt.Println("sum=", sum)
    fmt.Println("sub=", sub)
}

编译 
D:\project> go build go_dev/day1/package_example/main

编译到指定路径 D:\project\bin

D:\project> go build -o bin/xxx.exe go_dev/day1/package_example/main