go安装及入门

go安装及入门

一、简介

go是谷歌开发的静态强类型、可自动垃圾回收的语言，具有底层原生支持并发的特点。语法类似于c语言。这里对go安装及入门进行介绍。

二、安装

安装步骤如下：

1. 下载安装包，wget https://dl.google.com/go/go1.12.4.linux-amd64.tar.gz
2. 解压，sudo tar zxvf go1.12.4.linux-amd64.tar.gz -C /usr/local/ 解压的结果是/usr/local/go
3. 添加环境变量
   export GOROOT=/usr/local/go
   export PATH=$PATH:$GOHOME/bin

三、go语言特点

1. go内置并发机制，原生支持并发;
2. 声明的局部变量(全局变量可以不使用)必须使用，否则报错;
3. 变量名以大写开头则为公开变量(可被其它包引用)，以小写开头则为私有变量(不可被其它包引用);
4. go和c语言类似，使用指针;

四、go基本语法

4.1 go程序入口

go程序的入口在包名为main,函数为main中，示例如下：

package main
import "fmt"
func main() {
   fmt.Println("hello world")
}

4.2 变量

变量声明用var,如 var i，声明的同时赋值，可以用简写:=，如 i:=1

4.3 集合类

4.3.1 数组

格式如下：

//声明数组
var variable_name [size] variable_type
//数组直接初始化,指明size
arr := [size]type{val1,val2}
//数组直接初始化,根据值自动指定size
arr := [...]type{val1,val2}

示例如下：

//声明数组,指定数组大小
arr1 := [5]int{1, 7, 3, 5, 6}
fmt.Println(arr1)
//声明数组,自动指定数组大小
arr2 := [...]int{1, 7, 3, 5, 6}
fmt.Println(arr2)

4.3.2 切片

数组的长度是不可变，而切片是可变人，格式如下：

//声明切片
var slice1 []type
//声明切片
slice2 := make(type,length,capacity)
//切片直接初始化
slice3 := []type{val1,val2}

示例如下：

//声明切片
var slice0 []int
fmt.Println(slice0)

//声明切片
slice1 := make([]int, 2)
fmt.Println(slice1)

//切片直接赋值
slice2 := []int{1, 2, 3, 4, 5}
fmt.Println(slice2[2:4])
//添加元素
slice2 = append(slice2, 4)
fmt.Println(slice2)
//删除元素
slice2 = slice2[:3]
fmt.Println(slice2)

//遍历切片
for idx, val := range slice2{
fmt.Println(idx, val)
}

4.3.3 映射

格式如下：

map1 := make(map[key_type] val_type)

示例如下：

//创建map
stuMap:=make(map[string]string)
//赋值
stuMap["StuName"] = "mongo"
stuMap["stuNo"] = "001"
fmt.Println(stuMap)
fmt.Println(stuMap["StuName"])

//删除
delete(stuMap, "stuNo")
fmt.Println(stuMap)

//遍历
for k,v := range stuMap{
fmt.Println(k, v)
}

4.4 函数

函数定义格式如下：

func funcName([parameter_list]) [return_types]{...}

示例如下：

func max(n1 int, n2 int) int {
   if n1 > n2 {
      return n1
   }
   return n2
}

4.5 结构体(类)

结构体格式如下：

type struct_name struct {
    variable type
    variable type
}

示例如下：

type Stu struct {
   StuName string //属性名大写开头，外部可访问
   StuAge  int
   stuAdress  int //属性名小写开头，外部不能访问
}

4.6 接口

接口格式如下：

type interface_name interface{
    method_name() return_type
}

接口实现格式如下：

func(struct_name_variable struct_name) method_name() [return_type]{...}

示例如下：

type Stu struct {
	StuName string
	StuAge  int
}

//接口定义
type IStu interface {
	PrintName() string
}

//接口实现
func (stu Stu) PrintName() string {
	fmt.Println("stu name:", stu.StuName)
	return stu.StuName
}

func main() {
	//接口调用
	iStu := Stu{"apple", 18}
	iStu.PrintName()
}

4.7 并发

4.7.1 并发

使用关键字go开启一个并发任务，格式如下：

go method_name(parameter_list)

示例如下：

package main
import (
   "fmt"
   "time"
)
func PrintName(name string){
   for i:=0; i<10;i++ {
      time.Sleep(1* time.Second)
      fmt.Println(name)
   }
}
func main() {
   go PrintName("apple")
   PrintName("banana")
}

4.7.2 通道

通道用于数据传递，包含通道的声明、发送数据到通知、从通道中读取数据。格式如下：

//使用make声明通道
make(chan type)
//使用make声明通道,带size个缓冲区
make(chan type, size)
//向缓冲区发送或接受数据
<-

示例如下：

通道,指定类型为int
//ch1 := make(chan int)
通道,指定类型为任意格式
//ch2 := make(chan interface{})

//带10个缓冲区的通道
ch := make(chan int, 10)
//向通道中发送数据
ch <- 2
ch <- 3
//从通道中读取数据
x,y := <-ch, <-ch
fmt.Printf("x:%d y:%d", x, y)

五、运行

以运行代码hello.go为例。介绍两种运行方式。

5.1 直接执行

go run hello.go

5.2 编译为二进制文件再执行

#编译为二进制文件
go build hello.go
#查看生成的二进制文件,会看到hello
ls
#执行二进制文件
./hello