分门别类输入输出,Go lang1.18入门精炼教程,由白丁入鸿儒,go lang基本数据类型和输入输出EP03

简介: 前文再续,Go lang和Python一样,基础数据类型有着很多分类,分门别类,一应俱全。它们对应着不同的使用场景,分别是:整形、浮点、字符、字符串、布尔等等。常用的基本数据类型经常会参与日常业务逻辑的运算、判断以及输入输出操作。

前文再续,Go lang和Python一样,基础数据类型有着很多分类,分门别类,一应俱全。它们对应着不同的使用场景,分别是:整形、浮点、字符、字符串、布尔等等。常用的基本数据类型经常会参与日常业务逻辑的运算、判断以及输入输出操作。

整形 int

整形顾名思义,就是存储的数据类型是整数,Go lang中分为有符号和无符号,简单理解就是存储范围上的差异:

有符号整型:int8、int16、int32、int64、int。

无符号整型:uint8、uint16、uint32、uint64、uint。

package main  
  
import (  
    "fmt"  
    "math"  
    "unsafe"  
)  
  
// 有符号整型  
func Integer() {  
    var num8 int8 = 127  
    var num16 int16 = 32767  
    var num32 int32 = math.MaxInt32  
    var num64 int64 = math.MaxInt64  
    var num int = math.MaxInt  
    fmt.Printf("num8的类型是 %T, num8的大小 %d, num8是 %d\n",  
        num8, unsafe.Sizeof(num8), num8)  
    fmt.Printf("num16的类型是 %T, num16的大小 %d, num16是 %d\n",  
        num16, unsafe.Sizeof(num16), num16)  
    fmt.Printf("num32的类型是 %T, num32的大小 %d, num32是 %d\n",  
        num32, unsafe.Sizeof(num32), num32)  
    fmt.Printf("num64的类型是 %T, num64的大小 %d, num64是 %d\n",  
        num64, unsafe.Sizeof(num64), num64)  
    fmt.Printf("num的类型是 %T, num的大小 %d, num是 %d\n",  
        num, unsafe.Sizeof(num), num)  
}  
  
// 无符号整型  
func unsignedInteger() {  
    var num8 uint8 = 128  
    var num16 uint16 = 32768  
    var num32 uint32 = math.MaxUint32  
    var num64 uint64 = math.MaxUint64  
    var num uint = math.MaxUint  
    fmt.Printf("num8的类型是 %T, num8的大小 %d, num8是 %d\n",  
        num8, unsafe.Sizeof(num8), num8)  
    fmt.Printf("num16的类型是 %T, num16的大小 %d, num16是 %d\n",  
        num16, unsafe.Sizeof(num16), num16)  
    fmt.Printf("num32的类型是 %T, num32的大小 %d, num32是 %d\n",  
        num32, unsafe.Sizeof(num32), num32)  
    fmt.Printf("num64的类型是 %T, num64的大小 %d, num64是 %d\n",  
        num64, unsafe.Sizeof(num64), num64)  
    fmt.Printf("num的类型是 %T, num的大小 %d, num是 %d\n",  
        num, unsafe.Sizeof(num), num)  
}  
  
func main() {  
    Integer()  
    println("---------------------------------------")  
    unsignedInteger()  
}

程序返回:

num8的类型是 int8, num8的大小 1, num8是 127  
num16的类型是 int16, num16的大小 2, num16是 32767  
num32的类型是 int32, num32的大小 4, num32是 2147483647  
num64的类型是 int64, num64的大小 8, num64是 9223372036854775807  
num的类型是 int, num的大小 8, num是 9223372036854775807  
---------------------------------------  
num8的类型是 uint8, num8的大小 1, num8是 128  
num16的类型是 uint16, num16的大小 2, num16是 32768  
num32的类型是 uint32, num32的大小 4, num32是 4294967295  
num64的类型是 uint64, num64的大小 8, num64是 18446744073709551615  
num的类型是 uint, num的大小 8, num是 18446744073709551615

这里我们使用fmt.Printf将对应的整形数据类型打印出来,和Println不同的是,Printf可以使用通配符将变量嵌入到打印语句中,但也需要注意类型的一致性:

