(七)golang--变量之基本数据类型(看这篇就够了)

1.整数类型

类型 有无符号 占用存储空间 表示范围 备注
int8 1字节 -2**7~2**7-1  
int16 2字节 -2**15~2**15-1  
int32 4字节 -2**31~2**31-1  
int64 8,字节 -2**63~2**63-1  
uint8 1字节 0~2**8-1  
uint16 2字节 0~2**16-1  
uint32 4字节 0~2**32-1  
uint64 8字节 0~2**64-1  
int

32位系统4字节

64位系统8字节

-2**31~2**31-1

-2**63~2**63-1

 
uint

32位系统4字节

64位系统8字节

0~2**32-1

0~2**64-1

 

rune 与int32一样 -2**31~2**31-1

等价int32,表示

一个unicode码

byte 与uint8一样 0~2**8-1

当要存储字符时

使用byte

整型的使用细节:

(1)golang整数类型分为:有符号和无符号,int和uint的大小和系统有关;

(2)golang整型默认申明为int;

(3)如何在程序查看某个变量的数据类型?

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var num int64 = 10
    fmt.Printf("num的数据类型是 %T,占的字节数是 %d", num, unsafe.Sizeof(num))
}

(4)golang使用整数类型时,遵从保小不保大原则,即在保证程序正常运行的情况下,尽量使用占用空间小的数据类型;

(5)bit:计算机中最小的存储单位,byte:计算机中基本的存储单元;

2.浮点类型

类型 占用存储空间 表示范围
单精度float32 4字节 -3.403E38~3.403E38
双精度float64 8字节 -1.798E308~1.798E308

说明:

(1)浮点数在机器中存在的形式:浮点数=符号位+指数位+尾数位(浮点数都是有符号的)11110000111.111111111111111111000

(2)尾数部分可能丢失,造成精度损失;

(3)浮点型的存储分为三个部分:符号位+指数位+尾数位;

浮点型的使用细节:

(1)golang浮点类型有固定的范围和字段长度,不受操作系统的影响;

(2)默认为float64类别;

(3)浮点型常用两种形式表示:

  1)十进制:5.12、.512

  2)科学记数法形式:5.1234E2、5.1234E-2

(4)通常使用float64,它精度更高;

3.字符类型

字符串是一串固定长度的字符连接起来的字符序列。golang没有专门的存储字符类型,如果要存储单个字符,用byte来保存。go的字符串是由单个字节连接起来的,它与传统的字符串是由字符组成的不同。

package main

import (
    "fmt"
)

func main() {
    var c1 byte = 'a'
    fmt.Println(c1)
}

当我们直接输出字符c1,,得到的是它的ascII值:97。要用格式化输出:fmt.Printf("%c",c1)。而当我们要存储中文时,此时不能够用byte类型了,即ASCII值大于255时,会显示溢出,我们要用int来存储:

(补:格式化输出代表含义 %d:输出整型;%f:输出浮点型;%c:输出字符型;%v:输出原变量值;%T:输出变量的数据类型;%t:输出布尔值:%q:输出带双引号的字符串)

package main

import (
    "fmt"
)

func main() {
    var c1 byte = 'a'
    var c2 int = ''
    fmt.Println(c1)
    fmt.Printf("c1的值是:%c \n", c1)
    fmt.Printf("c2的值是:%c,它的ASCii值是:%d", c2, c2)
}

 字符类型使用细节:(再也不用担忧编码的问题了,所有的编码都是utf-8)
(1)字符常量使用单引号括起来的单个字符;

(2)go中允许使用转义字符'\'来将其后的字符转变为特殊字符型常量,例如 var c int = '\n';

(3)字符使用utf-8编码;

(4)go中,字符的本质是一个整数,直接输出时,会输出它对应的UTF-8编码的值;

(5)可以直接给变量赋予某个数字,然后格式化输出%c,会输出该数字对应的unicode字符;

(6)字符类型是可以进行运算的,相当于一个整数,因为它都对应unicode码;

4.布尔类型

只允许取两个值:true、false;占用1个字节;主要用在逻辑运算;

5.字符串类型

