一起学Go吧! Go语言基础语法篇二

前言

昨天发布了简单的Go语言的语法基础，今天咱继续来一起学习！让学习的快乐充实我们的每一天！

想先学习Go语言的同学可以看博主的前一篇

一起学Go吧! Go语言基础语法篇一

---

Go 语言指针

Go 语言中指针是很容易学习的，Go 语言中使用指针可以更简单的执行一些任务。

接下来让我们来一步步学习 Go 语言指针。

我们都知道，变量是一种使用方便的占位符，用于引用计算机内存地址。

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

以下实例演示了变量在内存中地址：

package main

import "fmt"

func main() {
   var a int = 10  
	//%x 代表十六进制方式输出
   fmt.Printf("变量的地址: %x\n", &a  )
}

执行以上代码输出结果为：

变量的地址: 20818a220

什么是指针?
一个指针变量指向了一个值的内存地址。
类似于变量和常量，在使用指针前你需要声明指针。指针声明格式如下：

var var_name *var-type

var-type 为指针类型，var_name 为指针变量名，* 号用于指定变量是作为一个指针。以下是有效的指针声明：

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

如何使用指针?

指针使用流程：

• 定义指针变量。
• 为指针变量赋值。
• 访问指针变量中指向地址的值。

在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。
由此可见，Go语言的指针用法与C语言的十分相似,简直一摸一样

指针实例

package main

import "fmt"

func main() {
   var a int= 20   /* 声明实际变量 */
   var ip *int        /* 声明指针变量 */

   ip = &a  /* 指针变量的存储地址 */

   fmt.Printf("a 变量的地址是: %x\n", &a  )

   /* 指针变量的存储地址 */
   fmt.Printf("ip 变量储存的指针地址: %x\n", ip )

   /* 使用指针访问值 */
   fmt.Printf("*ip 变量的值: %d\n", *ip )
}

以上实例执行输出结果为：

a 变量的地址是: 20818a220
ip 变量储存的指针地址: 20818a220
*ip 变量的值: 20

Go 空指针
当一个指针被定义后没有分配到任何变量时，它的值为 nil。

nil 指针也称为空指针。

nil在概念上和其它语言的null、None、nil、NULL一样，都指代零值或空值。

一个指针变量通常缩写为 ptr。

空指针实例

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("ptr 的值为 : %x\n", ptr  )
}

以上实例输出结果为：

ptr 的值为 : 0

空指针判断：

if(ptr != nil)     /* ptr 不是空指针 */
if(ptr == nil)    /* ptr 是空指针 */

Go 语言指针作为函数参数

实例

package main

import "fmt"

func swap(x *int, y *int) {
	var tmp int
	tmp = *x
	*x = *y
	*y = tmp
}

func main() {
	var a, b int = 1, 2
	swap(&a, &b)
	fmt.Println(a, b)
}

打印结果

---

Go语言结构体

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

结构体表示一项记录，比如保存图书馆的书籍记录，每本书有以下属性：

• Title ：标题
• Author ： 作者
• Subject：学科
• ID：书籍ID

定义结构体

结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。结构体的格式如下：

type struct_variable_type struct {
   member definition
   member definition
   ...
   member definition
}

一旦定义了结构体类型，它就能用于变量的声明，语法格式如下：

variable_name := structure_variable_type {value1, value2...valuen}
或
variable_name := structure_variable_type { key1: value1, key2: value2..., keyn: valuen}

实例

package main

import "fmt"

type Book struct {
	title   string
	author  string
	subject string
	book_id int
}

func main() {
	//1.先定义一个结构体变量，然后对变量属性赋值
	var book Book
	book.author = "rjc"
	book.title = "一起学Go吧！"
	book.subject = "Go"
	book.book_id = 1
	fmt.Println(book)

	//2.利用 Key : value 的形式直接创建对象,没有赋值的属性默认值为 0 或 nil
	var test Book = Book{title: "asd", author: "asd", subject: "go", book_id: 1}
	fmt.Println(test)
}

输出结果

Go语言切片(Slice)

Go 语言切片是对数组的抽象。

Go 数组的长度不可改变，在特定场景中这样的集合就不太适用，Go 中提供了一种灵活，功能强悍的内置类型切片(“动态数组”)，与数组相比切片的长度是不固定的，可以追加元素，在追加时可能使切片的容量增大。

定义切片
你可以声明一个未指定大小的数组来定义切片：

var identifier []type

切片不需要说明长度。

或使用 make() 函数来创建切片:

var slice1 []type = make([]type, len)

也可以简写为

slice1 := make([]type, len)

也可以指定容量，其中 capacity 为可选参数。

make([]T, length, capacity)

这里 len 是数组的长度并且也是切片的初始长度。

切片初始化

s :=[] int {1,2,3 }

直接初始化切片，[] 表示是切片类型，{1,2,3} 初始化值依次是 1,2,3，其 cap=len=3。

s := arr[:]

初始化切片 s，是数组 arr 的引用。

