程序员经验分享-hwhale

Go_流程、跳转控制语详解

2023-11-14

流程控制语句分类：

流程控制语句可以控制代码的执行顺序和条件

  1. 顺序结构：普通的代码，由上而下依次执行
  2. 分支结构(if, switch)
  3. 循环结构(for)

if语句：

条件表达式值必须是bool类型，不可省略括号，且左大括号不能另起一行

格式1：

if (关系表达式) {
    语句体;	
}

执行流程：

  1. 首先计算关系表达式的值
  2. 如果关系表达式的值为true就执行语句体
  3. 如果关系表达式的值为false就不执行语句体
  4. 继续执行后面的语句内容

if语句格式2：

if (关系表达式) {
    语句体1;	
} else {
    语句体2;	
}

执行流程：

  1. 首先计算关系表达式的值
  2. 如果关系表达式的值为true就执行语句体1
  3. 如果关系表达式的值为false就执行语句体2
  4. 继续执行后面的语句内容

if语句格式3：

if (关系表达式1) {
    语句体1;	
} else if (关系表达式2) {
    语句体2;	
} 
…
else {
    语句体n+1;
}

执行流程：

1. 首先计算关系表达式1的值
2. 如果值为true就执行语句体1；如果值为false就计算关系表达式2的值
3. 如果值为true就执行语句体2；如果值为false就计算关系表达式3的值
4. …
5. 如果没有任何关系表达式为true，就执行语句体n+1。

定义一个在0~100之间的变量a, 判断分数在什么范围，90 ~ 100优秀，80 ~ 89良好，70 ~ 79中等，60 ~ 69及格，0 ~ 59请努力加油！

func main() {
	// 定义一个在0~100之间的变量a, 判断分数在什么范围，90 ~ 100优秀，80 ~ 89良好，70 ~ 79中等，60 ~ 69及格，0 ~ 59请努力加油！
	var a float64
	fmt.Println("请输入成绩：")
	fmt.Scan(&a)

	if a >= 90 && a <= 100 {
		fmt.Println("优秀")
	} else if a >= 80 && a <= 89 {
		fmt.Println("良好")
	} else if a >= 70 && a <= 79 {
		fmt.Println("中等")
	} else if a >= 60 && a <= 69 {
		fmt.Println("及格")
	} else if a >= 0 && a <= 59 {
		fmt.Println("有脸吃饭？")
	} else {
		fmt.Println("成绩需在0~100之间")
	}
}

死代码：指永远不会被执行的代码，数据被定义成常量时就容易产生死代码

func main() {
	x := 8
	if x > 5 { 			//优先判断，条件表达式结果为true。
		println("a")
	} else if x > 7 { 	// 永远不会执行
		println("b")
	}
}

在if中可以定义局部变量赋值后再做条件判断，可以调用函数时传参再判断

func main() {
	if age := 18; age <= 18 {
		fmt.Println()
	}
	age // 只能在if中使用
}

switch语句：

  • switch和case后面是一个表达式，也可以是常量、变量、有返回值的函数，switch后面也可以不带表达式，无表达式时为true
  • case常量值不能重复，case后的表达式可以有多个，使用逗号间隔
  • Go语言中的switch默认给每个case自带break，因此匹配成功后不会向下执行其他的 case 分支，而是跳出整个switch
  • 如需要穿透后续的case须使用fallthrough强制执行下一个的case代码，switch只能穿透一个case，fallthrough必须放在case分支的最后一行，否则编译报错。
  • 如果所有的case都和表达式的值不匹配，就会执行default语句体部分，default不是必须要写的

格式：

 switch (表达式) {
  	case 1:
  		语句体1
  	case 2:
  		语句体2
  	...
  	default:
  		语句体
  }

执行流程：

  1. 首先计算出表达式的值
  2. 其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结束。
  3. 最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。 所以建议将default放在末尾

定义一个在0~100之间的变量a，判断分数在什么范围，90 ~ 100优秀，80 ~ 89良好，70 ~ 79中等，60 ~ 69及格，0 ~ 59请努力加油！

