GO（一）语言快速入门

环境工具准备：

Window系统下载https://golang.google.cn/dl/安装go1.4.windows-amd64.msi
或者通过下面网站下载

====================================================

package main //定义包名，表示一个可独立执行的程序，每个Go应用程序都包含一个名为main的包import "fmt" //告诉Go编译器这个程序需要使用fmt包的函数，包含了格式化输入输出func main(){ //程序开始执行的函数，每个可执行程序必须包含的（{ 不能在单独的行上）var stockcode = 123 //声明变量，并初始化var enddate = "2020-12-31"var url = "Code=%d&endDate=%s" //%d 表示整型数字，%s 表示字符串var target_url=fmt.Sprintf(url,stockcode,enddate) //Sprintf 根据格式化参数生成格式化的字符串并返回该字符串fmt.Println(target_url); //Printf 根据格式化参数生成格式化的字符串并写入标准输出//iota特殊常量const(a = iota //重置为0b //每行依次＋1   1c //2d = "hello" //helloe //hellof = 100 //100g //100h = iota //7 恢复计数i //8)fmt.Println(a,b,c,d,e,f,g,h,i)// 变量地址和指针变量var a int = 4var ptr *intptr = &afmt.Printf("a的值为%d\n",a) //4fmt.Printf("*ptr为%d\n",*ptr) //4
}

================================================================

条件语句

