乐趣区

关于go:分门别类输入输出Go-lang118入门精炼教程由白丁入鸿儒go-lang基本数据类型和输入输出EP03

前文再续,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 根底语法和设计理念的进一步意识和反思。

退出移动版