go基础之逻辑运算与条件判断（中）

运算符介绍

运算符是一种特殊符号，用以表示数据的运算、赋值和比较

1）算术运算符

2）赋值运算符

3）比较运算符

4）逻辑运算符

5）位运算符

6）其他运算符

算术运算符介绍

算术运算符是对数值类型的变量进行运算的，如：加减乘除。在go程序中使用的非常多

示例1

package main

import (
	"fmt"
	_"strconv"
)

 func main(){
	//重点讲解/ %
	//说明，如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
	fmt.Println(10/4)
	var n1 float32 = 10 / 4
	fmt.Println("n1 =",n1)
	// 希望小数保留小数部分，则需要有浮点数参与运算
	var n2 float32 = 10.0 / 4
	fmt.Println("n2 =", n2)

}
// 执行结果
// 2
// n1 = 2
// n2 = 2.5

　　示例2

package main

import (
	"fmt"
	_"strconv"
)

 func main(){
	//重点讲解/ %
	//说明，如果运算的数都是整数，那么除后，去掉小数部分，保留整数部分
	fmt.Println(10/4)
	var n1 float32 = 10 / 4
	fmt.Println("n1 =",n1)
	// 希望小数保留小数部分，则需要有浮点数参与运算
	var n2 float32 = 10.0 / 4
	fmt.Println("n2 =", n2)
	//%
	//公式a%b=a-a/b*b
	fmt.Println("10%3",10%3)
	fmt.Println("-10%3",-10%3)//-1
	fmt.Println("10%-3",10%-3)//1
	fmt.Println("-10%-3",-10%-3) //-1
	var i int = 10
	i ++ 
	fmt.Println("i=",i)
	i -- 
	fmt.Println("i=",i)

}
// 执行结果
// 2
// n1 = 2
// n2 = 2.5
// 10%3 1
// -10%3 -1
// 10%-3 1
// -10%-3 -1
// i= 11
// i= 10

　　细节说明

1）对于除号“/”,它的整数除和小数除有区别；整数之间做除数时，只保留整数部分而舍弃小数部分

2）当对一个数取模时，可以等价a%b=a-a/b*b,这样我们可以看的取模的一个本质运算

3）Golang 的自增自减只能当做一个独立语言使用，不能b:= a++;b:=a--

4)Golang 的++ 和-- 只能写在变量后面，不能写在变量前面，即: a++ a--

5)Golang的设计者去掉c/java 中的自增自减的容易混淆的写法，让Golang更加简洁统一（强制性的）

示例

package main

import (
	"fmt"
)

 func main(){
	var t int = 97
	r := t / 7
	c := t % 7

	fmt.Printf("还剩%v个星期,零%v天\n",r,c) 
	var h float32 =134.2
	var s float32 = 5.0 / 9*(h-100)
	fmt.Printf("%v 对应的摄氏温度=%v\n",h,s)
	}

// 执行结果
// 还剩13个星期,零6天
// 134.2 对应的摄氏温度=19

　　关系运算符

1）关系运算符的结果都是bool型，也就是要么true，要么是false

2) 关系表达式经常用在if结构的条件中或循环结构的条件中

示例

package main

import (
	"fmt"
)

 func main(){
	//演示关系运算符

	var n1 int = 9
	var n2 int = 8
	fmt.Println(n1==n2)//false
	fmt.Println(n1!=n2)//true
	fmt.Println(n1>n2)//true
	fmt.Println(n1>=n2)//true
	fmt.Println(n1<n2)//false
	fmt.Println(n1<=n2)//false

}

　　细节

1）关系运算符的结果都是bool

2）关系运算符组成的表达式，我们称为关系表达式： a>b

3) 比较运算符“==”不能写成“=”

逻辑运算符

介绍

用于连接多个条件（一般讲就是关系表达式），最终的结果也是bool值

逻辑运算符一览

假定A值为true，B值为false

示例

package main

