Golang开发实战学习（附源码）

王猪精

已于 2024-10-28 01:59:10 修改

阅读量2.4k

点赞数 51

文章标签： golang 开发语言

于 2024-10-25 00:56:44 首次发布

本文链接：https://blog.csdn.net/handsomewzj/article/details/143223439

版权

1.go语言基本组成

go语言的基本组成有：

包声明，编写源文件时，必须在非注释的第一行指明这个文件属于哪个包，如package main。
引入包，其实就是告诉Go 编译器这个程序需要使用的包，如import "fmt"其实就是引入了fmt包。
函数，和c语言相同，即是一个可以实现某一个功能的函数体，每一个可执行程序中必须拥有一个main函数。
变量，Go 语言变量名由字母、数字、下划线组成，其中首个字符不能为数字。
语句/表达式，在 Go 程序中，一行代表一个语句结束。每个语句不需要像 C 家族中的其它语言一样以分号 ; 结尾，因为这些工作都将由 Go 编译器自动完成。
注释，和c语言中的注释方式相同，可以在任何地方使用以 // 开头的单行注释。以 /* 开头，并以 */ 结尾来进行多行注释，且不可以嵌套使用，多行注释一般用于包的文档描述或注释成块的代码片段

2.变量与基本数据

2.1多变量声明

var x, y int
var c, d int = 1, 2
g, h := 123, "hello"

2.2全局变量声明

var ( 
    a int
    b bool
)

2.3匿名变量

匿名变量的特点是一个下画线“_”，这本身就是一个特殊的标识符，被称为空白标识符。它可以像其他标识符那样用于变量的声明或赋值（任何类型都可以赋值给它），但任何赋给这个标识符的值都将被抛弃，因此这些值不能在后续的代码中使用，也不可以使用这个标识符作为变量对其它变量进行赋值或运算。

使用匿名变量时，只需要在变量声明的地方使用下画线替换即可。

package main
import "fmt"

func GetData() (int, int) {
    return 10, 20
}
func main(){
    a, _ := GetData()
    _, b := GetData()
    fmt.Println(a, b)
}

需要注意的是匿名变量不占用内存空间，不会分配内存。匿名变量与匿名变量之间也不会因为多次声明而无法使用。

2.4变量作用域

作用域指的是已声明的标识符所表示的常量、类型、函数或者包在源代码中的作用范围，在此我们主要看一下go中变量的作用域，根据变量定义位置的不同，可以分为一下三个类型：

函数内定义的变量为局部变量，这种局部变量的作用域只在函数体内，函数的参数和返回值变量都属于局部变量。这种变量在存在于函数被调用时，销毁于函数调用结束后。
函数外定义的变量为全局变量，全局变量只需要在一个源文件中定义，就可以在所有源文件中使用，甚至可以使用import引入外部包来使用。全局变量声明必须以 var 关键字开头，如果想要在外部包中使用全局变量的首字母必须大写。
函数定义中的变量成为形式参数，定义函数时函数名后面括号中的变量叫做形式参数（简称形参）。形式参数只在函数调用时才会生效，函数调用结束后就会被销毁，在函数未被调用时，函数的形参并不占用实际的存储单元，也没有实际值。形式参数会作为函数的局部变量来使用。

2.5变量基本类型

2.6变量的输入和输出

2.6.1输入

2.6.2输出

2.7变量命名规范