s := arr[startIndex:endIndex] //左闭右开区间

将 arr 中从下标 startIndex 到 endIndex-1 下的元素创建为一个新的切片。

s := arr[startIndex:]

默认 endIndex 时将表示一直到arr的最后一个元素。

s := arr[:endIndex]

默认 startIndex 时将表示从 arr 的第一个元素开始。

切片的综合实例

package main

import "fmt"

func main() {
	var numbers []int

	for i := 0; i <= 10; i++ {
		/*append(numbers,i) 向 numbers 切片中添加 i 元素*/
		numbers = append(numbers, i)
	}
	
	/* 创建切片 numbers1 是之前切片的两倍容量*/
	/*len(numbers) 求numbers切片的长度, cap(numbers) 求numbers的容量*/
	test := make([]int, len(numbers), (cap(numbers))*2)
	
	/* copy函数将 numbers 的切片内容复制到 test 切片中 */
	copy(test, numbers)
	fmt.Println(test[:])
}

---

Go 语言范围(Range)

Go 语言中 range 关键字用于 for 循环中迭代数组(array)、切片(slice)、通道(channel)或集合(map)的元素。在数组和切片中它返回元素的索引和索引对应的值，在集合中返回 key-value 对。

实例

package main

import "fmt"

func main() {
	nums := []int{1, 2, 3}
	sum := 0
	sum1 := 0

	for _, num := range nums {
		sum1 += num
	}
	fmt.Println(sum1)
	//在数组上使用range将传入index和值两个变量。
	// 上面那个例子我们不需要使用该元素的序号，所以我们使用空白符"_"省略了。
	// 有时侯我们确实需要知道它的索引。
	for i, num := range nums {
		sum += num
		if num == 3 {
			fmt.Println(i)
		}
	}
	fmt.Println(sum)

	//range 也可以用在map的键值对上
	kvs := map[string]string{"a": "apple", "b": "banana"}
	for k, v := range kvs {
		fmt.Printf("%s -> %s\n", k, v)
	}

	//range也可以用来枚举Unicode字符串。第一个参数是字符的索引，第二个是字符（Unicode的值）本身。
	for i, c := range "go" {
		fmt.Println(i, c)
	}
}

输出结果

---

Go 语言Map(集合)

Map 是一种无序的键值对的集合。Map 最重要的一点是通过 key 来快速检索数据，key 类似于索引，指向数据的值。

Map 是一种集合，所以我们可以像迭代数组和切片那样迭代它。不过，Map 是无序的，我们无法决定它的返回顺序，这是因为 Map 是使用 hash 表来实现的。

定义 Map
可以使用内建函数 make 也可以使用 map 关键字来定义 Map:

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

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

如果不初始化 map，那么就会创建一个 nil map。nil map 不能用来存放键值对

实例

package main

import "fmt"

func main() {
	var mymap map[string]string /*创建集合*/
	mymap = make(map[string]string)

	/*map 插入key - value对*/
	mymap["please"] = "请"
	mymap["point"] = "点"
	mymap["good"] = "赞"
	mymap["symbol"] = "!"
	mymap["thanks"] = "谢谢!"

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

	//查看元素是否在集合中存在
	test, ok := mymap["test"]
	if ok {
		fmt.Println("OK!" + test)
	} else {
		fmt.Println("No OK!")
	}

	/*删除 map 中的元素*/
	delete(mymap, "symbol")

	for e := range mymap {
		fmt.Println(e)
	}

}

输出结果

---

Go 语言类型转换

类型转换用于将一种数据类型的变量转换为另外一种类型的变量。Go 语言类型转换基本格式如下：

type_name(expression)

实例

package main

import "fmt"

func main() {
	var sum int = 17
	var count int = 5
	var mean float32
	mean = float32(sum) / float32(count)
	fmt.Printf("mean的值为: %.2f\n", mean)
}

---

Go 语言接口

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

基本定义语法如下

/* 定义接口 */
type interface_name interface {
   method_name1 [return_type]
   method_name2 [return_type]
   method_name3 [return_type]
   ...
   method_namen [return_type]
}

/* 定义结构体 */
type struct_name struct {
   /* variables */
}

/* 实现接口方法 */
func (struct_name_variable struct_name) method_name1() [return_type] {
   /* 方法实现 */
}
...
func (struct_name_variable struct_name) method_namen() [return_type] {
   /* 方法实现*/
}

程序实例

package main

import "fmt"

/* 定义接口 */
type Phone interface {
	call()
}

type NokiaPhone struct {
}

func (nokiaPhone NokiaPhone) call() {
	fmt.Println("I am Nokia, I can call you!")
}

type IPhone struct {
}

func (iphone IPhone) call() {
	fmt.Println("I am iPhone, I can call you!")
}

func main() {
	var phone Phone
	phone = new(NokiaPhone)
	phone.call()

	phone = new(IPhone)
	phone.call()
}

