仓库地址 https://gitee.com/shinxb_1697178173/go_study 本仓库是在学习过程中创建
image.png

数据类型

  1. import (
  2.     "fmt"
  3.     "testing"
  4.     "unsafe"
  5. )
  7. /*
  8. 数据类型
  9. */
  11. func TestInt(t *testing.T)  {
  12.     fmt.Println("无符号数据了类型---")
  13.     var uintData uint                       // uint 在32位操作系统中表示 0 -- 2^32 -1 在64位操作系统中 0 - 2^64 -1
  14.     var uintData8 uint8                     // 无符号 8 位整型 (0 到 255)    2^8 - 1
  15.     var uintData16 uint16                   // 无符号 16 位整型 (0 到 255)    2^16 - 1
  16.     var uintData32 uint32                   // 无符号 32 位整型 (0 到 255)    2^32 - 1
  17.     var uintData64 uint64                   // 无符号 64 位整型 (0 到 255)    2^64 - 1
  18.     var uintDataptr uintptr                 // 存放指针
  19.     fmt.Println(unsafe.Sizeof(uintData))
  20.     fmt.Println(unsafe.Sizeof(uintData8))
  21.     fmt.Println(unsafe.Sizeof(uintData16))
  22.     fmt.Println(unsafe.Sizeof(uintData32))
  23.     fmt.Println(unsafe.Sizeof(uintData64))
  24.     fmt.Println(unsafe.Sizeof(uintDataptr))
  26.     fmt.Println("有符号数据了类型---")
  27.     var intData int                         // 更具具体操作系统决定大小
  28.     var intData8 int8                       // 有符号 -(2^7) 2^7-1
  29.     var intData16 int16                     // 有符号 -(2^15) 2^15-1
  30.     var intData32 int32                     // 有符号 -(2^31) 2^31-1
  31.     var intData64 int64                     // 有符号 -(2^63) 2^63-1
  33.     fmt.Println(unsafe.Sizeof(intData))
  34.     fmt.Println(unsafe.Sizeof(intData8))
  35.     fmt.Println(unsafe.Sizeof(intData16))
  36.     fmt.Println(unsafe.Sizeof(intData32))
  37.     fmt.Println(unsafe.Sizeof(intData64))
  39. }
  43. func TestFloat(t *testing.T)  {
  44.     // 浮点数都是有符号的
  45.     /*
  46.      存储方式 三部分存储 符号位 指数位 尾数部分
  47.     */
  48.     fmt.Println("浮点数---")
  49.     var price1 float32 = -123.43434343  // 尾数部分会丢失
  50.     var price2 float64 = -123.43434343  // 精度高
  52.     fmt.Println("price1=",price1,"price2=",price2)
  53.     // 输出结果 price1= -123.43434 price2= -123.43434343
  55.     fmt.Println(unsafe.Sizeof(price1))
  56.     fmt.Println(unsafe.Sizeof(price2))
  57. }
  59. func TestString(t *testing.T)  {
  60.     fmt.Println("字符串 byte类型")
  61.     // byte 类型和uin8一样 表示一个字节
  62.     /*
  63.         1 传统的字符串是由字符组成的 ，但是在Go中用字节来保存字符，所以在Go语言中字符串是单个字节连接起来的
  64.         2 Go中的字符使用UTF-8编码
  65.         3 英文字母一个字节 汉子三个字节
  66.         4 在GO中字符的本质是一个整数，直接输出的是该字符的编码值
  67.         5 字符类型是可以直接进行运算的
  68.         字符类型的本质 存储和读取的流程
  69.         [
  70.             存储 字符->码值->二进制->存储
  71.             读取 二进制->码值->字符->读取
  72.         ]
  73.     */
  74.     var bytesString1 byte
  75.     fmt.Println(unsafe.Sizeof(bytesString1))   // 输出 1
  76.     bytesString1 = 255
  77.     // 字符本质表示的是数字 编码值
  78.     bytesString2 := '国'                       // int32
  79.     fmt.Println(bytesString2)                  //  输出 22269
  81. }

channel

  • 发生阻塞的情况 ```go func TestGOChannelDemo1(t testing.T) { // channel 用于协程之间的通信 /

    1. 从一个被close的channel中接收数据不会被阻塞，而是立即返回，接收完已发送的数据后会返回元素类型的零值(zero value)

    2. 从一个返回nil的channel中接收数据会发生阻塞 */ // 1 不会发生阻塞 //var channelVal1 = make(chan int,10) //close(channelVal1) //i,ok :=<-channelVal1 //fmt.Println(i,ok)

      // 2 会发生阻塞 var channelVal2 = make(chan int,10) // channel中存在值则不会发生阻塞 channelVal2<-2 i,ok :=<-channelVal2 fmt.Println(i,ok)

}

  2. - Range遍历channel 
  4.       使用range 遍历时 channle必须是在关闭状态下，否则程序一致block 
  5. ```go
  6. func TestGOChannelDemo3(t *testing.T)  {
  7.     go func() {
  8.         time.Sleep(1 * time.Hour)
  9.     }()
  10.     c := make(chan int)
  11.     go func() {
  12.         for i := 0; i < 10; i = i + 1 {
  13.             c <- i
  14.         }
  15.         close(c)
  16.     }()
  17.     //range c产生的迭代值为Channel中发送的值，它会一直迭代直到channel被关闭 如果去除掉close 程序一致block
  18.     //for i := range c {
  19.     //    fmt.Println(i)
  20.     //}
  21.     //使用for 循环不会block
  22.     for i:=0;i<10;i++{
  23.         j:=<-c
  24.         fmt.Println(j)
  25.     }
  26.     fmt.Println("Finished")
  29. }