首页 > 编程语言 >Golang入门到实战核心编程-第五章-程序流程控制

Golang入门到实战核心编程-第五章-程序流程控制

时间：2023-01-07 17:33:15浏览次数：45  
标签：1.2 fmt 编程 程序流程 Golang 循环 跳转 Println 2.1

目录

1. 程序流程控制

1.1 程序流程个控制介绍

在程序流程中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

  1. 顺序控制；

  2. 分支控制；

  3. 循环控制；

1.2 三大流程控制介绍及案例

1.2.1 顺序流程控制

1.2.1.1 顺利流程控制介绍

程序从上到下逐行地执行，中间没有任何判断和跳转。

1.2.1.2 顺序流程控制流程图

1.2.1.3 顺序流程控制案例

以下案例的代码中，没有判断，没有跳转，因此程序按照默认的流程执行，即顺利流程控制。

func main() {
	var a int = 100
	fmt.Println("a 的地址=", &a)

	var ptr *int = &a
	fmt.Println("ptr 的值=", *ptr)
}

1.2.1.4 顺序流程控制注意事项

Golang中定义变量时采用合法的前向引用。如：

正确形式：

func main() {
	var num1 int = 10
	var num2 int = num1 + 20
	fmt.Println(num2)
}

错误形式：

func main() {
	var num2 int = num1 + 20
	var num1 int = 10
	fmt.Println(num2)
}

1.2.2 分支控制

1.2.2.1 分支控制介绍

让程序有选择的执行，分支控制有三种；

  1. 单分支；

  2. 双分支；

  3. 多分支；

1.2.2.1.1 单分支
1.2.2.1.1.1 单分支基本语法
if 条件表达式 {
    执行代码块
}

说明：当条件表达式为True时，就会执行{}的代码。注意{}是必须有的，就算只写一行代码。

1.2.2.1.1.2 单分支案例

编写一个程序，可以输入人的年龄，如果年龄大于18岁，输出“年龄大于18”；

func main() {
	var age byte

	fmt.Println("请输入年龄：")
	fmt.Scanln(&age)

	if age > 18 {
		fmt.Println("年龄大于18")
	}
}
1.2.2.1.1.3 单分支流程图

1.2.2.1.1.4 单分支流细节说明

Golang的if还有一个强大的地方就是条件判断语句里面允许声明一个变量，这个变量的作用域只能在该条件逻辑块内，其他地方不起作用，比如以下案例；

func main() {
	if age := 20; age > 18 {
		fmt.Println("年龄大于18")
	}
}
1.2.2.1.2 双分支
1.2.2.1.2.1 双分支基本语法
if 条件表达式 {
    执行代码块1
} else { 
    执行代码块2
}

说明：当条件表达式成立，即执行代码块1。否则执行代码块2。{}必须有。

1.2.2.1.2.2 双分支案例

编写一个程序，可以输入人的年龄，如果年龄大于18岁，输出“年龄大于18”，否则输出“年龄小于18”；

func main() {
	if age := 20; age > 18 {
		fmt.Println("年龄大于18")
	} else {
		fmt.Println("年龄小于18")
	}
}
1.2.2.1.2.3 双分支流程图

1.2.2.1.3 多分支
1.2.2.1.3.1 多分支基本语法
if 条件表达式1 {
    执行代码块1
} else if 条件表达式2 {
    执行代码块2
...
} else {
    执行代码块N
}

说明：

  1. 多分支的判断流程如下

    • 先判断条件表达式1是否成立，如果为真，就执行代码块1；

    • 如果条件表达式1为假，就去判断条件表达式2是否成立，如果条件表达式2为真，就执行代码块2；

    • 后面以此类推，如果所有的条件表达式不成立，则执行else的语句块；

  2. else非必须；

  3. 多分支只能有一个执行入口；

1.2.2.1.3.2 多分支案例

小明参加考试，和父亲达成承诺：

  1. 成绩为100分时，奖励一辆BMW；

  2. 成绩为80-99分时，奖励一台iphone7 plus；

  3. 成绩为60-79分时，奖励一个ipad；

  4. 其他分时，什么奖励也没有；

请从键盘输入小明成绩，并加以判断

package main

import "fmt"