/**if条件，if...else条件，if嵌套
*/
package main
import "fmt"func main(){var a int = 10if a < 20{fmt.Printf("a 小于 20 \n")if a== 10{ //嵌套fmt.Printf("a 等于 10 \n")}}else{fmt.Printf("a 大于 20 \n")}}

/**switch默认情况下 case 最后自带 break 语句，匹配成功后就不会执行其他 case，如果我们需要执行后面的 case，可以使用 fallthrough
*/
package main
import "fmt"func main(){var grade string = "B"var marks int = 90switch marks{case 90 : grade = "A"case 80 : grade = "B"case 50,60,70 : grade = "C"default: grade = "D"}switch{case grade == "A":fmt.Printf("优秀！\n")case grade == "B",grade == "C":fmt.Printf("良好\n")case grade == "D":fmt.Printf("及格\n")case grade == "F":fmt.Printf("不及格\n")default:fmt.Printf("差\n");}fmt.Printf("你的等级是%s\n",grade);
}

/**
判断某个interface变量中实际存储的变量类型switch x.(type){case type:statement(s);case type:statement(s);default:statement(s);}
*/
package main
import "fmt"func main(){var x interface{}switch i := x.(type){case nil:fmt.Printf("x 的类型 ：%T",i)case int:fmt.Printf("x 是int类型")case float64:fmt.Printf("x是func(int)类型")case bool,string:fmt.Printf("x是bool或string类型")default:fmt.Printf("未知类型")}
}

/**select只能用于通道操作，每个case必须是一个通道，要么发送要么接收
*/
package main
import("fmt""time"
)func main(){c1 := make(chan string) //创建通道c1c2 := make(chan string) //创建通道c2go func(){ //启动协程，从通道获取数据time.Sleep(1 * time.Second)c1 <- "one"}()go func(){time.Sleep(2 * time.Second)c1 <- "two"}()for i:= 0;i < 2;i++ {select{ //等待两个通道的数据case msg1 := <-c1: //如果接收到c1数据fmt.Println("received",msg1) //received onecase msg2 := <-c2:fmt.Println("received",msg2) //received two}}
}

循环语句

package main
import "fmt"func main(){sun := 0for i := 0;i <= 10; i++{sum += i}fmt.Println(sum)//省略初始值sum := 1for ; sum <=10; {sum += sum}fmt.Println(sum)//或者可以这样写for sum <= 10 {sum += sum}fmt.Println(sum)//无限循环,要停止无限循环，可以在命令窗口按下ctrl-c sum := 0for{sum ++ }fmt.Println(sum)//for-each range循环对字符串、数组、切片等进行迭代输出元素strings := []string{"google","runoob"}for i,s := range strings{fmt.Println(i,s)}numbers := [6]int{1,2,3,5}for i,x := range numbers{fmt.Printf("第 %d 位 x 的值 = %d\n",i,x)}//map迭代map1 := make(map[int]float32)map1[1] = 1.0map1[2] = 2.0map1[3] = 3.0map1[4] = 4.0for key,value := range map1 {//读取key,valuefmt.Printf("key is:%d - value is:%f\n",key,value)}for key := range map1{ //读取valuefmt.Printf("key is:%d\n",key)}for _,value := range map1{fmt.Printf("value is:%f\n",value)}
}

//循环嵌套(判断素数)
package main
import "fmt"
func main(){var i,j intfor i=2;i<100;i++{for j=2;j<=(i/j);j++{if(i%j==0){break;}}if(j>(i/j)){fmt.Printf("%d 是素数\n",i);}}
}

================================================

数组

package main
import "fmt"func main(){var n [10]int //长度为10的数组balance := [5]float32{1000.0,2.0,3.4,7.0,50.0}//声明数组的同时并初始化数组balance2 := [...]float32{1000.0,2.0,3.4,7.0,50.0} //声明并初始化非固定长度的数组balance3 := [5]float32{1:2.0,3:7.0}//声明数组，并将索引为1和3的元素初始化values := [][]int{} //创建多维数组，或者指定数组长度创建数组 sites := [2][2]string{}row1 := []int{1,2,3}row2 := []int{4,5,6}values = append(values,row1)//向values多维数组添加两个一维数组values = append(values,row2) values1 := [3][4]int{ //声明并初始化一个二维数组{0,1,2,3},{4,5,6,7},{8,9,10,11},}fmt.Println(values1)var i,j intfor i = 0; i < 10; i++ {n[i] = i + 100 }for j = 0;j < 10;j++{ //输出数组每个元素的值fmt.Printf("Element[%d] = %d\n",j,n[j])}
}

//将数组作为参数
package main
import "fmt"func main(){var balance = [5]int {1000,2,3,17,50}var avg float32avg = getAverage(balance,5)fmt.Printf("平均值为：%f",avg)
}/**函数返回多个值func swap(x,y string)(string,string){ 参数是可选的，返回类型可以有多个，也可以没有发挥return y,x}函数调用func main(){a,b := swap("Google","Runoob")fmt.Println(a,b)   结果 Runoob Google}
*/
//求数组平均值的函数
func getAverage(arr [5]int,size int) float32{var i,sum intvar avg float32for i = 0;i < size;i++ {//求数组个元素的和sum += arr[i]}avg = float32(sum)/float32(size)return avg;
}

指针

一个指针变量指向了一个值的内存地址

package main
import "fmt"func main(){var a int = 20var ip *int //声明指针变量，指向的是int类型变量的地址ip = &afmt.Printf("a变量的地址是：%x\n",&a) //20818a220fmt.Printf("ip变量储存的指针地址：%x\n",ip) //指针变量的地址20818a220fmt.Printf("*ip变量的值：%d\n",*ip) //使用指针访问值 //20
}

指针数组

package main
import "fmt"
const MAX int = 3func main(){a := []int{10,100,200}var i intvar ptr [MAX]*int; //声明整型指针数组for i = 0; i < MAX; i++{ptr[i] = &a[i] //数组每个元素的地址赋值给指针数组每个元素}for i = 0;i < MAX; i++ {fmt.Printf("a[%d] = %d\n",i,*ptr[i]) //通过指针数组的每个指针，输出变量}
}

指向指针的指针
一个指针变量存放的另一个指针变量的地址

package main
import "fmt"func main(){var a intvar ptr *intvar pptr **int //指向指针的指针变量声明a = 3000ptr = &apptr = &ptrfmt.Printf("变量a=%d\n",a) //变量 a = 3000fmt.Printf("指针变量*ptr = %d\n",*ptr) //指针变量 *ptr = 3000fmt.Printf("指向指针的指针变量 **pptr = %d\n",**pptr) //指向指针的指针变量 **pptr = 3000
}

指针作为函数参数

package main
import "fmt"func main(){var a int = 100var b int = 200fmt.Printf("交换前 a 的值 : %d\n", a )fmt.Printf("交换前 b 的值 : %d\n", b )swap(&a, &b); //调用函数交换值(参数为变量的地址)fmt.Printf("交换后 a 的值 : %d\n", a )fmt.Printf("交换后 b 的值 : %d\n", b )
}func swap(x *int, y *int) { //参数为指针类型var temp inttemp = *x    /* 保存 x 地址的值 */*x = *y      /* 将 y 赋值给 x */*y = temp    /* 将 temp 赋值给 y */
}

结构体

结构体中可以为不同项定义不同的数据类型（数组是存储同一类型）

package mainimport "fmt"type Books struct { //定义结构体，Books为结构体名称title stringauthor stringsubject stringbook_id int
}func main() {// 创建一个新的结构体，并初始化（{Go 语言 www.runoob.com Go 语言教程 6495407}）fmt.Println(Books{"Go 语言", "www.runoob.com", "Go 语言教程", 6495407})// 也可以使用 key => value 格式定义，并初始化（{Go 语言 www.runoob.com Go 语言教程 6495407}）fmt.Println(Books{title: "Go 语言", author: "www.runoob.com", subject: "Go 语言教程", book_id: 6495407})// 忽略的字段为 0 或 空 （{Go 语言 www.runoob.com  0}）fmt.Println(Books{title: "Go 语言", author: "www.runoob.com"})/**声明结构体类型的变量*/var Book1 Books        /* 声明 Book1 为 Books 类型 */var Book2 Books        /* 声明 Book2 为 Books 类型 *//* book 1 描述 */Book1.title = "Go 语言"Book1.author = "www.runoob.com"Book1.subject = "Go 语言教程"Book1.book_id = 6495407/* book 2 描述 */Book2.title = "Python 教程"Book2.author = "www.runoob.com"Book2.subject = "Python 语言教程"Book2.book_id = 6495700/* 打印 Book1 信息 */fmt.Printf( "Book 1 title : %s\n", Book1.title)fmt.Printf( "Book 1 author : %s\n", Book1.author)fmt.Printf( "Book 1 subject : %s\n", Book1.subject)fmt.Printf( "Book 1 book_id : %d\n", Book1.book_id)/* 打印 Book2 信息 */fmt.Printf( "Book 2 title : %s\n", Book2.title)fmt.Printf( "Book 2 author : %s\n", Book2.author)fmt.Printf( "Book 2 subject : %s\n", Book2.subject)fmt.Printf( "Book 2 book_id : %d\n", Book2.book_id)/**将结构体作为函数的参数*/printBook(Book1)printBook(Book2)/**结构体指针*/printBook1(&Book1)printBook1(&Book2)
}func printBook( book Books ) { //将结构体作为函数的参数fmt.Printf( "Book title : %s\n", book.title)fmt.Printf( "Book author : %s\n", book.author)fmt.Printf( "Book subject : %s\n", book.subject)fmt.Printf( "Book book_id : %d\n", book.book_id)
}func printBook1( book *Books ) {fmt.Printf( "Book title : %s\n", book.title)fmt.Printf( "Book author : %s\n", book.author)fmt.Printf( "Book subject : %s\n", book.subject)fmt.Printf( "Book book_id : %d\n", book.book_id)
}

map集合

package mainimport "fmt"func main() {var countryCapitalMap map[string]string /*创建集合，第一个string是key的类型，第二个string是value类型 */countryCapitalMap = make(map[string]string) //使用make函数定义Map/* map插入key - value对,各个国家对应的首都 */countryCapitalMap [ "France" ] = "巴黎"countryCapitalMap [ "Italy" ] = "罗马"countryCapitalMap [ "Japan" ] = "东京"countryCapitalMap [ "India" ] = "新德里"/*使用键遍历map类型的值 */for country := range countryCapitalMap {fmt.Println(country, "首都是", countryCapitalMap [country]) //France 首都是 巴黎}/*查看元素在集合中是否存在 */capital, ok := countryCapitalMap [ "American" ] /*如果确定是真实的,则存在,否则不存在 *//*fmt.Println(capital) *//*fmt.Println(ok) */if (ok) {fmt.Println("American 的首都是", capital)} else {fmt.Println("American 的首都不存在")}
}

delete()函数

用于删除集合中的元素

package mainimport "fmt"func main() {/* 创建map，并初始化 */countryCapitalMap := map[string]string{"France": "Paris", "Italy": "Rome", "Japan": "Tokyo", "India": "New delhi"}fmt.Println("原始地图")/* 打印地图 */for country := range countryCapitalMap {fmt.Println(country, "首都是", countryCapitalMap [ country ])}/*删除元素*/ delete(countryCapitalMap, "France")fmt.Println("法国条目被删除")fmt.Println("删除元素后地图")/*打印地图*/for country := range countryCapitalMap {fmt.Println(country, "首都是", countryCapitalMap [ country ])}
}

=============================================

切片

package mainimport "fmt"func main() {/**var n []int 未指定大小的数组定义切片var n []int = make([]int,10) 或 n := make([]type,10)通过make函数创建切片，10表示数组的长度，也是切片的初始长度s := [] int{1,2,3} 切片初始化，[]切片类型s := arr[:] 初始化切片s，是数组arr的引用s := arr[startIndex:endIndex]s := arr[startIndex:] 没有endIndex，表示一直到arr的最后一个元素s := arr[:endIndex] 表示从arr的第一个元素开始s1 := s[startIndex:endIndex] 通过切片s初始化切片s1s := make([]int,len,cap) 通过内置函数make()初始化切片s，[]int表示元素类型为int的切片*/var numbers = make([]int,3,5)printSlice(numbers)
}func printSlice(x []int){//len方法获取长度，cap方法测量切片最长可以达到多少fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x) //len=3 cap=5 slice=[0 0 0]
}

空切片

package mainimport "fmt"func main() {var numbers []intprintSlice(numbers)if(numbers == nil){fmt.Printf("切片是空的")//切片是空的}
}func printSlice(x []int){fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x) //len=0 cap=0 slice=[]
}

切片截取

package mainimport "fmt"func main() {/* 创建切片 */numbers := []int{0,1,2,3,4,5,6,7,8}  printSlice(numbers)/* 打印原始切片 */fmt.Println("numbers ==", numbers) //numbers == [0 1 2 3 4 5 6 7 8]/* 打印子切片从索引1(包含) 到索引4(不包含)*/fmt.Println("numbers[1:4] ==", numbers[1:4]) //numbers[1:4] == [1 2 3]/* 默认下限为 0*/fmt.Println("numbers[:3] ==", numbers[:3]) //numbers[:3] == [0 1 2]/* 默认上限为 len(s)*/fmt.Println("numbers[4:] ==", numbers[4:]) //numbers[4:] == [4 5 6 7 8]numbers1 := make([]int,0,5) //创建切片printSlice(numbers1) //len=0 cap=5 slice=[]/* 打印子切片从索引  0(包含) 到索引 2(不包含),根据切片numbers创建numbers2 */number2 := numbers[:2]printSlice(number2) //len=2 cap=9 slice=[0 1]/* 打印子切片从索引 2(包含) 到索引 5(不包含) */number3 := numbers[2:5]printSlice(number3) //len=3 cap=7 slice=[2 3 4]}func printSlice(x []int){fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x) //len=9 cap=9 slice=[0 1 2 3 4 5 6 7 8]
}

切片增加容量append()和copy()函数

package mainimport "fmt"func main() {var numbers []intprintSlice(numbers)/* 允许追加空切片，添加一个元素0 */numbers = append(numbers, 0)printSlice(numbers) //len=1 cap=1 slice=[0]/* 向切片添加一个元素 */numbers = append(numbers, 1)printSlice(numbers) //len=2 cap=2 slice=[0 1]/* 同时添加多个元素 */numbers = append(numbers, 2,3,4)printSlice(numbers) //len=5 cap=6 slice=[0 1 2 3 4]/* 创建切片 numbers1 是之前切片的两倍容量*/numbers1 := make([]int, len(numbers), (cap(numbers))*2)/* 拷贝 numbers 的内容到 numbers1 */copy(numbers1,numbers)printSlice(numbers1)   //len=5 cap=12 slice=[0 1 2 3 4]
}func printSlice(x []int){fmt.Printf("len=%d cap=%d slice=%v\n",len(x),cap(x),x) //len=0 cap=0 slice=[]
}

Range 范围

用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。

package mainimport "fmt"var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}func main() {/**for key, value := range oldMap {newMap[key] = value}key,value可以省略for key := range oldMap 只读取keyfor _, value := range oldMap 只读取value*/for i, v := range pow {fmt.Printf("2**%d = %d\n", i, v)}//创建一个map，并初始化map1 := make(map[int]float32)map1[1] = 1.0map1[2] = 2.0map1[3] = 3.0map1[4] = 4.0// 读取 key 和 valuefor key, value := range map1 {fmt.Printf("key is: %d - value is: %f\n", key, value)}// 读取 keyfor key := range map1 {fmt.Printf("key is: %d\n", key)}// 读取 valuefor _, value := range map1 {fmt.Printf("value is: %f\n", value)}
}

package main
import "fmt"
func main() {//使用 range 去求一个 slice 的和。使用数组跟这个很类似nums := []int{2, 3, 4}sum := 0for _, num := range nums { //遍历valuesum += num}fmt.Println("sum:", sum) //sum: 9//在数组上使用 range 将传入索引和值两个变量。上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。有时侯我们确实需要知道它的索引。for i, num := range nums {if num == 3 {fmt.Println("index:", i) //index: 1}}//range 也可以用在 map 的键值对上。kvs := map[string]string{"a": "apple", "b": "banana"}for k, v := range kvs {fmt.Printf("%s -> %s\n", k, v) //a -> apple  b -> banana}//range也可以用来枚举 Unicode 字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。for i, c := range "go" {fmt.Println(i, c) //0 103   1 111}
}

=========================================

接口

另外一种数据类型即接口，它把所有的具有共性的方法定义在一起，任何其他类型只要实现了这些方法就是实现了这个接口

package mainimport ("fmt"
)/**定义接口type interface_name interface {method_name1 [return_type]method_name2 [return_type]method_name3 [return_type]...method_namen [return_type]}定义了一个接口Phone,接口里面有一个方法call()
*/
type Phone interface {call()
}/**定义结构体type struct_name struct {          }定义结构体NokiaPhone
*/
type NokiaPhone struct {}
/**func (struct_name_variable struct_name) method_name1() [return_type] {方法实现}
*/
func (nokiaPhone NokiaPhone) call() {fmt.Println("I am Nokia, I can call you!")
}/**定义结构体IPhone
*/
type IPhone struct {}func (iPhone IPhone) call() {fmt.Println("I am iPhone, I can call you!")
}func main() {var phone Phonephone = new(NokiaPhone)phone.call() //I am Nokia, I can call you!phone = new(IPhone)phone.call() //I am iPhone, I can call you!}

错误处理

通过内置的错误接口提供了非常简单的错误处理机制

package mainimport ("fmt"
)// 定义一个 DivideError 结构
type DivideError struct {dividee intdivider int
}/**error类型是一个接口类型type error interface {Error() string}
*/
// 实现 `error` 接口
func (de *DivideError) Error() string {strFormat := `Cannot proceed, the divider is zero.dividee: %ddivider: 0
`return fmt.Sprintf(strFormat, de.dividee)
}// 定义 `int` 类型除法运算的函数
func Divide(varDividee int, varDivider int) (result int, errorMsg string) {if varDivider == 0 {dData := DivideError{dividee: varDividee,divider: varDivider,}errorMsg = dData.Error()return} else {return varDividee / varDivider, ""}}func main() {// 正常情况if result, errorMsg := Divide(100, 10); errorMsg == "" {fmt.Println("100/10 = ", result)}// 当除数为零的时候会返回错误信息if _, errorMsg := Divide(100, 0); errorMsg != "" {fmt.Println("errorMsg is: ", errorMsg)}}

并发

通过 go 关键字来开启 goroutine ，goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的

package mainimport ("fmt""time"
)func say(s string) {for i := 0; i < 5; i++ {time.Sleep(100 * time.Millisecond)fmt.Println(s)}
}func main() {/**go 函数名( 参数列表 )使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。 同一个程序中的所有 goroutine 共享同一个地址空间*/go say("world")say("hello")//输出的 hello 和 world 是没有固定先后顺序。因为它们是两个 goroutine 在执行
}

通道（channel）

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

package mainimport "fmt"func sum(s []int, c chan int) {//声明c为一个通道sum := 0for _, v := range s {sum += v}c <- sum // 把 sum 发送到通道 c
}func main() {s := []int{7, 2, 8, -9, 4, 0}c := make(chan int) //声明一个通道go sum(s[:len(s)/2], c)go sum(s[len(s)/2:], c)x, y := <-c, <-c // 从通道 c 中接收，并赋值给x,yfmt.Println(x, y, x+y) //-5 17 12
}

通道缓冲区

ch := make(chan int, 100) 通过make的第二个参数
带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态，就是说发送端发送的数据可以放在缓冲区里面，可以等待接收端去获取数据，而不是立刻需要接收端去获取数据。

package mainimport "fmt"func main() {// 这里我们定义了一个可以存储整数类型的带缓冲通道// 缓冲区大小为2ch := make(chan int, 2)// 因为 ch 是带缓冲的通道，我们可以同时发送两个数据// 而不用立刻需要去同步读取数据ch <- 1ch <- 2// 获取这两个数据fmt.Println(<-ch) //1fmt.Println(<-ch) //2
}

遍历通道与关闭通道

package mainimport ("fmt"
)func fibonacci(n int, c chan int) {x, y := 0, 1for i := 0; i < n; i++ {c <- xx, y = y, x+y}close(c) //关闭通道
}func main() {c := make(chan int, 10)go fibonacci(cap(c), c)// range 函数遍历每个从通道接收到的数据，因为 c 在发送完 10 个// 数据之后就关闭了通道，所以这里我们 range 函数在接收到 10 个数据// 之后就结束了。如果上面的 c 通道不关闭，那么 range 函数就不// 会结束，从而在接收第 11 个数据的时候就阻塞了。for i := range c { //遍历通道fmt.Println(i)}
}