GO语言第二天(运算符和流程控制)

第一节：字符与字符串的区别

package main

import "fmt"

func main(){

// var a byte = 'a' 字符

// var b string = "b" 字符串

// 换行表示 \n \\ 表示一个\ 以便用于文件操作

// var b string = "hello\nworld" \n 自动换行

　　var b string = "hello\077world" //%s 遇到\0停止

//fmt.Println("%s",b)

　　fmt.Println(b)

　　//fmt .Println(a==b)

}

func main(){

　　//var str string = "hello word "

　　//在go语言一个汉字算作3个字符串，为了和linux统一处理

　　var str string = "不信你试试看看吧it"

　　//计算字符串个数

　　num := len(str)

　　fmt.Println(num)

}

第二节：占位符使用

package main

import "fmt"

func mian (){

　　//var a int64 =10

　　a := 10 //int

　　fmt.Printf("%d\n",a)

　　//var b float =10

b := 10.0 //float64

　　fmt.Printf("%f\n",b)

　　var c bool = true

　　fmt.Printf("%t\n",c)

　　var d byte = "A"

　　fmt.Printf("%c\n",d)

　　var e string = "hello"

　　fmt.Printf("%s\n",e)

　　fmt.Printf("%p\n",&a)

　　//%T 打印变量对应的数据类型　

　　fmt.Printf("%T\n",a)
　　fmt.Printf("%T\n",b)
　　fmt.Printf("%T\n",c)
　　fmt.Printf("%T\n",d)
　　fmt.Printf("%T\n",e)
　　//%% 会打印一个%
　　fmt.Printf("35%%")

}

func mian(){

　　//计算机能够识别的进制二进制八进制十进制十六进制

　　a:=123//十进制数据
　　b:=0123//八进制数据以0开头的数据是八进制
　　c:=0xabc//十六进制以0x开头的数据是十六进制
　　//go语言中不能直接表示二进制数据

　　//fmt.Println(a)
　　//fmt.Println(b)
　　//fmt.Println(c)
　　//%b 占位符表示输出一个二进制数据
　　//fmt.Printf("二进制值为：%b\n",a)
　　//fmt.Printf("二进制值为：%b\n",b)
　　//fmt.Printf("二进制值为：%b\n",c)
　　//%o 占位符表示输出一个八进制数据
　　//fmt.Printf("%o\n",a)
　　//fmt.Printf("%o\n",b)
　　//fmt.Printf("%o\n",c)
　　//%x %X 占位符表示输出一个十六进制数据

　　fmt.Printf("%X\n",a)

　　fmt.Printf("%X\n",b)

　　fmt.Printf("%X\n",c)

}

第3节：常量定义和使用

package main

import "fmt"

func mian(){

　　//常量定义和使用

　　//在程序运行过程中不能发生改变的量，称为常量

　　//常量的存储位置在数据区

　　//栈区系统为每一个程序分配1M的空间用来存储变量，在程序运行结束系统自动会释放

　　var s1 int = 10

　　var s2 int = 20

　　// 常量的存储位置在数据区不能通过& 取地址来访问

　　const a int = 10

　　fmt.Println(&s1)

　　fmt.Println(&s2)

　　//a=20//常量的值不允许修改

　　fmt.Println(a)

}

func mian(){

　　//常量一般用大写字母表示

　　const NAX int = 10

　　b := 20

　　c := NAX + b

　　fmt.Println(c)　

　　//字面常量

　　fmt.Println(123)

　　fmt.Println("hello world")

　　//硬常量 32

　　d:=c+32

　　e:="hello"

　　e=e+"world"

　　fmt.Println(d)

　　fmt.Println(e)

}

第四节：枚举iota

package main

iport "fmt"

func mian(){

const(

　　a = iota　　//iota = 0 静止每新增一航自动加一、重新定义跳转

　　b = iota // iota = 1 自动加以如果在同一行加一

　　// b = iota c = iota 则 b = c = iota = 1

　　c = iota 　　// iota = 2

　　d = iota // iota = 3

　　)

　　fmt.Println(a)

　　fmt.Println(b)

　　fmt.Println(c)　

　　fmt.Println(d)

　　//定义变量为状态

　　value := a

　　fmt.Println(value)

　　value = b

　　 fmt.Println(value)

}