func main() {
	var num1 int
	fmt.Println("请输入小明成绩：")
	fmt.Scanln(&num1)

	if num1 == 100 {
		fmt.Println("奖励一辆BMW")
	} else if num1 >= 80 && num1 < 100 {
		fmt.Println("奖励一台iphone7 plus")
	} else if num1 >= 60 && num1 < 80 {
		fmt.Println("奖励一个ipad")
	} else {
		fmt.Println("什么奖励也没有")
	}
}
1.2.2.1.3.3 多分支流程图

1.2.2.1.4 嵌套分支
1.2.2.1.4.1 嵌套分支基本语法

在一个分支结构中又完整的嵌套了另一个完整的分子结构，里面的分支的结构称为内层分支外面的分支结构称为外层分支。

if 条件表达式 {
    if 条件表达式 {
    } else {
    }
}
1.2.2.1.4.2 嵌套分支案例

如果跑进8秒内进入决赛，否则淘汰，并根据性别进入不通的小组。

package main

import "fmt"

func main() {
	var sec float32
	var gen string

	fmt.Println("请输入时间：")
	fmt.Scanln(&sec)

	fmt.Println("请输入性别：")
	fmt.Scanln(&gen)

	if sec < 8 {
		if gen == "男" {
			fmt.Println("进入男子组决赛")
		} else if gen == "女" {
			fmt.Println("进入女子组决赛")
		}
	} else {
		fmt.Println("淘汰！")
	}
}
1.2.2.1.5 switch分支结构
1.2.2.1.5.1 switch分支结构介绍

  1. switch语句用于基本不同条件执行不同动作，每一个case分支都是唯一的，从上倒下逐一测试，直到匹配为止；

  2. 匹配项后面也不需要在加break；

1.2.2.1.5.2 switch分支结构基本语法
switch {

case 表达式1，表达式2...:
    语句块1

case 表达式3，表达式4...:
    语句块2

... // 可以有多个case语句

default:
    语句块
}
1.2.2.1.5.3 switch分支结构流程图

1.2.2.1.5.4 switch分支结构案例

编写一个程序，程序可以接收一个字符，比如：a,b,c...，a表示星期一，b表示星期二...，根据用户的输入显示相应的信息。

package main

import (
	"fmt"
)

func main() {
	var inp byte
	fmt.Println("请输入字符：")
	// 这里接受的时候需要使用格式化类型接收
	fmt.Scanf("%c", &inp)

	switch inp {
	case 'a':
		fmt.Println("星期一")
	case 'b':
		fmt.Println("星期二")
	case 'c':
		fmt.Println("星期三")
	case 'd':
		fmt.Println("星期四")
	case 'e':
		fmt.Println("星期五")
	case 'f':
		fmt.Println("星期六")
	case 'g':
		fmt.Println("星期日")
	default:
		fmt.Println("星期不知道几")
	}
}
1.2.2.1.5.4 switch分支结构细节

  1. case后是一个表达式（即：常量值、变量、一个有返回值的函数等都可以）；

  2. case后的各个表达式的值的数据类型，必须和switch的表达式数据类型一致；

  3. case后面可以带多个表达式，使用逗号间隔。比如case表达式1，表达式2等；

  4. case后面的表达式如果是常量值（字面量），则要求不能重复；

  5. case后面不需要带break，程序匹配到一个case后就会执行对应的代码块，然后退出switch，如果一个都匹配不到，则执行default；

  6. default语句不是必须的；

  7. switch后也可以不带表达式，类似if-else分支来使用；

  8. switch后也可以直接声明/定义一个变量，分号结束，不推荐；

  9. switch穿透fallthrough，如果在case语句块后增加fallthrough，则会继续执行下一个case，也叫switch穿透；

  10. Type Switch：switch语句还可以被用于type-switch来判断某个interface变量中实际指向的变量类型

1.2.2.1.5.4 switch和if比较

  1. 如果判断的具体数字不多，而且符合整数、浮点数、字符、字符串这几种类型，建议使用switch语句，简洁高效；

  2. 其他情况：对区间判断和结果为bool类型的判断，使用if，if的使用范围更广；

1.2.3 循环控制

1.2.3.1 for循环控制

1.2.3.1.1 for循环控制介绍

让代码不断的循环执行，快速入门，打印十句“Hello world！”。

for i := 0; i < 10; i++ {
	fmt.Println("Hello, World!")
}
1.2.3.1.2 for循环控制基本语法
for 循环变量初始化；循环条件；循环变量迭代{
    循环操作（语句）
}

