名人说：莫愁千里路，自有到来风。 ------钱珝
创作者：Code_流苏(CSDN)（一个喜欢古诗词和编程的Coder😊）目录
1、数据类型
①布尔类型
bool，表示逻辑值，可以是true或false，例如一道判断读错的题，对就打√，错则写×，而这里的√就是true，×其实就是false，计算机里也一样，二进制，用0、1来代表对错，开关。
go
var isRight bool = true
if isRight {
fmt.Println("正确")
} else {
fmt.Println("错误")
}案例：布尔型
go
//创作者：Code_流苏(CSDN)
package main
import "fmt"
func main() {
//var 变量名 数据类型
//bool: true false
//bool 默认值为false
var isFlag bool = true
var isFlag2 bool = false
fmt.Println(isFlag)
//%T 用于输出一个值的类型
//%t 用于格式化布尔值 如果有一个布尔型变量 b，使用 fmt.Printf("%t", b) 会输出 b 的值为 true 或 false。
fmt.Printf("%T,%t\n", isFlag, isFlag)
fmt.Printf("%T,%t\n", isFlag2, isFlag2)
}
②整型
整型包括int、int8、int16、int32、int64以及它们的无符号版本uint、uint8、uint16、uint32、uint64。其中没有明确大小的int和uint的大小依赖于执行程序的操作系统。
咱们常用的主要是int，例如一个人的年龄，年龄多大，这个数一般就是整型，整数：
go
var age int = 18
fmt.Println("年龄:", age)③浮点型
float32和float64，分别对应IEEE 754标准的单精度和双精度浮点数，这两个是咱们日后学习中常用的。
例如，咱们日常生活中常常会谈及身高问题，而身高按米来算的话往往就会涉及小数部分，此时就可以使用浮点数来进行这些数据的处理。
go
var height float64 = 1.75
fmt.Println("身高:", height)案例：整型与浮点型。
go
package main
import "fmt"
func main() {
//定义一个整型
//byte uint8
//rune int32
//int int64
var age int = -200
fmt.Printf("%T,%d\n", age, age)
//定义一个浮点型
//默认是6位小数打印 3.140000
var money float64 = 3.19
fmt.Printf("%T,%.1f\n", money, money)
var num1 float32 = -123.0000901
var num2 float64 = -123.0000901
fmt.Println("num1 = ", num1, "num2 = ", num2)
}
④string
string，表示文本数据，相当于C++、Java里面的字符串类型。
案例：string类型。
go
package main
import "fmt"
func main() {
var str string
str = "Hello,yueliusu"
fmt.Printf("%T,%s\n", str, str)
// 单引号 字符，整型-ASCII字符码
v1 := 'A'
v2 := "A"
//编码表 ASCII码表
//扩展：
//所有的中国字的编码表：GBK
//全世界的编码表：Unicode
fmt.Printf("%T,%d\n", v1, v1) //int32,65
fmt.Printf("%T,%s\n", v2, v2)
//字符串连接 +
fmt.Println("hello" + ",liusu")
//转义字符\
fmt.Println("hello\"liusu")
fmt.Println("hello\nliusu") // n 换行符
fmt.Println("hello\tliusu") // t制表符
}
⑤类型转换
Go语言中要求显式的类型转换，使用形式如T(v)将值v转换为类型T，也就是你如果要转换类型，要给出指定的类型然后加()来转换。例如，将int类型的数据转换成float64类型。
go
var integer int = 10
var floatNumber float64 = float64(integer)
fmt.Println("转换后的浮点数:", floatNumber)案例：int与float64之间的类型转换。
go
package main
import "fmt"
func main() {
a := 3 //int
b := 5.0 //float64
//需求：将int类型的a转换为float64类型 类型转换
c := float64(a)
d := int(b)
//整型是不能转化为bool类型的
//e := bool(a)
fmt.Printf("%T\n", a)
fmt.Printf("%T\n", b)
fmt.Printf("%T\n", c)
fmt.Printf("%T\n", d)
}
需要注意的是，有些类型是不能相互转换的。
2、运算符
①算术运算符
算术运算符就是咱们日常所见到的加减乘除等 ，用符号表示就是：+、-、*、/、%等。
例如，5加2等于几？
go
fmt.Println("5 + 2 =", 5+2) //5 + 2 = 7案例：算术运算
go
package main
import "fmt"
func main() {
var a int = 10
var b int = 3
//算术运算符：+ - * / % ++ --
fmt.Println(a + b)
fmt.Println(a - b)
fmt.Println(a * b)
fmt.Println(a % b)
a++ // a++ 等同于 a = a + 1
fmt.Println(a) // 10 + 1 = 11
a-- //a-- 等同于 a = a - 1
fmt.Println(a) // 11 - 1 = 10
a = 100
a--
fmt.Println(a) // 100 - 1 = 99
}
②逻辑运算符
逻辑运算符，顾名思义，重在思维逻辑，与或非，对应符号与表达：&&（AND）、||（OR）、!（NOT），与的意思就是只有大家一起努力，这个项目才能完成，非的意思是，这个项目只要有人能完成，不论多少人，这个项目就是完成，非的意思就很明显了，非真即假。
例如，true与false
go
fmt.Println("true && false =", true && false) //false案例：逻辑运算
go
package main
func main() {
var a bool = false
var b bool = true
//逻辑与&& 同时为真
println(a && b)
//逻辑或|| 一个为真就成立
println(a || b)
//逻辑非，真为假，假为真
println(!a)
}
③关系运算符
关系运算符，重点在关系，既然涉及到关系，必然涉及的多者，比如1与2，张三与李四，男生与女生等等，常用的关系运算符有：==、!=、<、<=、>、>=。
例如，比较5与2的大小。
go
fmt.Println("5 > 2 =", 5 > 2) //true案例：11与10关系运算
go
package main
import "fmt"
func main() {
var a int = 11
var b int = 10
//关系运算符 == != > < >= <=
fmt.Println(a == b) //false
fmt.Println(a != b) //true
fmt.Println(a < b) //false
fmt.Println(a > b) //true
fmt.Println(a >= b) //true
fmt.Println(a <= b) //false
}
④位运算符
通过学习计组、操作系统，我们可以知道位运算是什么，因为计算机存储数据就是用的二进制01代码，而常说的一个二进制位，就是这里的位，位运算，也就是操控这些来进行的计算。对应的位运算符有：&（与 AND）、|（或 OR）、^（异或 XOR）、<<（左移）、>>（右移）。
详细来看，Go 语言支持的位运算符如下表所示。例如 A 为60，B 为13：
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 按位与运算符"&"是双目运算符。都是1结果为1，否则是0 | (A & B) 结果为 12, 二进制为 0000 1100 |
| | | 按位或运算符"|"是双目运算符。 都是0结果为0，否是是1 | (A | B) 结果为 61, 二进制为 0011 1101 |
| ^ | 按位异或运算符"^"是双目运算符。 不同则为1，相同为0 | (A ^ B) 结果为 49, 二进制为 0011 0001 |
| &^ | 位清空，a &^ b，对于b上的每个数值，如果为0，则取a对应位上的数值，如果为1，则取0. | (A &^ B) 结果为 48, 二进制为 0011 0000 |
| << | 左移运算符"<<"是双目运算符。左移n位就是乘以2的n次方。 其功能把"<<"左边的运算数的各二进位全部左移若干位，由"<<"右边的数指定移动的位数，高位丢弃，低位补0。 | A << 2 结果为 240 ，二进制为 1111 0000 |
| >> | 右移运算符">>"是双目运算符。右移n位就是除以2的n次方。 其功能是把">>"左边的运算数的各二进位全部右移若干位，">>"右边的数指定移动的位数。 | A >> 2 结果为 15 ，二进制为 0000 1111 |
又如5与2：
go
fmt.Println("5 & 2 =", 5&2) //0，解释：5的4位二进制为0101，2的4位2进制位0010，两者做&运算，结果为0000，也就是0。案例：位运算
go
package main
import "fmt"
func main() {
//60的二进制 0011 1100
var a uint = 60
//13的二进制 0000 1101
var b uint = 13
//位运算
var c uint = 0
//按位与 & 同1则1，其余为0
c = a & b
//0011 1100
//0000 1101
//0000 1100 = 12
fmt.Printf("%d,二进制形式为：%b \n", c, c)
//按位或 | 同0则0，其余为1
c = a | b
//0011 1100
//0000 1101
//0011 1101 = 61
fmt.Printf("%d,二进制形式为：%b \n", c, c)
//按位异或 ^ 不同为1，相同为0
c = a ^ b
fmt.Printf("%d,二进制形式为：%b \n", c, c)
//按位清空 &^ 对于b上的每位数值，若为0，则取a对应位上的数值，若为1，则取0
c = a &^ b
fmt.Printf("%d,二进制形式为：%b \n", c, c)
//左移运算符 << 为双目运算符，左移n位就是乘以2的n次方
c = a << 2
fmt.Printf("%d,二进制形式为：%b \n", c, c)
//右移运算符 >> 为双目运算符，右移n位就是除以2的n次方
c = a >> 2
fmt.Printf("%d，二进制形式为:%b \n", c, c)
}
⑤赋值运算符
赋值运算符，类似于超市里有很多商品，需要赋予这些商品价值，而价值也可以通过价格来体现，价格就看做所赋予的值。赋值运算符常见的有：=、+=、-=、*=、/=等。
| 运算符 | 描述 | 实例 |
|---|---|---|
| = | 简单的赋值运算符，将一个表达式的值赋给一个左值 | C = A + B 将 A + B 表达式结果赋值给 C |
| += | 相加后再赋值 | C += A 等于 C = C + A |
| -= | 相减后再赋值 | C -= A 等于 C = C - A |
| *= | 相乘后再赋值 | C *= A 等于 C = C * A |
| /= | 相除后再赋值 | C /= A 等于 C = C / A |
| %= | 求余后再赋值 | C %= A 等于 C = C % A |
| <<= | 左移后赋值 | C <<= 2 等于 C = C << 2 |
| >>= | 右移后赋值 | C >>= 2 等于 C = C >> 2 |
| &= | 按位与后赋值 | C &= 2 等于 C = C & 2 |
| ^= | 按位异或后赋值 | C ^= 2 等于 C = C ^ 2 |
| |= | 按位或后赋值 | C |= 2 等于 C = C | 2 |
例如，10+5
go
var a int = 10
a += 5
fmt.Println("a =", a) //15案例：赋值运算
go
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)
}
⑥其它运算符
其它运算符还有用于指针的&（取地址）和*（指针解引用）等。
| 运算符 | 描述 | 实例 |
|---|---|---|
| & | 返回变量存储地址 | &a; 将给出变量的实际地址。 |
| * | 指针变量。 | *a; 是一个指针变量 |
案例：& 与 *
go
package main
import "fmt"
func main() {
var a int = 4
var b int32
var c float32
var ptr *int
//& 返回变量存储地址 例如：&a; 取的是变量的实际地址
//* 指针变量 例如：*a; a是一个指针变量
/* 运算符实例 */
fmt.Printf("1、a的变量类型为 %T \n", a)
fmt.Printf("2、b的变量类型为 %T \n", b)
fmt.Printf("3、c的变量类型为 %T \n", c)
/* & 和 * 运算符实例 */
ptr = &a /* 'ptr'接收了变量a的地址*/
fmt.Printf("a的值为：%d\n", a)
fmt.Printf("ptr的值为 %p\n", ptr)
fmt.Printf("*ptr为%d\n", *ptr)
}
3、流程控制
常见的结构主要有三种，顺序、选择、循环结构。如：
go
package main
func main() {
//1、顺序结构：从上到下，逐行执行，默认逻辑
//2、选择结构：条件满足某些代码才会执行 (满足某些条件)
//if
//switch
//select 后面channel再讲
//3、循环结构：条件满足某些代码被反复执行0到n次
//for
}顺序结构，咱们平时写代码、写作等顺序往往就是顺序结构，一个接着一个来，此处不再多讲，重点叙述一下选择结构和循环结构。
①if（选择）
基本的条件分支语句，可以使用else和else if来扩展。
- if
go
if score >= 90 {
fmt.Println("A")
} - if ... else
go
if age := 18; age >= 18 {
fmt.Println("成年")
} else {
fmt.Println("未成年")
}- if ... else if
案例1：分数评级
go
package main
import "fmt"
// if 如果 else if 否则如果 else否则
func main() {
//var a int = 15
//
//if a > 20 {
// fmt.Println("a>20")
//}
//if a > 10 {
// fmt.Println("a>10")
//}
var score int
println("请输入分数：")
fmt.Scanf("%d", &score)
//评级 A B C D E
if score >= 90 && score <= 100 {
fmt.Println("A")
} else if score >= 80 && score < 90 {
fmt.Println("B")
} else if score >= 78 && score < 80 {
fmt.Println("C")
} else if score >= 60 && score < 70 {
fmt.Println("D")
} else {
fmt.Println("E")
}
}
案例2：if嵌套，登录判断
go
//创作者：Code_流苏(CSDN)
package main
import "fmt"
func main() {
var a, b int
var pwd int = 20221020
//用户的输入
fmt.Print("请输入密码：")
fmt.Scan(&a)
//业务：验证密码是否正确
if a == pwd {
fmt.Print("请再次输入密码：")
fmt.Scan(&b)
if b == pwd {
fmt.Println("登录成功")
} else {
fmt.Println("登录失败，账户已锁定")
}
} else {
fmt.Println("登录失败，密码错误")
}
}
②switch（选择）
用于基于不同的条件执行不同的代码块。Go的switch比其他语言更为灵活，表达式不必为常量或整数。
例如，星期几
go
dayOfWeek := 3
switch dayOfWeek {
case 1:
fmt.Println("星期一")
case 2:
fmt.Println("星期二")
default:
fmt.Println("其他天")
}案例1：成绩评级
go
package main
import "fmt"
func main() {
var score int
fmt.Scanf("%d", &score)
//Switch匹配 case
switch score {
case 90:
fmt.Println("A")
case 80:
fmt.Println("B")
case 50, 60, 70:
fmt.Println("C")
default:
fmt.Println("D")
}
}
案例2：fallthrough关键字
如果在 case 的代码块中使用了 fallthrough 关键字，即使这个 case 匹配成功，程序也会继续执行下一个 case 的代码块。
go
package main
import "fmt"
// 如果在 case 的代码块中使用了 fallthrough 关键字，
// 即使这个 case 匹配成功，程序也会继续执行下一个 case 的代码块。
func main() {
var num int = 1
switch num {
case 1:
fmt.Println("one")
fallthrough
case 2:
fmt.Println("two")
case 3:
fmt.Println("three")
default:
fmt.Println("other number")
}
}
③for（循环）
Go语言中唯一的循环结构，可以用来实现传统的for循环、while循环（通过for实现）、无限循环（省略循环条件）。
例如，输出循环次数
go
for i := 0; i < 5; i++ {
fmt.Println("循环次数:", i)
}案例：计算1到100的和
go
package main
func main() {
//for 条件的起始值：循环条件：控制变量自增或者自减
//如果是全部省略，for {}的形式，循环将会因为没有条件的限制而一直进行下去
sum := 0
//计算1到100的和
for i := 1; i <= 100; i++ {
sum = sum + i
}
println(sum)
}
案例2：打印5*5方阵
go
package main
import "fmt"
/*打印一个5×5的*方阵
*****
*****
*****
*****
*****
*/
func main() {
for i := 0; i < 5; i++ {
for j := 0; j < 5; j++ {
fmt.Print("*")
}
fmt.Print("\n")
}
}
案例3：打印9*9乘法表
go
package main
import "fmt"
// 目标：使用for循环打印99乘法表
func main() {
// j 1 2 3
for i := 1; i <= 9; i++ {
for j := 1; j <= i; j++ {
fmt.Printf("%d*%d=%d\t", j, i, i*j)
}
println()
}
}
④break & continue
break用于中断当前循环，continue用于跳过当前循环的剩余代码，直接开始下一次循环迭代。
例如，输出1到5之间的奇数。
go
for i := 0; i < 10; i++ {
if i == 5 {
break // 中断循环
}
if i%2 == 0 {
continue // 跳过本次循环迭代
}
fmt.Println("奇数:", i)
}案例：break & continue
go
//创作者：Code_流苏(CSDN)
package main
import "fmt"
func main() {
//break 结束当前整个循环
for i := 1; i <= 10; i++ {
if i == 5 {
break
}
fmt.Println(i)
}
println("break内容结束")
//continue 结束单次循环
for i := 1; i <= 10; i++ {
if i == 5 {
continue
}
fmt.Println(i)
}
println("continue内容结束")
}
综上来看，Go语言的简洁性，一部分就体现在它的流程控制语句中：没有do或while循环，switch比许多其他语言更加强大且灵活。
4、总结
分支结构
-
if
-
if ... else if
-
if ... else
-
if ... else if ... else if ... else if... else
-
swtich - case
-
swtich - case - fallthrough
-
swtich - case - default
循环
- for init；end；post {}
- for { } 死循环
- break
- continue
- for循环的嵌套使用。
很感谢你能看到这里，如有相关疑问，还请下方评论留言。
Code_流苏(CSDN) （一个喜欢古诗词和编程的Coder😊）
希望本篇内容能对大家有所帮助，如果大家喜欢的话，请动动手点个赞和关注吧，非常感谢你们的支持！