func main() {
	var score float64
	fmt.Println("请输入成绩：")
	_, err := fmt.Scan(&score)
	if err != nil {
		return 
	}

	switch {
	case score >= 90 && score <= 100:
		fmt.Println("优秀")
	case score >= 80 && score <= 89:
		fmt.Println("良好")
	case score >= 70 && score <= 79:
		fmt.Println("中等")
	case score >= 60 && score <= 69:
		fmt.Println("及格")
	case score >= 0 && score <= 59:
		fmt.Println("有脸吃饭？")
	default:
		fmt.Println("成绩必须在0~100之间")
	}
}

case表达式值的数据类型必须和switch的数据类型一致

func main() {
	var num1 int = 1
	var num2 int64 = 1
	var num3 float64 = 1
	switch num1 {
	case num2: // 报错：'num1' (类型 'int64' 和 'int' 不匹配) 的 switch 中的 case 'num2' 无效
		fmt.Println(num2)
	case num3: // 报错：'num1' (类型 'int64' 和 'int' 不匹配) 的 switch 中的 case 'num2' 无效
		fmt.Println(num2)
	default:
		fmt.Println("error")
	}
}

case的后面可以有多个表达式，使用逗号间隔即可，但case的表达式后面如果跟的是常量值，则要求不能重复

func main() {
	var num1 int = 1
	var num2 int = 1

	switch num1 {
	case num2, 2, 3:
		fmt.Println("没问题")
	case 3: // 报错：case 3的值重复，常量值不能重复
		fmt.Println("有问题")
	case num1 + num2: // 这里的结果也是2，但是不是常量值，所以不会报错
		fmt.Println("没问题")
	}
}

fallthrough必须放在case块结尾

func main() {
	var num int = 10
	switch num {
	case 10:
		fmt.Println("case 10 匹配成功")
		fallthrough // 默认只能穿透一层
	case 20:
		fmt.Println("只能穿透到这里")
	case 30:
		fmt.Println("case 30 匹配成功")
	default:
		fmt.Println("default")
	}
}

输出：

case 10 匹配成功
只能穿透到这里

fallthrough如果放在default的前面，则会穿透default

func main() {
	var num int = 30
	switch num {
	case 10:
		fmt.Println("case 10 匹配成功")
	case 20:
		fmt.Println("case 20 匹配成功")
	case 30:
		fmt.Println("case 30 匹配成功")
		fallthrough // 默认只能穿透一层
	default:
		fmt.Println("default")
	}
}

输出：

case 30 匹配成功
default

如果fallthrough前面手动执行break就会中断fallthrough执行

func main() {
	var num int = 50
	switch num {
	default:
		fmt.Println("default在fallthrough前，则不会执行default")
	case 10:
		fmt.Println("case 10 匹配成功")
	case 20:
		fmt.Println("case 20 匹配成功")
		break   // 如果执行fallthrough前手动break就会中断fallthrough执行
		fallthrough // 默认只能穿透一层
	case 30:
		fmt.Println("走到这里说明被穿透了")
	}
}

switch还被用来替换if语句，被省略的switch条件表达式默认值为true，继而与case比较表达式结果匹配

func main() {
	switch x := 5; { // 相当于定义了变量x=5，"switch x := 5; true { ... } ，但是一定要加分号，否则报错
	case x > 5:
		fmt.Println("x > 5")
	case x > 0 && x <= 5: // 多条件是 OR 关系，不能写成“case x > 0, x <= 5”。
		fmt.Println("x > 0 && x <= 5")
	default:
		fmt.Println("default")
	}
}

for循环

循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句，当反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环。

range和fori循环中的局部变量都会被重复使用

for (初始化语句;条件判断语句;条件控制语句) {
	循环体语句;
}

// 三种for定义格式：

func main() {
  // 格式1
	for i := 0; i < 3; i++ {}//初始化表达式支持函数调用或定义局部变量。
	
  x := 3
	for x < 10 { // 循环外定义初始化
		x++
	}
	
	for { 		// 死循环，相当于"while true {}” 或 “for true {}”。
		循环体语句
	}
  
  for ; ; {} // 死循环，只不过格式不同
}

格式解释：

  • 初始化语句： 用于表示循环开启时的起始状态，就是循环开始的时候什么样
  • 条件判断语句：用于表示循环反复执行的条件，就是判断循环是否能一直执行下去
  • 循环体语句： 用于表示循环反复执行的内容，就是循环反复执行的事情
  • 条件控制语句：用于表示循环执行中每次变化的内容，就是控制循环是否能执行下去