for语句执行过程如下：

1、先对表达式 1 赋初值；

2、判别赋值表达式 init 是否满足给定条件，若其值为真，满足循环条件，则执行循环体内语句，然后执行 post，进入第二次循环，再判别 condition；否则判断 condition 的值为假，不满足条件，就终止for循环，执行循环体外语句。

for 循环的 range 格式可以对 slice、map、数组、字符串等进行迭代循环。格式如下：

for key, value := range oldMap {
    newMap[key] = value
}

以上代码中的 key 和 value 是可以省略。

如果只想读取 key，格式如下：

for key := range oldMap

或者这样：

for key, _ := range oldMap

如果只想读取 value，格式如下：

for _, value := range oldMap
1.2.3.1.3 for循环控制流程图

1.2.3.1.4 for循环控制使用细节

  1. 循环条件是返回一个布尔值的表达式；

  2. for循环的第二种使用方式；

for 循环判断条件 {
    // 循环执行语句
}

将变量初始化和变量迭代写到其他位置

  1. for循环的第三种使用方式
for {
    // 循环执行语句
}

写法等价for ; ; {}是一个无限循环，通常需要配合break语句使用。

  1. Golang提供for-range的方式，可以方便遍历字符串和数组；

传统方式：

func main() {
	str := "HelloWorld"
	for i := 0; i < len(str); i++ {
		fmt.Printf("i=%d val=%c\n", i, str[i])
	}
}

如果我们的字符串含有中文，那么传统的遍历字符串方式，会出现乱码。因为传统的对字符串的遍历是按照字节来遍历，而一个汉子在UTF-8编码对应3个字节。如何解决，需要将str转换[]rune切片。

func main() {
	var str string = "HelloWorld你好世界"
	str1 := []rune(str)
	for i := 0; i < len(str1); i++ {
		fmt.Printf("i=%d val=%c\n", i, str1[i])
	}
}

for-range方式：

func main() {
	str := "HelloWorld世界"
	for index, val := range str {
		fmt.Printf("index=%d val=%c\n", index, val)
	}
}

注意：for-range在遍历字符串时，是按照字符来遍历的，而不是按照字节，所以可以字节遍历中文。

1.2.3.2 while和do...while循环控制

1.2.3.2.1 while和do...while循环控制介绍

Golang语言没有while和do...while语法，可以通过for循环来实现相应效果。

for循环的while语法及案例：

循环变量初始化

for {
    if 循环条件表达式 {
        brek // 跳出for循环
    }
    
    循环操作（语句）
    循环变量迭代
}

func main() {
	var num int = 0
	for {
		if num > 10 {
			break
		}
		fmt.Println("hello world")
		num++
	}
}

for循环的do...while语法及案例：

循环变量初始化

for {
    循环操作（语句）
    循环变量迭代
    
    if 循环条件表达式 {
        break // 跳出for循环
    }
}

func main() {
	var num int = 0
	for {
		fmt.Println("hello ok")
		num++
		if num > 10 {
			break
		}
	}
}

说明：while和do...while的区别在于，while在不成立时可能一次都不会执行，do...while不管是否成立最少会执行一次。

1.2.3.3 多重循环控制

1.2.3.3.1 多重循环控制介绍

  1. 将一个循环放在另一个循环体内，就形成了嵌套循环。在外边的for称为外层循环在里面的for循环称为内层循环；（建议一般使用两层，最多不超过三层）

  2. 实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内存循环，才可结束外层的当次循环，开始下一次的循环；

  3. 假设外层循环次数为m次，内层为n次，则内层循环体实质上需要执行m * n = mn次；

1.2.3.3.1 多重循环控制案例
  1. 统计三个班成绩情况，每个班有五名同学，求出各个班的平均分和所有班级的平均分，学生成绩从键盘输入；
