一、猜拳游戏程序：
功能：
1、要有一个游戏主界面
2、提示用户输入石头，剪刀，布 三个选项之一
3、用户输入与系统内置随机结果比较
4、输出比较的结果，谁赢谁输
5、统计用户赢的次数多还是机器赢的次数多
扩展：
1、登录验证，身份信息加密存储
2、AI算法实现，实现预判用户输入
具体实现：
/********************************************************************
2 *文件名:xm1.go
3 *作 者:Mr.Yu
4 *时 间:2023年05月21日 星期日 10时22分11秒
5 *版 本:1.0
6 *作 用:
7 ********************************************************************/
8 package main
9
10 /*"crypto/md5","encoding/hex"用于对玩家账户和密码进行加密保护
11 "math/rand","time"产生随机数用于简单AI*/
12 import (
13 "fmt"
14 "crypto/md5"
15 "encoding/hex"
16 "math/rand"
17 "time"
18 )
19
20 /*定义全局变量，以下变量分别代表“玩家历史出招”，“胜负历史”，“玩家总胜数”，“AI总胜数”，“平局总数”
21 以便于对历史数据进行统计实现历史战绩功能和让AI进行分析预判*/
22 var (
23 wjls []int
24 sfls []string
25 wjzs int = 0
26 aizs int = 0
27 pjzs int = 0
28 )
29
30 /*主体函数部分*/
31
32 func main() {
33 /*定义用于存放账号密码的map*/
34 zhmm := make(map[string]string,100)
35 /*定义用于打破部分层循环的条件变量，用于返回登录界面和结束游戏*/
36 var (
37 kill int = 0
38 kill1 int = 0
39 kill2 int = 0
40 )
41
42 /*最外层核心循环（登录界面）*/
43
44 for kill == 0{
45 /*重置循环条件kill1*/
46 kill1 = 0
47 /*调用登陆界面函数，打印登录界面*/
48 dljm()
49 /*该部分用于接收玩家选项*/
50 var dljmxx int
51 fmt.Println("\n请选择（输入序号）：\n")
52 yz,_ := fmt.Scanln(&dljmxx)
53 if yz == 0 || dljmxx < 1 || dljmxx > 3 {
54 fmt.Println("\n非法选项！请重新输入！\n")
55 continue
56 /*该支路用于注册玩家账号密码*/
57 }else if dljmxx == 1{
58 /*用于接收接收玩家账号和密码*/
59 var zh string
60 var mm string
61 /*创建账号*/
62 for {
63 fmt.Println("\n请输入一个4～8位的账号作为你的游戏账号（只能由有效字符构成）：\n")
64 yz1,_ := fmt.Scanln(&zh)
65 /*调用账号检索函数判断账号是否已存在，返回验证值*/
66 yz2 := zhjs(zh,zhmm)
67 if yz1 == 0 || len([]rune(zh)) < 4 || len([]rune(zh)) > 8 {
68 fmt.Println("\n请输入4～8位的有效字符！\n")
69 continue
70 }else if yz2 == 0 {
71 fmt.Println("\n当前账号已存在！\n")
72 continue
73 }else {
74 break
75 }
76 }
77 /*创建密码*/
78 for {
79 fmt.Println("\n请输入一个6～8位的密码作为你的游戏密码（只能由有效字符构成）：\n")
80 yz1,_ := fmt.Scanln(&mm)
81 if yz1 == 0 || len([]rune(mm)) < 6 || len([]rune(mm)) > 8 {
82 fmt.Println("\n请输入6～8位的有效字符！\n")
83 continue
84 }else {
85 break
86 }
87 }
88 /*调用账号密码存储函数，对账号和密码进行存放*/
89 zhmmcc(zh,mm,zhmm)
90 fmt.Println("\n注册成功！现在你可以登陆了！\n")
91 /*该支路用于玩家登录游戏*/
92 }else if dljmxx == 2 {
93 for kill1 == 0{
94 /*重置循环条件kill2*/
95 kill2 = 0
96 var zh1 string
97 var mm1 string
98 fmt.Println("\n请输入你的账号：\n")
99 yz1,_ := fmt.Scanln(&zh1)
100 /*调用账号检索函数，判断账号是否存在，返回验证值*/
101 yz2 := zhjs(zh1,zhmm)
102 if yz1 == 0 {
103 fmt.Println("\n输入非法！请重新输入！\n")
104 continue
105 }else if yz2 == 1 {
106 fmt.Println("\n账号不存在！请先注册！\n")
107 break
108 }else {
109 for kill2 == 0{
110 fmt.Println("\n请输入密码：\n")
111 yz1,_ := fmt.Scanln(&mm1)
112 /*调用密码检索函数，判断密码是否正确，返回验证值*/
113 yz2 := mmjs(zh1,mm1,zhmm)
114 if yz1 == 0 {
115 fmt.Println("\n输入非法！请重新输入！\n")
116 continue
117 }else if yz2 == 0 {
118 fmt.Println("\n密码错误！请重新输入！\n")
119 continue
120 }else {
121 fmt.Println("登陆成功！现在你可以开始游玩了！")
122
123 /*第二层核心循环（主界面）*/
124
125 for {
126 var zjmxx int
127 /*调用主界面函数，打印主界面*/
128 zjm()
129 fmt.Println("\n请选择（输入序号）：\n")
130 yz1,_ := fmt.Scanln(&zjmxx)
131 if yz1 == 0 || zjmxx < 1 || zjmxx > 5 {
132 fmt.Println("\n选项非法！请重新输入！\n")
133 continue
134 /*该支路用于开启猜丁壳简单模式*/
135 }else if zjmxx == 1 {
136 /*调用简单模式函数*/
137 jdms()
138 /*该支路用于开启猜丁壳困难模式*/
139 }else if zjmxx == 2 {
140 /*调用困难模式函数*/
141 knms()
142 /*该支路用于查看历史战绩*/
143 }else if zjmxx == 3 {
144 /*调用历史战绩函数*/
145 lszj()
146 /*该支路用于返回登录页面*/
147 }else if zjmxx == 4 {
148 kill1 = 1
149 kill2 = 1
150 break
151 /*该支路用于在主界面直接退出游戏*/
152 }else {
153 fmt.Println("\n期待你的下次游玩！\n")
154 kill = 1
155 kill1 = 1
156 kill2 = 1
157 break
158 }
159 }
160 }
161 }
162 }
163 }
164 /*该支路用于在登录界面退出游戏*/
165 }else {
166 fmt.Println("\n期待你的下次游玩！\n")
167 break
168 }
169 }
170 }
171
172 /*自定义函数（功能）部分*/
173
174 /*登录界面函数*/
175 func dljm() {
176 for i:=0;i < 21;i++ {
177 print("*~")
178 }
179 fmt.Println()
180 fmt.Println("*~\t\t我爱猜丁壳\t\t*~")
181 fmt.Println("*~\t\t1.注册账号\t\t*~")
182 fmt.Println("*~\t\t2.登陆账号\t\t*~")
183 fmt.Println("*~\t\t3.退出游戏\t\t*~")
184 for i:=0;i < 21;i++ {
185 print("*~")
186 }
187 fmt.Println()
188 }
189 /*主界面函数*/
190 func zjm() {
191 for i:=0;i < 21;i++ {
192 print("*~")
193 }
194 fmt.Println()
195 fmt.Println("*~\t\t开始对决吧\t\t*~")
196 fmt.Println("*~\t\t1.简单模式\t\t*~")
197 fmt.Println("*~\t\t2.困难模式\t\t*~")
198 fmt.Println("*~\t\t3.历史战绩\t\t*~")
199 fmt.Println("*~\t\t4.登陆界面\t\t*~")
200 fmt.Println("*~\t\t5.退出游戏\t\t*~")
201 for i:=0;i < 21;i++ {
202 print("*~")
203 }
204 fmt.Println()
205 /*账号检索函数，用于在注册账号时判断账号是否重复，和在登录时判读账号是否存在*/
206 }
207 func zhjs(zh string,zhmm map[string]string) int {
208 /*由于账号和密码都是加密存放的，所以要先进行加密，在进行检索*/
209 md5sj := md5.New()
210 md5sj.Write([]byte(zh))
211 zhh := md5sj.Sum(nil)
212 jmzh := hex.EncodeToString(zhh)
213 for k,_ := range zhmm {
214 if k == jmzh {
215 return 0
216 }
217 }
218 return 1
219 }
220 /*帐号密码存储函数，通过map类型和md5,对密码和帐号进行存放*/
221 func zhmmcc(zh,mm string,zhmm map[string]string) {
222 /*调用加密函数对账号和密码进行加密，返回加密的账号和密码*/
223 zh,mm = md5jm(zh,mm)
224 zhmm[zh] = mm
225 }
226 /*加密函数通过md5对数据进行简单加密*/
227 func md5jm(zh,mm string) (string,string){
228 md5sj := md5.New()
229 md5sj.Write([]byte(zh))
230 zhh := md5sj.Sum(nil)
231 jmzh := hex.EncodeToString(zhh)
232 md5sj1 := md5.New()
233 md5sj1.Write([]byte(mm))
234 mmm := md5sj1.Sum(nil)
235 jmmm := hex.EncodeToString(mmm)
236 return jmzh,jmmm
237 }
238 /*密码检索函数*/
239 func mmjs(zh1,mm1 string,zhmm map[string]string) int {
240 zh1,mm1 = md5jm(zh1,mm1)
241 if zhmm[zh1] == mm1 {
242 return 1
243 }else {
244 return 0
245 }
246 }
247 /*简单模式函数*/
248 func jdms() {
249 /*产生随机数用作AI*/
250 rand.Seed(time.Now().UnixNano())
251 var wj int
252 ai := rand.Intn(3)
253 /*接收玩家招式，判断对局情况，并打印出对局情况*/
254 for {
255 fmt.Println("\n请你出招（0代表石头，1代表剪刀，2代表布）：\n")
256 yz,_ := fmt.Scanln(&wj)
257 if yz == 0 || wj < 0 || wj > 2 {
258 fmt.Println("\n输入非法！请重新输入！\n")
259 continue
260 }else {
261 /*调用结果打印函数打印结果*/
262 jgdy(wj,ai)
263 break
264 }
265 }
266 /*调用数据统计函数，并向该函数传递关键数据，用以统计关键历史数据*/
267 sjtj(wj,ai)
268 }
269 /*数据统计函数，统计关键历史数据，辅助生成历史战绩，和为困难AI提供玩家习惯*/
270 func sjtj(wj,ai int) {
271 wjls = append(wjls,wj)
272 if wj == ai {
273 sfls = append(sfls,"平局")
274 pjzs++
275 }else if (wj == 0 && ai == 1) || (wj == 1 && ai == 2) || (wj == 2 && ai == 0) {
276 sfls = append(sfls,"玩家获胜")
277 wjzs++
278 }else {
279 sfls = append(sfls,"AI获胜")
280 aizs++
281 }
282 }
283 /*困难模式函数（困难AI采用简单的手写算法，及通过对玩家的历史出招进行分析，当存在一个玩家最常用的招式时AI固定采用该
招式的克制招式，当存在两个最常用的招式时AI通过随机数自定一个克制招式，当存在三个最常用招式或还未有历史招式时困难模
式函数将调用简单模式跳转至简单模式启动，这里的玩家历史出招统计了以往玩家在简单模式和困难模式的全部出招）*/
284 func knms() {
285 var wj int
286 var (
287 a int
288 b int
289 c int
290 )
291 if len(wjls) < 1 {
292 /*调用为简单模式*/
293 jdms()
294 }else {
295 for _,v := range wjls {
296 if v == 0 {
297 a++
298 }else if v == 1 {
299 b++
300 }else {
301 c++
302 }
303 }
304 if a == b && b == c {
305 /*调用为简单模式*/
306 jdms()
307 }else {
308 for {
309 /*该随机数是用于在玩家有两个最常用招式的时候随机一个克制招式*/
310 ai := rand.Intn(2)
311 fmt.Println("\n请你出招（0代表石头，1代表剪刀，2代表布）：\n")
312 yz,_ := fmt.Scanln(&wj)
313 if yz == 0 || wj < 0 || wj > 2 {
314 fmt.Println("\n输入非法！请重新输入！\n")
315 continue
316 }else {
317 if a == b && a > c {
318 if ai == 0 {
319 /*调用结果打印函数和数据统计函数*/
320 jgdy(wj,2)
321 sjtj(wj,2)
322 }else if ai == 1 {
323 jgdy(wj,0)
324 sjtj(wj,0)
325 }
326 }else if a == c && a > b {
327 if ai == 0 {
328 jgdy(wj,2)
329 sjtj(wj,2)
330 }else if ai == 1 {
331 jgdy(wj,1)
332 sjtj(wj,1)
333 }
334 }else if b == c && b > a {
335 if ai == 0 {
336 jgdy(wj,0)
337 sjtj(wj,0)
338 }else if ai == 1 {
339 jgdy(wj,1)
340 sjtj(wj,1)
341 }
342 }else if a > b && a > c {
343 jgdy(wj,2)
344 sjtj(wj,2)
345 }else if b > a && b > c {
346 jgdy(wj,0)
347 sjtj(wj,0)
348 }else {
349 jgdy(wj,1)
350 sjtj(wj,1)
351 }
352 }
353 break
354 }
355 }
356 }
357 }
358 /*结果打印函数*/
359 func jgdy(wj,ai int) {
360 if ai == 0 && wj == 0 {
361 fmt.Println("\nAI：石头，玩家：石头，平局！\n")
362 }else if ai == 1 && wj == 1 {
363 fmt.Println("\nAI：剪刀，玩家：剪刀，平局！\n")
364 }else if ai == 2 && wj == 2 {
365 fmt.Println("\nAI：布，玩家：布，平局！\n")
366 }else if ai == 0 && wj == 1 {
367 fmt.Println("\nAI：石头，玩家：剪刀，AI获胜！\n")
368 }else if ai == 0 && wj == 2 {
369 fmt.Println("\nAI：石头，玩家：布，玩家获胜！\n")
370 }else if ai == 1 && wj == 0 {
371 fmt.Println("\nAI：剪刀，玩家：石头，玩家获胜！\n")
372 }else if ai == 1 && wj == 2 {
373 fmt.Println("\nAI：剪刀，玩家：布，AI获胜！\n")
374 }else if ai == 2 && wj == 0 {
375 fmt.Println("\nAI：布，玩家：石头，AI获胜！\n")
376 }else if ai == 2 && wj == 1 {
377 fmt.Println("\nAI：布，玩家：剪刀，玩家获胜！\n")
378 }
379 }
380 /*历史战绩函数*/
381 func lszj() {
382 fmt.Println("\n历史战绩：\n")
383 fmt.Println("玩家总胜：",wjzs)
384 fmt.Println("AI总胜：",aizs)
385 fmt.Println("平局总数：",pjzs)
386 fmt.Println("\n详情：\n")
387 for _,v := range sfls {
388 fmt.Println(v)
389 }
390 fmt.Println()
391 }
二、学生管理信息系统程序：
功能：
1、有学生管理系统主界面
2、主界面要有增、删、改，查的选项
3、可以向系统新建学生信息，信息越全越好（姓名，性别，年龄，年级，专业，住址 .......）
4、针对学生信息可以完成基本维护工作，且保证数据一致性。
5、系统要有退出选项，不能无限制增加。
具体实现：
1 /********************************************************************
2 *文件名:xm2.go
3 *作 者:Mr.Yu
4 *时 间:2023年05月27日 星期六 19时02分45秒
5 *版 本:1.0
6 *作 用:
7 ********************************************************************/
8 package main
9
10 import "fmt"
11
12 /*定义全局变量xsxx，用以存储学生信息，该复杂map的第一层的key为学生学号，第二层的key为6个信息类别名*/
13 var xsxx = make(map[int] map[string]string)
14
15 /*主体函数部分*/
16
17 func main() {
18 for {
19 /*定义变量zjmxx用于接收用户在主界面的选项*/
20 var zjmxx int
21 /*定义变量kill接受修改函数部分的返回值，并用于判断是否直接退出主系统*/
22 var kill int
23 zjm()
24 /*接收用户在主界面的选项，并判断是否合法*/
25 fmt.Println("\n请输入对应操作的序号：\n")
26 yz,_ := fmt.Scanln(&zjmxx)
27 if yz == 0 || zjmxx < 1 || zjmxx > 5 {
28 fmt.Println("\n输入非法！请重新输入！\n")
29 continue
30 }else {
31 /*该支路用于添加学生信息*/
32 if zjmxx == 1 {
33 /*调用添加学生信息函数*/
34 tj()
35 /*该支路用于删除学生信息*/
36 }else if zjmxx == 2 {
37 /*调用删除学生信息函数*/
38 sc()
39 /*该支路用于修改学生信息*/
40 }else if zjmxx == 3 {
41 /*调用修改学生信息函数，返回用户在修改界面是否直接退出主程序的选择*/
42 kill = xg()
43 /*该支路用于查询学生信息*/
44 }else if zjmxx == 4 {
45 /*调用查询学生信息函数*/
46 cx()
47 }else {
48 break
49 }
50 }
51 if kill == 1 {
52 break
53 }
54 }
55 }
56
57 /*自定义函数（功能）部分*/
58
59 /*主界面函数，用于打印主界面*/
60 func zjm() {
61 for i := 0;i < 21;i++ {
62 print("*~")
63 }
64 fmt.Println()
65 fmt.Println("*~\t\t<学生信息系统>\t\t*~")
66 fmt.Println("*~\t\t1.添加学生信息\t\t*~")
67 fmt.Println("*~\t\t2.删除学生信息\t\t*~")
68 fmt.Println("*~\t\t3.修改学生信息\t\t*~")
69 fmt.Println("*~\t\t4.查询学生信息\t\t*~")
70 fmt.Println("*~\t\t5.退出信息系统\t\t*~")
71 for i := 0;i < 21;i++ {
72 print("*~")
73 }
74 fmt.Println()
75 }
76 /*添加函数，用于添加学生信息*/
77 func tj() {
78 /*以下变量分别用于接收学生的学号、姓名、年龄、性别、年级、专业、住址*/
79 var (
80 xsxh int
81 xsxm string
82 xsnl string
83 xsxb string
84 xsnj string
85 xszy string
86 xszz string
87 )
88 for {
89 fmt.Println("\n请输入学生学号：\n")
90 yz,_ := fmt.Scanln(&xsxh)
91 if yz == 0 {
92 fmt.Println("\n输入非法！请重新输入！\n")
93 continue
94 }else {
95 fmt.Println("\n请分别输入学生的姓名、年龄、性别、年级、专业、住址：\n")
96 yz1,_ := fmt.Scanln(&xsxm,&xsnl,&xsxb,&xsnj,&xszy,&xszz)
97 if yz1 == 0 {
98 fmt.Println("\n输入非法！请重新输入！\n")
99 continue
100 }else {
101 xsxx[xsxh] = make(map[string]string)
102 xsxx[xsxh]["学生姓名"] = xsxm
103 xsxx[xsxh]["学生年龄"] = xsnl
104 xsxx[xsxh]["学生性别"] = xsxb
105 xsxx[xsxh]["学生年级"] = xsnj
106 xsxx[xsxh]["学生专业"] = xszy
107 xsxx[xsxh]["学生住址"] = xszz
108 }
109 }
110 fmt.Println("\n添加成功！\n")
111 break
112 }
113 }
114 /*删除函数*/
115 func sc() {
116 var xsxh int
117 for {
118 fmt.Println("\n请输入你的删除对象的学号：\n")
119 yz,_ := fmt.Scanln(&xsxh)
120 if yz == 0 {
121 fmt.Println("\n输入非法！请重新输入！\n")
122 continue
123 }else {
124 delete(xsxx,xsxh)
125 }
126 fmt.Println("\n删除成功！\n")
127 break
128 }
129 }
130 /*学生信息修改界面函数，用于打印学生信息修改界面*/
131 func xgjm() {
132 for i := 0;i < 21;i++ {
133 print("*~")
134 }
135 fmt.Println()
136 fmt.Println("*~\t\t<学生信息修改>\t\t*~")
137 fmt.Println("*~\t\t1.修改学生姓名\t\t*~")
138 fmt.Println("*~\t\t2.修改学生年龄\t\t*~")
139 fmt.Println("*~\t\t3.修改学生性别\t\t*~")
140 fmt.Println("*~\t\t4.修改学生年级\t\t*~")
141 fmt.Println("*~\t\t5.修改学生专业\t\t*~")
142 fmt.Println("*~\t\t6.修改学生住址\t\t*~")
143 fmt.Println("*~\t\t7.返回上一界面\t\t*~")
144 fmt.Println("*~\t\t8.退出信息系统\t\t*~")
145 for i := 0;i < 21;i++ {
146 print("*~")
147 }
148 fmt.Println()
149 }
150 /*索引函数，用于判断对应学号是否存在*/
151 func sy(xsxh int) int{
152 var sfcz int
153 for k := range xsxx {
154 if xsxh == k {
155 sfcz = 1
156 }
157 }
158 return sfcz
159 }
160 /*修改函数*/
161 func xg() int{
162 /*以下变量分别用于接收用户在修改界面的选择
163 和学生的学号、姓名、年龄、性别、年级、专业、住址
164 以及两个是否打断循环的条件*/
165 var (
166 xgjmxx int
167 xsxh int
168 xsxm string
169 xsnl string
170 xsxb string
171 xsnj string
172 xszy string
173 xszz string
174 kill1 int
175 kill2 int
176 )
177 for {
178 /*接收用户输入的学号，并判断是否存在以及是否合法*/
179 fmt.Println("\n请输入代修改对象的学号：\n")
180 yz,_ := fmt.Scanln(&xsxh)
181 /*调用索引函数，返回学号是否存在的判断结果*/
182 sfcz := sy(xsxh)
183 if yz == 0 || sfcz == 0 {
184 fmt.Println("\n输入非法或该学号不存在！请重新输入！\n")
185 continue
186 }else {
187 for {
188 /*调用学生信息修改界面函数*/
189 xgjm()
190 /*接收用户在修改界面的选项，并判断是否合法*/
191 fmt.Println("\n请输入对应操作的序号：\n")
192 yz,_ := fmt.Scanln(&xgjmxx)
193 if yz == 0 || xgjmxx < 1 || xgjmxx > 8 {
194 fmt.Println("\n输入非法！请重新输入！\n")
195 continue
196 }else {
197 /*该支路用于修改学生姓名*/
198 if xgjmxx == 1 {
199 for {
200 fmt.Println("\n请输入学生姓名：\n")
201 yz,_ := fmt.Scanln(&xsxm)
202 if yz == 0 {
203 fmt.Println("\n输入非法！请重新输入！\n")
204 continue
205 }else {
206 xsxx[xsxh]["学生姓名"] = xsxm
207 }
208 break
209 }
210 /*该支路用于修改学生年龄*/
211 }else if xgjmxx == 2 {
212 for {
213 fmt.Println("\n请输入学生年龄：\n")
214 yz,_ := fmt.Scanln(&xsnl)
215 if yz == 0 {
216 fmt.Println("\n输入非法！请重新输入！\n")
217 continue
218 }else {
219 xsxx[xsxh]["学生年龄"] = xsnl
220 }
221 break
222 }
223 /*该支路用于修改学生性别*/
224 }else if xgjmxx == 3 {
225 for {
226 fmt.Println("\n请输入学生性别：\n")
227 yz,_ := fmt.Scanln(&xsxb)
228 if yz == 0 {
229 fmt.Println("\n输入非法！请重新输入！\n")
230 continue
231 }else {
232 xsxx[xsxh]["学生性别"] = xsxb
233 }
234 break
235 }
236 /*该支路用于修改学生年级*/
237 }else if xgjmxx == 4 {
238 for {
239 fmt.Println("\n请输入学生年级：\n")
240 yz,_ := fmt.Scanln(&xsnj)
241 if yz == 0 {
242 fmt.Println("\n输入非法！请重新输入！\n")
243 continue
244 }else {
245 xsxx[xsxh]["学生年级"] = xsnj
246 }
247 break
248 }
249 /*该支路用于修改学生专业*/
250 }else if xgjmxx == 5 {
251 for {
252 fmt.Println("\n请输入学生专业：\n")
253 yz,_ := fmt.Scanln(&xszy)
254 if yz == 0 {
255 fmt.Println("\n输入非法！请重新输入！\n")
256 continue
257 }else {
258 xsxx[xsxh]["学生专业"] = xszy
259 }
260 break
261 }
262 /*该支路用于修改学生住址*/
263 }else if xgjmxx == 6 {
264 for {
265 fmt.Println("\n请输入学生住址：\n")
266 yz,_ := fmt.Scanln(&xszz)
267 if yz == 0 {
268 fmt.Println("\n输入非法！请重新输入！\n")
269 continue
270 }else {
271 xsxx[xsxh]["学生住址"] = xszz
272 }
273 break
274 }
275 /*该支路用于返回主界面*/
276 }else if xgjmxx == 7 {
277 kill1 = 1
278 /*该支路用于退出主系统*/
279 }else {
280 kill1 = 1
281 kill2 = 1
282 }
283 }
284 if kill1 == 1 {
285 break
286 }
287 }
288 }
289 break
290 }
291 return kill2
292 }
293 /*查询函数*/
294 func cx() {
295 var xsxh int
296 for {
297 fmt.Println("\n请输入学生学号：\n")
298 yz,_ := fmt.Scanln(&xsxh)
299 if yz == 0 {
300 fmt.Println("\n输入非法！请重新输入！\n")
301 continue
302 }else {
303 fmt.Println()
304 for k,v := range xsxx[xsxh]{
305 fmt.Println(k,":",v)
306 }
307 fmt.Println()
308 }
309 break
310 }
311 }
1703
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