执行流程：

  1. 执行初始化语句
  2. 执行条件判断语句，看其结果是true还是false
    如果是false，循环结束
    如果是true，继续执行
  3. 执行循环体语句
  4. 执行条件控制语句
  5. 回到2继续

求1-100之间的偶数和，并把求和结果在控制台输出

func main() {
	var sum int
	for i := 0; i <= 100; i++ {
		if i%2 == 0 {
			sum += i
		}
	}
	fmt.Println(sum)
}

// 每次直接加2，不需要if判断
func main() {
	var sum int
	for i := 2; i <= 100; i += 2 {
		sum += i
	}
	fmt.Println(sum)
}

可以遍历字符串和数组

func main() {
	var name string = "itzhuzhu"
	for i := 0; i < len(name); i++ {
		fmt.Printf("%c\n", name[i])
	}
}

如果遍历的字符串内含有中文会报错，因为遍历是按照字节来的，一个中文占用3个字节，需要转成切片再遍历，或者使用range遍历，range是按照字符遍历的

func main() {
	var name string = "itzhuzhu我乱码了吗"
	str := []rune(name)
	for i := 0; i < len(str); i++ {
		fmt.Printf("%c\n", str[i])
	}
}

range方式遍历

func main() {
	var name string = "haha我乱码了吗"
	for i, v := range name {
		fmt.Printf("索引：%d,数据：%c", i, v)
	}
}

range

  • range本质是一个函数，在使用的时候可以加括号使用
  • 修改range得到的value不影响原切片/数组的数据，value就是个副本，和原数据无关，但是在range循环里打印的话还是副本的内容
  • range和fori循环中的局部变量都会被重复使用

range 关键字用于

  • for循环中迭代数组、切片、channel、map的元素
  • 在数组和切片中它返回元素的索引值
  • 在集合中返回 key-value 对的 key 值

格式：

  // for 索引,值 := range 循环数据 
	for index,value := range arr {}

通过参数列表传递多个参数，使用range获取数据

func main() {
	//Demo01(1, 2, 3, 4, 5)
	//Demo02(1, 2, 3, 4, 5)
	Demo03(1, 2, 3, 4, 5)
}

// i代表索引    v代表数据

func Demo01(num ...int) {
	for i, v := range num {
		fmt.Print("i = ", i, "    ")
		fmt.Println("v = ", v)
	}
}

// 如果只写一个变量，取出的是索引

func Demo02(num ...int) {
	for v := range num {
		//fmt.Print("a = ", a, "    ")
		fmt.Println("v = ", v)
	}
}

// 可以把a使用_代替，表示是一个匿名变量，匿名变量不会保存具体的数据，就可以用v取出数据

func Demo03(num ...int) {
	for _, v := range num {
		//fmt.Print("a = ", a, "    ")
		fmt.Println("v = ", v)
	}
}

演示：

type Student struct {
	name string
	age  int
}

func main() {
	s := Student{"韩信", 10}
	s2 := Student{"娜可露露", 20}
	s3 := []Student{s, s2}
	arr := [3]int{1, 2, 3}

	// range是一个函数，也可以写成 for i, v := range (arr) {
	// 将arr遍历然后返回给v，所以在range内修改arr的值，不会影响原数据
	for i, v := range arr {
		arr[0] = 10
		fmt.Println("range", i, v)
	}
  
  // 同样的修改v的值也不会影响原数据
	for _, v := range s3 {
		v.age = 99
		fmt.Println("range", v.age)
	}
  
	fmt.Println(arr)
	fmt.Println(s3)
}

无论是普通for循环，还是range迭代，其定义的局部变量都会重复使用

func main() {
	str := [3]string{"a", "b", "c"}
	for i, s := range str {
		println(&i, &s)
	}
}

输出：

0x14000062ee0 0x14000062ef8
0x14000062ee0 0x14000062ef8
0x14000062ee0 0x14000062ef8

如果range调用函数，函数只会被执行一次

func data() []int {
	fmt.Println("初始化")
	return []int{10, 20, 30}
}

func main() {
	for i, x := range data() {
		fmt.Println(i, x)
	}
}