func main() {
	// 班级数量
	var classNumber int = 2
	// 学生数量
	var studentNumber int = 5
	// 所有班级的总分
	var overallAverage float64
	// 循环班级数量
	for i := 1; i <= classNumber; i++ {
		// 班级总分
		var classAverage float64
		// 循环学生数量
		for j := 1; j <= studentNumber; j++ {
			// 学生成绩
			var score float64
			// 接收学生成绩
			fmt.Printf("请输入%d班级, 第%d位同学的成绩:\n", i, j)
			fmt.Scanln(&score)
			// 学生成绩相加赋值给班级总分
			classAverage += score
		}
		// 班级平均分计算
		fmt.Printf("%d班的平均分是: %f\n", i, classAverage/float64(studentNumber))
		// 班级总分相加赋值给所有班级总分
		overallAverage += classAverage
	}
	// 所有班级总分计算及平均分计算
	fmt.Printf("所有班级的总分是：%v 所有班级的平均分是：%v", overallAverage, overallAverage/(float64(studentNumber)*float64(classNumber)))
}
  1. 统计三个班及格人数，每个班有五名同学；
func main() {
	var classNumber int = 3
	var studentNumber int = 5
	// 及格总人数
	var totalPassNumber int
	for i := 1; i <= classNumber; i++ {
		// 班级及格人数
		var passNumber int
		for j := 1; j <= studentNumber; j++ {
			var score float64
			fmt.Printf("请第%d个班级,第%d个同学输入成绩:\n", i, j)
			fmt.Scanln(&score)
			// 判断是否及格，及格在班级及格人数中加一
			if score >= 60.0 {
				passNumber++
			}
		}
		fmt.Printf("第%d个班级,及格人数是: %d\n", i, passNumber)
		totalPassNumber += passNumber
	}
	fmt.Printf("所有班级总及格人数是：%d\n", totalPassNumber)
}
  1. 打印金字塔，使用for循环完成以下案例，可以接收一个整数，表示层数，打印出金字塔；

1. 打印一个矩形

func main() {
	// 控制层数
	for i := 1; i <= 3; i++ {
		// 控制打印数量
		for j := 1; j <= 3; j++ {
			fmt.Print("*")
		}
		fmt.Println("")
	}
}

/*
打印结果：
***
***
***
*/

2. 打印半个金字塔

我们发现半个金字塔的每行的打印数量和行数相同，所以把控制打印的数量的常量，修改为当前行数的变量，这样每次都是根据行数的打印对应的数量。

func main() {
	// 控制层数
	for i := 1; i <= 3; i++ {
		// 控制打印数量
		for j := 1; j <= i; j++ {
			fmt.Print("*")
		}
		fmt.Println("")
	}
}

/*
打印结果：
*
**
***
*/

3. 打印整个金字塔

func main() {
	// 控制层数
	for i := 1; i <= 3; i++ {
		// 控制空格数量
		for k := 1; k <= 3-i; k++ {
			fmt.Print(" ")
		}
		// 控制打印数量
		for j := 1; j <= 2*i-1; j++ {
			fmt.Print("*")
		}
		fmt.Println("")
	}
}

/*
打印结果：
  *         1 层 1 个 *， 规律：2 * 层数 - 1   空格 2 规律：所有层数 - 当前层数
 ***       2 层 3 个 *，规律：2 * 层数 - 1   空格 1 规律：所有层数 - 当前层数
*****     3 层 5 个 *，规律：2 * 层数 - 1   空格 0 规律：所有层数 - 当前层数
*/

4. 将层数做成一个变量

func main() {
	// 层数常量
	var totalLevel int = 5
	// 控制层数
	for i := 1; i <= totalLevel; i++ {
		// 控制空格数量
		for k := 1; k <= totalLevel-i; k++ {
			fmt.Print(" ")
		}
		// 控制打印数量
		for j := 1; j <= 2*i-1; j++ {
			fmt.Print("*")
		}
		fmt.Println("")
	}
}

/*
打印结果：
    *
   ***
  *****
 *******
*********
*/

5. 打印空心金字塔

预期打印：
  *
 * * 
*****

分析：在我们给每行打印*号时，需要考虑是打印*还是打印空格。观察预期打印我们发现，每行的第一个和最后一个打印*号，其他部分打印空格。还发现最后一行打印全*号。

func main() {
	// 层数常量
	var totalLevel int = 5
	// 控制层数
	for i := 1; i <= totalLevel; i++ {
		// 控制空格数量
		for k := 1; k <= totalLevel-i; k++ {
			fmt.Print(" ")
		}
		// 控制打印数量
		for j := 1; j <= 2*i-1; j++ {
                        // 如果是在打印第一个、最后一个及最后一行，都打印*，其余都打印空格
			if j == 1 || j == 2*i-1 || i == totalLevel{
				fmt.Print("*")
			} else {
				fmt.Print(" ")
			}

		}
		fmt.Println("")
	}
}

