Go开辟—基础语法入门

目次

• 基础语法
  
  
  
  • 语法框架
    
  • 数据范例
    
  • 范例转换
    
  • 变量var定义
    
  • 常量
    
  • iota 枚举
    
  • 数组
    
    
    
    • 切片
      
    
    
  • 结构体
    
    
    
    • 结构体方法
      
    
    
  • 指针
    
  • map
    
  • 范例转换
    
  • 导入包
    
  • 字符串strings包
    
    
    
    • 字符拼接
      
    • Contains
      
    • Replace
      
    • 更多函数解释
      
    
    
  • 输入输出
    
    
    
    • 字符串格式化
      
    • fmt：Scanf、Scan、Scanln
      
      
      
      • Scanf
        
      • Scan
        
      • Scanln
        
      
      
    • fmt：Println、Print、Printf、Sprintf
      
      
      
      • Println
        
      • Print
        
      • Printf
        
      • Sprintf
        
      
      
    
    
  • 条件控制
    
    
    
    • if else
      
    • Switch
      
    • For
      
    
    
  • 函数
    
    
    
    • 格式
      
    • 可数的参数变量函数
      
    • 可变参数相同范例参数变量函数
      
    • 返回一个值
      
    • 返回多个值
      
    • 匿名函数
      
    • 初始化函数
      
    • 指定变量名作为返回值
      
    
    
  • 重载方法Methods
    
    
    
    • ⽅法表达式
      
    
    
  • defer(很重要，对理解通道和遍历通道)
    
  
  
• 基础语法阶段练习
  
  
  
  • 简朴编码解码器
    
  • 简朴图书馆
    
  
  

基础语法

语法框架

1. package main
2. import "fmt"
3. func main() {
4.         fmt.Println("Hello Go!")
5. }

复制代码

基本使用，首先学会打印，目前介绍两个即可

1. println("hello word")
2. fmt.Println("hello word")  //这个属于fmt包的，使用的时候需要引入import "fmt"

复制代码

数据范例

1. 单引号：rune类型
2. 双引号：string类型
3. 数字型：int , uint uint32
4. bool型：true , false

复制代码

范例转换

1. //相同类型转换 ，比如整数类型，直接
2. var int_num int = 111
3. var f64_num float64 = float64(int_num)
6. //不同类型的转换
7. //借助"strconv"包
8. //int转string
9. str1 := strconv.Itoa(int_num)
11. //以后遇到了再慢慢补充

复制代码

变量var定义

1. //第一种，比较完整的定义与赋值
2. var a int
3. var a int = 123
5. //简短声明，这种就是忽略了你var作为变量的意思还有去掉了类型，直接通过值来自动帮你搞定
6. a := 123
8. //多个变量声明，这个和python无二
9. #正常声明
10. var a,b int
11. #正常声明加赋值
12. var a,b int = 1,2
13. #简短多变量
14. a,b := 1,2
17. //匿名变量
18. #首先说明一下：在go中，如果你定义了变量不使用他会报错，所以匿名变量就出现了，让你定义暂存可以不用
19. _,a := 1,2

复制代码

_下划线匿名变量，存储起来。
在go中，如果你定义了变量而不消就会报错，所以匿名变量存储是一个比较好的解决方式。

1. //比如当你使用for r循环的时候会有一个下标需要你接受，但是你又不想用他
2. for _, value := range arr{
3.     fmt.Println(value)
4. }

复制代码

常量

常量用const，且不受使用影响的，定义了可以不使用

1. const S int = 123 //常规定义常量
3. const S = 123  //可以不用指定类型，会隐式指定合适的类型
5. //定义多个常量，使用括号包裹
6. const (
7.     a = 1
8.     s = "s"
9.     b = true
10. )

复制代码

iota 枚举