go的字符串是由字节连接而成;

package main

import (
    "fmt"
)

func main() {
    var address string = "北京长城"
    fmt.Println(address)
}

字符串的使用细节:
(1)go语言的字符串的字节使用utf-8编码;

(2)与python一样,一旦字符串赋值了,就不能被更改;

(3)两种表示形式

  1)双引号,会识别转义字符;

  2)反引号,以字符串的原生形式输出,包括换行和特殊字符,可以实现防止攻击,输出源代码等

package main

import (
    "fmt"
)

func main() {
    var c = "abc\nabc"
    var d = `abc\nabc`
    fmt.Println(c)
    fmt.Println(d)
}

   3)字符串的拼接,当我们要拼接多行字符串时,要将加号留在每行末尾:(注意单个字符进行拼接是指对unicode值进行相加)

package main

import (
    "fmt"
)

func main() {
    var str = "hello " + "world " +
        "!"
    fmt.Println(str)
}

 6.基本数据类型的默认值

整型:0

浮点型:0

字符串:""

布尔类型:false

7.基本数据类型之间的转换

golang和java、c不同,Go在不同类型变量之间赋值需要显示转换,也就是golang中数据类型不能自动转换;

基本语法:T(v),即将变量v转换成T数据类型

整数型之间的转换:例如var i int8 = 10; var n1 int64 = int64(i)

(1)数据类型转换可以从范围小-->范围大,范围大-->范围小;

(2)被转换的是变量存储的数据(即值),变量本身的数据类型并没有变化;

(3)在转换中,比如将int64转成int8,编译时不会报错,只是转换的结果是按溢出处理,和我们希望的结果不一样;

基本数据类型和string之间的转换

(1)fmt.Sprintf("%参数",表达式):参数和表达式的类型要匹配;结果返回转换后的字符串;

package main

import (
    "fmt"
)

func main() {
    var num1 int = 99
    var num2 float64 = 23.456
    var b bool = false
    var c byte = 'g'
    var str1 = fmt.Sprintf("%d", num1)
    var str2 = fmt.Sprintf("%f", num2)
    var str3 = fmt.Sprintf("%t", b)
    var str4 = fmt.Sprintf("%c", c)
    fmt.Printf("%T--%q\n", str1, str1)
    fmt.Printf("%T--%q\n", str2, str2)
    fmt.Printf("%T--%q\n", str3, str3)
    fmt.Printf("%T--%q", str4, str4)
}

 (2)使用strconv函数package main

import (
    "fmt"
    "strconv"
)

func main() {
    var num1 int = 99
    var num2 float64 = 23.456
    var b bool = false
    //FormatInt()第一个参数必须转成int64,第二个是十进制表示
    var str1 = strconv.FormatInt(int64(num1), 10)
    //FormatFloat,'f'表示格式,10表示保留小数,64表示float64
    var str2 = strconv.FormatFloat(num2, 'f', 10, 64)
    var str3 = strconv.FormatBool(b)
      //将int转换成string
      var str4 = strconv.Itoa(num1)
    fmt.Printf("%T--%q\n", str1, str1)
    fmt.Printf("%T--%q\n", str2, str2)
    fmt.Printf("%T--%q\n", str3, str3)
    fmt.Printf("%T--%q\n", str4, str4)
}

 string和基本数据类型转换:

package main

import (
    "fmt"
    "strconv"
)

func main() {
    var s1 string = "true"
    var s2 string = "888"
    var s3 string = "23.45"
    var num1 int64
    var num2 float64
    var b bool
    b, _ = strconv.ParseBool(s1)
    num1, _ = strconv.ParseInt(s2, 10, 64)
    num2, _ = strconv.ParseFloat(s3, 64)
    fmt.Printf("%T--%t\n", b, b)
    fmt.Printf("%T--%d\n", num1, num1)
    fmt.Printf("%T--%f\n", num2, num2)
}

 

 注意:要确保string类型要能够转换成有效的数据,即"hello"不能转换成布尔值、整型、浮点型

posted on 2019-11-09 17:31 西西嘛呦 阅读(...) 评论(...) 编辑 收藏

导航