以下是记录我学习Go时练习的小程序段，接上篇，已经过编译通过，在此记录，以供翻阅复习
//关系运算符
package main
import "fmt"
func main(){
var a int=21
var b int=10
if (a == b){
fmt.Println("第一行 -a 等于 b\n")
}else {
fmt.Println("第一行 -a不等于 b\n")
}
if(a<b){
fmt.Println("第二行 -a 小于 b\n")
}else{
fmt.Println("第二行 -a不小于 b\n")
}
if(a>b){
fmt.Println("第三行 -a 大于 b\n")
}else{
fmt.Println("第三行 -a不大于 b\n")
}
a=5
b=20
if(a<=b){
fmt.Println("第四行 -a 小于等于 b\n")
}
if(b>=a){
fmt.Println("第五行 -b 大于等于 a\n")
}
}
//逻辑运算符
package main
import "fmt"
func main(){
var a bool = true
var b bool = false
if(a&&b){
fmt.Println("第一行-条件为true\n")
}
if(a||b){
fmt.Println("第二行 -条件为true\n")
}
//修改a和b 的值
a=false
b=true
if(a&&b){
fmt.Println("第三行 -条件为true\n")
}else{
fmt.Println("第三行 -条件为false\n")
}
if(!(a&&b)){
fmt.Println("第四行 -条件为true\n")
}
}
/*以上实例运行结果：
第二行 - 条件为 true
第三行 - 条件为 false
第四行 - 条件为 true
*/
//位运算符
package main
import "fmt"
func main(){
var a uint =60
var b uint=13
var c uint=0
c = a & b
fmt.Println("第一行 -c的值为\n",c)
c = a | b
fmt.Println("第二行 -c的值为\n",c)
c = a ^ b
fmt.Println("第三行 -c的值为\n",c)
c = a<<2
fmt.Println("第四行 -c的值为\n",c)
c = a>>2
fmt.Println("第五行 -c的值为\n",c)
}
/*以上实例运行结果：
第一行 - c 的值为 12
第二行 - c 的值为 61
第三行 - c 的值为 49
第四行 - c 的值为 240
第五行 - c 的值为 15*/
//赋值运算符
package main
import "fmt"
func main(){
var a int =21
var c int
c=a
fmt.Printf("第 1 行 - = 运算符实例，c 值为 = %d\n", c )
c+=a
fmt.Printf("第 2 行 - += 运算符实例，c 值为 = %d\n", c )
c-=a
fmt.Printf("第 3 行 - -= 运算符实例，c 值为 = %d\n", c )
c*=a
fmt.Printf("第 4 行 - *= 运算符实例，c 值为 = %d\n", c )
c/=a
fmt.Printf("第 5 行 - /= 运算符实例，c 值为 = %d\n", c )
c=200
c<<=2
fmt.Printf("第 6 行 - <<= 运算符实例，c 值为 = %d\n", c )
c>>=2
fmt.Printf("第 7 行 - >>= 运算符实例，c 值为 = %d\n", c )
c&=2
fmt.Printf("第 8 行 - &= 运算符实例，c 值为 = %d\n", c )
c|=2
fmt.Printf("第 9 行 - |= 运算符实例，c 值为 = %d\n", c )
c^=2
fmt.Printf("第 10 行 - ^= 运算符实例，c 值为 = %d\n", c )
}
/*
第 1 行 - = 运算符实例，c 值为 = 21
第 2 行 - += 运算符实例，c 值为 = 42
第 3 行 - -= 运算符实例，c 值为 = 21
第 4 行 - *= 运算符实例，c 值为 = 441
第 5 行 - /= 运算符实例，c 值为 = 21
第 6 行 - <<= 运算符实例，c 值为 = 800
第 7 行 - >>= 运算符实例，c 值为 = 200
第 8 行 - &= 运算符实例，c 值为 = 0
第 9 行 - |= 运算符实例，c 值为 = 2
第 10 行 - ^= 运算符实例，c 值为 = 0
*/
//其他运算符
//& 返回变量存储的地址
//* 指针变量
package main
import "fmt"
func main(){
var a int=4
var b int32
var c float32
var ptr *int
/*运算符实例*/
fmt.Printf("第 1 行 - a 变量类型为 = %T\n", a );
fmt.Printf("第 2 行 - b 变量类型为 = %T\n", b ); //%T返回类型
fmt.Printf("第 3 行 - c 变量类型为 = %T\n", c );
/* &和*运算符实例*/
ptr=&a
fmt.Printf("a 的值为 %d\n", a);
fmt.Printf("*ptr 为 %d\n", *ptr);
}
/*
第 1 行 - a 变量类型为 = int
第 2 行 - b 变量类型为 = int32
第 3 行 - c 变量类型为 = float32
a 的值为 4
*ptr 为 4
*/
//判断用户密码输入
package main
import "fmt"
func main(){
var a int
var b int
fmt.Println("请输入密码： \n")
fmt.Scan( &a ) //输入的数据记得用&引用
if a==1111111{
fmt.Println("请再次输入密码： ")
fmt.Scan( &b )
if b==1111111{
fmt.Println("密码正确，门锁已打开")
}else{
fmt.Println("非法入侵，已自动报警")
}
}else{
fmt.Println("非法入侵，已自动报警")
}
}
//switch语句 值或者判断
package main
import "fmt"
func main(){
/*定义局部变量*/
var grade string ="B"
var marks int =90
switch marks{
case 90:grade="A"
case 80:grade ="B"
case 50,60,70:grade="C"
default:grade ="D"
}
switch {
case grade=="A":
fmt.Println("优秀！\n")
case grade =="B",grade=="C":
fmt.Printf("良好\n" )
case grade=="D":
fmt.Printf("及格\n" )
case grade=="F":
fmt.Printf("不及格\n" )
default:
fmt.Printf("差\n" )
}
fmt.Printf("你的等级是%s\n",grade)
}
/*
优秀！
你的等级是A
*/
//TypeSwitch
//可以被用于 type-switch 来判断某个 interface 变量中实际存储的变量类型。
package main
import "fmt"
func main(){
var x interface{}
switch i:=x.(type){
case nil:
fmt.Printf(" x 的类型 :%T",i)
case int:
fmt.Printf("x 是 int 型")
case float64:
fmt.Printf("x 是 float64 型")
case func(int) float64:
fmt.Printf("x 是 func(int) 型")
case bool,string:
fmt.Printf("x 是 bool 或 string 型" )
default:
fmt.Println("未知型")
}
}
//以上代码执行结果为：
//x 的类型 :<nil>
//fallthrough会强制执行后面的case语句
//fallthrough不会判断下一条case的表达式是否为true
package main
import "fmt"
func main(){
switch {
case false:
fmt.Println("1>case条件为false")
fallthrough
case true:
fmt.Println("2>case 条件语句为true")
fallthrough
case false:
fmt.Println("3>case条件语句为false")
fallthrough
case true:
fmt.Println("4>case 条件语句是true")
case false:
fmt.Println("5>case条件语句为false")
fallthrough
default:
fmt.Println("6>默认case")
}
}
/*
以上代码执行结果为：
2、case 条件语句为 true
3、case 条件语句为 false
4、case 条件语句为 true
*/
/*从以上代码输出的结果可以看出：
switch 从第一个判断表达式为 true 的 case 开始执行，
如果 case 带有 fallthrough，程序会继续执行下一条 case，
且它不会去判断下一个 case 的表达式是否为 true。*/
//无限循环
package main
import "fmt"
func main(){
for true{
fmt.Println("这是无限循环\n")
}
}
//ctrl+C可退出