1. const (
2.                 aas = iota //指定变量名等于iota后，往后的变量都不用给值，变量名随意，默认这里从0开始
3.                 bbs
4.                 ccs
5.                 dds
6. )
7. fmt.Println("这里是iota的常量值：")
8. fmt.Println(aas, bbs, ccs, dds)

复制代码

数组

在go中你会发现啥都反过来定义了，包括数组。

1. var arr  = [len]int{元素1,元素2}  
2. 在平时是int arr[]，在go中就比较恶心，需要时间适应一下

复制代码

初始化数组

1. #正常初始化，固定长度
2. var arr = [2]int{1,2}
4. #简短初始化，固定长度
5. arr := [2]int{1,2}
7. #自动计算长度
8. arr := [...]int{1,2,3,4,5}
11. len(arr) //计算数组长度

复制代码

遍历数组（就是正常编程语言都有的for，后面条件控制再细讲for）

1. for i := 0; i < len(arr); i++{
2.     fmt.Println(arr[i])
3. }
5. for index, value := range arr {
6.     fmt.Println(index,value)
7. }
9. //不想使用下标的话可以用_匿名变量接受就可以不用管他了。
10. for _, value := range arr {
11.     fmt.Println(value)
12. }

复制代码

数组中是不能使用append的，由于固定了长度。
切片

就是一个动态数组，可以对他进行空间上的操纵，雷同于c语言中new一个空间那样
所以切片解决了无法append添加的障碍，使用append必要用变量接受

1. var arr = []int{1, 2, 3, 4, 5, 6, 777, 999} //不加数组
2. fmt.Println(arr)
3. arr = append(arr,99999999)
6. //注意：make的时候长度要小于等于容量，容量为了让你添加元素的时候大于容量了用来扩容的
7. //在项目中给的容量要合适，否则大量扩容开销会很大。       
8. arr := make(数组类型, 长度, 容量)
9. arr := make(数组类型，长度) //容量默认和长度一样
12. cap(arr) //计算数组容量

复制代码

append

1. arr = append(list,1,2,3,4,5,6)  //切片想要增加多少元素自行添加，没有个数限制，但是记得添加完成后保存返回的数组

复制代码

结构体

格式：

1. type 结构体名字 struct{
2.     变量1 类型
3.     变量2 类型
4. }

复制代码

示例：

1. type Person struct{
2.     name string
3.     age int
4.     sex int
5. }
7. //结构体有点奇怪，和之前的普通类型赋值有点区别，人家int是这样的：var i int = 1，类型在变量名后面，等号前面
8. //而结构体这里就不是，变量名后面不用类型了，直接等于号，然后才是结构体类型。
9. var p = Person{name:"张三",age:18,sex:1}
11. //打印结构体中的变量的时候可以使用.来指定
12. fmt.Println(p.age)

复制代码

结构体方法

在golang中的特色，由于golang没有类，所以就不能类.方法名，所以就有告终构体方法这种来解决

1. func (var *Struct_Name) FuncName( var0, var1... ) return type { }
2. (var *Struct_Name↑↑↑↑↑是接收器，每一个方法只能有一个接收器)
5. 比如：
6. type Person struct{
7.     xxx xxx
8. }
9. func (p *Person) toString() string{
10.     return p.xxx
11. }
12. 使用的时候就可以直接：
13. p := Person{
14.     xxx:xxx,   
15. }
16. fmt.Println(p.toString())

复制代码

指针

和其他语言差不多，按照c语言的解释

1. *指针类型
2. &取地址
3. var p *int //这个就是定义指针变量，如果不给值的话默认=nil，这是golang中的空值
4. var num int = 123
5. p = &num
6. fmt.Println(p)   //直接拿到的就是地址值
7. fmt.Println(*p)  //*不在定义的时候使用就是解引用，将地址的值取出来

复制代码

打印地址与地址值

1. p是一个指针
2. var p *int = nil
3. var n2 int = 10
4. p = &n2
5. println(p) //出来是地址
6. fmt.Prinrtln(p) //出来也是地址