%%    一个%字面量  
%b    一个二进制整数值(基数为 2),或者是一个(高级的)用科学计数法表示的指数为 2 的浮点数  
%c    字符型。可以把输入的数字按照 ASCII 码相应转换为对应的字符  
%d    一个十进制数值(基数为 10)  
%f    以标准记数法表示的浮点数或者复数值  
%o    一个以八进制表示的数字(基数为 8)  
%p    以十六进制(基数为 16)表示的一个值的地址,前缀为 0x,字母使用小写的 a-f 表示  
%q    使用 Go 语法以及必须时使用转义,以双引号括起来的字符串或者字节切片[]byte,或者是以单引号括起来的数字  
%s    字符串。输出字符串中的字符直至字符串中的空字符(字符串以’\0‘结尾,这个’\0’即空字符)  
%t    以 true 或者 false 输出的布尔值  
%T    使用 Go 语法输出的值的类型  
%x    以十六进制表示的整型值(基数为十六),数字 a-f 使用小写表示  
%X    以十六进制表示的整型值(基数为十六),数字 A-F 使用小写表示

一般情况下,在32位系统下是采用32位整形, 64 位系统下则是64位整形。

浮点 float

浮点型表示存储的数据是实数,比如 3.1415926。

package main  
  
import (  
    "fmt"  
    "math"  
)  
  
func showFloat() {  
    var num1 float32 = math.MaxFloat32  
    var num2 float64 = math.MaxFloat64  
    fmt.Printf("num1的类型是%T,num1是%g\n", num1, num1)  
    fmt.Printf("num2的类型是%T,num1是%g\n", num2, num2)  
}  
  
func main() {  
    showFloat()  
}

程序返回:

num1的类型是float32,num1是3.4028235e+38  
num2的类型是float64,num1是1.7976931348623157e+308

我们还可以针对浮点进行保留小数操作,比如百分位展示:

package main  
  
import (  
    "fmt"  
    //"math"  
    "reflect"  
    "strconv"  
)  
  
func showFloat() {  
  
    numF := 3.1415926  
    value, _ := strconv.ParseFloat(fmt.Sprintf("%.2f", numF), 64)  
    fmt.Println(reflect.TypeOf(value), value)  
}  
  
func main() {  
    showFloat()  
}

程序返回:

float64 3.14

字符 byte/rune

组成字符串的每一个元素叫做字符:

package main  
  
import (  
    "fmt"  
    //"math"  
    //"reflect"  
    "unsafe"  
)  
  
func showChar() {  
    var x byte = 65  
    var y uint8 = 65  
    fmt.Printf("x = %c\n", x) // x = A  
    fmt.Printf("y = %c\n", y) // y = A  
}  
  
func sizeOfChar() {  
    var x byte = 65  
    fmt.Printf("x = %c\n", x)  
    fmt.Printf("x 占用 %d 个字节\n", unsafe.Sizeof(x))  
  
    var y rune = 'A'  
    fmt.Printf("y = %c\n", y)  
    fmt.Printf("y 占用 %d 个字节\n", unsafe.Sizeof(y))  
}  
  
func main() {  
    showChar()  
    sizeOfChar()  
}

系统输出:

x = A  
y = A  
x = A  
x 占用 1 个字节  
y = A  
y 占用 4 个字节

一望而知,byte 类型只能表示 28个值,所以你想表示其他一些值,例如中文的话,就得使用 rune 类型。

字符串 string

字符串几乎是最常用的数据类型之一,使用起来也很方便:

package main  
  
import (  
    "fmt"  
)  
  
func main() {  
  
    mystring := "hello\tgolang1.18"  
  
    fmt.Println(mystring)  
  
}

有些字符串没有现成的文字代号,所以只能用转义字符来表示,比如这里的\t。

布尔 bool

布尔通常情况下表示真或者假,通常出现在条件语句中:

package main  
  
import (  
    "fmt"  
)  
  
func showBool() {  
    a := true  
    b := false  
    fmt.Println("a=", a)  
    fmt.Println("b=", b)  
    fmt.Println("true && false = ", a && b)  
    fmt.Println("true || false = ", a || b)  
}  
  
func main() {  
    showBool()  
}

程序返回:

a= true  
b= false  
true && false =  false  
true || false =  true

在Python中,布尔数据类型可以参与数值运算,也可以与其他类型进行转换。但是在 Go 中,真值是用 true 表示,并且 不与 1 相等;同样地,假值是用 false 表示,并且不与 0 相等,使用上相对严格,没有Python那么挥洒自如。

数据运算

常见的数学运算符:

+ - * / %(求余) ++ --

常见的比较运算符:

== != > < >= <=

逻辑运算符:

&&    所谓逻辑与运算符。如果两个操作数都非零,则条件变为真  
||    所谓的逻辑或操作。如果任何两个操作数是非零,则条件变为真  
!    所谓逻辑非运算符。使用反转操作数的逻辑状态。如果条件为真,那么逻辑非操后结果为假

以及位运算:

&    二进制与操作副本位的结果,如果它存在于两个操作数    (A & B) = 12, 也就是 0000 1100  
|    二进制或操作副本,如果它存在一个操作数    (A | B) = 61, 也就是 0011 1101  
^    二进制异或操作副本,如果它被设置在一个操作数就是按位取非    (A ^ B) = 49, 也就是 0011 0001  
&^    二进制位清空&^    (A&^B)=48,也就是110000  
<<    二进制左移位运算符。左边的操作数的值向左移动由右操作数指定的位数    A << 2 =240 也就是 1111 0000  
>>    二进制向右移位运算符。左边的操作数的值由右操作数指定的位数向右移动    A >> 2 = 15 也就是 0000 1111

最后是赋值运算符:

=    简单的赋值操作符,分配值从右边的操作数左侧的操作数    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

和Python如出一辙,Golang在数据运算方面的设计相对克制,不像Ruby,语法糖如繁星满天,数不数胜。

基本数据的输入输出

Go lang可以捕获到用户在终端的数据输入:

package main  
  
import (  
    "fmt"  
)  
  
func main() {  
    var x int  
    var y float64  
    fmt.Println("请输入一个整数,一个浮点类型:")  
    fmt.Scanln(&x, &y) //读取键盘的输入,通过操作地址,赋值给x和y   阻塞式  
    fmt.Printf("x的数值:%d,y的数值:%f\n", x, y)  
  
    fmt.Scanf("%d,%f", &x, &y)  
    fmt.Printf("x:%d,y:%f\n", x, y)  
}

终端运行:

C:\Users\liuyue\www\tornado6>go run test.go  
请输入一个整数,一个浮点类型:  
1 3.14  
x的数值:1,y的数值:3.140000  
  
x:1,y:3.140000

藉此,我们就可以完成一个小型的计算器应用了:

package main  
  
import (  
    "fmt"  
)  
  
func main() {  
    var x int  
    var y int  
    fmt.Println("请输入一个整数")  
    fmt.Scanln(&x)  
    fmt.Println("请再输入一个整数")  
    fmt.Scanln(&y)  
    sum := x + y  
    fmt.Printf("两数的和为:%d", sum)  
  
}

终端运行:

C:\Users\liuyue\www\tornado6>go run test.go  
请输入一个整数  
1  
请再输入一个整数  
2  
两数的和为:3

然后通过之前提到过的编译命令,直接打包成应用程序:

C:\Users\liuyue\www\tornado6>go build test.go  
  
C:\Users\liuyue\www\tornado6>test.exe  
请输入一个整数  
1  
请再输入一个整数  
2  
两数的和为:3  
C:\Users\liuyue\www\tornado6>

非常方便。

结语

基础数据类型是代码逻辑的最小单位,它将作为元素,存储在之后的复合数据类型中,同时,也会参与到分支、循环、判断等逻辑中。通晓基础数据类型,有助于加强我们对golang基础语法和设计理念的进一步认识和反思。