在上面的例子中，我们定义了一个接口Phone，接口里面有一个方法call()。然后我们在main函数里面定义了一个Phone类型变量，并分别为之赋值为NokiaPhone和IPhone。然后调用call()方法，输出结果如下：

---

Go 错误处理

程序错误可以解决，但是坚决抵制触犯法律错误(抵制删库跑路，抵制删除源代码！！ )

当然，写程序的过程中，也尽量多思考后再动手

回归正文
Go 语言通过内置的错误接口提供了非常简单的错误处理机制。

error类型是一个接口类型，这是它的定义：

type error interface {
    Error() string
}

我们可以在编码中通过实现 error 接口类型来生成错误信息。

函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息：

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    // 实现
}

在下面的例子中，我们在调用Sqrt的时候传递的一个负数，然后就得到了non-nil的error对象，将此对象与nil比较，结果为true，所以fmt.Println(fmt包在处理error时会调用Error方法)被调用，以输出错误，请看下面调用的示例代码：

result, err:= Sqrt(-1)

if err != nil {
   fmt.Println(err)
}

实例

package main

import "fmt"

//定义一个 DivideError 结构
type DivideError struct {
	dividee int
	divider int
}

//实现 `error` 接口
func (de *DivideError) Error() string {
	strFormat := `
		Cannot proceed, the divider is zero.
    	dividee: %d
    	divider: 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并发

Go 语言支持并发，我们只需要通过 go 关键字来开启 goroutine 即可。

goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。

goroutine 语法格式：

go 函数名( 参数列表 )

Go 允许使用 go 语句开启一个新的运行期线程， 即 goroutine，以一个不同的、新创建的 goroutine 来执行一个函数。 同一个程序中的所有 goroutine 共享同一个地址空间。

实例

package main

import (
	"fmt"
	"time"
)

func say(s string) {
	for i := 0; i < 5; i++ {
		time.Sleep(100 * time.Millisecond)
		fmt.Println(s)
	}
}

func main() {
	go say("world!")
	say("hello")
}

打印结果

---

通道（channel）

通道（channel）是用来传递数据的一个数据结构。

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

ch <- v    // 把 v 发送到通道 ch
v := <-ch  // 从 ch 接收数据
           // 并把值赋给 v

声明一个通道很简单，我们使用chan关键字即可，通道在使用前必须先创建：

ch := make(chan int)

注意：默认情况下，通道是不带缓冲区的。发送端发送数据，同时必须有接收端相应的接收数据。

以下实例通过两个 goroutine 来计算数字之和，在 goroutine 完成计算后，它会计算两个结
果的和：

package main

import "fmt"

func sum(s []int, c chan int) {
	sum := 0
	for _, 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中接收
	fmt.Println(x, y, x+y)
}

输出结果为

通道缓冲区
通道可以设置缓冲区，通过 make 的第二个参数指定缓冲区大小：

ch := make(chan int, 100)

带缓冲区的通道允许发送端的数据发送和接收端的数据获取处于异步状态，就是说发送端发送的数据可以放在缓冲区里面，可以等待接收端去获取数据，而不是立刻需要接收端去获取数据。

不过由于缓冲区的大小是有限的，所以还是必须有接收端来接收数据的，否则缓冲区一满，数据发送端就无法再发送数据了。

注意：如果通道不带缓冲，发送方会阻塞直到接收方从通道中接收了值。如果通道带缓冲，发送方则会阻塞直到发送的值被拷贝到缓冲区内；如果缓冲区已满，则意味着需要等待直到某个接收方获取到一个值。接收方在有值可以接收之前会一直阻塞。

实例

package main

import "fmt"

func main() {
	//这里我们定义了一个可以存储整数类型的带缓冲通道
	//缓冲区大小 为 2
	ch := make(chan int, 2)

	//因为 ch 是带缓冲的通道，我们可以同时发送两个数据
	//而不用立刻需要去同步读取数据
	ch <- 1
	ch <- 2

	// 获取这两个数据
	fmt.Println(<-ch)
	fmt.Println(<-ch)
}

输出结果

Go 遍历通道与关闭通道
Go 通过 range 关键字来实现遍历读取到的数据，类似于与数组或切片。格式如下：

v, ok := <-ch

如果通道接收不到数据后 ok 就为 false，这时通道就可以使用 close() 函数来关闭。

实例

package main

import "fmt"

func fibonacci(n int, c chan int) {
	x, y := 0, 1
	for i := 0; i < n; i++ {
		c <- x
		x, 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)
	}
}

---

总结

到这里，Go语言的基础语法就完结啦！在学习的时候最好保证自己的效率和持续性，不要间断。各位童鞋们，我们一起加油向未来看齐！

各位童鞋们，看完如果有帮助的话可以给博主点赞呀！

---

坚持分享，坚持原创，喜欢博主的靓仔靓女们可以看看博主的首页博客！
您的点赞与收藏是我分享博客的最大赞赏！
博主博客地址: https://blog.csdn.net/weixin_43967679