复制代码

fmt.Println打印地址与地址值对结构体打印的时候就有差别

1. type test struct {
2.         s1 int
3.         s2 string
4. }
6. func main(){
7.     st := &test{  //st简短赋值，st是指针来的，因为赋值的是给他结构体指针
8.                 s1: 1000,
9.                 s2: "ok",
10.         }
11.         println(st)
12.         fmt.Println(st)
13.    
14.     //打印结构体内的变量，指针依旧是用.号来指定（这与c语言有点不同，c是需要结构体指针指向的时候用->符号）
15.     fmt.Println(st.s1)
16. }
19. //go真挺奇怪的，结构体这里又不给你打印地址，给你加个&，但是一些int，string等等都是会直接地址出来的

复制代码

map

格式：

1. map[键的类型]值的类型
3. 定义的时候正常定义就行
4. var m = map[string]string
5. m := map[string]string

复制代码

例子：(值的范例可以是很多)

1. var m = map[string]Person{
2.     "a":1,  //,逗号一定要有，不管有多少个，一定要添加上逗号，否则会报错
3. }
4. fmt.Println(m)
5. type Person struct{
6.     name string
7.     age int
8. }
9. m = map[string]Person
10. fmt.Println(m)

复制代码

删除

1. m := map[string]int{
2.     "name":123
3.     "fff":222
4. }
5. delete(m, "name")  //删除键为name的元素

复制代码

范例转换

在go中范例转换也是一样的操纵

1. var a float64 = 3.14
2. var i int = int(a)  //强制转成int类型，那就是去掉小数点（不作四舍五入）

复制代码

这里有个很好的例子

1. var s string = "hello"
2. var b []byte = []byte(s)
3. var s2 string = string(b)

复制代码

如果要把int转string的话不可以直接string(int_type)
他会把你这个数字当成ascii来转成字符的

1. func main() {
2.     fmt.Println("打印ascii，通过string转换为字符：")
4.     fmt.Println(string(65))
6.     fmt.Println(string(66))
8.     fmt.Println(string(67))
10. }

复制代码

导入包

这里和python导入包差不多，同样可以命名别名

1. import "fmt" //导入单个
2. import (  //导入多个
3.         "fmt"
4.     "math"
5. )
7. //给包起别名
8. import f "fmt"
9. //用的时候就可以不用fmt.Println了，可以f.Println使用你起的别名

复制代码

字符串strings包

字符拼接

1. 可以直接使用+号拼接

复制代码

反引号： Hello, World! ，⽤于多⾏字符串和包含特殊字符的字符串
意思是你用反引号就可以原封不动输入你反引号内的东西，包括tab键回车换行等等。
特别是处理一些http请求返来的数据或者xml格式的数据非常好用

Contains

匹配字符是否存在

1. strings.Contains(字符串1, "要匹配的字符串2")  //如果匹配的字符串2存在字符串1中的话返回true，否则false

复制代码

Replace

1. fmt.Println(strings.Replace("hello world", "world", "Go", 1)) //hello go

复制代码

ReplaceAll就是更换所有了
更多函数解释