func mian(){

　　// const(

　　//a = iota // iota = 0

　　// b // b = 1

　　// c // c = 2

　　//如果定义枚举是常量写在同一行值相同换一行值加一

　　//在定义枚举时可以为其赋初始值但是换行后不会根据值增长

　　)

　　const(

　　a = 10

　　b,c = iota,iota

　　d,e

　　)

　　fmt.Println(a)

　　fmt.Println(b)

　　fmt.Println(c)

　　fmt.Println(d)

　　fmt.Println(e)

}

第五节：算数运算符

package main

iport "fmt"

func mian(){

　　a := 10 // int

　　b := 0 // int

　　//整型数据相除结果为整型

　　//除数不能为0

　　c := a/b

　　fmt.Println(c)

}

// 取余运算

func mian(){

　　a := 10 　　// int

　　b := 2　　// int　

　　//取余运算符取模运算符

　　//取余运算符只能用于整型数据

　　//取余运算符除数不能为0

　　c := a%b

　　fmt.Println(c)

}

//自增自减运算符

func mian(){

　　a := 10 　　// int

　　// a = a+1

　　// ++ 　　只能写在变量的后面叫做后自增

　　// -- 　　只能写在变量的后面叫做后自减

　　//不能将自增自减运用在表达式中如 b --a 会报错误

　　fmt.Println(a)

}

第6节：类型转换

package main

iport "fmt"

func mian(){

　　a := 10

　　b := 3.99

　　//将不同类型转成同样类型计算操作

　　//类型转换格式数据类型（变量）数据类型（表达式）

　　// c := float64 (a) *b

　　//将浮点类型转成整数型数据，保留浮点整数部分，舍弃小数部分，不会进行四舍五入

　　c := a * int(b)

　　fmt>println(c)

}

func main(){

　　//虽然int 32和 int 64 都是整数类型单数不允许相互转换

　　//只有类型匹配的数据才能进行计算

　　// 在go语言中习惯将低类型转成高类型保证数据完整性

　　var a int32 = 10

　　var b int64 = 20

　　c := int64(a) + b

　　fmt.Println(c)

　　fmt.Println("%T",c)

}

func mian(){

　　//fmt.Printf("%周%天\n",46/7,46%7)

　　//编程实现107653秒是几天几小时几分钟几秒?

　　//miao:=107653

　　//fenzhong:=miao/60

　　//xiaoshi:=fenzhong/60

　　//tian:=xiaoshi/24

　　//time:=107653

　　//fmt.Println("天：",time/60/60/24%365)

　　/fmt.Println("时：",time/60/60%24)

　　//fmt.Println("分：",time/60%60)

　　//fmt.Println("秒：",time%60)

}

第7节：赋值运算符

package main

import "fmt"

func mian(){

　　a := 10

　　//a = a+5

　　//a +=5

　　//a -= 5

　　//a *= 5

　　//a /=5

　　// a % = 5 a = a%5

　　// a += 5*3 a = a + 5*3

　　// a += 5*a a = a+ 5*a

　　//a ++

　　b := a +5*a

　　fmt.Println(a)

　　fmt.Println(b)

}

第8节：比较运算符

package main

import "fmt"

func main(){

　　//关系运算用于程序中的逻辑判断返回值为布尔类型

　　a := 10

　　// b := 20

　　// == 两边相等两边一致如 a == a true a== b false

　　//fmt.Println(a == b) false

　　//fmt.Println(a <= b) true

　　fmt.Println(a <= b) true

}

第9节：逻辑运算符

package main

import "fmt"

func main(){

　　//逻辑非！非真为假非假为真

　　//只能对bool 类型变量或者bool类型表达使用逻辑非运算符

　　var a bool = false

　　a = true

　　b := 20

　　c := 20

　　fmt.Println(!(b==c)) // fmt.Println(!b) 报错 err

　　fmt.Println(!a)

}

