Golang学习(四) 基本数据类型

每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间

基本数据类型

整数类型（int  int8 int16 int32 int64, uint,uint8,uint16,uint32,uint64,byte）(字节数)
浮点数   (float32 float64)
字符型  没有专门的字符型，使用byte来保存单个字符"字母"(不能用汉字)
布尔型  bool
字符串型  string

一、整数型

顾名思义，就是整数，不同的类型，占用的内存空间也不同

案例  int8

package main

import (
  "fmt"
)

func main()  {
  //这里使用-129超出了int8类型的限制，所以会报错
  var i int8 = -129
  fmt.Println(i)
}

案例2 uint8

package main

import (
    "fmt"
)

func main()  {
    //uint8 只能表示正数，(0-255)的范围
    var i uint8 = 255
    fmt.Println(i)
}

int类型 其他使用

package main

import (
  "fmt"
)

func main()  {
  //我是64位系统
  var a int = 8900
  fmt.Println(a)

  var b uint = 1
  fmt.Println(b)

  var c byte = 255
  fmt.Println(c)

  var i rune = 255
  fmt.Println(i)
}

整数使用细节

1、Golang各整数类型分为: 有符号 和无符号，int  uint的大小和系统有关

int    #有符号的    存在负数
uint   #无符号的    没有负数

2、golang的整型默认声明为int型

package main

import (
    "fmt"
)

func main()  {

    var n1 = 100 // n1是什么类型？


    //fmt.Printf() 可以用于做格式化输出
    //查看n1的数据类型是什么  
    //fmt.Printf("%T",xxx) 显示数据类型
    fmt.Printf("n1 的数据类型是 %T",n1)
}

3、查看某个变量的字节大小和数据类型

package main

import (
  "fmt"
  "unsafe"   //引入包
)

func main()  {
  var n2 int64 = 10

  //unsaf.Sizeof(n2) 是unsafe包的一个函数，可以返回n2变量占用的字节数
  fmt.Printf("n2 的数据类型是 %T,n2占用的字节数是 %d ",n2, unsafe.Sizeof(n2))
}

4、golang程序中整形变量在使用时，遵守保效不保大的原则

在保证程序正确运行下，尽量使用占用空间小的数据类型

比如 我要使用年龄变量，人最大年龄 1-155左右，如果我们使用int64 就很浪费空间，byte 是0-255 刚好合适

var age byte = 100 

5、bit 计算机最小存储单位

一个byte  等于 8 bit

二、浮点类型

浮点类型，就是带小数点的整数  ( •̀ ω •́ )✧

package main

import (
    "fmt"

)

func main()  {
    var price float32 = 10.22  //小数值
    fmt.Println(price)
}

 浮点值空间占用大小

1、 浮点数在机器中存放的形式

浮点数= "符号位+指数位+尾数位"    浮点数都是有符号的(负数)

package main

import (
    "fmt"
)

func main()  {
    var num1 float32 = -0.00089
    var num2 float64 = -7809656.09   //支持负数
    fmt.Println("num1",num1, "num2",num2)
}

返回

num1 -0.00089 num2 -7.80965609e+06

#当数值过大时，会使用科学计算

2、尾数部分可能丢失，造成精度损失

package main

import (
    "fmt"
)

func main()  {
    var num3 float32 = -123.0000901
    var num4 float64 = -123.0000901
    fmt.Println(num3,num4)
}

返回

-123.00009 -123.0000901

结论

浮点数可能会造成精度损失，后续如果需要保存一个精度高的数，应该选float64

浮点数使用细节

1、 通常情况下应该使用float64，因为他比float32更精确

2、 golang 的浮点型默认声明为"float64"类型

3、浮点型常量有两种表示形式

    十进制数形式:      如 5.12  .512(必须有小数点，0.512)
    科学计数法形式:    5.1234e2 = 5.12 * 10 的2次方    5.12E-2 =5.12/10的2次方

package main

import (
    "fmt"
)

func main()  {
    num6 := .123    //这里是简写，可以不写0
    num7 := 5.12
    fmt.Println("num6=",num6,"num7=",num7)
}

科学计数法

package main

import (
    "fmt"
)

func main()  {
    num8 := 5.1234e2     // 5.1234 * 10 的2次方
    num9 := 5.1234E2     // 5.1234 * 10 的2次方
    num10 := 5.1234E-2   // 5.1234 / 10的2次方
    fmt.Println(num8)
    fmt.Println(num9)
    fmt.Println(num10)
}

三、char  字符类型

Golang中没有专门的字符类型，如果要存储单个字符（字母）  一般使用byte存储

package main

import (
    "fmt"
)

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

 返回

97    
48

#这里的值是对应ASCLL码

如果需要输出他原先的值，需要格式化输出