输出：

初始化
0 10
1 20
2 30

跳转控制语句break：

  • 跳转控制语句break用在循环语句中跳出当前循环，执行循环后面的语句，可以在switch、for中使用
  • 多重循环时默认跳出最近的循环，在循环嵌套中可以使用关键字label标记要跳出的位置

演示：

func main() {
	for i := 1; i <= 5; i++ {
		if i == 3 {
			break
		}
		fmt.Println(i) // 结果是1、2   break会直接跳出for循环
	}
}

计算100以内的偶数和，当偶数和大于100时停止循环并打印出当前i的值

func main() {
	sum := 0
	for i := 0; i < 100; i++ {
		if i%2 == 0 {
			sum += i
			if sum > 100 {
				fmt.Println("sum>100时，i=", i)
				break
			}
		}
	}
}

输出：

sum>100时，i= 20

指定跳转：

func main() {
  lable: // 要跳过的代码前
	要跳过的代码
	break lable//要跳过的代码后的位
}

多重循环，内循环为2时结束全部循环

func main() {
label:
	for i := 0; i < 10; i++ {
		for j := 0; j < 10; j++ {
			if j == 2 {
				break label
			}
			fmt.Println(j)
		}
	}
}

输出：

0
1

跳转控制语句continue：

  • 跳转控制语句（continue）:满足条件后，跳过本次循环，继续下次循环，基于条件控制, 在循环内部使用，for可以用
  • 注意： continue只能在循环中进行使用！
  • 在多重循环中可以使用标号label跳出循环

判断5以内的奇数并打印

func main() {
	for i := 1; i <= 5; i++ {
		if i == 2 {
			continue
		}
		fmt.Println(i)  // 结果是1、3、4、5     continue会跳过2，执行后面的
	}
}

多重循环时判断是否等于2，等于2时跳过当前循环，继续下一次循环

func main() {
	for i := 0; i < 3; i++ {
		for j := 0; j < 3; j++ {
			if j == 2 {
				continue
			}
			fmt.Print(j)
		}
	}
}

输出：

010101

跳转控制语句（return）:

retur表示终止函数或方法

func main() {
	// 		return // 放在这里等于是结束函数
	for i := 1; i <= 5; i++ {
		if i == 3 {
			break
		}
		fmt.Println("return前")
		return // 放在这里是结束循环
		fmt.Println("return后")
		fmt.Println(i)
	}
}

输出：

return前

跳转控制语句（goto）

跳转控制语句（goto）:转移到指定的行，goto一般配合条件判断使用，可以用来做条件转移，跳出循环等操作但是，在结构化程序设计中一般不主张使用 goto语句， 以免造成程序流程的混乱，使理解和调试程序都产生困难。

goto格式：

goto label
...
label : statement

演示：

func main() {
	goto label // 跳过123，执行45
	fmt.Println(1)
	fmt.Println(2)
	fmt.Println(3)
label:
	fmt.Println(4)
	fmt.Println(5)
}

如果向后面跳，会死循环

func main() {
label:
	fmt.Println("走我了吗")
	goto label
}

不能跳到其他函数或内部代码块

func main() {
	goto loop // 未解析的标签 'loop'
	goto test // 未解析的标签 'test'
	for i := 0; i < 5; i++ {
	loop: // 未使用的标签 'loop'
		fmt.Println("goto03...")
	}
}

func gotoTest() {
test: // 未使用的标签 'test'
}

循环嵌套

循环嵌套也可以说是多重循环，就是在一个循环体里面嵌入另一个循环

打印乘法口诀表案例：

func forDemo6() {
	for i := 1; i <= 9; i++ { // 外循环控制行
		for j := 1; j <= i; j++ { // 内循环控制列
			fmt.Printf("%d*%d=%d ", j, i, j*1)
		}
		fmt.Print("\n")
	}
}

输出结果：

1*1=1 
1*2=1 2*2=2 
1*3=1 2*3=2 3*3=3 
1*4=1 2*4=2 3*4=3 4*4=4 
1*5=1 2*5=2 3*5=3 4*5=4 5*5=5 
1*6=1 2*6=2 3*6=3 4*6=4 5*6=5 6*6=6 
1*7=1 2*7=2 3*7=3 4*7=4 5*7=5 6*7=6 7*7=7 
1*8=1 2*8=2 3*8=3 4*8=4 5*8=5 6*8=6 7*8=7 8*8=8 
1*9=1 2*9=2 3*9=3 4*9=4 5*9=5 6*9=6 7*9=7 8*9=8 9*9=9
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Golang

