【Go语言】Go语言环境安装、基础语法及Go语言实例

1、Go语言环境安装

参考教程:https://www.runoob.com/go/go-environment.html
安装包下载地址:https://golang.google.cn/dl/
Windows版本的安装包为go1.13.7.windows-amd64.msi。
安装完成配置Path环境变量:添加路径E:\Go\bin。
在命令行测试环境搭建是否成功(编写Go语言的Hello World程序):
在目录H:\IDEAWorkspace\下创建hello.go文件如下:

package main

import "fmt"

func main() {
	fmt.Printf("hello, world\n")
}

进入目录H:\IDEAWorkspace

C:\Users\DELL>H:
H:\>cd H:\IDEAWorkspace
H:\IDEAWorkspace>go run hello.go
hello, world

或者

H:\IDEAWorkspace>go build
H:\IDEAWorkspace>IDEAWorkspace
hello, world

2、Go语言基础语法

(1)数据类型
布尔型:go语言用bool表示。
整型:go语言里面有int8,int16,int32,int64,分别对应Java中的byte,short,int,long,同时go语言里面还有专门表示无符号数的uint8,uint16,uint32和uint64。
浮点型:float32,float64。
字符串类型:string。
go语言中的uint8表示Java中的byte类型,go语言中的rune表示int32类型,也就是4个字节有符号的整数,对应Java中的int。即byte是uint8的别名,rune是int32的别名。
除此之外,go语言数据类型包括一些派生类型:指针类型(Pointer)、数组类型、结构体类型(struct)、channel类型、函数类型、切片类型、接口类型(interface)、map类型等。
(2)变量的声明与赋值
1)先声明再赋值

var name string
name = "csdn"

2)声明并且赋值

var name = "csdn"		// 编译器会根据值自行判定变量类型

3)使用:=声明并且赋值

name := "csdn"			// 这里省略var关键字,效果和第二种是一样的

(3)if条件语句

if 布尔表达式 {
	/* 在布尔表达式为true时执行 */
}

需要注意的是,Go中的if条件语句没有括号,例如:

if a == 10 {
	/* 如果条件为true则执行以下语句 */
	fmt.Println("a == 10")
}

此外,if还有另外一种形式,它包含一个statement可选语句部分,该组件在条件判断之前运行。它的语法是:

if statement; condition {

}

例如:

if a:=1; a<10 {
	/* 如果条件为true,则执行以下语句 */
	fmt.Println("a<10")
}

(4)循环语句
1)格式一:和其他语言的for语法类似

for init; condition; post {

}

init:一般为赋值表达式,给控制变量赋初值。
condition:关系表达式或逻辑表达式,循环控制条件。
post:一般为赋值表达式,给控制变量增量或减量。
例如:

for i := 1; i < 10; i++ {
	fmt.Println("i=", i)
}

2)格式二:跟while循环类似

for condition {}

例如:

for 0 == 0 {}
for true {}

3)格式三:死循环,类似while(true) {}

for { }

例如:

for {
	server.Listen(8080)			// 服务器监听8080端口
}

(5)结构体
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合(相当于Java中的类class)。
go语言中的结构体定义如下:

type identifier struct {
	field1 type1
	field2 type2
}

用结构体可以表示一个具有某一特征的对象。field1,field2是对象的属性,type1,type2是属性的数据类型。例如:

type Person struct {
	name string
	age uint32
	birth string
	height float32
	weight float32
}

第一种结构体赋值方式:

t := new(T)		// 变量t是一个指向T的指针,此时结构体字段的值是它们所属类型的零值
person := new(Person)

第二种结构体赋值方式:

t := &T{}

&T{}这种语法叫做混合字面量语法(composite literal syntax),类似&struct1 {a, b, c},这种混合字面量语法是一种简写,底层仍然会调用new(),这里值的顺序必须按照字段顺序来写。

person := &Person {name: "juejin", age: 12}

如果要访问结构体成员,需要使用点号 . 操作符,格式为:“结构体.成员名”。
例如:

person := &Person {name: "juejin", age: 12}
fmt.Printf("name: %s, age: %d", person.name, person.age)

(6)数组
1)数组是有序的元素序列,go中数组语法如下:

var variable_name [SIZE] variable_type

例如:

// 定义一个10个长度string类型的数组array
var array[10] string
// 数组赋值
array[0] = "go"
array[1] = "java"
array[2] = "c++"

数组赋值:上面代码可以看出,直接通过访问数组下标即可对数组元素进行赋值。
2)数组初始化:声明时初始化,语法如下:

var variable_name = [SIZE]variable_type {value1, value2,...}

例如:

var array = [5]string {"go", "java", "c++"}

3)数组遍历
普通for循环遍历,例如:

for i := 0; i < 5; i++ {
	fmt.Printf("array[%d] = %s \n", i, array[i])
}

for range遍历,这是go里面一种特有的遍历方式,例如:

// 这段代码可以实现跟上面代码相同的效果
for index, value := range array {
	fmt.Printf("array[%d] = %s \n", index, value)
}

