GO语言入门

GO语言概述

什么是GO语言

• Go（又称Golang）是Google开发的一种静态强类型、编译型、并发型，并具有垃圾回收功能的编程语言

GO语言特性

• 语法接近C，但对于变量的声明有所不同
• 支持垃圾回收功能
• 不包括：枚举、异常处理、继承、泛型、断言、虚函数等功能
• 增加了切片（Slice）型、并发、管道、垃圾回收、接口（Interface）等特性的语言级支持

GO三大纪律

• 每行程序结束后不需要撰写分号（;）
• 大括号（{）不能够换行放置
• if判断式和for循环不需要以小括号包裹起来

GO语言体系结构(GOPATH目录下各文件夹用途)

• src存放源代码
• pkg存放编译后生成的文件
• bin存放编译后生成的可执行文件

GO语言开发基础

GO数据类型

• 布尔型
• 数值型
• 字符串型
  Go的字符串是由单个字节连接起来的，字符串的字节使用UTF-8编码标识Unicode文本
• 派生类型
  数组类型、切片类型、Map类型
  指针类型（Pointer）、结构化类型（struct）、Channel类型
  函数类型、接口类型（interface）

GO变量声明

• 指定变量类型，如果没有初始化，则变量默认为零值
• 类型在后面
• 不加分号
• 变量声明后必须使用，不然报错，go变量拒绝浪费(常量不使用不会报错)
• 占位符，使用下划线 _ 定义

常量

• iota 特殊常量，可以认为是一个可以被编译器修改的常量
• 常量中的数据类型只可以是布尔型、数字型（整数型、浮点型和复数）和字符串型
• 常量定义使用const关键字

方法

• 方法如果被外部类调用，首字母要大写

    var v name v type 
	var a int
	var b, c float32
	var d bool
	var e = "Shanghai"
	ff := 1234

for循环

(go语言只有for循环，没有while没有do while)

	//无线循环for
	for{
	    // 无限循环执行部分
	}

	//普通for
	for i:=0;i<5;i++ {
		fmt.Print(i)
	}

	//相当于while的for
	i := 0
	for i<5 {
		fmt.Println(i)
		i++
	}

GO语言字符串

strings包

	str2 := strings.ToUpper(str1)
	fmt.Println(str2)

strconv包

	a := 100

	str1 := strconv.Itoa(a)
	fmt.Println(str1)

	fmt.Println(reflect.TypeOf(str1))
	fmt.Println(reflect.TypeOf(a))

接口interface

• 接口interface是个万能类型，不只用于接口
• 可以定义一个通用的模型，如汽车接口，可以实现为宝马、奥迪

结构体

• 结构体使用struct和type定义
• 结构体名字首字母大写

go语言切片

• go语言切片是对数组的抽象
• append和copy，增加slice容量

go语言异常处理

• defer
• panic
• recover

go通道

• 通道（channel）是用来传递数据的一个数据结构
• 通道用于两个goroutine之间通过传递一个指定类型的值来同步运行和通讯
• 操作符<-用于指定通道方向发送或接收
• 如果未指定方向，则为双向通道

go 并发

• go语言支持并发需要通过go关键字来开启goroutine
• goroutine是轻量级线程，调度由Golang运行时进行管理

GO语言示例

示例1：方法加go后执行顺序不固定，体现出并发的效果

package main

import (
	"fmt"
	"time"
)

func Hello(){
	fmt.Println("Hello")
}

func DelayP(){
	for i:=0;i<5;i++ {
		fmt.Println(i)
		time.Sleep(time.Microsecond)
	}
}

func main() {
	go Hello()
	//Hello()
	//DelayP()
	go DelayP()
	time.Sleep(6 * time.Second)
	fmt.Println("End of program!")
}

示例2：

package main

import (
	"fmt"
	"time"
)

var echo chan string
var receive chan string

func Echo(){
	time.Sleep(time.Second * 2)
	echo <- "Arthur Beyond"
}

func Receive() {
	time.Sleep(time.Second * 2)
	temp := <- echo
	receive <- temp
}

func main() {
	echo = make(chan string)
	receive = make(chan string)

	go Echo()
	go Receive()

	getStr := <- receive
	fmt.Println("in main function")
	fmt.Println(getStr)
}

示例3：

package main

import (
	"fmt"
	"os"
	"os/signal"
	"sync"
	"syscall"
	"time"
)
func consumer(stop <-chan bool) {
	for {
		select {
		case <-stop:
			fmt.Println("exit sub goroutine")
			return
		default:
			fmt.Println("running...")
			time.Sleep(500 * time.Millisecond)
		}
	}
}
func main() {
	stop := make(chan bool)
	var wg sync.WaitGroup
	// Spawn example consumers
	for i := 0; i < 3; i++ {
		wg.Add(1)
		go func(stop <-chan bool) {
			defer wg.Done()
			consumer(stop)
		}(stop)
	}
	waitForSignal()
	close(stop)
	fmt.Println("stopping all jobs!")
	wg.Wait()
}
func waitForSignal() {
	sigs := make(chan os.Signal)
	signal.Notify(sigs, os.Interrupt)
	signal.Notify(sigs, syscall.SIGTERM)
	<-sigs
}