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

2022 年 8 月 08 日
本文字数：4607 字
阅读完需：约 15 分钟

前文再续，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 基础语法和设计理念的进一步认识和反思。

发布于: 刚刚阅读数: 2

原文链接:【http://xie.infoq.cn/article/30e80f6f97eef0dbfb50dfa0b】。文章转载请联系作者。

刘悦的技术博客

关注

专注技术，凝聚意志，解决问题 v3u.cn 2020.12.21 加入

还未添加个人简介

发布

暂无评论

创作场景

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

整形 int

浮点 float

字符 byte/rune

字符串 string

布尔 bool

数据运算

基本数据的输入输出

结语

刘悦的技术博客

评论