GO语言入门

系统管理员 2023-06-15 07:17 21阅读 0赞

## 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
    }