/*
打印结果：
    *
   * *
  *   *
 *     *
*********
*/
  1. 打印九九乘法表
func main() {
	for i := 1; i <= 9; i++ {
		for j := 1; j <= i; j++ {
			fmt.Printf("%v x %v = %v\t", j, i, i*j)
		}
		fmt.Println("")
	}
}

1.2.4 跳转控制语句

1.2.4.1 break跳转控制

1.2.4.1.1 break跳转控制介绍

通过一个需求引出break，随机生成1-100的一个数，直到生成了99这个数，看看你一共用了几次？

分析：编写一个无限循环控制，然后不停的随机生成数，当生成99时，就退出这个无限循环。

func main() {
	// 在Golang中，需要生成一个随机种子，否则返回的值总是固定的。
	// time.Now().Unix()：返回一个从1970/1/1 00:00到现在的一个秒数
	var countNumber int
	for {
		rand.Seed(time.Now().UnixNano())
		n := rand.Intn(100) + 1
		fmt.Println(n)
		countNumber++
		if n == 99 {
			break
		}
	}
	fmt.Printf("生成99一共用了%d次", countNumber)
}

Go 语言中 break 语句用于以下两方面：

  • 用于循环语句中跳出循环，并开始执行循环之后的语句。

  • break 在 switch（开关语句）中在执行一条 case 后跳出语句的作用。

  • 在多重循环中，可以用标号 label 标出想 break 的循环。

1.2.4.1.2 break跳转控制语法
{    ...
    break
    ...
}
1.2.4.1.3 break跳转控制流程图

1.2.4.1.4 break跳转控制细节说明

  1. break语句出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块；

  2. 标签的基本使用

func main() {
	// 演示指定标签的形式来使用break
label1: //设置一个标签
	for i := 0; i < 4; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				// break 默认会跳出最近的for循环
				break label1 // break后面可以指定标签，跳出标签对应的循环
			}
			fmt.Println("j=", j)
		}
	}
}
1.2.4.1.5 break跳转控制案例
  1. 100以内的数求和，求出当和第一次大于20的当前数。
func main() {
	var sum int
	for i := 1; i <= 100; i++ {
		sum += i
		if sum > 20 {
			fmt.Println("当sum>20时,当前数是：", i)
			break
		}
	}
}
  1. 实现登录验证，有三次机会，如果用户名为“张无忌”，密码“888”提示登录成功，否则提示还有几次机会。
func main() {
	for i := 1; i <= 3; i++ {
		var username string
		var password string
		fmt.Println("请输入用户和密码：")
		fmt.Scanf("%v %v", &username, &password)
		if username == "张无忌" && password == "888" {
			fmt.Println("登录成功！！！")
			break
		}
		fmt.Printf("登录失败，还有%d次机会\n", 3-i)
	}
}

1.2.4.2 continue跳转控制

1.2.4.2.1 continue跳转控制介绍

  1. continue语句用于结束本次循环，继续执行下一次循环；

  2. continue语句出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的哪一层循环，这个和前面的标签使用的规则一样。

1.2.4.2.2 continue跳转控制语法
{   ...
    continue
    ...
}
1.2.4.2.2 continue跳转控制流程图

1.2.4.2.2 continue跳转控制案例
  1. 实现打印1-100的奇数，使用for循环+continue
func main() {
	for i := 1; i <= 100; i++ {
		if i%2 == 0 {
			continue
		}
		fmt.Println(i)
	}
}
  1. 从键盘读入个数不确定的整数，并判断读入的正数和负数的个数，输入为0时结束进程，使用for循环、break和continue完成。
func main() {
	var positiveNumber int
	var negaiveNumber int
	for {
		var num int
		fmt.Println("请输入一个整数：")
		fmt.Scanln(&num)
		if num == 0 {
			break
		} else if num > 0 {
			positiveNumber++
			continue
		}
		negaiveNumber++

	}
	fmt.Printf("正数个数：%d 负数个数：%d\n", positiveNumber, negaiveNumber)
}
  1. 某人有100,000元，每经过一次路口，需要缴费，规则：当现金>50000，每次交5%；当现金<=50000，每次交1000；计算该人可以经过多少次路口，使用for和break方式完成。