if语句

Switch语句

for循环

流程控制语句

Go_流程、跳转控制语详解 的相关文章

  • go struct{} 空结构体的特点和作用

    空结构体的特点和作用 参考代码 package main import fmt unsafe func main empStruct 空结构体的实例和作用 func empStruct 空结构体的特点 1 不占用内存 2 地址不变 var

  • golang-bufio 缓冲扫描

    前面两篇博客 介绍了 bufio 包中的缓冲读和写 bufio go 下面再来介绍一下缓冲扫描 scan go 这个扫描的是用来对缓存读的更高级封装 提供了一些更易用的方法 缓冲扫描 Scanner 提供了一个方便的接口来读取数据 例如使用

  • 【Golang入门】Golang第一天心得

    生活所迫 入门一下Go 很奇葩的第一点 接口 package main import fmt 定义一个接口 type Shape interface Area float64 定义一个矩形类型 type Rectangle struct W

  • Go Web编程实战（6）----反射

    目录 反射 反射的3大原则 接口类型变量 转换为 反射类型对象 反射类型对象 转换为 接口类型变量 反射类型对象 修改 值必 可写的 反射 与其他语言一样 Go语言的反射同样是指 计算机程序在运行时 可以访问 检测和修改它本身状态或行为的一

  • golang: Logrus实现日志打印

    Github https github com sirupsen logrus golang标准库的日志框架非常简单 仅仅提供了print panic和fatal三个函数 对于更精细的日志级别 日志文件分割以及日志分发等方面并没有提供支持

  • Golang适合高并发场景的原因分析

    典型的两个现实案例 我们先看两个用Go做消息推送的案例实际处理能力 360消息推送的数据 16台机器 标配 24个硬件线程 64GB内存 Linux Kernel 2 6 32 x86 64 单机80万并发连接 load 0 2 0 4 C

  • go 进阶 go-zero相关: 七. 拦截器与熔断拦截器

    目录 一 拦截器的基础使用 1 服务端拦截器 2 客户端拦截器 二 拦截器底层底层执行原理 三 go zero默认添加的拦截器 客户端 1 熔断器拦截器 BreakerInterceptor 服务端 一 拦截器的基础使用 在go zero

  • 【golang】error parsing regexp: invalid or unsupported Perl syntax (正则表达式校验密码)

    要在 Go 中编写密码校验规则 确保密码不少于8位且包含数字和字母 你可以使用正则表达式和 Go 的 regexp 包来实现 以下是一个示例代码 错误示范 package main import fmt regexp func valida

  • Go语言包管理（一）

    Go语言中的包 我们在使用其他语言 比如Java Python 都有类似包的概念 Go也不例外 其核心思想即为分组和模块化 人的大脑对庞大和复杂的事情很难掌控 可以对其采用分而治之的策略 使其模块化 从而更容易管理 如下是标准库中net包的

  • Go_接口、多态、接口继承、空接口、类型断言

    接口 接口是把所有具有共性的方法定义在一起 是方法集 任何类型实现了接口中所有的方法 就是实现了这个接口 接口可以实现多态 接口传递的是地址值 接口定义及调用 定义格式 tepe 接口名 interface 方法名 参数 返回值 调用格式1

  • Golang三剑客之Pflag、Viper、Cobra

    如何构建应用框架 想知道如何构建应用框架 首先你要明白 一个应用框架包含哪些部分 在我看来 一个应用框架需要包含以下 3 个部分 命令行参数解析 主要用来解析命令行参数 这些命令行参数可以影响命令的运行效果 配置文件解析 一个大型应用 通常

  • 为什么最近听说 Go 岗位很少很难？

    大家好 我是煎鱼 其实这个话题已经躺在我的 TODO 里很久了 近来很多社区的小伙伴都私下来交流 也有在朋友圈看到朋友吐槽 Go 上海的大会没什么人 还不如 Rust 大会 比较尴尬 今天主要是看看为什么 Go 岗位看起来近来很难的样子 也

  • Go 程序编译过程（基于 Go1.21）

    版本说明 Go 1 21 官方文档 Go 语言官方文档详细阐述了 Go 语言编译器的具体执行过程 Go1 21 版本可以看这个 https github com golang go tree release branch go1 21 sr

  • 掌握 Go 语言中的循环结构：从基础到高级

    一 if else 分支结构 1 if 条件判断基本写法 package main import fmt func main score 65 if score gt 90 fmt Println A else if score gt 75

  • go-zero 开发入门-加法客服端示例

    定义 RPC 接口文件 接口文件 add proto 的内容如下 syntax proto3 package add 当 protoc gen go 版本大于 1 4 0 时需加上 go package 否则编译报错 unable to d

  • go-zero开发入门之网关往rpc服务传递数据1

    go zero 的网关往 rpc 服务传递数据时 可以使用 headers 但需要注意前缀规则 否则会发现数据传递不过去 或者对方取不到数据 go zero 的网关对服务的调用使用了第三方库 grpcurl 入口函数为 InvokeRPC

  • go-zero开发入门-API服务开发示例

    接口定义 定义 API 接口文件 接口文件 add api 的内容如下 syntax v1 info title API 接口文件示例 desc 演示如何编写 API 接口文件 author 一见 date 2023年12月07日 vers

  • Go 语言中切片的使用和理解

    切片与数组类似 但更强大和灵活 与数组一样 切片也用于在单个变量中存储相同类型的多个值 然而 与数组不同的是 切片的长度可以根据需要增长和缩小 在 Go 中 有几种创建切片的方法 使用 datatype values 格式 从数组创建切片

  • go语言实现文件夹上传前后端代码案例

    go语言实现文件夹上传前后端代码案例 前端用于上传的测试界面 如果上传的文件夹有子文件要遍历子文件夹创建出子文件夹再进行拷贝 需要获取文件名和对应的路径 将文件的相对路径和文件对象添加到FormData中 这几行代码很关键 for let

  • go开发--操作mysql数据库

    在 Go 中访问 MySQL 数据库并进行读写操作通常需要使用第三方的 MySQL 驱动 Go 中常用的 MySQL 驱动有 github com go sql driver mysql 和 github com go xorm xorm