只能由数字，字母，(下划线）组成
不能以数字开头
大写字母和小写字母是不同的：heapsort和heapsort是两个不同的名字
不能是关键字

2.8字符与字符串区别

2.9基本预算符

2.10赋值运算符

2.11案例

2.11.1计算圆的周长和面积

package main
import "fmt"

func main() {
    const PI = 3.14
    fmt.Println("请输入半径：")
    var r float64
    fmt.Scan(&r)
    area := PI * r * r
    p := 2 * PI * r
    fmt.Printf("面积：%.2f 周长：%.2f", area, p)
}

2.11.2计算总分与平均分

package main
import "fmt"

func main() {
    //某学生三门课成绩为，语文：90，数学：85，英语：70，编程求总分与平均分
    var chinese int = 90
    var math int = 85
    var english int = 70
    //计算总分
    score := chinese + math + english
    //平均分
    avg := float64(score) / 3
    fmt.Printf("总分是：%d，平均分是：%.2f\n", score, avg)
}

2.11.3判断闰年

package main
import "fmt"

func main() {
    //判断闰年
    var year int
    fmt.Println("请输入年份:")
    fmt.Scan(&year)
    if year%4 == 0 && year%100 != 0 || year%400 == 0 {
        fmt.Println(year, "是闰年")
    } else {
        fmt.Println(year, "不是闰年")
    }
}

3.程序结构

3.1分支结构

3.1.1if结构

if判断(判断不等式和java不同,go语言中没有小括号,但是用法和java是一样的)

package main
import "fmt"
func main(){
    //注意100>20是一个表达式
    if 100 > 20 {
        fmt.Println("true")
    }
}

3.1.2if else结构

package main
import "fmt"
func main(){
    var performance = 80
    if performance >= 90 {
    	fmt.Println("奖励你最爱的100快")
    } else {
    	fmt.Println("跪方便面")
    }
}

3.1.3if else if结构

package main
import "fmt"
func main(){
    var performance int
	fmt.Println("请输入你要查询的成绩")
	fmt.Scan(&performance)
	if performance >= 90 {
		fmt.Println("你的成绩为忧")
	} else if performance >= 60 {
		fmt.Println("成绩为良")
	} else if performance <= 20 {
		fmt.Println("你真是个人才")
	} else {
		fmt.Println("你的成绩不及格")
	}
}

3.1.4在 if 语句中声明变量

在 if 语句中，布尔表达式之前声明变量是 Go 语言的惯用法，这种使用方式可以提高代码的可读性。由于是在 if 语句中声明的变量，因此变量的作用域也只在 if 语句中，外部无法访问这些变量。下面是示例：

package main
import "fmt"

func main() {
	mp := map[string]string{"name": "cmy"}

	if name, ok := mp["name"]; ok {
		fmt.Printf("存在 key → name：%s\n", name)
	} else {
		fmt.Println("key 不存在")
	}
	fmt.Println("原分支代码")
}

在 if 语句中定义 name，ok 变量，使用 ok 判断 key 是否存在，如果存在则执行分支里的代码。

3.1.4switch结构

switch T {
case value1:
	// 分支 1
case value2, value3, ...:
	// 分支 2
...
default:
	// 默认分支
}

T 可以是常量、变量和布尔表达式等，case 关键字后面的 value 类型，必须与 T 的类型是一致的，且 value 是唯一的。Go 会根据 T 的值与各个 case 后面的 value 进行匹配，匹配成功则执行对应 case 分支，case 后面可以有多个 value。default 为默认分支，可有可无，如果前面的 case 都没匹配上，则会执行 default 分支。

示例

package main
import "fmt"

func main() {
	name := "小明"
	if name == "小红" {
		fmt.Println("您好，小红！")
	} else if name == "小明" {
		fmt.Println("您好，小明！")
	} else {
		fmt.Println("您好，陌生人！")
	}
	fmt.Println("原分支代码")
}

上面的代码，可以使用 switch 分支改造：

package main
import "fmt"
func main() {
	name := "小明"
	switch name {
	case "小明":
		fmt.Println("您好，小明！")
	case "小红":
		fmt.Println("您好，小红！")
	default:
		fmt.Println("您好，陌生人！")

	}
	fmt.Println("原分支代码")
}

执行结果：

您好，小明！
原分支代码

name 等于小明，与第一个 case 分支匹配成功，执行这个分支的代码，然后继续执行原分支的代码。

switch 分支当 if 分支使用

当 switch 分支后面不带常量、变量或布尔表达式等时，其效果与 if 分支类似。

package main
import "fmt"
func main() {
	switch {
	case 1+1 != 2:
		fmt.Println("1 + 1 不等于 2")
	case 1+1 == 2:
		fmt.Println("1 + 1 等于 2")
	default:
		fmt.Println("0")

	}
	fmt.Println("原分支代码")
}

当 switch 后面什么都没有时，程序会根据 case 后面布尔表达式的值进行分支的选择。

在 switch 语句中声明变量

和 if 一样，我们也可以在 switch 语句中声明变量，变量的作用域也只在 swtich 语句中，外部无法访问这些变量。

package main
import "fmt"

func main() {
	mp := map[string]string{"name": "cmy"}
	switch name := mp["name"]; name {
	case "cmy":
		fmt.Println("cmy")
	case "kk":
		fmt.Println("kk")
	default:
		fmt.Println("unknown")

	}
	fmt.Println("原分支代码")
}

fallthrough

Go 语言中，不同于其他语言，switch 块内，每个 case 无需声明 break 来终止。如果我们想执行多个 case 分支，可以使用 fallthrough 关键字来实现。

package main
import "fmt"

func main() {
	mp := map[string]string{"name": "cmy"}
	switch name := mp["name"]; name {
	case "cmy":
		fmt.Println("cmy")
		fallthrough
	case "kk":
		fmt.Println("kk")
	default:
		fmt.Println("unknown")

	}
	fmt.Println("原分支代码")
}

执行结果：

cmy
kk
原分支代码

在第一个 case 分支后面使用了 fallthrough，不论下一个 case 是否与 cmy 匹配，都会执行这个分支的代码。

3.1.5if和switch综合案例

package main
import "fmt"

func main(){
    //1:定义变量存储月份与年
    var year int
    fmt.Println("请输入年")
    fmt.Scan(&year)
    var mouth int
    fmt.Println("请输入月")
    fmt.Scan(&mouth)
    var day int
    //2:判断输入的月份是否正确
    if mouth >= 1 && mouth <= 12{
    //3:如果1.3,5,7,8,10,12输入的天数31天
        switch mouth{
             case 1:
                    day = 31
             case 3:
                    day = 31
             case 5:
                    day = 31
             case 7:
                    day = 31
             case 8:
                    day = 31
             case 10:
                    day = 31
             case 12:
                    day = 31
    //4:2判断闰年29天，28天
             case 2 :
                if year % 400 == 0 || year % 4 ==0 && year % 100 != 0{
                    day = 29
                } else {
                    day =28
                }
    //5:其它月份输出的是30天
             default :
                    day = 20
            } 
        } else {
                fmt.Println("输入的月份不正确")
            }
    fmt.Println("该月份的天数为：%d",day)
}

3.2循环结构

3.2.1基本案例演示

求1-100之间的所有数字之和

package main
import "fmt"
func main(){
    var i int 
    var sum int
    for i = 1; i <= 100; i++{
        sum = sum + i
    }
    fmt.Println(sum)
}

求1-100之间的所有偶数之和

package main
import "fmt"
func main(){
    var i int 
    var sum int
    for i = 2; i <= 100; i += 2{
        sum = sum + i
    }
    fmt.Println(sum)
}

3.2.2break语句以及应用案例

break：结束当前循环

package main
import "fmt"
func main() {
    for i := 0; i < 10; i++ {
        if i == 3 {
            break//结束当前循环
        }
        fmt.Println(i)
    }
}

应用案例

要求用户输入用户名和密码，只要不是admin、888888就提示错误，重新输入，输错三次就结束整个程序

死循环：所谓的死循环指的就是一直循环，无法终止。

for{要执行的代码}

package main
import "fmt"
func main() {
    var userName string
    var userPwd string
    var count int
    for {
        fmt.Println("请输入用户名:")
        fmt.Scan(&userName)
        fmt.Println("请输入密码:")
        fmt.Scan(&userPwd)
        if userName == "admin" && userPwd == "888888" {
            fmt.Println("输入正确")
            break
        } else {
            count++
            if count >= 3 {
                fmt.Println("最多输错三次，结束程序")
                break
            }
            fmt.Println("输入错误，重新输入")
        }
    }
}

3.2.3continue语句以及应用案例

continue:结束本轮循环，然后进行循环条件判断，如果成立进行然后进入下一轮循环，退出循环。

应用案例：用continue实现：计算1到100（含）之间的除了能被7整除之外所有整数的和

package main
import "fmt"
func main() {
    //用continue实现：计算1到100（含）之间的除了能被7整除之外所有整数的和
    sum := 0
    for i := 1; i <= 100; i++ {
        if i%7 == 0 {
            continue
        }
        sum += i
    }
    fmt.Println(sum)
}

3.2.4循环嵌套

案例1：2006年营业额80000元，每年增长25%，请问按此增长速度，到哪一年营业额将达到20万元

package main
import "fmt"
func main() {
    //2006年营业额80000元，每年增长25%，请问按此增长速度，到哪一年营业额将达到20万元
    var year int = 2006
    var money float64
    for money = 80000; money <= 200000; money = money * 1.25 {
        year++
    }
    fmt.Println(year)
}

案例2：找出100-999间的水仙花数（水仙花：指一个三位数，它的每位数字的立方