import (
	"fmt"
)

 func main(){
	//逻辑运算符的使用
	var age int = 40
	if age > 30 && age < 50 {
		fmt.Println("正值青年")
	}
	if age > 30 && age < 40 {
		fmt.Println("正值壮年")
	}
	if age > 30 || age < 50 {
		fmt.Println("正值青年")
	}
	if age > 30 || age < 40 {
		fmt.Println("正值壮年")
	}
	if age > 30 {
		fmt.Println("ok5")
	}
	if !(age>30) {
		fmt.Println("ok6")
	}

}
//执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo20\main.go
// 正值青年
// 正值青年
// 正值壮年
// ok5

　　注意事项与说明

1）&& 也叫短路与：如果第一个条件为false，则第二个条件不会判断，最终结果为false

2）||也叫短路或，如果第一个条件为true，则第二个条件不会判断，最终结果为true

示例

package main

import (
	"fmt"
)
// 声明一个函数
func test() bool{
	fmt.Println("test........")
	return true
}
 func main(){
	//逻辑运算符的使用
	var i int = 10
	//短路与
	if i < 9 && test(){
		fmt.Println("ok....")
	} 
	//短路或
	if i < 9 || test(){
		fmt.Println("hello....")
	} 
}
//执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo20\main.go
// test........
// hello....

　　赋值运算

介绍：赋值运算符就是将某个运算后的值，赋给指定的变量

赋值运算符的分类

示例

package main

import (
	"fmt"
)

func main(){
	//var i int
	//i = 10
	//交换两个值
	a := 9
	b := 2
	fmt.Println("a=",a,"b=",b)
	//临时变量
	t := a
	a = b
	b = t
	fmt.Println("a=",a,"b=",b)
	//复合型赋值的操作
	a +=17
	fmt.Println("a=",a)
}

//执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo21\main.go
// a= 9 b= 2
// a= 2 b= 9
// a= 19

　　交换两个值

package main

import (
	"fmt"
	//"src01/demo16/test"
)

func main(){
	//基本赋值
	// var i int
	// i = 10 //基本赋值
	// 交换两个变量 
	var a int = 10
	var b int = 20
	fmt.Println(a)
	fmt.Println(b)
	a = a + b
	b = a - b
	a = a - b
	fmt.Println(a)
	fmt.Println(b)

}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo23\main.go
// 10
// 20
// 20
// 10

交换两个变量的值 a,b = b,a

package main

import (
	"fmt"
	//"src01/demo16/test"
)

func main(){
	//基本赋值
	// var i int
	// i = 10 //基本赋值
	// 交换两个变量 
	var a int = 10
	var b int = 20
	fmt.Println(a)
	fmt.Println(b)

	a,b = b,a//交换两个变量的值
	
	fmt.Println(a)
	fmt.Println(b)

}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo23\main.go
// 10
// 20
// 20
// 10

　赋值运算符的特点

1）运算顺序从右向左

2）赋值运算符的左边，只能是变量，右边可以是变量表达式，常量值

3）复合赋值运算符等价于下面效果

a+=3 等价a=a+3

运算符优先级问题

1）运算符有不同的优先级，所谓优先级就是表达式运算中的顺序。如右表，上述一行运算符总优先于下一行

2）只有单目运算符，赋值运算符是从右向左运算的

3）大致的顺序整理

1.括号，++，--

2：单目运算

3：算术运算

4：移位运算

5：关系运算

6：位运算

7：逻辑运算

8：赋值运算符

9：逗号

位运算符

其他运算符

示例

package main

import (
	"fmt"
	//"src01/demo16/test"
)

func main(){
	
	a := 100
	fmt.Println("a的地址值",&a)
	var ptr *int = &a
	fmt.Println("ptr 指向的值是=", *ptr)


}

// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo22\main.go
// a的地址值 0xc00000a0a8
// ptr 指向的值是= 100

　　特别说明；go 语言不支持三元运算符

示例

package main

import (
	"fmt"
	//"src01/demo16/test"
)

func main(){
	
	a := 100
	fmt.Println("a的地址值",&a)
	var ptr *int = &a
	fmt.Println("ptr 指向的值是=", *ptr)
	var n int
	var i int  = 10
	var j int  = 12
	if i > j {
		n= i
	}else{
		n = j
	}
	fmt.Println(n)

}

// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo22\main.go
// a的地址值 0xc00000a0a8
// ptr 指向的值是= 100
// 12