1. 函数 函数作⽤
2. Contains 检查字符串是否包含⼦字符串
3. ContainsAny 检查字符串是否包含任何⼀个给定字符
4. ContainsRune 检查字符串是否包含指定的 rune 字符
5. Count 计算⼦字符串在字符串中出现的次数
6. EqualFold 忽略⼤⼩写⽐较两个字符串是否相等
7. Fields 将字符串按空⽩字符分割成切⽚
8. HasPrefix 检查字符串是否以指定前缀开头
9. HasSuffix 检查字符串是否以指定后缀结尾
10. Index 返回⼦字符串在字符串中第⼀次出现的位置
11. IndexAny 返回字符串中任意⼀个字符第⼀次出现的位置
12. IndexByte 返回指定字节在字符串中第⼀次出现的位置
13. IndexRune 返回指定 rune 字符在字符串中第⼀次出现的位置
14. Join 将字符串切⽚⽤指定分隔符连接成⼀个字符串
15. LastIndex 返回⼦字符串在字符串中最后⼀次出现的位置
16. LastIndexAny 返回字符串中任意⼀个字符最后⼀次出现的位置
17. Repeat 重复字符串指定次数
18. Replace 替换字符串中的⼦字符串
19. ReplaceAll 替换字符串中的所有⼦字符串
20. Split 将字符串按指定分隔符分割成切⽚
21. SplitAfter 将字符串按指定分隔符分割成切⽚，保留分隔符
22. SplitAfterN 将字符串按指定分隔符分割成切⽚，保留分隔符，最多分割 N 次
23. SplitN 将字符串按指定分隔符分割成切⽚，最多分割 N 次
24. Title 将字符串的每个单词的⾸字⺟⼤写
25. ToLower 将字符串转换为⼩写
26. ToUpper 将字符串转换为⼤写
27. Trim 去除字符串两端的指定字符
28. TrimSpace 去除字符串两端的空⽩字符
29. TrimPrefix 去除字符串前缀
30. TrimSuffix 去除字符串后缀
31. NewReplacer 创建⼀个字符串替换器

复制代码

输入输出

字符串格式化

常见的格式化占位符

1. %v：值的默认格式表示
2. %+v：类似%v，在结构体中会添加字段名
3. %T：值的类型
4. % %：百分号本身
5. %t：单词true或false
6. %b：整数以⼆进制方式显示
7. %o：整数以八进制方式显示
8. %d：整数以十进制方式显示
9. %x：整数以十六进制方式显示
10. %c：相应Unicode码点表示的字符
11. %f：float类型输出，保留小数点几位可控，比如保留两位：%.2f
12. %e：科学计数法，如-1234.456e+78
13. %E：科学计数法，如-1234.456E+78
14. %s：解析变量，直接打印值，这个打印字符串常用，在你读取byte的时候，若byte为字符串也可以直接帮你打印字符串值
15. %q：打印值的时候加上双引号

复制代码

fmt：Scanf、Scan、Scanln

Scanf

接收输入内容并输出，这个必要加格式化符号接收，雷同C语言，与后续两个不一样，但都是必要给地址

1. var name string
2. fmt.Scanf("%s",&name) //接收用户输入的数据就要用取地址符号，跟c语言一样。
3. //这里的scanf双引号内不能有其他字符干扰，比如不能："请输入字符：%s"，这是接收不到用户输入的数据到name中的。
4. //PS：使用Scanf函数的时候他会返回两个值，第一个是是否接收到了数据：接收到了返回1，没有就返回0；第二个是返回错误信息(string)
5. //所以我们也可以这样子写接受的数据用户判断：_, err := fmt.Scanf("%s", &name)
7. //输出：name赋值成功后就可以正常输出了，按照对应的格式输出即可（使用fmt.Printf函数输出）
8. fmt.Printf("%s",name)

复制代码

tips:

1. Scanf如果是单次获取多个值，使⽤空格隔开，并⾮回⻋，因为fmt.Scanf 的格式化字符串中，逗号（,）会被视为输⼊的⼀部分。

复制代码

Scan

输入的时候空格或者回车隔开
（由于他会等候你输入完成符合接收的个数，如果你接受一个，那么你空格隔开后只接受第一个空格前面作为值）
在使用Scan的时候，用户输入完成之后，会返回两个值：用户输入的个数，错误信息。
注意：使用他，如果你要输入两个值，就必须输入两个，如果要他输入三个值，就必须是三个。否则会不停壅闭。
其实说实话这个就有点扯了，毕竟你都要求输入几个了，还返回啥多少个个数呢是吧，一般人想的都是我不知道输入几个才会想着去打印知道我输入了几个。

