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