Go语言学习Day3:数据类型、运算符与流程控制

名人说:莫愁千里路,自有到来风。 ------钱珝
创作者:Code_流苏(CSDN)(一个喜欢古诗词和编程的Coder😊)

目录

1、数据类型

①布尔类型

bool,表示逻辑值,可以是truefalse,例如一道判断读错的题,对就打√,错则写×,而这里的√就是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)
}
②整型

整型包括intint8int16int32int64以及它们的无符号版本uintuint8uint16uint32uint64。其中没有明确大小的intuint的大小依赖于执行程序的操作系统。

咱们常用的主要是int,例如一个人的年龄,年龄多大,这个数一般就是整型,整数:

go 复制代码
var age int = 18
fmt.Println("年龄:", age)
③浮点型

float32float64,分别对应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(选择)

基本的条件分支语句,可以使用elseelse 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语言的简洁性,一部分就体现在它的流程控制语句中:没有dowhile循环,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😊)
希望本篇内容能对大家有所帮助,如果大家喜欢的话,请动动手点个赞和关注吧,非常感谢你们的支持!

相关推荐
明月看潮生20 分钟前
青少年编程与数学 02-003 Go语言网络编程 15课题、Go语言URL编程
开发语言·网络·青少年编程·golang·编程与数学
明月看潮生26 分钟前
青少年编程与数学 02-003 Go语言网络编程 14课题、Go语言Udp编程
青少年编程·golang·网络编程·编程与数学
hlsd#2 小时前
go 集成go-redis 缓存操作
redis·缓存·golang
qq_1728055915 小时前
GIN 反向代理功能
后端·golang·go
__AtYou__16 小时前
Golang | Leetcode Golang题解之第535题TinyURL的加密与解密
leetcode·golang·题解
kevin_tech20 小时前
Go API 多种响应的规范化处理和简化策略
开发语言·后端·golang·状态模式
幺零九零零1 天前
【Golang】sql.Null* 类型使用(处理空值和零值)
数据库·sql·golang
cookies_s_s1 天前
Golang--DOS命令、变量、基本数据类型、标识符
golang
__AtYou__1 天前
Golang | Leetcode Golang题解之第541题反转字符串II
leetcode·golang·题解
flying robot1 天前
Go的JSON转化
golang