func mian(){

　　// 逻辑与 && 表达式 1 && 表达式2 同真为真其余为假

　　a:=10

　　b:=20

　　c:=30

　　d:=20

　　fmt.Println(a>b && c<d)

}

func main(){

　　//逻辑或 || 表达式1 || 表达式2 同假为假其余为真

　　a:=10

　　b:=20

　　c:=30

　　d:=20

　　fmt.Println(a<b || c>d)

}

func mian(){

　　//去地址运算符

　　//var a int =10

　　//fmt.Println(&a)

　　a:=10

　　//指针变量

　　p:=&a

　　//* 取值运算符

　　fmt.Println(*p)

}

第10节:运算优先级

package main

import "fmt"

//第一优先级 括号 （） 结构体成员.  数组下标[]

//第二优先级 单目运算符

//第三优先级 逻辑非! 取地址& 取值* 自增++ 自减--


//第四优先级 双目运算符
//乘除 * / %
//加减 + -
//关系 == != > >= < <=
//逻辑 || &&
//赋值 = += -= *= /= %=

func main1002(){   var year int

   fmt.Println("请输入年份")
   fmt.Scan(&year)
   //1、能够被400整除 2、能够被4整除 不能被100整除
   //
   b:=year%400==0 || year %4==0 && year%100!=0
   fmt.Println(b)

}

第11节：if 条件语句

package mian 
import "fmt"
func mian(){

var score int
fmt.Scan(&score)

//if 条件判断根据是否满足条件指向对应的代码
//else 作为if 补充条件 如果条件不满足执行else代码
//格式 if 表达式{
// 代码体
// }else {
// 代码体
//}

if score >700 {
   fmt.Println("我要上清华")
} else{
   fmt.Println("我要上蓝翔")
}

func main(){
   a:=10
   if a>5{
      fmt.Println(a)
   }
   //采用就近原则 找到上面尚未配对的if进行匹配操作
   if a>8{
      fmt.Println(a)
   }else {
      fmt.Println("haha")
   }
}

func main(){
   //三只小猪称体重
   //a=10 b=8 c=12

   var a,b,c int
   fmt.Println("请输入三只小猪体重")
   fmt.Scan(&a,&b,&c)

   if a > b {
      if a>c{
         fmt.Println("a重")
      }else{
         fmt.Println("c重")
      }
   }else {
      if b>c{
         fmt.Println("b重")
      }else{
         fmt.Println("c重")
      }
   }
}

package main

import "fmt"

//if 可以嵌套 可以判断区间  执行效率比较低
//switch 执行效率高  不能嵌套和区间判断
func main() {

   var w int
   fmt.Scan(&w)
   //swich中的只不能是浮点型数据 浮点型数据是一个约等于的数据
   //switch 选择想可以是一个整型变量
   switch w {
   case 1:
      fmt.Println("星期一")
   case 2:
      fmt.Println("星期二")
   case 3:
      fmt.Println("星期三")
   case 4:
      fmt.Println("星期四")
   case 5:
      fmt.Println("星期五")
   case 6:
      fmt.Println("星期六")
   case 7:
      fmt.Println("星期日")
   //如果输入的值没有找到 默认进入default 中
   default:
      fmt.Println("输入错误")
   }

   //switch score>700 {
   //case true:
   // fmt.Println(score)
   //case false:
   // fmt.Println(score)
   //}
}
func main(){
   var score int
   fmt.Println("请输入分数")
   fmt.Scan(&score)

   switch score/10 {
   case 10:
      //fmt.Println("A")
      fallthrough//让switch执行下一个分支的代码  如果不写 执行到下一个分支就会自动停止
   case 9:
      fmt.Println("A")
   case 8:
      fmt.Println("B")
   case 7:
      fmt.Println("C")
   case 6:
      fmt.Println("D")
   default:
      fmt.Println("E")
   }
}

posted on 2021-02-22 20:53 闷骚熊猫阅读(44) 评论(0) 编辑收藏举报

刷新页面返回顶部

闷骚熊猫

导航

公告

GO语言第二天(运算符和流程控制)