1. var s string
2. var num int
3. count , err := fmt.Scan(&s,&num)
4. if err != nil{
5.     fmt.Println("错误信息：",err)
6. }else {
7.     fmt.Println("输入个数：",count)
8. }

复制代码

Scanln

输入的时候用空格隔开，回车表示输入竣事

1. var name, desc string
2. count, err := fmt.Scanln(&name, &desc)
3. if err != nil {
4.     fmt.Println("发生错误：", err)
5. }
6. fmt.Println("name：", name, "count：", count)

复制代码

fmt：Println、Print、Printf、Sprintf

Println

1. fmt.Println("1",2,name)  //输出并且在结尾加上回车换行，多个值可以用逗号隔开，不可以使用格式化字符串

复制代码

Print

不接受可以格式化字符，对每一个操纵数都相当于用了 %v(自动转合适的范例输出)。
不会回车换行

1. fmt.Println(str)

复制代码

Printf

打印特别式化的字符串

1. fmt.Printf("%s",str)
2. fmt.Printf("%d",123)

复制代码

Sprintf

格式化并返回一个字符串，不输出内容

1. fmt.Sprintf("%s",str)
2. fmt.Sprintf("%d",num)

复制代码

条件控制

if else

1. if 条件 {
2.     ...
3. } else if{ //注意，else一定要在if的{后面接，如果回车换行写会报错。
4.     ...
5. } else {//注意，else一定要在if的{后面接，如果回车换行写会报错。
6.     ...
7. }

复制代码

比如接着上面输入输出的代码进一步判定

1. var (
2.     name string
3. )
4. _, err := fmt.Scanf("%s", &name)
5. if err != nil {
6.     fmt.Println("没有接受到输入数据。")
7. } else {
8.     fmt.Printf("name = %s", name)
9. }

复制代码

练习：要求用户输入姓名、性别、年龄

1. package main
3. import (
4.         "fmt"
5. )
7. func main() {
8.         var (
9.                 name  string
10.                 age   int
11.                 score float64
12.         )
14.         fmt.Println("请输入姓名、年龄、分数：（例如：张三 25 89.5）：")
15.         _, err := fmt.Scanf("%s %d %f", &name, &age, &score)
16.         if err != nil {
17.                 fmt.Println("输出错误")
18.         }
20.         fmt.Printf("姓名：%s\n年龄：%d\n分数：%.2f", name, age, score)
21. }

复制代码

Switch

格式示例