相关文章
|
6天前
|
监控 算法 Go
Golang深入浅出之-Go语言中的服务熔断、降级与限流策略
【5月更文挑战第4天】本文探讨了分布式系统中保障稳定性的重要策略:服务熔断、降级和限流。服务熔断通过快速失败和暂停故障服务调用来保护系统;服务降级在压力大时提供有限功能以保持整体可用性;限流控制访问频率,防止过载。文中列举了常见问题、解决方案,并提供了Go语言实现示例。合理应用这些策略能增强系统韧性和可用性。
55 0
|
6天前
|
JavaScript 前端开发 Go
Go语言的入门学习
【4月更文挑战第7天】Go语言,通常称为Golang,是由Google设计并开发的一种编程语言,它于2009年公开发布。Go的设计团队主要包括Robert Griesemer、Rob Pike和Ken Thompson,这三位都是计算机科学和软件工程领域的杰出人物。
17 1
|
6天前
|
分布式计算 Java Go
Golang深入浅出之-Go语言中的分布式计算框架Apache Beam
【5月更文挑战第6天】Apache Beam是一个统一的编程模型,适用于批处理和流处理,主要支持Java和Python,但也提供实验性的Go SDK。Go SDK的基本概念包括`PTransform`、`PCollection`和`Pipeline`。在使用中,需注意类型转换、窗口和触发器配置、资源管理和错误处理。尽管Go SDK文档有限,生态系统尚不成熟,且性能可能不高,但它仍为分布式计算提供了可移植的解决方案。通过理解和掌握Beam模型,开发者能编写高效的数据处理程序。
142 1
|
6天前
|
缓存 测试技术 持续交付
Golang深入浅出之-Go语言中的持续集成与持续部署(CI/CD)
【5月更文挑战第5天】本文介绍了Go语言项目中的CI/CD实践,包括持续集成与持续部署的基础知识,常见问题及解决策略。测试覆盖不足、版本不一致和构建时间过长是主要问题,可通过全面测试、统一依赖管理和利用缓存优化。文中还提供了使用GitHub Actions进行自动化测试和部署的示例,强调了持续优化CI/CD流程以适应项目需求的重要性。
57 1
|
6天前
|
Kubernetes Cloud Native Go
Golang深入浅出之-Go语言中的云原生开发:Kubernetes与Docker
【5月更文挑战第5天】本文探讨了Go语言在云原生开发中的应用,特别是在Kubernetes和Docker中的使用。Docker利用Go语言的性能和跨平台能力编写Dockerfile和构建镜像。Kubernetes,主要由Go语言编写,提供了方便的客户端库与集群交互。文章列举了Dockerfile编写、Kubernetes资源定义和服务发现的常见问题及解决方案,并给出了Go语言构建Docker镜像和与Kubernetes交互的代码示例。通过掌握这些技巧,开发者能更高效地进行云原生应用开发。
58 1
|
6天前
|
负载均衡 监控 Go
Golang深入浅出之-Go语言中的服务网格(Service Mesh)原理与应用
【5月更文挑战第5天】服务网格是处理服务间通信的基础设施层,常由数据平面(代理,如Envoy)和控制平面(管理配置)组成。本文讨论了服务发现、负载均衡和追踪等常见问题及其解决方案,并展示了使用Go语言实现Envoy sidecar配置的例子,强调Go语言在构建服务网格中的优势。服务网格能提升微服务的管理和可观测性,正确应对问题能构建更健壮的分布式系统。
30 1
|
6天前
|
消息中间件 Go API
Golang深入浅出之-Go语言中的微服务架构设计与实践
【5月更文挑战第4天】本文探讨了Go语言在微服务架构中的应用,强调了单一职责、标准化API、服务自治和容错设计等原则。同时,指出了过度拆分、服务通信复杂性、数据一致性和部署复杂性等常见问题,并提出了DDD拆分、使用成熟框架、事件驱动和配置管理与CI/CD的解决方案。文中还提供了使用Gin构建HTTP服务和gRPC进行服务间通信的示例。
30 0
|
6天前
|
Prometheus 监控 Cloud Native
Golang深入浅出之-Go语言中的分布式追踪与监控系统集成
【5月更文挑战第4天】本文探讨了Go语言中分布式追踪与监控的重要性,包括追踪的三个核心组件和监控系统集成。常见问题有追踪数据丢失、性能开销和监控指标不当。解决策略涉及使用OpenTracing或OpenTelemetry协议、采样策略以及聚焦关键指标。文中提供了OpenTelemetry和Prometheus的Go代码示例,强调全面可观测性对微服务架构的意义,并提示选择合适工具和策略以确保系统稳定高效。
115 5
|
6天前
|
负载均衡 算法 Go
Golang深入浅出之-Go语言中的服务注册与发现机制
【5月更文挑战第4天】本文探讨了Go语言中服务注册与发现的关键原理和实践,包括服务注册、心跳机制、一致性问题和负载均衡策略。示例代码演示了使用Consul进行服务注册和客户端发现服务的实现。在实际应用中,需要解决心跳失效、注册信息一致性和服务负载均衡等问题,以确保微服务架构的稳定性和效率。
22 3
|
6天前
|
前端开发 Go
Golang深入浅出之-Go语言中的异步编程与Future/Promise模式
【5月更文挑战第3天】Go语言通过goroutines和channels实现异步编程,虽无内置Future/Promise,但可借助其特性模拟。本文探讨了如何使用channel实现Future模式,提供了异步获取URL内容长度的示例,并警示了Channel泄漏、错误处理和并发控制等常见问题。为避免这些问题,建议显式关闭channel、使用context.Context、并发控制机制及有效传播错误。理解并应用这些技巧能提升Go语言异步编程的效率和健壮性。
30 5
Golang深入浅出之-Go语言中的异步编程与Future/Promise模式