func main() {
	var intersections int
	var money float64 = 100000
	for {

		if money <= 0 {
			break
		} else if money > 50000 {
			money = money - (money * 0.05)
		} else if money <= 50000 {
			money -= 1000
		}
		intersections++
	}
	fmt.Printf("一共走过了%d个路口", intersections)
}

1.2.4.3 goto跳转控制

1.2.4.3.1 goto跳转控制介绍

  1. Golang语言的goto语句可以无条件地转移到程序中指定的行；

  2. goto语句通常与条件语句配合使用，可用来实现条件转移，跳出循环体等功能；

  3. 在Golang程序设计中一般不主张使用goto语句，以免造成程序流程的混乱，使理解和调试程序都产生困难；

1.2.4.3.2 goto跳转控制语法
goto label
...
label:statement
1.2.4.3.2 goto跳转控制案例
func main() {
	var n int = 10
	fmt.Println("ok1")
	if n == 10 {
		goto label1
	}

	fmt.Println("ok2")
	fmt.Println("ok3")
label1:
	fmt.Println("ok4")
	fmt.Println("ok5")
}

1.2.4.4 return跳转控制

1.2.4.4.1 return跳转控制介绍

return使用在方法，表示跳出所在的函数或方法。

1.2.4.4.2 return跳转控制案例
func main() {
	for i := 1; i < 10; i++ {
		if i == 2 {
			return
		}
		fmt.Println(i)
	}
	fmt.Println("Hello, world!")
}

标签：1.2,fmt,编程,程序流程,Golang,循环,跳转,Println,2.1
From： https://www.cnblogs.com/aadam/p/17032927.html

相关文章

  • 场景编程集锦-应对能源危机
    1.场景描述受俄乌战事的影响，全球能源价格上涨，引发欧盟地区通胀加剧。许多国家和地区面临着汽车加油站缺油断气、电力供应紧张、工业和生活燃气短缺等严峻形势，为了应对能源......
  • Golang入门到实战核心编程-第四章-运算符
    目录1.运算符介绍2.算数运算符2.1算数运算符介绍2.2算数运算符一览2.3算数运算符案例2.4算数运算符细节说明3.关系运算符3.1关系运算符介绍3.2关系运算符一览3.3......
  • Golang入门到实战核心编程-第三章-变量
    目录1.Golang数据类型分类2.数据类型的默认值3.数据类型及大小3.1查看变量的数据类型3.2查看变量占用字节大小4.数据类型介绍4.1整数类型4.1.1整型各个类型对比4.1......
  • 客服系统即时通讯IM开发（二）Golang + Gin框架实现服务端WebScoket【唯一客服】网站在线
    我的客服系统使用的Golang+Gin作为后端服务，所以下面的代码是演示demo在Go语言中使用Gin框架实现WebSocket的方法如下：安装gin-gonic/websocket库。在Gin......
  • C++ - TCP/UDP网络编程
    前言socket编程分为TCP和UDP两个模块，其中TCP是可靠的、安全的，常用于发送文件等，而UDP是不可靠的、不安全的，常用作视频通话等。如下图：头文件与库：#include<WinSock2.h>......
  • 2023年01月编程语言流行度排名
    点击查看最新编程语言流行度排名（每月更新）2023年01月编程语言流行度排名编程语言流行度排名是通过分析在谷歌上搜索语言教程的频率而创建的一门语言教程被搜索的次数越多......
  • 003.函数式编程（函数式接口Predicate）
    1.函数式接口Predicate  2.代码示例packagecom.imooc.lambda;importjava.util.Arrays;importjava.util.List;importjava.util.function.Predicate;/**......
  • Jody在编程
    如果说编程语言是一种人与机器的交流，那么普通的文字，话语就是心灵的交汇。虽然关于交流沟通的书我没有看过几本，但是基础的逻辑还是了解的。之所以这样开篇，是因为基于文字......
  • python网络编程
    网络编程1软件开发架构、网络编程简介、OSI七层协议以及网络相关设施2TCP/IP协议、Socket套接字以及黏包问题的解决方案3UDP协议、多道技术、进程理论以及同步异步、......
  • Golang的变量声明
    变量使用步骤声明赋值引用packagemainimport"fmt"funcmain(){ //1.变量的声明 varzlint //2.变量的赋值 zl=19 //3.变量的使用 fmt.Println(......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99