1. color := "blue"
2. switch day {
3.     case "red", "深红":  //可以多个条件算一个case
4.             fmt.Println("红色")
5.     case "blue", "深蓝":
6.             fmt.Println("蓝色")
7.     case "black":
8.             fmt.Println("黑色")
9.     default:
10.             fmt.Println("不知道")

复制代码

练习：区分工作日和周末

1. var (
2.     day string
3. )
4. fmt.Println("请输入星期几：（星期一 or 1）")
5. fmt.Scanf("%s", &day)
6. switch day {
7.         case "星期一", "1", "星期二", "2", "星期三", "3", "星期四", "4", "星期五", "5":
8.             fmt.Println("工作日")
9.         case "星期六", "6", "星期日", "7":
10.             fmt.Println("周末")
11.         default:
12.             fmt.Println("给我干哪了，这还是地球么？")
13. }

复制代码

For

条件循环

1. //打印0-9
2. for i := 0; i < 10; i++{
3.     fmt.Println(i)
4. }

复制代码

死循环

1. //死循环
2. for ;; {
3.     fmt.Println("666")
4. }

复制代码

range提取循环

1. var arr = []int{1,2,3,4,5,6,7,8888}
2. for index, value := range arr{
3.     fmt.Printf("index: %d, value：%d\n", index,value)
4. }
6. //不想使用下标的话可以用_匿名变量接受就可以不用管他了。

复制代码

tips:

1. range使用的时候，切记要记得 :=赋值， for _,value := range arr

复制代码

函数

格式

在上面学习中其实已经相识了函数是长啥样了，这里正式说一下， 同时必要注意一些细节

1. func 函数名([参数名]) {
2.     ...
3. }
5. 比如最常见的：
6. func main(){
7.     fmt.Println("123")
8. }

复制代码

可数的参数变量函数

1. func f(name string, age int){
2.     ...
3. }

复制代码

可变参数相同范例参数变量函数

1. func f(arr ...int){
2.     for _,i range arr{
3.         fmt.Println(i)  //接收多个参数为一个数组，然后遍历即可。
4.     }
5. }

复制代码

返回一个值

1. 格式：
2. func f()返回的值类型{
3.     ...
4. }
5. func f()(返回的值类型){
6.     ...
7. }
9. 例如：
10. func f()int{
11.     return 1111
12. }

复制代码

返回多个值

1. 格式：
2. func f()(返回的值1类型,返回的值2类型...){
3.    
4. }
6. 例如：
7. func f()(int,string){
8.     return 1, "123"
9. }

复制代码

匿名函数

1. 格式：
2. func(a int, s string){
3.     fmt.Println(a,s)
4. }(123,"123")

复制代码

初始化函数

初始化函数会在main函数运行之前运行，比如你项目必要在运行之前做一些前置初始化动作可以放在init函数实行。

1. func init() {
2.         fmt.Println("我是初始化init函数。")
3. }

复制代码

指定变量名作为返回值

1. /**
2. 需要注意的点：
3. 在返回值的地方先定义了一个变量，然后在函数内就不用定义该变量了，直接赋值即可。
4. 不可以和传入的参数名相同，因为也是在做定义变量的操作。
5. **/
6. func fff(a int, b int) (x int, y int, c int) {
7.         x = a
8.         y = b
9.         c = x + y
10.         return
11. }
12. func main(){
13.     x, y, c := fff(4, 4)
14.         fmt.Println(x, y, c)
15. }
16. //输出：4 4 8

复制代码

重载方法Methods

方法接受者。
由于go中没有类这种说法，所以只能是在结构体中作文章，那么go中就提供了这种叫做方法接受者，就是雷同于 类.方法 ，方法前面跟一个结构体（可以是指针，指针是不消拷贝）
用法：

1. func (变量名 结构体)方法名 (){}
2. func (变量名 *结构体)方法名 (){}
3. 在方法名前面加上↑↑↑，就表示这个结构体实现了这个方法，后续使用的时候就可以结构体.方法使用这个方法了
5. 方法的其他返回值或者接受的参数的方式都没变，只是在方法名前作为结构体实现的方法而已。

复制代码

简朴例子：

1. package main
3. import "fmt"
5. type Person struct {
6.         name string
7.         age  int
8. }
10. func (p Person) getName() string {
11.         return p.name
12. }
14. func main() {
15.         p := Person{
16.                 name: "zhangsan",
17.                 age:  12,
18.         }
19.         fmt.Println(p.getName())
21. }

复制代码

⽅法表达式

方法表达式使用 结构体.方法  、(*结构体).方法
两种方式其实都可以，使用指针的就是必要对你结构体中某个变量进行修改就要用到指针去接收方法表达式
使用表达式：

• 方法名(结构体变量,参数1,参数2,,,,)
  
• 方法名(&结构体变量,参数1,参数2,,,,)
  

1. type Circle struct {
2.         radius float64
3. }
5. func (c Circle) Area() float64 {
6.         //计算圆的面积：π * r的平方
7.         return (math.Pi * c.radius * c.radius)
8. }
9. func (c *Circle) Scale(f float64) {
10.         c.radius = c.radius * f //缩放
11. }
12. func main() {
13.         c := Circle{
14.                 radius: 2,
15.         }
16.         f := Circle.Area
17.         fmt.Printf("圆的面积是：%.2f\n", f(c))
18.         f2 := (*Circle).Scale   
19.         f2(&c, 2) //半径扩大两倍
20.         fmt.Printf("缩放2倍后的面积为：%.2f\n", f(c))
21. }

复制代码

defer(很重要，对理解通道和遍历通道)

现总结：
通道后面会解释，这里先临时知道通道这个词即可...
如果你要对通道进行遍历，一定要在遍历之前记性关闭通道，通常在协程中defer进行关闭，意思是当进步行竣事就会关闭通道，那么这就恰恰符合了协程ok后才彻底关闭通道，否则你主函数和go协程这两个不是同一个东西，协程操纵了通道，你又要在主函数中进行关闭的话就会报错。
遍历通道解决办法就是：
使用了go协程：可以利用defer直接在go协程中关闭，或者使用sync.WaitGroup，但是你要是用sync.WaitGroup关闭的话也要在主进程中

1. go func() {
2.         wg.Wait() // 等待
3.         close(ch) // 关闭通道
4. }()

复制代码

上面这段在后面也会提到。
然后如果直接在主进程中进行遍历的话直接close通道就行，由于没有协程必要等候。

1. 理解:
2. defer你只需要理解为帮助函数后执行。
3. 比如：当你打开文件，打开文件后需要关闭，但是中间操作的时候报错了就产生了资源浪费，这时候就可以给defer f.close()进行关闭，可以理解为main函数中就算中途报错结束了，defer也会帮你关闭f句柄。
6. 多个 defer 的话会反过来执行，比如
7. defer fmt.Println(1)
8. defer fmt.Println(2)
9. defer fmt.Println(3)
10. 输出
11. 3
12. 2
13. 1

复制代码

下面经典举例子：
下面的函数和其他技能在后面都会提到，这里只是作为一个例子先放上来作为理解的知识点，主要还是方便复习，初学可以忽略，学完基础再返来理解也是挺不错的。

1. func start_Ch_scan_port() {
2.         var (
3.                 ch        = make(chan int)
4.                 count int = 0
5.         )
6.         var Ch_scan_port = func(hostname string) {
7.                 defer close(ch)   //如果你不在这里添加关闭通道，那么你在主函数中关闭通道的话，你是无法对通道关闭然后遍历的。
8.                                         //因为你在主进程关闭通道的话就会发生报错，因为协程经常会还没执行完成就被抢占过去然后close就会导致一些还没执行完成的进程执行失败。
9.                 for i := 0; i < 65535; i++ {
10.                         //扫描到开放端口放到ch通道中即可，主函数一直等待读取通道信息
11.                         address := fmt.Sprintf("%s:%d", hostname, i)                //ip端口
12.                         conn, err := net.DialTimeout("tcp", address, 2*time.Second) //2秒
13.                         if err == nil {
14.                                 conn.Close()
15.                                 ch <- i
16.                         }
18.                 }
19.                 runtime.Goexit()
20.         }
22.         go Ch_scan_port("127.0.0.1")
23.         runtime.Gosched() //等待go协程执行完
24.     //正常思维都是在这里go协程执行完成后就在这里进行close，因为你后面要对通道进行遍历了，但是在这里进行close(ch)的话就会发生报错，因为Gosched之后，在go协程中最后那几个可能还没彻底执行完，所以就会报错。
25.         for i := range ch {
26.                 fmt.Printf("open: %d\n", i)
27.                 count++
28.         }
29.         fmt.Printf("------------Open ports: %d-------------\n", count)
30.         fmt.Println("------------Scan——Done------------")
31. }

复制代码

可以参考的屎山代码如下：

1. /*
2. 根据⽤户输⼊的内容，实现切换编解码的功能.
3. 支持base64 url hex编解码
4. 功能1：选择编码还是解码
5. --->功能1.2：选择编解码的类型
6. ------->功能1.2.3：输入内容进行编解码
7. 功能2：exit才是推出
9. //编码
10. to := dongle.Encode.FromString(x).ByBase64().ToString()
11. //解码
12. to1 := dongle.Decode.FromString(q).ByBase64().ToString()
13. */

复制代码

简朴图书馆

功能需求

1. package main
3. import (
4.         "fmt"
6.         "github.com/dromara/dongle"
7. )
9. /*
10. 根据⽤户输⼊的内容，实现切换编解码的功能.
11. 支持base64 url hex编解码
12. 功能1：选择编码还是解码
13. --->功能1.2：选择编解码的类型
14. ------->功能1.2.3：输入内容进行编解码
15. 功能2：exit才是推出
17. //编码
18. to := dongle.Encode.FromString(x).ByBase64().ToString()
19. //解码
20. to1 := dongle.Decode.FromString(q).ByBase64().ToString()
21. */
23. func choice_de_en(choice string, flag *bool) bool {
24.         var result string
25.         switch choice {
26.         case "1": //选择编码模式
27.                 result = encode(flag)
28.                 if *flag == false {
29.                         return false //退出程序
30.                 }
31.                 fmt.Printf("编码结果：%s\n", result)
32.         case "2": //选择解码模式
33.                 result = decode(flag)
34.                 if *flag == false {
35.                         return false //退出程序
36.                 }
37.                 fmt.Printf("解码结果：%s\n", result)
38.         }
39.         return true
40. }
42. func choice_string_type(mess string) string {
43.         fmt.Printf("请输入数字选择%s码类型 1：Base64 2：Url 3：Hex (输入exit为退出程序)\n", mess)
44.         var crypto_type string
45.         fmt.Scanln(&crypto_type)
46.         return crypto_type
47. }
49. func decode(flag *bool) string {
50.         crypto_type := choice_string_type("解")
51.         if crypto_type == "exit" {
52.                 *flag = false
53.                 return ""
54.         }
55.         fmt.Println("请输入你要解码的密文：")
56.         var txt string
57.         fmt.Scanln(&txt)
58.         switch crypto_type {
59.         case "1": //base64解码
60.                 return dongle.Decode.FromString(txt).ByBase64().ToString()
61.         case "2": //url解码
62.                 return dongle.Decode.FromString(txt).BySafeURL().ToString()
63.         case "3": //hex解码
64.                 return dongle.Decode.FromString(txt).ByHex().ToString()
65.         default:
66.                 return ""
67.         }
68. }
70. func encode(flag *bool) string {
71.         crypto_type := choice_string_type("编")
72.         if crypto_type == "exit" {
73.                 *flag = false
74.                 return ""
75.         }
76.         fmt.Printf("请输入你要编码的明文：")
77.         var txt string
78.         fmt.Scanln(&txt)
79.         switch crypto_type {
80.         case "1": //base64编码
81.                 return dongle.Encode.FromString(txt).ByBase64().ToString()
82.         case "2": //url编码
83.                 return dongle.Encode.FromString(txt).BySafeURL().ToString()
84.         case "3": //hex编码
85.                 return dongle.Encode.FromString(txt).ByHex().ToString()
86.         default:
87.                 return ""
88.         }
89. }
91. func main() {
93.         for {
94.                 var choice string
95.                 fmt.Println("请输入数字选择模式 1：编码模式 2：解码模式 (输入exit为退出程序)")
96.                 fmt.Scanln(&choice)
97.                 if choice == "exit" {
98.                         break
99.                 }
100.                 flag := true  //作为退出程序的标记，方便不管在哪个函数内都能识别到用户是否选择退出了
101.                 if !choice_de_en(choice, &flag) { //如果返回false就退出程序
102.                         break
103.                 }
104.         }
105. }

复制代码

可以参考的屎山代码如下：

1. 添加新书到图书馆。 查找书籍信息。
2. 列出所有书籍。 更新书籍信息。 删除书籍。

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。