　　求两个数最大值；三个数最大值

package main

import (
	"fmt"
	//"src01/demo16/test"
)

func main(){
	//var y int
	var q int = 5
	var w int = 9
	fmt.Println("两个数最大值")
	if q > w {
		fmt.Println("最大值：",q)
	}else{
		fmt.Println("最大值：",w)
	}
	fmt.Println("三个数最大值")
	d := 8
	c := 4
	f := 9
	var y int 
	if d > c {
		y = d
	}else{
		y = c
	}
	if f >y{
		y = f
	}
	fmt.Println("最大值",y)

}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo24\main.go
// 两个数最大值
// 最大值： 9
// 三个数最大值
// 最大值 9

　　键盘输入语句

介绍在编程中，需要接收用户输入的数据，就可以使用键盘输入语句来获取

步骤：

1）导入fmt包

2）调用fmt包的fmt.Scanln() 或者fmt.Scanf()

示例1

package main

import (
	"fmt"
	//"src01/demo16/test"
)

func main(){
	//声明变量
	var name string
	var age byte
	var sal float32
	var isPass bool
	
	fmt.Println("请输入姓名")
	fmt.Scanln(&name)
	fmt.Println("请输入年零")
	fmt.Scanln(&age)
	fmt.Println("请输入薪水")
	fmt.Scanln(&sal)
	fmt.Println("请输入是否通过考试(true/false)")
	fmt.Scanln(&isPass)
	fmt.Printf("名字是%v \n年龄是%v \n薪水是%v \n是否通过考试%v \n",name,age,sal,isPass)

}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo25\main.go
// 请输入姓名
// 晨曦
// 请输入年零
// 18  
// 请输入薪水
// 1900
// 请输入是否通过考试(true/false)
// true
// 名字是晨曦 
// 年龄是18
// 薪水是1900
// 是否通过考试true

　　示例2

package main

import (
	"fmt"
	//"src01/demo16/test"
)

func main(){
	//声明变量
	var name string
	var age byte
	var sal float32
	var isPass bool


	fmt.Println("请输入你的姓名，年龄，薪水，是否通过考试，输入时用空格隔开")
	fmt.Scanf("%s %d %f %t", &name, &age, &sal, &isPass)
	 fmt.Printf("名字是%v \n年龄是%v \n薪水是%v \n是否通过考试%v \n",name,age,sal,isPass)


}
// 执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo25\main.go
// 请输入你的姓名，年龄，薪水，是否通过考试，输入时用空格隔开
// 晨曦 19 1900 true
// 名字是晨曦 
// 年龄是19
// 薪水是1900
// 是否通过考试true

　　进制

进制介绍

对于整数，有四种表示方式

1）二进制：0,1，满2进1

2）十进制：0-9，满10进1

3）八进制：0-7，满8进1 以数字0开头

4）十六进制：0-9及A-F，满16进1，以0x或0X开头表示此处的A-F不区分大小写

原码反码补码

与或异或

示例

package main

import (
	"fmt"
	//"src01/demo16/test"
)

func main(){

	//位运算
	fmt.Println(2&3)
	fmt.Println(2|3)
	fmt.Println(2^3)
	fmt.Println(2^-2)
	//fmt.Println(2^3)
	//fmt.Println(2^3)






}
//执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo27\main.go
// 2
// 3
// 1
// -4

　　位运算符和移位运算符

golang 中有2个移位运算符

>>、<< 右移和左移

右移运算符>>：低位溢出，符号位不变，并用符号位补溢出的高位

左移运算符<<: 符号位不变，低位补0

示例

package main

import (
	"fmt"
	//"src01/demo16/test"
)

func main(){


        a:=1>>2
	c:=1<<2
	fmt.Println("a=",a,"c=",c)




}
//执行结果
// PS D:\golang\goproject\src\src01\go_code> go run src\chapter03\demo27\main.go
// a= 0 c= 4

posted @ 2026-02-27 20:40 烟雨楼台，行云流水阅读(7) 评论(0) 收藏举报

刷新页面返回顶部

尘曦一期一会

尽自己最大的努力，剩下的交给缘分

go基础之逻辑运算与条件判断（中）

公告