在《基础篇》和《入门篇》当中,我们已经知道了Golang的基本属性、方法等知识,接下来,在本文当中就详细介绍一下Go中的一些常用操作和语法函数,包含下面几个内容。相信阅读完后续章节的朋友,就能大致对Go语言的项目开发有了一个基础的掌握。
为响应交流的朋友反馈篇幅过长的问题,本主尽量分开不同的知识点(PS:勤快点,别懒了),细致短促的讲解Go当中的知识点,以便朋友更加深入的学习。
- 分支、循环
- 函数
- 指针
- 结构体
1、分支、循环
(1) if 语句
语法格式如下:(与java类似,区别在于它的条件不需要括号"()")
if expression(表达式) {
/* 为 true 时执行 */
} else if expression2 {
/* 为 false ,expression2为true时执行 */
} else{
/* 都为false时,执行*/
}
示例:
func main() {
/* 定义局部变量 */
var a int = 2
/* 使用 if 语句判断布尔表达式 */
if a < 5 {
/* 如果条件为 true 则执行以下语句 */
fmt.Printf("a 小于 5\n" )
}
fmt.Printf("a 的值为 : %d\n", a)
}
(2)switch 语句
语法格式如下:(与java类似,区别在于Go中不需要像java一样在每一个case当中显式声明break,当找到匹配项时自动跳出)
switch var1 { // var1可以是任意类型
case val1: // 可以是同类型的任意值
...
case val2: // 且必须是相同的类型
...
default:
...
}
示例:
package main
import "fmt"
func main() {
/* 定义局部变量 */
var name string = "bboyHan"
var salary int = 30
//方式一:
switch age {
case 30000: name = "Tom"
case 25000: name = "Jerry"
case 22000,25000,30 : name = "bboyHan" //case 后可以由多个数值
default: name = "unknown"
}
//方式二:
switch {
case name == "Tom" :
fmt.Printf("good man!\n" )
case name == "Jerry", name == "bboyHan" :
fmt.Printf("lazy man\n" )
case name == "Kimi" :
fmt.Printf("good woman\n" )
case name == "Tomy":
fmt.Printf("a dog\n" )
default:
fmt.Printf("unknown\n" );
}
fmt.Printf("He(She) is a %s \n", name );
注意点:case定义的常量不可以重复,case后可以有多个常量值。另外,case中的表达式是可选的,可以省略。如果该表达式被省略,则被认为是switch true,并且每个case表达式都被计算为true,并执行相应的代码块。
func main() {
num := 75
switch {
case num >= 0 && num <= 50:
fmt.Println("num is greater than 0 and less than 50")
case num >= 51 && num <= 100:
fmt.Println("num is greater than 51 and less than 100")
case num >= 101:
fmt.Println("num is greater than 100")
}
}
(3)select 语句
select会随机执行一个可运行的case。如果没有case可运行,它将会阻塞,直到有case可运行。通常可以使用在通信之上,比如接收和发送消息,生产者与消费者的关系等等。如果有多个case都可以运行,Select会随机公平地选出一个执行。其他不会执行。记住!其它的是不会执行。
package main
import "fmt"
func main() {
var c1, c2, c3 chan int //定义通信通道
var i1, i2 int
select {
case i1 = <-c1:
fmt.Printf("接收消息:received ", i1, " from c1\n")
case c2 <- i2:
fmt.Printf("发送消息:sent ", i2, " to c2\n")
case i3, ok := <-c3:
if ok {
fmt.Printf("接收消息:received ", i3, " from c3\n")
} else {
fmt.Printf("c3 is closed - 消息关闭\n")
}
default:
fmt.Printf("no communication - 未连接 \n")
}
}
2、循环语句
Golang当中,for是唯一的循环语句,并不像java一样还有while、dowhile等语法,显得更加简单明了。
语法结构:
for init; condition; post {
//执行内容
}
// init : 初始化语句,只执行一次
// condition : 判断条件
// post : 迭代后执行的语句
// init、condition、post 三部分都可以省略,可以选择,如:
for condition { }
for { }
示例:
package main
import "fmt"
func main() {
nums := []int{1, 2, 3}
sum := 0
for _, num := range nums { // 埋雷, orz,想知道"_"时什么意思请往下看
sum += num
}
fmt.Println(sum)
for i, num := range nums {
if num == 2 {
fmt.Println(i)
}
}
kvs:= map[string]string{"a":"apple","b":"banana"}
for k,v := range kvs{
fmt.Printf("%s - %s\n",k,v)
}
for i,c := range "go"{
fmt.Println(i,c) // 打印字符ASCII值
}
}
其中还有break、continue跳出循环语句的使用,与其它语言类似
//continue
func main() {
for i := 1; i <= 10; i++ {
if i%2 == 0 {
continue //跳出本次循环
}
fmt.Printf("%d ", i)
}
}
//break
func main() {
for i := 1; i <= 10; i++ {
if i > 5 {
break //当大于5时,结束循环
}
fmt.Printf("%d ", i)
}
fmt.Printf("\nline after for loop")
}
func main() {
var a int
A:
for a < 5 {
if a == 3 {
a++
goto A //当执行到这时,返回到第3行继续执行代码
}
fmt.Printf("%d, --- \n", a)
a++
}
}
2、函数
我在《入门篇》提到过一个Go语言当中必不可少的函数,就是main函数,所谓函数,就是执行特定任务的代码块,在Go中,函数定义比较有趣的一点就是,它可以有多个返回值,十分方便
(1)语法格式:
func funcName(param1 type1, param2 type2) (output1 type1, output2 type2) {
//...
//函数具体实现内容
//返回多个值
return value1, value2
}
示例:(定义两个数交换的函数)
func swap(i int, i2 int) (int, int) {
return i2,i
}
//输入3、5,得出结果5,3
func main() {
a,b := swap(3,5)
fmt.Println(a,b)
}
扫雷:上文当中出现了Go当中一个有趣的标识符,就是空白标识符"_",它的作用是可以代替任何类型的任何值。同时,它的作用还可以被当作一个占位符表示,在后续的函数方法当中不使用其值的情况下,就可以使用"_"来代替。
就像在上面的例子当中求数组[1,2,3]的和时,不需要使用索引的值,就使用了空白标识符
(3)可变参数
另外,Go同样支持可变参数的传递
示例:(定义一个函数,遍历并输出)
func numFunc(arg ...int) {
for _, n := range arg {
fmt.Printf("The number is: %d\n", n)
}
}
(2) 函数可作为变量
在Go中,函数也是一种变量,我们可以通过type来定义它,在下文介绍的结构体中实例具体阐述。
type count int
func NewCount(i int) count {
return count(i)
}
func main() {
c := NewCount(10)
fmt.Println(c)
}
3、指针
在函数当中,我们也听说过值传递和引用传递,在Go中,引入了一个指针的概念。所谓指针,就是指变量在内存当中,是存放于一个地址上的,修改变量实际是修改变量地址处的内存。
传递指针,其实就是引用的传递,那就让我们来看看如何定义指针的吧
语法格式:
var a *int // 使用"*",定义指针类型
var b = &a // 使用"&",接收a的地址
示例:
func main() {
var i int
var ptr *int
var pptr **int
i = 10
ptr = &i //接收i的地址值
pptr = &ptr //接收ptr的地址值
fmt.Printf("%d\n", i)
fmt.Printf("%d\n", *ptr)
fmt.Printf("%d\n", **pptr)
}
4、结构体
(1)接口
接口,即一组方法签名,当类型为接口中定义的方法进行实现时,就可以称之为实现了一个接口。在java当中我们也有面向对象的概念,这与OOP的概念十分相似,接口指定了类型应该具有的方法,类型决定了如何实现这些方法。
语法结构:
// 定义接口
type interface_name interface {
method1 [return_type]
method2 [return_type]
method3 [return_type]
...
methodN [return_type]
}
// 定义结构体
type struct_name struct {
...
}
// 实现接口方法
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 dosomething interface {
work() int
study() int
}
type Student struct {
name string
age int
}
func (stu Student) work() int {
fmt.Printf("name:%s,age:%d -- work\n", stu.name, stu.age)
return 3
}
func (stu Student) study() {
fmt.Printf("name:%s,age:%d -- study\n", stu.name, stu.age)
}
func main() {
s1 := new(Student)
s1.name = "zhang san"
s1.age = 23
s2 := new(Student)
s2.name = "Li si"
s2.age = 23
i := s1.work // 作为变量使用
a := i()
fmt.Println(a)
s2.study()
}
我们知道,在java当中,有一个类叫做Object,且认为所有的类都继承实现了Object类,作为java当中的顶级存在。在Go中,虽然没有继承这一概念,但同样的,也认为任意的类型都实现了空interface(我们这样定义:interface{}),也就是包含0个method的interface。
注意点:
1、接口对象不能调用实现对象的属性
2、interface可以被任意的对象实现
3、一个对象可以实现任意多个interface
4、interface的变量可以持有任意实现该interface类型的对象
----------------------------------------------------------------------
后续章节,敬请期待......
有任何建议或问题,欢迎加微信一起学习交流,欢迎从事IT,热爱IT,喜欢深挖源代码的行业大牛加入,一起探讨。
个人微信号:bboyHan
![](https://i-blog.csdnimg.cn/blog_migrate/219156d89d0d5a9e05dbfd4e70c0fd02.png)