上面代码中,index即为数组元素下标,value即为数组元素的值,假如不需要使用到index或者value,可以用_进行代替。例如:

// 这段代码可以实现跟上面代码相同的效果
for _, value := range array {
	fmt.Printf("value = %s \n", value)
}

(7)切片
切片:go语言提供了一种类似“动态数组”结构的数据类型,这种类型就是切片slice。
slice的本质是一个数据结构,实现了对数组操作的封装。
切片slice的声明语法如下:

var identifier []type

例如:

// 声明一个为int64类型的切片
var array []int64

slice和数组的声明语法是不同的,go语言中声明数组时是需要指定长度的,例如:

// 声明一个为int64类型长度为10的数组
var array[10] int64

初始化操作也不一样,对slice的初始化是使用make初始化。

// 初始化一个int64类型的切片
array = make( []int64, 10)

而对数组的初始化是:

array = [10]int64 {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

切片slice的常用方法:append,实现对slice元素的添加,例如:

array := make([]int64, 10)
// 往切片中添加两个元素
array = append(array, 1)
array = append(array, 2)

截取:可以通过设置下限及上限来截取切片 [lower-bound : upper-bound],例如:

package main
import "fmt"

func main() {
	/* 创建切片 */
	numbers := []int{0, 1, 2, 3, 4, 5, 6, 7, 8}
	/* 打印原始切片 */
	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]
}

获取切片长度:通过len方法。

len(slice)

遍历:和数组一样,slice可以通过range关键字进行遍历。例如:

package main
import "fmt"

func main() {
	// 使用range去求一个slice的和
	nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
	sum := 0
	for _, num := range nums {
		sum += num
	}
	fmt.Println("sum:", sum)
	for i, num := range nums {
		if num == 3 {
			fmt.Println("index:", i)
		}
	}
}

(8)map
map是一种无序的键值对的集合。go语言中的语法如下:

/* 声明变量,map的默认值是nil map */
var map_variable map[key_data_type]value_data_type

例如:

var dataMap map[string]string

map初始化:map可以使用make进行初始化。

/* 使用make函数 */
map_variable := make(map[key_data_type]value_data_type)

例如:

dataMap := make(map[string]string)

如果不初始化map,那么就会创建一个nil map,nil map不能用来存放键值对。例如下面代码会执行失败:

package main
func main(){
	var dataMap map[string]string
	dataMap["csdn"] = "hello csdn"
}

输出:panic: assignment to entry in nil map
和数组不同,map可以根据新增的key-value对动态地伸缩,因此它不存在固定长度或者最大限制。但是可以选择标明map的初始容量capacity,语法如下:

make(map[keytype]valuetype, capacity)

例如:

dataMap := make(map[string]string, 20)

map遍历:和slice相似,map的遍历同样也可以使用for range进行遍历,例如:

kvs := map[string]string {"a": "apple", "b": "banana"}
for k, v := range kvs {
	fmt.Printf("%s -> %s\n", k, v)
}

map基本操作
假设有一个map m:
设置/修改元素值:

m[key] = elem

获取元素:

elem = m[key]

删除元素:

delete(m, key)

检测某个键是否存在:

elem, ok = m[key]

如果key在m中,ok为true,否则,ok为false,并且elem是map的元素类型的零值。
同样的,当从map中读取某个不存在的键时,结果是map的元素类型的零值。
(9)函数
go语言函数定义格式如下:

func function_name([parameter_list])[return_types]{
	函数体
}

与许多后端语言不同的是,go语言中的函数是支持多返回值的,比如我们将上述函数修改一下,实现取两个数最大值和最小值的功能。

// 此函数实现了取两个数最大值的功能
func max(a int32, b int32) int32 {
	if a > b {
		return a
	} else {
		return b
	}
}

// 此函数实现了取两个数最大值和最小值的功能
func getMaxAndMin(a int32, b int32)(int32, int32) {
	if a > b {
		return a, b
	} else {
		return b, a
	}
}

(10)方法
go语言还有一种特殊的函数,叫做方法。一个方法就是一个包含了接受者的函数,接受者可以是命名类型或者结构体类型的一个值或者是一个指针。所有给定类型的方法属于该类型的方法集。语法格式如下:

func (variable_name variable_data_type) function_name([parameter_list])[return_type] {
	/* 函数体 */
}

例如:

// 我们用面向对象的思想实现一个封装的结构体
type Person struct {
	name string		// 姓名
	age uint32		// 年龄
}

// 获取姓名
func (p *Person) GetName() string {
	return p.name
}

// 设置姓名
func (p *Person) SetName(name string) {
	p.name = name
}

3、Go语言实例

import "fmt"

type Person interface {
	SetName(string)
	GetName() string
}

type person struct {
	name string
}

func (p *person) GetName() string {
	return p.name
}

func (p *person) SetName(name string) {
	p.name = name
}

func doSomething(p Person) {
	fmt.Println(p.GetName())
}

func main() {
	p := &person{
		name : "Tom"
	}
	fmt.Println(p.GetName())
	doSomething(p)
}
已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 书香水墨 设计师:CSDN官方博客 返回首页