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

巴特西