随机推荐

  • OpenCV4-图像二值化

    OpenCV4 图像二值化 图像二值化 1 环境配置 OpenCV版本 OpenCV4 1 2 图像二值化 二值图像 图像中的像素灰度值无论在什么数据类型中都只有最大值和最小值两种取值 这种 非黑即白 的图像称为二值图像 将非二值图像经过计

  • Java基础——函数与数组

    上一节中给大家留得习题都完成的怎么样呀 有什么问题就给阿Q留言吧 阿Q会知无不言 言无不尽的 今天让我们进一步学习一下java中的函数与数组吧 函数 也称之为方法 1 定义在类中 有特定功能的一段小程序 可以提高代码的复用性和维护性 2 函

  • 毕业项目SSM框架配置文件之SqlMapConfig.xml

  • Registry学习资料

    官网 https registry project readthedocs io en latest index html

  • npm安装、使用方法

    文章目录 npm安装 使用方法 1 npm介绍 2 npm查看版本 3 npm查看所有命令列表 4 npm查看所有命令用法 5 npm查看配置 6 npm永久换源 7 npm查看换源是否成功 8 npm创建模块 9 npm查看项目已安装的所

  • 【springboot】@RequestBody和@ResponseBody以及@PathVariable的使用及区别

    1 RequestBody和 ResponseBody RequestBody 通过 requestBody可以将请求体中的JSON字符串绑定到相应的bean上 当然 也可以将其分别绑定到对应的字符串上 实质上接受的是一个JSON的字符串

  • 基于Linux用C语言实现TCP/UDP图片和文件传输（socket）

    目录 一 TCP实现 1 服务端 2 客户端 二 UDP实现 1 服务端 2 客户端 一 TCP实现 传输控制协议 TCP Transmission Control Protocol 是为了在不可靠的互联网络上提供可靠的端到端字节流而专门设

  • Python-turtle库

    star py import turtle turtle pensize 5 turtle color red turtle penup turtle goto 150 150 turtle pendown turtle begin fil

  • Opencv之Unsharp Mask(USM)锐化

    1 介绍 USM技术是通过增强图像的高频部分的内容来提高视觉效果 用具体的公式表达即为 y n m x n m z n m 其中 x n m 为输入图像 y n m 为输出图像 而z n m 为校正信号 一般是通过对x进行高通滤波获取 是用

  • Shader入门指南

    Unity3D Shader入门指南 一 分类 Unity3d2014 04 28 17 40 16人阅读 评论 0 收藏 举报 unity3dShader3d渲染 目录 本文转载自 http onevcat com 2013 07 sha

  • 25岁竟要求产品经验10年？我一直以为是个段子，没想到居然是真的

    你是不是以为工作3年要求有10年工作经验是个段子 今天告诉你这是真事儿 25岁要求工作经验10年 你好歹给人家工作5年的机会吧 这样也好说剩下的5年工作经验靠加班 HR这样说我没法接啊 哈哈 按照对方逻辑来 毕竟25岁都没有 相关工作经验最

  • TCP拥塞控制原理

    一 拥塞控制的一般原理 1 产生拥塞的原因 在某段时间 若对网络中某一资源的需求超过了该资源所能提供的可用部分 网络的性能就会变坏 即对资源的需求 可用资源 注意拥塞控制与流量控制的区别 拥塞控制是防止过多的数据注入网络中 使得网络中路由器

  • CentOS7平台命令安装Anaconda3、配置Python3开发环境

    要在 CentOS 7 上安装 Anaconda3 您可以按照以下步骤进行操作 1 下载 Anaconda3 安装包 首先 访问 Anaconda 官方网站以获取最新版本的 Anaconda3 安装包的下载链接 可以使用 wget 命令来下

  • 【数据库原理及应用教程(第4版

    文章目录 一 选择题 二 填空题 三 简答题 Reference 一 选择题 1 2 3 4 5 6 7 8 9 10 B C B D A 1 在 SQL Server 中不是对象的是 A 用户 B 数据 C 表 D 数据类型 2 声明了变

  • studio和solo哪个好_beats studio3 和solo3的区别再哪里？

    首先两款机子在外观上就有很大的区别 前者是solo3 后者是studio3 仔细观察可以发现solo3的耳罩比较小 是圆形的 studio3的是椭圆形的 两款都是头戴式 外观设计 录音师是包耳的 SOLO是压耳的 体积的话 录音师大 SOL

  • async与await

    async await 是ES7提出的基于Promise的解决异步的最终方案 一 async async是一个加在函数前的修饰符 被async定义的函数会默认返回一个Promise对象resolve的值 因此对async函数可以直接then

  • UI 自动化测试框架：PO 模式+数据驱动 【详解版】

    目录 1 PO 设计模式简介 什么是 PO 模式 PO 模式的优点 2 工程结构简介 工程结构 框架特点 3 工程代码示例 page 包 action 包 business process 包 util 包 conf 包 1 PO 设计模式

  • 基于Centos 7虚拟机的磁盘操作（添加磁盘、分区、格式分区、挂载）

    目录 一 添加硬盘 二 查看新磁盘 三 磁盘分区 3 1新建分区 3 2 格式分区 3 3 挂载分区 3 4 永久挂载新分区 3 5 取消挂载分区 一 添加硬盘 1 在虚拟机处选择编辑虚拟机设置 然后选择添加 2 选择硬盘 然后选择下一步

  • 敏捷宣言以及敏捷开发的特点

    敏捷宣言 敏捷宣言 也叫做敏捷软件开发宣言 正式宣布了对四种核心价值和十二条原则 可以指导迭代的以人为中心的软件开发方法 敏捷宣言强调的敏捷软件开发的四个核心价值是 个体和互动高于流程和工具 工作的软件高于详尽的文档 客户合作高于合同谈判

  • Go_流程、跳转控制语详解

    流程控制语句分类 流程控制语句可以控制代码的执行顺序和条件 顺序结构 普通的代码 由上而下依次执行 分支结构 if switch 循环结构 for if语句 条件表达式值必须是bool类型 不可省略括号 且左大括号不能另起一行 格式1 if

热门标签