package main

import (
    "fmt"
)

func main()  {
   var c1 byte = 'a'
   var c2 byte = '0'

   //fmt.Println(c1)
   //fmt.Println(c2)


    fmt.Printf("c1=%c c2=%c",c1,c2)
}

返回

c1=a c2=0

字符类型使用细节

1、字符常量是用单引号('')括起来的单个字符
例如: var c1 byte = 'a'

2、 GO中允许使用转义字符'\'来将后面的字符转换为特殊型常量
例如  var c3 char = '\n'   //\n 表示换行符

3、 Go语言的字符使用UTF-8编码
4、 在Go中，字符的本质是一个整数，直接输出时，是该字符对应的UTF-8编码的值
5、 可以直接给某个变量赋一个数字，然后按格式化输出时%c 会输出该数字对应的unicode字符
6、 字符类型是可以进行运算的，相当于一个整数，因为他都对应有Unicode码

四、布尔值类型

1. 布尔类型也叫bool类型， true 和false
2. bool 类型占用1 个字节
3. bool类型适用于逻辑运算

五、字符串类型

字符串就是字符串(～￣▽￣)～

 字符串的使用细节

1、字符串一旦赋值，字符串就不能修改，在go中字符串是不可变的

package main

import (
    "fmt"
)

func main()  {
    var str = "hello"
    str[0] = 'a'  //这里不能去修改str的内容，即go中的字符串是不可变的
    fmt.Println(str)
}

2、字符串的反引号

 反引号定义的字符，会以字符串的原生形式输出，包括换行符和特殊字符，可以防止攻击、输出源代码等效果

package main

import (
    "fmt"
)

func main()  {

    //这里我可以用反引号输出，这样他里面的特殊符号都失效了
    // "`" 波浪号的那个键的反引号
    str2 := `
    func main()  {
    var str2 = "abc\nabc"
    fmt.Println(str2)
       }
    `
    fmt.Println(str2)
}

返回

    func main()  {
    var str2 = "abc\nabc"
    fmt.Println(str2)
       }

3、字符串拼接方式

package main

import (
  "fmt"
)

func main()  {
     //字符串相加即可拼接
  str3 :=  "ss" + "dd"
  fmt.Println(str3)
}

4、当一行字符串太长时，需要使用到多行字符串

package main

import (
  "fmt"
)

func main()  {

  //当一个拼接的字符串很长时
  var str2 = "hello" + "world" + "hello" + "world" + "hello" + "world"

  //可以改为如下
  //注意，需要讲加号放在上一行
  var str3 = "hello" + "world" +
    "hello" + "world" +
    "hello" + "world"
  fmt.Println(str2,str3)
}

六、基本数据类型的默认值

以上的数据类型的变量，在声明后是有自己的默认值的

数据类型	默认值
整数型	0
浮点数型	0
字符串型	""
布尔值型	false

七、强制数据类型转换

数据类型(变量)   如下，我希望将int类型的值转换为float类型

package main
import (
  "fmt"
)

func main()  {
  var  i int = 100
  //希望将i转成float类型
  var n1 float32 = float32(i)
  fmt.Printf("i=%v n1=%v\n",i,n1)
  fmt.Printf("i=%T n1=%T",i,n1)
}

 返回

i=100 n1=100
i=int n1=float32

强制数据类型转换细节

1. go语言中，数据类型的转换可以是从   表示范围小--》表示范围大，也可以 范围大 ————》 范围小
2. 被转换的是 "变量存储的数据" 变量本身的数据类型是没有变化的
3. 在转换中，比如将int64 转换成int8，编译不会报错，只是转换的结果是按照溢出处理，和我们希望的结果不一样

案例1

package main
import (
  "fmt"
)

func main()  {
  var n1 int32 = 10
  var n2 int64
  var n3 int8

  n2 = n1 + 12
  n3 = n1 + 12
  fmt.Println(n1,n2,n3)
}

这样能用吗？不能

因为 n1的数据类型还是int32，与n2的数据类型不同是不能直接赋予的，int8同理

修改为如下

package main
import (
    "fmt"
)

func main()  {
    var n1 int32 = 10
    var n2 int64
    var n3 int8

    n2 = int64(n1) + 12   //转换对应的数据类型后即可计算
    n3 = int8(n1) + 12    //不过从大数据类型转小数据类型，可能会丢失精度
    fmt.Println(n1,n2,n3)
}

案例2

package main
import (
    "fmt"
)

func main()  {
    var n1 int32 = 12
    var n3 int8
    var n4 int8

    //这样可行吗？
    n4 = int8(n1) + 127  //虽然编译通过，但是会溢出
    n3 = int8(n1) + 128  //编译会错，无法赋予超过127
    fmt.Println(n3,n4)
}